@cmodjs/core 1.6.0 → 2.0.0

package/src/jobs/status-line.ts

@@ -2,21 +2,18 @@ import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
 import { engineOf } from '../runtime/engine.js'
 import { usageOf } from '../runtime/sessions.js'
+import { onStateChange } from '../runtime/state.js'
 import type { Usage } from '../session/session.js'
 import { messageOf } from '../utils/text.js'
 import { withinDeadline } from './context.js'
 
 const deadline: Deadline = { ms: 2000, job: 'statusLine' }
 
-export function statusLine<State extends object = Record<never, never>>(options: {
-  readonly text: (usage: Usage, mod: Mod<State>) => string | undefined | Promise<string | undefined>
-  readonly interval?: number
-}): Job<void, State> {
-  const { text, interval = 10000 } = options
+export function statusLine<State extends object = Record<never, never>>(options: { readonly text: (usage: Usage, mod: Mod<State>) => string | undefined | Promise<string | undefined> }): Job<void, State> {
+  const { text } = options
   return (job) => {
     const { mod, announce, reserveName } = job
     const { claude, router } = engineOf(mod)
-    if (!(interval >= 1)) throw new Error(`${mod.name}: the status line interval is ${interval}. Give it in milliseconds, 1 or more.`)
     reserveName('statusLine', '', `${mod.name}: a status line is already added. A mod has one status line: join the texts in one statusLine.`)
 
     let shown: string | undefined
@@ -41,7 +38,7 @@ export function statusLine<State extends object = Record<never, never>>(options:
       refresh()
       return next(e)
     })
-    claude.clock.every(interval, refresh)
+    onStateChange(mod.state, refresh)
     refresh()
   }
 }

package/src/mod.ts

@@ -1,8 +1,7 @@
 import type {
   AskOptions,
-  ClassicHookInputs,
   CmodDependencies,
-  ConfigRow,
+  ConfigRow as ClaudeConfigRow,
   FsStatOptions,
   HookStream,
   HttpInit,
@@ -11,7 +10,6 @@ import type {
   ModelCompleteRequest,
   ModelCompleteResult,
   PaneOpenArgs,
-  PermissionRequestDecision,
   ProcessRunInit,
   ProcessRunResult,
   ProcessSpawnChunk,
@@ -26,7 +24,7 @@ import type { Step } from './installer.js'
 import { checkOptions, type Option, type Options, type OptionValues } from './options.js'
 import { bound } from './runtime/bound.js'
 import { Mod as modSender } from './session/context/turn/message/sender.js'
-import type { Sessions } from './session/session.js'
+import { sessionEvents, type BeforeMethod, type CommandRun, type CommandRunAnswer, type OnMethod, type OnMethods, type Sessions } from './session/session.js'
 import type { Pane } from './ui/define-pane.js'
 import type { Place, PlaceProps } from './ui/places.js'
 import type { Disposable } from './utils/disposable.js'
@@ -67,132 +65,6 @@ export type PaneHandle = {
   readonly isFocused: boolean
 }
 
-export const SessionStart = 'SessionStart'
-export const SessionEnd = 'SessionEnd'
-export const UserPromptSubmit = 'UserPromptSubmit'
-export const InstructionsLoaded = 'InstructionsLoaded'
-export const PreToolUse = 'PreToolUse'
-export const PermissionRequest = 'PermissionRequest'
-export const PermissionDenied = 'PermissionDenied'
-export const PostToolUse = 'PostToolUse'
-export const PostToolUseFailure = 'PostToolUseFailure'
-export const PostToolBatch = 'PostToolBatch'
-export const SubagentStart = 'SubagentStart'
-export const SubagentStop = 'SubagentStop'
-export const Notification = 'Notification'
-export const PreCompact = 'PreCompact'
-export const Stop = 'Stop'
-export const StopFailure = 'StopFailure'
-export const CwdChanged = 'CwdChanged'
-export const FileChanged = 'FileChanged'
-export const UserPromptExpansion = 'UserPromptExpansion'
-export const Setup = 'Setup'
-export const ConfigChange = 'ConfigChange'
-export const DirectoryAdded = 'DirectoryAdded'
-export const PreModelSwitch = 'PreModelSwitch'
-export const PostModelSwitch = 'PostModelSwitch'
-export const PostCompact = 'PostCompact'
-export const MessageDisplay = 'MessageDisplay'
-export const TodoCreated = 'TaskCreated'
-export const TodoCompleted = 'TaskCompleted'
-export const TeammateIdle = 'TeammateIdle'
-export const Elicitation = 'Elicitation'
-export const ElicitationResult = 'ElicitationResult'
-export const WorktreeCreate = 'WorktreeCreate'
-export const WorktreeRemove = 'WorktreeRemove'
-
-export const hooks = [
-  Setup,
-  SessionStart,
-  SessionEnd,
-  UserPromptSubmit,
-  UserPromptExpansion,
-  InstructionsLoaded,
-  ConfigChange,
-  DirectoryAdded,
-  PreModelSwitch,
-  PostModelSwitch,
-  PreToolUse,
-  PermissionRequest,
-  PermissionDenied,
-  PostToolUse,
-  PostToolUseFailure,
-  PostToolBatch,
-  MessageDisplay,
-  SubagentStart,
-  SubagentStop,
-  TodoCreated,
-  TodoCompleted,
-  TeammateIdle,
-  Elicitation,
-  ElicitationResult,
-  Notification,
-  PreCompact,
-  PostCompact,
-  Stop,
-  StopFailure,
-  CwdChanged,
-  FileChanged,
-  WorktreeCreate,
-  WorktreeRemove,
-] as const
-
-export type Hook = (typeof hooks)[number]
-
-export type HookAnswer = {
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-  decision?: 'block'
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName?: Hook
-    additionalContext?: string
-    permissionDecision?: 'allow' | 'deny' | 'ask'
-    permissionDecisionReason?: string
-    updatedInput?: Record<string, unknown>
-    sessionTitle?: string
-    suppressOriginalPrompt?: boolean
-    initialUserMessage?: string
-    watchPaths?: string[]
-    reloadSkills?: boolean
-    decision?: PermissionRequestDecision
-    updatedToolOutput?: unknown
-    updatedMCPToolOutput?: unknown
-    retry?: boolean
-    displayContent?: string
-    worktreePath?: string
-  }
-}
-
-type CallFiles = { read: string[]; changed: string[] }
-
-type HookInputs = Omit<ClassicHookInputs, 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'CwdChanged'> & {
-  PreToolUse: {
-    session_id: string
-    cwd: string
-    hook_event_name: 'PreToolUse'
-    tool_name: string
-    tool_input: Record<string, unknown>
-    tool_use_id: string
-    agent_id?: string
-    agent_type?: string
-    files: CallFiles
-  }
-  PostToolUse: ClassicHookInputs['PostToolUse'] & { files: CallFiles }
-  PostToolUseFailure: ClassicHookInputs['PostToolUseFailure'] & { files: CallFiles }
-  CwdChanged: Omit<ClassicHookInputs['CwdChanged'], 'transcript_path'>
-}
-
-export type HookInput<H extends Hook> = HookInputs[H]
-
-export type HookListener<H extends Hook> = (input: HookInput<H>) => HookAnswer | void | Promise<HookAnswer | void>
-
-export type HookOptions = {
-  readonly timeoutMs?: number
-}
-
 export type Metadata = Readonly<Record<string, string>>
 
 export type FileMatch = {
@@ -215,6 +87,8 @@ export type Stat = Omit<Entry, 'name'> & {
   readonly realPath?: string
 }
 
+export type FileChange = { readonly path: string; readonly type: 'change' | 'add' | 'unlink' }
+
 export type Allowed = {
   allows(value: string): boolean
 }
@@ -237,15 +111,36 @@ export type SettingsFile = {
   update(values: Readonly<Record<string, unknown>>): Promise<void>
 }
 
-export type Setting = Pick<ConfigRow, 'key' | 'label' | 'kind' | 'value' | 'isLocked'> & {
+export type SettingsFileChange = { readonly source: 'user' | 'project' | 'local' | 'policy' | 'skills'; readonly path?: string }
+
+export type SettingsFileChangeListener = (change: SettingsFileChange) => { readonly refuse: string } | void | Promise<{ readonly refuse: string } | void>
+
+export type ConfigRow = Pick<ClaudeConfigRow, 'key' | 'label' | 'kind' | 'value' | 'isLocked'> & {
   readonly description?: string
   readonly options?: readonly string[]
   readonly plugin?: string
 }
 
+export type CommandInfo = { readonly name: string; readonly description: string; readonly source: 'builtin' | 'plugin' | 'user' | 'mcp'; readonly plugin?: string }
+
+export type CommandRunResult = { readonly text?: string; readonly note?: string }
+
 export type Imports = {
   readonly sessions: Sessions
-  readonly settings: { list(): Promise<Setting[]>; readonly user: SettingsFile; readonly project: SettingsFile; readonly local: SettingsFile }
+  readonly commands: {
+    list(): Promise<CommandInfo[]>
+    run(name: string, args?: string): Promise<CommandRunResult>
+    readonly beforeRun: BeforeMethod<CommandRun, CommandRunAnswer>
+    readonly onRun: OnMethod<CommandRun>
+  }
+  readonly config: { list(): Promise<ConfigRow[]> }
+  readonly settings: {
+    readonly user: SettingsFile
+    readonly project: SettingsFile
+    readonly local: SettingsFile
+    beforeFileChange(listener: SettingsFileChangeListener): Disposable
+    beforeFileChange(matcher: Matcher<SettingsFileChange>, listener: SettingsFileChangeListener): Disposable
+  }
   readonly model: { complete(request: ModelCompleteRequest, options?: ModelCompleteOptions): Promise<ModelCompleteResult> }
   readonly fs: {
     read(path: string): Promise<string>
@@ -254,6 +149,7 @@ export type Imports = {
     find(glob: string | readonly string[]): Promise<readonly FileMatch[]>
     list(path?: string): Promise<Entry[]>
     stat(path: string, options?: FsStatOptions): Promise<Stat>
+    onChange(matcher: { readonly path: string | readonly string[] }, listener: (change: FileChange) => unknown): Disposable
   }
   readonly metadata: {
     read(path: string): Promise<Metadata>
@@ -271,16 +167,26 @@ export const sessions: Imports['sessions'] = {
     return bound().sessions.current
   },
   list: (options) => bound().sessions.list(options),
-  search: (text, options) => bound().sessions.search(text, options),
-  on: ((...args: Parameters<Imports['sessions']['on']>) => bound().sessions.on(...args)) as Imports['sessions']['on'],
-  before: ((...args: Parameters<Imports['sessions']['before']>) => bound().sessions.before(...args)) as Imports['sessions']['before'],
+  search: (text, matcher, options) => bound().sessions.search(text, matcher, options),
+  ...(Object.fromEntries(Object.keys(sessionEvents).map((named) => [`on${named}`, (...args: unknown[]) => (bound().sessions[`on${named}` as keyof OnMethods] as (...each: unknown[]) => Disposable)(...args)])) as OnMethods),
 }
 
 export const settings: Imports['settings'] = {
-  list: () => bound().settings.list(),
   user: { read: () => bound().settings.user.read(), update: (values) => bound().settings.user.update(values) },
   project: { read: () => bound().settings.project.read(), update: (values) => bound().settings.project.update(values) },
   local: { read: () => bound().settings.local.read(), update: (values) => bound().settings.local.update(values) },
+  beforeFileChange: ((matcherOrListener: never, listener?: never) => bound().settings.beforeFileChange(matcherOrListener, listener as never)) as Imports['settings']['beforeFileChange'],
+}
+
+export const commands: Imports['commands'] = {
+  list: () => bound().commands.list(),
+  run: (name, args) => bound().commands.run(name, args),
+  beforeRun: ((...args: never[]) => (bound().commands.beforeRun as (...each: never[]) => Disposable)(...args)) as Imports['commands']['beforeRun'],
+  onRun: ((...args: never[]) => (bound().commands.onRun as (...each: never[]) => Disposable)(...args)) as Imports['commands']['onRun'],
+}
+
+export const config: Imports['config'] = {
+  list: () => bound().config.list(),
 }
 
 export const model: Imports['model'] = {
@@ -294,6 +200,7 @@ export const fs: Imports['fs'] = {
   find: (glob) => bound().fs.find(glob),
   list: (path) => bound().fs.list(path),
   stat: (path, options) => bound().fs.stat(path, options),
+  onChange: (matcher, listener) => bound().fs.onChange(matcher, listener),
 }
 
 export const metadata: Imports['metadata'] = {
@@ -317,12 +224,10 @@ export type Mod<State extends object = Record<never, never>, Declared extends Op
   readonly state: Readonly<State>
   readonly options: OptionValues<Declared>
   readonly permissions: Permissions
-  on<H extends Hook>(hook: H, listener: HookListener<H>, options?: HookOptions): Disposable
-  on<H extends Hook>(hook: H, matcher: Matcher<HookInput<H>>, listener: HookListener<H>, options?: HookOptions): Disposable
   every(ms: number, listener: () => unknown): Disposable
   after(ms: number, listener: () => unknown): Disposable
   use<Handle>(job: Job<Handle, State>): Handle
-  log(text: string): void
+  log(text: string, options?: { readonly to?: 'debug' | 'transcript' }): void
   readonly ui: {
     pane(pane: Pane<State>): PaneHandle
     render<P extends Place>(place: P, Component: (props: PlaceProps<P>) => RenderElement): Disposable
@@ -378,21 +283,21 @@ export function defineMod<State extends StateGroups = Record<never, never>, Name
 export type { Matcher } from './utils/matcher.js'
 export type { Place, PlaceProps } from './ui/places.js'
 export { AbovePrompt, AskUserQuestion, CommandOutput, PromptHint, SessionMode, Spinner, ToolGroup, ToolProgress, TurnDuration } from './ui/places.js'
-export { Session, UsageChange, type BeforeAnswer, type BeforeEvent, type BeforeListener, type Client, type Listener, type RecordPart, type Refusal, type SearchOptions, type SessionEvent, type SessionPayload, type SessionScope, type SessionSend, type Sessions, type TaskStartArgs, type ToolCallArgs, type Usage } from './session/session.js'
-export { ContextEnd, ContextStart, type Context } from './session/context/context.js'
-export { TurnEnd, TurnStart, type Turn } from './session/context/turn/turn.js'
-export { Message, type MessageType } from './session/context/turn/message/message.js'
+export { Session, type AnswerOptions, type BeforeMethods, type Surface, type Listener, type ListenerTime, type OnMethods, type ReadOptions, type RecordPart, type Refusal, type SearchOptions, type SessionScope, type SessionSend, type Sessions, type CurrentSession, type Placement, type ProjectSetup, type SessionStartAsked, type SessionStarted, type SessionEnded, type ModelChange, type CwdChange, type DirectoryAdd, type Worktree, type Notification, type Elicitation, type ElicitationResponse, type McpServer, type PermissionUpdate, type PermissionCheck, type PermissionRequest, type PermissionDenial, type BatchedCall, type ToolBatch, type Todo, type ReplyDisplay, type TaskOwner, type TaskStartArgs, type ToolCallArgs, type Usage, type CommandRun, type CommandRunAnswer } from './session/session.js'
+export type { Context } from './session/context/context.js'
+export type { Turn } from './session/context/turn/turn.js'
+export type { Message, MessageType } from './session/context/turn/message/message.js'
 export { Prompt } from './session/context/turn/message/prompt.js'
 export { Note } from './session/context/turn/message/note.js'
 export { Reply } from './session/context/turn/message/reply.js'
 export { ToolCall } from './session/context/turn/message/tool-call.js'
 export { ToolResult } from './session/context/turn/message/tool-result.js'
 export { Skill } from './session/context/turn/message/skill.js'
-export { Document } from './session/context/turn/message/document.js'
+export { InstructionFile } from './session/context/turn/message/instruction-file.js'
 export { Notice } from './session/context/turn/message/notice.js'
-export { Channel, Person, Schedule, Sdk, type Sender, type SenderType } from './session/context/turn/message/sender.js'
-export { GoalChange, type Goal } from './session/goal/goal.js'
-export { Task, TaskEnd, TaskStart } from './session/goal/task.js'
+export { Channel, Engine, Person, Schedule, Sdk, type Sender, type SenderType } from './session/context/turn/message/sender.js'
+export type { Goal } from './session/goal/goal.js'
+export { Task } from './session/goal/task.js'
 export { longestMs } from './runtime/deadline.js'
 export { notInstalled } from './runtime/dependencies.js'
 export { messageOf } from './utils/text.js'

package/src/records.ts

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

package/src/register.ts

@@ -70,8 +70,9 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
       send: (args) => $.session.send(args),
     },
     prompt: { submit: (args) => $.prompt.submit(args) },
+    turn: { abort: (args) => $.turn.abort(args) },
     model: { complete: (request, options) => $.model.complete(request, options) },
-    command: { register: (command) => $.command.register(command) },
+    command: { register: (command) => $.command.register(command), list: () => $.command.list(), run: (args) => $.command.run(args) },
     tool: { register: (tool) => $.tool.register(tool), call: (input: ToolCallArgs) => $.tool.call(input) },
     agent: {
       list: () => $.agent.list(),
@@ -149,6 +150,7 @@ export function registerMod<State extends object, Declared extends Options>(addH
   addHook('session.receive', routeToMod)
   addHook('agent.spawn', routeToMod)
   addHook('prompt.attachment', routeToMod)
+  addHook('turn.start', routeToMod)
 }
 
 export function registerPermissionCheck(addHook: On): void {

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 { 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,39 @@ 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 { Task, TaskStart } from '../session/goal/task.js'
 import type { BeforeEvent } 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'
 
-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 +61,50 @@ 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 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 +119,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 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 +145,7 @@ 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 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))
       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 +153,36 @@ 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) => {
+      spawned.set(e.tool_use_id, e.prompt)
       if (!(await wants(TaskStart))) return next(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 }
+      if (answer.refuse !== undefined) {
+        spawned.delete(e.tool_use_id)
+        return { deny: answer.refuse }
+      }
       return next(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) => {
+      if (!(await wants(TurnEnd))) return next(e)
+      const turn = (await place()).taskTurns[e.agent_id]
+      if (turn === undefined) return 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 answer.refuse === undefined ? below : { ...below, block: answer.refuse }
     }),
     router.add('classic.Stop', async (e, next) => {
       if (!(await wants(TurnEnd))) return next(e)
@@ -154,6 +206,7 @@ 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 } }
@@ -167,7 +220,8 @@ export async function foldAnswers(event: BeforeEvent, change: SessionChange, ask
     try {
       const answer = answerOf(event, await ask(latest))
       if (answer === undefined) continue
-      result = { ...result, ...answer }
+      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)
     } catch (error) {
@@ -181,16 +235,15 @@ export function answerOf(event: BeforeEvent, answer: unknown): Partial<Answers>
   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'],
+    prompt: ['text', 'note', 'title', 'refuse'],
     note: ['text'],
     skill: ['text'],
-    document: ['text', 'refuse'],
+    instructionFile: ['text', 'refuse'],
     reply: ['text'],
     toolCall: ['input', 'result', 'refuse'],
-    toolResult: ['text'],
+    toolResult: ['output', 'isError', 'note'],
     notice: ['text'],
     taskStart: ['owner', 'refuse'],
-    taskEnd: ['refuse'],
     turnEnd: ['refuse'],
     contextEnd: ['refuse'],
   }

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