@cmodjs/core 1.6.0 → 2.0.1

package/src/session/session.ts

@@ -1,7 +1,8 @@
 import type { Disposable } from '../utils/disposable.js'
 import type { Matcher } from '../utils/matcher.js'
+import type { Sender } from './context/turn/message/sender.js'
 import type { Context, ContextEnd, ContextStart } from './context/context.js'
-import type { Document } from './context/turn/message/document.js'
+import type { InstructionFile } from './context/turn/message/instruction-file.js'
 import type { Message, MessageType } from './context/turn/message/message.js'
 import type { Note } from './context/turn/message/note.js'
 import type { Notice } from './context/turn/message/notice.js'
@@ -29,7 +30,7 @@ export type SessionPayload = {
   readonly toolCall: ToolCall
   readonly toolResult: ToolResult
   readonly skill: Skill
-  readonly document: Document
+  readonly instructionFile: InstructionFile
   readonly notice: Notice
   readonly contextStart: Context
   readonly contextEnd: Context
@@ -44,16 +45,15 @@ export type SessionPayload = {
 export type Refusal = { readonly refuse: string }
 
 export type BeforeAnswer = {
-  readonly prompt: { readonly text: string } | Refusal
+  readonly prompt: { readonly text?: string; readonly note?: string; readonly title?: string } | Refusal
   readonly note: { readonly text: string }
   readonly skill: { readonly text: string }
-  readonly document: { readonly text: string } | Refusal
+  readonly instructionFile: { readonly text: string } | Refusal
   readonly reply: { readonly text: string }
   readonly toolCall: { readonly input: Readonly<Record<string, unknown>> } | { readonly result: string } | Refusal
-  readonly toolResult: { readonly text: string }
+  readonly toolResult: { readonly output?: unknown; readonly isError?: true; readonly note?: string }
   readonly notice: { readonly text: string }
   readonly taskStart: { readonly owner: { readonly model: string } } | Refusal
-  readonly taskEnd: Refusal
   readonly turnEnd: Refusal
   readonly contextEnd: Refusal
 }
@@ -62,29 +62,70 @@ export type BeforeEvent = keyof BeforeAnswer
 
 export type Usage = {
   readonly model: string
-  readonly context: { readonly tokens?: number; readonly window?: number; readonly percent?: number }
+  readonly contextWindow: { readonly tokenCount?: number; readonly size?: number; readonly percent?: number }
   readonly cost?: { readonly usd: number }
 }
 
-export type Client = 'terminal' | 'desktop' | 'mobile' | 'vscode'
+export type Surface = 'terminal' | 'desktop' | 'mobile' | 'vscode'
 
-export type Listener<Event extends SessionEvent> = (payload: SessionPayload[Event]) => unknown
+export const sessionEvents = {
+  Message: 'message',
+  Prompt: 'prompt',
+  Note: 'note',
+  Reply: 'reply',
+  ToolCall: 'toolCall',
+  ToolResult: 'toolResult',
+  Skill: 'skill',
+  InstructionFile: 'instructionFile',
+  Notice: 'notice',
+  ContextStart: 'contextStart',
+  ContextEnd: 'contextEnd',
+  TurnStart: 'turnStart',
+  TurnEnd: 'turnEnd',
+  TaskStart: 'taskStart',
+  TaskEnd: 'taskEnd',
+  GoalChange: 'goalChange',
+  UsageChange: 'usageChange',
+} as const satisfies Readonly<Record<string, SessionEvent>>
 
-export type BeforeListener<Event extends BeforeEvent> = (payload: SessionPayload[Event]) => BeforeAnswer[Event] | void | Promise<BeforeAnswer[Event] | void>
+export const beforeEvents = ['Prompt', 'Note', 'Skill', 'InstructionFile', 'Reply', 'ToolCall', 'ToolResult', 'Notice', 'TaskStart', 'TurnEnd', 'ContextEnd'] as const satisfies readonly (keyof typeof sessionEvents)[]
 
-export type SearchOptions = {
-  readonly limit?: number
-  readonly before?: Pick<Message, 'session' | 'id'>
+export type EventName = keyof typeof sessionEvents
+
+export type BeforeName = (typeof beforeEvents)[number]
+
+export type PayloadOf<Name extends EventName> = SessionPayload[(typeof sessionEvents)[Name]]
+
+export type AnswerOf<Name extends BeforeName> = (typeof sessionEvents)[Name] extends BeforeEvent ? BeforeAnswer[(typeof sessionEvents)[Name]] : never
+
+export type ReadOptions = { readonly timeoutMs?: number }
+
+export type AnswerOptions = ReadOptions & { readonly onFailure?: 'pass' | 'refuse' }
+
+export type ListenerTime = { readonly deadline: number; readonly signal: AbortSignal }
+
+export type Listener<Payload, Answer = void> = (payload: Payload, time: ListenerTime) => Answer | void | Promise<Answer | void>
+
+export type OnMethod<Payload> = {
+  (listener: Listener<Payload, unknown>, options?: ReadOptions): Disposable
+  (matcher: Matcher<Payload>, listener: Listener<Payload, unknown>, options?: ReadOptions): Disposable
 }
 
-export type RecordPart = {
-  search(text: string, options?: SearchOptions): Promise<Message[]>
-  on<Event extends SessionEvent>(event: Event, listener: Listener<Event>): Disposable
-  on<Event extends SessionEvent>(event: Event, matcher: Matcher<SessionPayload[Event]>, listener: Listener<Event>): Disposable
-  before<Event extends BeforeEvent>(event: Event, listener: BeforeListener<Event>): Disposable
-  before<Event extends BeforeEvent>(event: Event, matcher: Matcher<SessionPayload[Event]>, listener: BeforeListener<Event>): Disposable
+export type BeforeMethod<Payload, Answer> = {
+  (listener: Listener<Payload, Answer>, options?: AnswerOptions): Disposable
+  (matcher: Matcher<Payload>, listener: Listener<Payload, Answer>, options?: AnswerOptions): Disposable
 }
 
+export type OnMethods = { readonly [Name in EventName as `on${Name}`]: OnMethod<PayloadOf<Name>> }
+
+export type BeforeMethods = { readonly [Name in BeforeName as `before${Name}`]: BeforeMethod<PayloadOf<Name>, AnswerOf<Name>> }
+
+
+export type RecordPart = OnMethods &
+  BeforeMethods & {
+    search(text: string, matcher?: Matcher<Message>): AsyncIterable<Message>
+  }
+
 export type SessionSend = {
   readonly type: typeof Prompt | typeof Note
   readonly text: string
@@ -95,6 +136,7 @@ export type TaskStartArgs = {
   readonly prompt: string
   readonly agentType?: string
   readonly model?: string
+  readonly title: string
   readonly name?: string
   readonly cwd?: string
 }
@@ -115,7 +157,7 @@ export type Session = RecordPart & {
   readonly startedAt: string
   readonly lastAt: string
   readonly forkedFrom?: string
-  goal(): Promise<Goal>
+  readonly goal: Goal
   context(): Promise<Context>
   contexts(): Promise<Context[]>
   turn(): Promise<Turn | undefined>
@@ -125,17 +167,178 @@ export type Session = RecordPart & {
   startTask(task: TaskStartArgs): Promise<Task>
   callTool(call: ToolCallArgs): Promise<ToolResult>
   usage(): Promise<Usage>
-  clients(): Promise<Client[]>
+  surfaces(): Promise<Surface[]>
 }
 
+export type TaskOwner = Omit<Session, 'startTask' | 'callTool'>
+
+type ProcessEvent = { readonly on: string; readonly before?: string }
+
+export const processEvents = {
+  ProjectSetup: { on: 'Setup', before: 'Setup' },
+  SessionStart: { on: 'SessionStart', before: 'SessionStart' },
+  SessionEnd: { on: 'SessionEnd' },
+  ModelChange: { on: 'PostModelSwitch', before: 'PreModelSwitch' },
+  CwdChange: { on: 'CwdChanged' },
+  DirectoryAdd: { on: 'DirectoryAdded' },
+  WorktreeCreate: { on: 'WorktreeCreate', before: 'WorktreeCreate' },
+  WorktreeRemove: { on: 'WorktreeRemove' },
+  Notification: { on: 'Notification' },
+  Elicitation: { on: 'Elicitation', before: 'Elicitation' },
+  ElicitationResponse: { on: 'ElicitationResult', before: 'ElicitationResult' },
+  PermissionCheck: { on: 'tool.check', before: 'tool.check' },
+  PermissionRequest: { on: 'PermissionRequest', before: 'PermissionRequest' },
+  PermissionDenial: { on: 'PermissionDenied', before: 'PermissionDenied' },
+  ToolBatch: { on: 'PostToolBatch', before: 'PostToolBatch' },
+  TodoCreate: { on: 'TaskCreated', before: 'TaskCreated' },
+  TodoComplete: { on: 'TaskCompleted', before: 'TaskCompleted' },
+  ReplyDisplay: { on: 'MessageDisplay', before: 'MessageDisplay' },
+} as const satisfies Readonly<Record<string, ProcessEvent>>
+
+export type Placement = {
+  readonly session: string
+  readonly task?: string
+  readonly agentType?: string
+  readonly cwd: string
+  readonly permissionMode?: string
+}
+
+export type SessionStartAsked = Placement & {
+  readonly source: 'startup' | 'resume' | 'clear' | 'fork' | 'compact'
+  readonly model?: string
+  readonly title?: string
+  readonly idleSeconds?: number
+  readonly contextTokenCount?: number
+  readonly isCacheWarm?: boolean
+  readonly cacheWriteUsd?: number
+}
+
+export type SessionStarted = Omit<SessionStartAsked, 'source'> & { readonly source: 'startup' | 'resume' | 'clear' | 'fork' }
+
+export type ProjectSetup = Placement & { readonly trigger: 'init' | 'maintenance' }
+
+export type SessionEnded = Placement & { readonly reason: 'clear' | 'resume' | 'logout' | 'exit' | 'other' }
+
+export type ModelChange = Placement & {
+  readonly model: string
+  readonly previous: string
+  readonly requested?: string
+  readonly source: 'command' | 'picker' | 'sdk' | 'auto' | 'resume'
+  readonly contextTokenCount: number
+  readonly isCacheWarm: boolean
+  readonly cacheTtl: '5m' | '1h'
+  readonly cacheWriteUsd: number
+  readonly pricing?: 'configured' | 'catalog' | 'default'
+}
+
+export type CwdChange = Placement & { readonly previous: string }
+
+export type DirectoryAdd = Placement & { readonly directory: string; readonly source: 'command' | 'sdk' }
+
+export type Worktree = Placement & { readonly name?: string; readonly path?: string }
+
+export type Notification = Placement & { readonly text: string; readonly title?: string; readonly type: string }
+
+export type Elicitation = Placement & { readonly id?: string; readonly server: string; readonly text: string; readonly mode?: 'form' | 'url'; readonly url?: string; readonly schema?: Readonly<Record<string, unknown>> }
+
+export type ElicitationResponse = Placement & { readonly id?: string; readonly server: string; readonly mode?: 'form' | 'url'; readonly action: 'accept' | 'decline' | 'cancel'; readonly content?: Readonly<Record<string, unknown>> }
+
+export type McpServer = { readonly name: string; readonly source: string }
+
+type PermissionRules = { readonly rules: readonly { readonly toolName: string; readonly ruleContent?: string }[]; readonly behavior: 'allow' | 'deny' | 'ask' }
+
+type PermissionDestination = { readonly destination: 'userSettings' | 'projectSettings' | 'localSettings' | 'session' | 'cliArg' }
+
+export type PermissionUpdate = PermissionDestination &
+  (
+    | (PermissionRules & { readonly type: 'addRules' | 'replaceRules' | 'removeRules' })
+    | { readonly type: 'setMode'; readonly mode: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk' | 'auto' }
+    | { readonly type: 'addDirectories' | 'removeDirectories'; readonly directories: readonly string[] }
+  )
+
+export type PermissionCheck = Placement & {
+  readonly name: string
+  readonly input: Readonly<Record<string, unknown>>
+  readonly callId?: string
+  readonly decision: 'allow' | 'ask' | 'refuse'
+  readonly reason?: string
+  readonly rule?: string
+  readonly ceiling?: 'allow' | 'ask' | 'refuse'
+}
+
+export type PermissionRequest = Placement & { readonly name: string; readonly input: Readonly<Record<string, unknown>>; readonly suggestions: readonly PermissionUpdate[]; readonly mcpServer?: McpServer }
+
+export type PermissionDenial = Placement & { readonly name: string; readonly input: Readonly<Record<string, unknown>>; readonly callId: string; readonly reason: string; readonly mcpServer?: McpServer }
+
+export type BatchedCall = { readonly callId: string; readonly name: string; readonly input: Readonly<Record<string, unknown>>; readonly output?: unknown }
+
+export type ToolBatch = Placement & { readonly calls: readonly BatchedCall[] }
+
+export type Todo = Placement & { readonly id: string; readonly subject: string; readonly description?: string; readonly teammate?: string }
+
+export type ReplyDisplay = Placement & { readonly replyId: string; readonly index: number; readonly isLast: boolean; readonly text: string }
+
+export type CommandRun = Placement & { readonly name: string; readonly args: string; readonly source?: 'builtin' | 'plugin' | 'user' | 'mcp'; readonly from: Sender }
+
+export type CommandRunAnswer = { readonly args?: string; readonly note?: string } | { readonly result: string; readonly exitCode?: number } | Refusal
+
+export type ProcessPayload = {
+  readonly ProjectSetup: ProjectSetup
+  readonly SessionStart: SessionStarted
+  readonly SessionEnd: SessionEnded
+  readonly ModelChange: ModelChange
+  readonly CwdChange: CwdChange
+  readonly DirectoryAdd: DirectoryAdd
+  readonly WorktreeCreate: Worktree
+  readonly WorktreeRemove: Worktree
+  readonly Notification: Notification
+  readonly Elicitation: Elicitation
+  readonly ElicitationResponse: ElicitationResponse
+  readonly PermissionCheck: PermissionCheck
+  readonly PermissionRequest: PermissionRequest
+  readonly PermissionDenial: PermissionDenial
+  readonly ToolBatch: ToolBatch
+  readonly TodoCreate: Todo
+  readonly TodoComplete: Todo
+  readonly ReplyDisplay: ReplyDisplay
+}
+
+export type ProcessAsked = Omit<ProcessPayload, 'SessionStart'> & { readonly SessionStart: SessionStartAsked }
+
+export type ProcessAnswer = {
+  readonly ProjectSetup: Record<never, never>
+  readonly SessionStart: { readonly note?: string; readonly title?: string; readonly reloadSkills?: true; readonly firstPrompt?: string }
+  readonly ModelChange: { readonly ask: string } | Refusal
+  readonly WorktreeCreate: { readonly result: string }
+  readonly Elicitation: Refusal
+  readonly ElicitationResponse: Refusal
+  readonly PermissionCheck: { readonly allow: true } | { readonly ask: string } | Refusal
+  readonly PermissionRequest: { readonly allow: true; readonly input?: Readonly<Record<string, unknown>>; readonly updates?: readonly PermissionUpdate[] } | (Refusal & { readonly interrupt?: true })
+  readonly PermissionDenial: { readonly retry: true }
+  readonly ToolBatch: { readonly note: string }
+  readonly TodoCreate: Refusal
+  readonly TodoComplete: Refusal
+  readonly ReplyDisplay: { readonly text: string }
+}
+
+export type ProcessName = keyof typeof processEvents
+
+export type ProcessOnMethods = { readonly [Name in ProcessName as `on${Name}`]: OnMethod<ProcessPayload[Name]> }
+
+export type ProcessBeforeMethods = { readonly [Name in keyof ProcessAnswer as `before${Name}`]: BeforeMethod<ProcessAsked[Name], ProcessAnswer[Name]> }
+
+export type CurrentSession = Session & ProcessOnMethods & ProcessBeforeMethods
+
 export type SessionScope = {
   readonly running?: boolean
   readonly since?: string
   readonly everyProject?: boolean
 }
 
-export type Sessions = Omit<RecordPart, 'search'> & {
-  readonly current: Session
+export type SearchOptions = SessionScope & { readonly before?: Pick<Message, 'session' | 'id'> }
+
+export type Sessions = OnMethods & {
+  readonly current: CurrentSession
   list(options?: SessionScope): Promise<Session[]>
-  search(text: string, options?: SessionScope & SearchOptions): Promise<Message[]>
+  search(text: string, matcher?: Matcher<Message>, options?: SearchOptions): AsyncIterable<Message>
 }

package/src/testing/claude-code.ts

@@ -0,0 +1,23 @@
+import type { Args, ClassicHookInputs, EventResult } from 'claude-code'
+import type { Hook, RoutedEvent } from '../runtime/hooks.js'
+
+type FilledField = 'session_id' | 'transcript_path' | 'cwd' | 'hook_event_name' | 'tool_use_id'
+
+export type HookInputOf<H extends Hook | 'PreToolUse'> = Omit<ClassicHookInputs[H], FilledField> & Partial<Pick<ClassicHookInputs[H], FilledField & keyof ClassicHookInputs[H]>>
+
+export type ClaudeCode = {
+  fire<H extends Hook | 'PreToolUse'>(hook: H, input: HookInputOf<H>, below?: EventResult<`classic.${H}`>): Promise<EventResult<`classic.${H}`>>
+  fire<N extends RoutedEvent>(event: N, input: Args<N>, below?: EventResult<N>): Promise<EventResult<N>>
+}
+
+const drivers = new WeakMap<object, ClaudeCode>()
+
+export function keepClaudeCode(tested: object, driver: ClaudeCode): void {
+  drivers.set(tested, driver)
+}
+
+export function claudeCodeOf(tested: object): ClaudeCode {
+  const driver = drivers.get(tested)
+  if (driver === undefined) throw new Error('claudeCodeOf takes a mod testMod returned.')
+  return driver
+}

package/src/testing/fake-claude.ts

@@ -15,6 +15,7 @@ export type Fakes = {
   http: { fetch?: Claude['http']['fetch'] }
   settings: { read?: Claude['settings']['read'] }
   config: { list?: Claude['config']['list'] }
+  command: { list?: Claude['command']['list']; run?: Claude['command']['run'] }
   ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open']; scroll?: Claude['ui']['scroll']; copy?: Claude['ui']['copy']; focus?: Claude['ui']['focus'] }
   session: { messages?: Claude['session']['messages']; append?: Claude['session']['append']; send?: Claude['session']['send'] }
   prompt: { submit?: Claude['prompt']['submit'] }
@@ -55,7 +56,7 @@ export function calledAnswer(caller: string, answer: EventResult<'cmod.call'>):
 
 export function fakeClaude(plugin: { readonly name: string; readonly root: string }): FakeClaude {
   const calls: TestCall[] = []
-  const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, config: {}, ui: {}, session: {}, prompt: {}, model: {}, agent: {}, clock: {}, cmod: {}, tool: {} }
+  const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, config: {}, command: {}, ui: {}, session: {}, prompt: {}, model: {}, agent: {}, clock: {}, cmod: {}, tool: {} }
   const emptyDisk = fakeFiles({})
   const shown: Shown = { notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
   const unplacedPanes = new Set<string>()
@@ -190,12 +191,15 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       send: rejected('session.send', () => fakes.session.send ?? (async () => ({ isDelivered: true as const }))),
     },
     prompt: { submit: rejected('prompt.submit', () => fakes.prompt.submit ?? submitPrompt) },
+    turn: { abort: rejected('turn.abort', () => async () => undefined) },
     model: { complete: rejected('model.complete', () => fakes.model.complete) },
     command: {
       register: async (command) => {
         shown.commands.push(command.name)
         return { command: command.name }
       },
+      list: rejected('command.list', () => fakes.command.list ?? (async () => shown.commands.map((name) => ({ name, description: '', source: 'plugin' as const, plugin: plugin.name })))),
+      run: rejected('command.run', () => fakes.command.run ?? (async () => ({}))),
     },
     tool: {
       register: async (tool) => {

package/src/testing/fake-sessions.ts

@@ -1,6 +1,6 @@
 import { isObject } from '../records.js'
-import { Document } from '../session/context/turn/message/document.js'
-import { Message, searchText, skillPrefix, type Row } from '../session/context/turn/message/message.js'
+import { InstructionFile } from '../session/context/turn/message/instruction-file.js'
+import { Message, messagesOf, noFiles, searchText, skillPrefix, type Row } 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'
@@ -11,7 +11,7 @@ import { Task } from '../session/goal/task.js'
 import { Skill } from '../session/context/turn/message/skill.js'
 import { ToolCall } from '../session/context/turn/message/tool-call.js'
 import { ToolResult } from '../session/context/turn/message/tool-result.js'
-import { createConversation, emptyConversation, searchLimit, type ContextData, type Conversation, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
+import { createConversation, emptyConversation, searchLimit, type ContextData, type Conversation, type SessionChange, type SessionData, type TaskData, type TurnData, type TurnEnding } from '../session/conversation.js'
 import type { Place } from '../runtime/before.js'
 import type { Claude } from '../runtime/claude.js'
 import { conversationMethods, everySession, isHeardBy, resultOf, type Subscription } from '../runtime/sessions.js'
@@ -23,9 +23,9 @@ export type MessageDraft =
   | { readonly type: typeof Note; readonly text: string; readonly from?: Sender }
   | { readonly type: typeof Reply; readonly text: string }
   | { readonly type: typeof ToolCall; readonly name: string; readonly input?: Readonly<Record<string, unknown>>; readonly callId?: string }
-  | { readonly type: typeof ToolResult; readonly callId: string; readonly text: string; readonly isError?: boolean }
+  | { readonly type: typeof ToolResult; readonly callId: string; readonly output: string; readonly isError?: boolean }
   | { readonly type: typeof Skill; readonly name: string; readonly text: string }
-  | { readonly type: typeof Document; readonly path: string; readonly text: string }
+  | { readonly type: typeof InstructionFile; readonly path: string; readonly text: string }
   | { readonly type: typeof Notice; readonly text: string }
 
 export type FakeSession = Partial<Omit<SessionData, 'id'>> & {
@@ -49,16 +49,17 @@ type Heard = { readonly event: Subscription['event']; readonly matcher: unknown
 export type FakeSessions = {
   answer(caller: string, method: string, input: unknown): unknown
   add(draft: MessageDraft, task?: string): Message[]
+  draft(draft: MessageDraft, task?: string): Message
   place(): Place
   wants(mod: string, event: string): boolean
-  endTurn(): void
+  endTurn(ending?: TurnEnding): void
   compact(): void
   startTask(task: { readonly title: string; readonly agentType?: string; readonly model?: string; readonly openedBy?: string; readonly parent?: string }): string
   start(id: string): void
   readonly sent: { readonly session: string; readonly task?: string; readonly type: string; readonly text: string; readonly as?: string }[]
 }
 
-export function fakeSessions({ project, given, push, callTool }: { readonly project: () => string; readonly given: readonly FakeSession[]; readonly push: (mod: string, session: string, change: SessionChange) => void; readonly callTool: Claude['tool']['call'] }): FakeSessions {
+export function fakeSessions({ project, cwd, given, push, callTool }: { readonly project: () => string; readonly cwd: () => string; readonly given: readonly FakeSession[]; readonly push: (mod: string, session: string, change: SessionChange) => void; readonly callTool: Claude['tool']['call'] }): FakeSessions {
   const kept = new Map<string, Kept>()
   const heard = new Map<string, Map<string, readonly Heard[]>>()
   const watches = new Map<string, Map<string, readonly string[]>>()
@@ -90,7 +91,7 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
 
   const add = (session: Kept, draft: MessageDraft, task?: string) => {
     const before = session.messages.length
-    record(session, session.conversation.add(rowOf(draft, `message-${(ids += 1)}`, now()), task))
+    record(session, session.conversation.add(rowOf(draft, `message-${(ids += 1)}`, now(), cwd()), task))
     return session.messages.slice(before)
   }
 
@@ -109,8 +110,8 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
   const currentSession = () => sessionOf(current)
 
   const place = (): Place => {
-    const { session, context, contextOpenedAt, turn, tasks, taskTurns } = currentSession().conversation.state
-    return { session, context, contextOpenedAt, ...(turn === undefined ? {} : { turn }), tasks, taskTurns }
+    const { session, context, contextOpenedAt, turn, tasks, taskTurns, openCalls } = currentSession().conversation.state
+    return { session, context, contextOpenedAt, ...(turn === undefined ? {} : { turn }), tasks, taskTurns, ...(openCalls === undefined ? {} : { openCalls }) }
   }
 
   const taskOf = (session: Kept, id: string) => {
@@ -144,8 +145,8 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
         const session = kept.get(message.session)
         const task = request['task']
         if (request['session'] !== undefined && message.session !== request['session']) return false
-        if (typeof task === 'string' && (message.task === undefined || !isUnder(session, message.task, task) || (request['isGoal'] === true && message.task === task))) return false
-        if (task === undefined && request['isGoal'] === true && message.task === undefined) return false
+        if (request['isAgent'] === true && message.task !== task) return false
+        if (typeof task === 'string' && (message.task === undefined || !isUnder(session, message.task, task))) return false
         return (request['turn'] === undefined || message.turn === request['turn']) && (request['context'] === undefined || message.context === request['context'])
       }
       const found = [...kept.values()]
@@ -155,7 +156,7 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
         .toSorted((first, second) => second.at.localeCompare(first.at))
       const before = isObject(request['before']) ? request['before'] : undefined
       const start = before === undefined ? 0 : found.findIndex((message) => message.session === before['session'] && message.id === before['id']) + 1
-      return found.slice(start, start + (typeof request['limit'] === 'number' ? request['limit'] : searchLimit))
+      return found.slice(start, start + searchLimit)
     },
     [conversationMethods.messages](request) {
       const session = sessionOf(String(request['session']))
@@ -200,21 +201,26 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
       const input = isObject(request['input']) ? request['input'] : {}
       const task = typeof request['task'] === 'string' ? request['task'] : undefined
       const isLive = task === undefined ? session.data.isRunning : session.data.isRunning && taskOf(session, task).closedAt === undefined
-      if (action === 'usage') return { model: task === undefined ? session.data.model : (taskOf(session, task).model ?? session.data.model), context: {} }
-      if (action === 'clients') return isLive ? ['terminal'] : []
+      if (action === 'usage') return { model: task === undefined ? session.data.model : (taskOf(session, task).model ?? session.data.model), contextWindow: {} }
+      if (action === 'surfaces') return isLive ? ['terminal'] : []
       if (!isLive) throw new Error(`session ${task ?? session.data.id} has ended`)
+      if (action === 'abort') {
+        const open = task === undefined ? session.conversation.state.turn : session.conversation.state.taskTurns[task]
+        if (open?.prompt.id !== input['turn']) throw new Error(`turn ${String(input['turn'])} has ended, so there is nothing to abort.`)
+        return null
+      }
       if (action === 'send') {
         sent.push({ session: session.data.id, ...(task === undefined ? {} : { task }), type: String(input['type']), text: String(input['text']), ...(typeof input['as'] === 'string' ? { as: input['as'] } : {}) })
         return null
       }
       if (action === 'startTask') {
         const id = `task-${(ids += 1)}`
-        const data: TaskData = { id, title: typeof input['name'] === 'string' ? input['name'] : '', agentType: typeof input['agentType'] === 'string' ? input['agentType'] : 'general-purpose', openedBy: '', openedAt: now(), ...(typeof input['model'] === 'string' ? { model: input['model'] } : {}) }
+        const data: TaskData = { id, title: typeof input['title'] === 'string' ? input['title'] : '', agentType: typeof input['agentType'] === 'string' ? input['agentType'] : 'general-purpose', openedBy: '', openedAt: now(), ...(typeof input['model'] === 'string' ? { model: input['model'] } : {}) }
         record(session, session.conversation.startTask(data))
         return data
       }
-      if (session.data.id === current) return resultOf(place(), await callTool({ ...input['input'] as object, tool: String(input['name']) } as never))
-      return { id: '', type: ToolResult, at: now(), session: session.data.id, context: session.conversation.state.context, callId: '', text: '', isError: false }
+      if (session.data.id === current) return resultOf(place(), { name: String(input['name']), input: input['input'] as Readonly<Record<string, unknown>>, cwd: project() }, await callTool({ ...input['input'] as object, tool: String(input['name']) } as never))
+      return { id: '', type: ToolResult, at: now(), session: session.data.id, context: session.conversation.state.context, callId: '', name: '', input: {}, cwd: project(), files: noFiles, output: '', isError: false }
     },
     [conversationMethods.subscribe](request, caller) {
       const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []
@@ -236,11 +242,19 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
       }
     },
     add: (draft, task) => add(currentSession(), draft, task),
+    draft(draft, task) {
+      const where = place()
+      const [unplaced] = messagesOf(rowOf(draft, `message-${(ids += 1)}`, now(), cwd()), task !== undefined)
+      if (unplaced === undefined) throw new Error(`A ${draft.type} draft makes no message.`)
+      const call = unplaced.type === ToolResult ? where.openCalls?.[unplaced.callId] : undefined
+      const turn = task === undefined ? where.turn : where.taskTurns[task]
+      return { ...unplaced, ...call, session: where.session, context: task === undefined ? where.context : (where.tasks[task]?.context ?? where.context), ...(turn === undefined ? {} : { turn: turn.prompt.id }), ...(task === undefined ? {} : { task }) }
+    },
     place,
     wants: (mod, event) => [current, everySession].some((target) => (watches.get(mod)?.get(target) ?? []).includes(event)),
-    endTurn() {
+    endTurn(ending = {}) {
       const session = currentSession()
-      record(session, session.conversation.add({ id: `turn-end-${(ids += 1)}`, at: now(), type: 'system', name: 'turn_duration', isMeta: false, isSummary: false, content: [] }))
+      record(session, session.conversation.endTurn(now(), { reason: 'answer', ...ending }))
     },
     compact() {
       const session = currentSession()
@@ -262,16 +276,16 @@ export function fakeSessions({ project, given, push, callTool }: { readonly proj
   }
 }
 
-function rowOf(draft: MessageDraft, id: string, at: string): Row {
+function rowOf(draft: MessageDraft, id: string, at: string, cwd: string): Row {
   const base = { id, at, isMeta: false, isSummary: false }
   const text = (value: string) => [{ type: 'text', text: value }]
   const origin = (from: Sender | undefined) => (from === undefined || from.type === Person ? { kind: 'human' } : from.type === Mod ? { kind: 'plugin', name: from.name, ...(from.as === Person ? { asUser: true } : {}) } : from.type === 'session' ? { kind: 'peer' } : from.type === Task ? { kind: 'task-notification' } : { kind: from.type === Schedule ? 'scheduled-trigger' : from.type, ...(from.name === undefined ? {} : { server: from.name }) })
   if (draft.type === Prompt) return { ...base, type: 'user', content: text(draft.text), origin: origin(draft.from) }
   if (draft.type === Note) return { ...base, type: 'user', isMeta: true, content: text(draft.text), origin: origin(draft.from ?? { type: Mod, name: 'test' }) }
   if (draft.type === Reply) return { ...base, type: 'assistant', content: text(draft.text) }
-  if (draft.type === ToolCall) return { ...base, type: 'assistant', content: [{ type: 'tool_use', id: draft.callId ?? `toolu_${id}`, name: draft.name, input: draft.input ?? {} }], cwd: '/test/project' }
-  if (draft.type === ToolResult) return { ...base, type: 'user', content: [{ type: 'tool_result', tool_use_id: draft.callId, content: draft.text, ...(draft.isError === true ? { is_error: true } : {}) }] }
+  if (draft.type === ToolCall) return { ...base, type: 'assistant', content: [{ type: 'tool_use', id: draft.callId ?? `toolu_${id}`, name: draft.name, input: draft.input ?? {} }], cwd }
+  if (draft.type === ToolResult) return { ...base, type: 'user', content: [{ type: 'tool_result', tool_use_id: draft.callId, content: draft.output, ...(draft.isError === true ? { is_error: true } : {}) }] }
   if (draft.type === Skill) return { ...base, type: 'user', isMeta: true, content: text(`${skillPrefix} /skills/${draft.name}\n\n${draft.text}`) }
-  if (draft.type === Document) return { ...base, type: 'attachment', name: 'nested_memory', content: text(draft.text), path: draft.path }
+  if (draft.type === InstructionFile) return { ...base, type: 'attachment', name: 'nested_memory', content: text(draft.text), path: draft.path }
   return { ...base, type: 'system', name: 'informational', content: text(draft.text) }
 }