@cmodjs/core 1.6.0 → 2.0.1

package/src/runtime/before.ts

@@ -1,8 +1,8 @@
 import type { Args, Frozen } from 'claude-code'
 import type { Disposable } from '../mod.js'
 import { ContextEnd } from '../session/context/context.js'
-import { Document } from '../session/context/turn/message/document.js'
-import { Message, messagesOf, rowOfAppend, withTexts, type Unplaced } from '../session/context/turn/message/message.js'
+import { InstructionFile, isRulePath } from '../session/context/turn/message/instruction-file.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'
@@ -13,22 +13,40 @@ import { ToolCall } from '../session/context/turn/message/tool-call.js'
 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 { TaskEnd, TaskStart } from '../session/goal/task.js'
-import type { BeforeEvent } from '../session/session.js'
+import { Task, TaskStart } from '../session/goal/task.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'>
+export type Place = Pick<ConversationState, 'session' | 'context' | 'contextOpenedAt' | 'turn' | 'tasks' | 'taskTurns' | 'openCalls'>
 
 export type Decide = (event: BeforeEvent, change: SessionChange) => Promise<Partial<Answers> | undefined>
 
-export type Answers = { readonly text: string; readonly refuse: string; readonly input: Readonly<Record<string, unknown>>; readonly result: string; readonly owner: { readonly model: string } }
+export type Answers = {
+  readonly text: string
+  readonly output: unknown
+  readonly isError: true
+  readonly note: string
+  readonly title: string
+  readonly refuse: string
+  readonly input: Readonly<Record<string, unknown>>
+  readonly result: string
+  readonly owner: { readonly model: string }
+}
 
 export type BeforeHooks = { readonly place: () => Promise<Place>; readonly wants: (event: BeforeEvent) => Promise<boolean>; readonly decide: Decide }
 
-const appended: readonly BeforeEvent[] = [Note, Reply, ToolResult, Notice]
+const appended: readonly BeforeEvent[] = [Note, Reply, Notice]
+
+type ClassicFields = Readonly<Record<string, unknown>>
+
+const withNote = (below: unknown, note: string | undefined): ClassicFields => {
+  const fields = (below ?? {}) as ClassicFields
+  return note === undefined ? fields : { ...fields, additionalContext: [...((fields['additionalContext'] as readonly string[] | undefined) ?? []), note] }
+}
 
 const relayTag = /^(?:<cross-session-message[^>]*>\s*)?<cmod-relay>([\s\S]*)<\/cmod-relay>(?:\s*<\/cross-session-message>[\s\S]*)?$/
 
@@ -44,28 +62,51 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
   const message = (where: Place, unplaced: Unplaced, task: string | undefined, isInTurn = true): SessionChange => {
     const turn = isInTurn ? (task === undefined ? where.turn : where.taskTurns[task]) : undefined
     const context = task === undefined ? where.context : (where.tasks[task]?.context ?? where.context)
-    return { type: Message, message: { ...unplaced, session: where.session, context, ...(turn === undefined ? {} : { turn: turn.prompt.id }), ...(task === undefined ? {} : { task }) } as Message }
+    const call = unplaced.type === ToolResult ? where.openCalls?.[unplaced.callId] : undefined
+    return { type: Message, message: { ...unplaced, ...call, session: where.session, context, ...(turn === undefined ? {} : { turn: turn.prompt.id }), ...(task === undefined ? {} : { task }) } as Message }
+  }
+  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()
+    const name = String(e['tool_name'])
+    const callId = String(e['tool_use_id'])
+    const input = (typeof e['tool_input'] === 'object' && e['tool_input'] !== null ? e['tool_input'] : {}) as Readonly<Record<string, unknown>>
+    const task = typeof e['agent_id'] === 'string' ? e['agent_id'] : undefined
+    const result = { id: callId, at: now(), type: ToolResult, callId, name, input, cwd: String(e['cwd']), files: noFiles, output: isFailure ? e['error'] : e['tool_response'], isError: isFailure } as const
+    const answer = await asked(ToolResult, message(where, result, task))
+    const below = await next(e as never)
+    const rewritten = answer.output === undefined || isFailure ? {} : name.startsWith('mcp__') ? { updatedMCPToolOutput: answer.output } : { updatedToolOutput: answer.output }
+    const failed = answer.isError === true && !isFailure ? { block: answer.note ?? `${name} failed.` } : {}
+    return { ...withNote(below, answer.isError === true ? undefined : answer.note), ...rewritten, ...failed }
   }
   const added: Disposable[] = [
     router.add('prompt.submit', async (e, next) => {
-      if (!(await wants(Prompt)) || e.text.startsWith('/')) return next(e)
+      if (!(await wants(Prompt))) return next(e)
       const where = await place()
       const answer = await asked(Prompt, message(where, { id: '', at: now(), type: Prompt, text: e.text, from: senderOf(e.origin, false) }, undefined, false))
       if (answer.refuse !== undefined) return { drop: answer.refuse }
-      return next(answer.text === undefined ? e : { ...e, text: answer.text })
+      const text = answer.text ?? e.text
+      if (answer.title !== undefined) titles.set(text, answer.title)
+      const context = answer.note === undefined ? e.context : [...(e.context ?? []), answer.note]
+      const ran = await next({ ...e, text, ...(context === undefined ? {} : { context }) })
+      const passed = titles.get(text)
+      if (passed !== undefined && ('drop' in ran || ran.text !== text)) {
+        titles.delete(text)
+        if (!('drop' in ran) && typeof ran.text === 'string') titles.set(ran.text, passed)
+      }
+      return ran
     }),
-    router.add('command.run', async (e, next) => {
-      if (!(await wants(Prompt))) return next(e)
-      const typed = e.args === '' ? `/${e.command}` : `/${e.command} ${e.args}`
-      const where = await place()
-      const answer = await asked(Prompt, message(where, { id: '', at: now(), type: Prompt, text: typed, from: senderOf(e.origin, false) }, undefined, false))
-      if (answer.refuse !== undefined) return { text: answer.refuse }
-      if (answer.text === undefined || answer.text === typed) return next(e)
-      const same = new RegExp(`^/${e.command}(?:\\s+|$)`).exec(answer.text)
-      if (same !== null) return next({ ...e, args: answer.text.slice(same[0].length) })
-      void claude.prompt.submit({ text: answer.text })
-      return {}
+    router.add('classic.UserPromptSubmit', async (e, next) => {
+      const named = titles.get(e.prompt)
+      titles.delete(e.prompt)
+      const below = await next(e)
+      return named === undefined ? below : { ...below, sessionTitle: named }
     }),
+    router.add('classic.PostToolUse', toolResultHook(false) as never),
+    router.add('classic.PostToolUseFailure', toolResultHook(true) as never),
     router.add('session.receive', async (e, next) => {
       if (!(await wants(Prompt)) || relayOf(e) !== undefined) return next(e)
       const where = await place()
@@ -80,10 +121,10 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
       return answer.text === undefined ? next(e) : { text: answer.text }
     }),
     router.add('prompt.attachment', async (e, next) => {
-      if (!(await wants(Document)) || e.type !== 'nested_memory') return next(e)
+      if (!(await wants(InstructionFile)) || e.type !== 'nested_memory') return next(e)
       const where = await place()
-      const path = /^Contents of (.+?) \(/.exec(e.text)?.[1] ?? ''
-      const answer = await asked(Document, message(where, { id: '', at: now(), type: Document, path, text: e.text }, e.agentId))
+      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 }
     }),
@@ -106,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() }, 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)
@@ -114,23 +156,46 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
       return next({ ...reserved, ...answer.input } as Frozen<Args<'tool.call'>>)
     }),
     router.add('agent.spawn', async (e, next) => {
-      if (!(await wants(TaskStart))) return next(e)
+      spawned.set(e.tool_use_id, e.prompt)
+      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 } })
-      if (answer.refuse !== undefined) return { deny: answer.refuse }
-      return next(answer.owner === undefined ? e : { ...e, model: answer.owner.model })
+      if (answer.refuse !== undefined) {
+        spawned.delete(e.tool_use_id)
+        return { deny: answer.refuse }
+      }
+      return start(answer.owner === undefined ? e : { ...e, model: answer.owner.model })
     }),
-    router.add('classic.SubagentStop', async (e, next) => {
-      if (!(await wants(TaskEnd)) && !(await wants(TurnEnd))) return next(e)
+    router.add('classic.SubagentStart', async (e, next) => {
       const where = await place()
-      const task = where.tasks[e.agent_id]
-      if (task === undefined) return next(e)
-      const turn = where.taskTurns[e.agent_id]
-      const ending = (await wants(TaskEnd)) ? await asked(TaskEnd, { type: TaskEnd, task: { ...task, closedAt: now() } }) : {}
-      const refuse = ending.refuse ?? ((await wants(TurnEnd)) && turn !== undefined ? (await asked(TurnEnd, { type: TurnEnd, turn: { ...turn, closedAt: now() } })).refuse : undefined)
+      const openedBy = where.tasks[e.agent_id]?.openedBy
+      const prompt = openedBy === undefined ? undefined : spawned.get(openedBy)
+      if (openedBy !== undefined) spawned.delete(openedBy)
+      if (!(await wants(Prompt))) return next(e)
+      const open = where.taskTurns[e.agent_id]?.prompt
+      const text = open?.text ?? prompt
+      if (text === undefined) return next(e)
+      const answer = await asked(Prompt, message(where, { id: open?.id ?? '', at: now(), type: Prompt, text, from: open?.from ?? { type: Task } }, e.agent_id, false))
+      return withNote(await next(e), answer.note)
+    }),
+    router.add('classic.SubagentStop', async (e, next) => {
+      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 stopped(await next(e))
+      const answer = await asked(TurnEnd, { type: TurnEnd, turn: { ...turn, closedAt: now() } })
       const below = await next(e)
-      return refuse === undefined ? below : { ...below, block: 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)
@@ -154,47 +219,56 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
 }
 
 export function withAnswer(change: SessionChange, answer: Partial<Answers>): SessionChange {
+  if (change.type === Message && answer.output !== undefined && change.message.type === ToolResult) return { ...change, message: { ...change.message, output: answer.output } }
   if (change.type === Message && answer.text !== undefined) return { ...change, message: { ...change.message, text: answer.text } as Message }
   if (change.type === Message && answer.input !== undefined && change.message.type === ToolCall) return { ...change, message: { ...change.message, input: answer.input } }
   if (change.type === TaskStart && answer.owner !== undefined) return { ...change, task: { ...change.task, model: answer.owner.model } }
   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
-      result = { ...result, ...answer }
-      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', 'refuse'],
-    note: ['text'],
-    skill: ['text'],
-    document: ['text', 'refuse'],
-    reply: ['text'],
-    toolCall: ['input', 'result', 'refuse'],
-    toolResult: ['text'],
-    notice: ['text'],
-    taskStart: ['owner', 'refuse'],
-    taskEnd: ['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/claude.ts

@@ -5,6 +5,9 @@ import type {
   Args,
   EngineInterface,
   AskOptions,
+  CommandInfo,
+  CommandRunArgs,
+  CommandRunResult,
   CommandSpec,
   ConfigRow,
   ElementTable,
@@ -93,8 +96,9 @@ export type Claude = {
     send: EngineInterface['session']['send']
   }
   readonly prompt: { submit: EngineInterface['prompt']['submit'] }
+  readonly turn: { abort: EngineInterface['turn']['abort'] }
   readonly model: { complete: EngineInterface['model']['complete'] }
-  readonly command: { register(command: CommandSpec): Promise<{ command: string }> }
+  readonly command: { register(command: CommandSpec): Promise<{ command: string }>; list(): Promise<readonly CommandInfo[]>; run(args: CommandRunArgs): Promise<CommandRunResult> }
   readonly tool: { register(tool: ToolSpec): Promise<{ tool: string }>; call: EngineInterface['tool']['call'] }
   readonly agent: {
     list(): Promise<AgentInfo[]>

package/src/runtime/conversations.ts

@@ -3,18 +3,18 @@ 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'
 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'
 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,8 +64,23 @@ 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
+  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
@@ -75,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)
@@ -94,6 +110,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()
@@ -128,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()
@@ -149,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))))
     })
@@ -189,8 +226,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 +236,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 } })
   }
 
@@ -228,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))),
@@ -360,9 +397,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 +409,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 +439,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 +489,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'])
@@ -540,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)
     },
   }
@@ -556,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 && !(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/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.`
 }