@cmodjs/core 0.3.0 → 1.5.0

package/src/session/session.ts

@@ -0,0 +1,141 @@
+import type { Disposable } from '../utils/disposable.js'
+import type { Matcher } from '../utils/matcher.js'
+import type { Context, ContextEnd, ContextStart } from './context/context.js'
+import type { Document } from './context/turn/message/document.js'
+import type { Message, MessageType } from './context/turn/message/message.js'
+import type { Note } from './context/turn/message/note.js'
+import type { Notice } from './context/turn/message/notice.js'
+import type { Prompt } from './context/turn/message/prompt.js'
+import type { Reply } from './context/turn/message/reply.js'
+import type { Person } from './context/turn/message/sender.js'
+import type { Skill } from './context/turn/message/skill.js'
+import type { ToolCall } from './context/turn/message/tool-call.js'
+import type { ToolResult } from './context/turn/message/tool-result.js'
+import type { Turn, TurnEnd, TurnStart } from './context/turn/turn.js'
+import type { Goal, GoalChange } from './goal/goal.js'
+import type { Task, TaskEnd, TaskStart } from './goal/task.js'
+
+export const Session = 'session'
+
+export const UsageChange = 'usageChange'
+
+export type SessionEvent = typeof Message | MessageType | typeof ContextStart | typeof ContextEnd | typeof TurnStart | typeof TurnEnd | typeof TaskStart | typeof TaskEnd | typeof GoalChange | typeof UsageChange
+
+export type SessionPayload = {
+  readonly message: Message
+  readonly prompt: Prompt
+  readonly note: Note
+  readonly reply: Reply
+  readonly toolCall: ToolCall
+  readonly toolResult: ToolResult
+  readonly skill: Skill
+  readonly document: Document
+  readonly notice: Notice
+  readonly contextStart: Context
+  readonly contextEnd: Context
+  readonly turnStart: Turn
+  readonly turnEnd: Turn
+  readonly taskStart: Task
+  readonly taskEnd: Task
+  readonly goalChange: Goal
+  readonly usageChange: Usage
+}
+
+export type Refusal = { readonly refuse: string }
+
+export type BeforeAnswer = {
+  readonly prompt: { readonly text: string } | Refusal
+  readonly note: { readonly text: string }
+  readonly skill: { readonly text: string }
+  readonly document: { 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 notice: { readonly text: string }
+  readonly taskStart: { readonly owner: { readonly model: string } } | Refusal
+  readonly taskEnd: Refusal
+  readonly turnEnd: Refusal
+  readonly contextEnd: Refusal
+}
+
+export type BeforeEvent = keyof BeforeAnswer
+
+export type Usage = {
+  readonly model: string
+  readonly context: { readonly tokens?: number; readonly window?: number; readonly percent?: number }
+  readonly cost?: { readonly usd: number }
+}
+
+export type Client = 'terminal' | 'desktop' | 'mobile' | 'vscode'
+
+export type Listener<Event extends SessionEvent> = (payload: SessionPayload[Event]) => unknown
+
+export type BeforeListener<Event extends BeforeEvent> = (payload: SessionPayload[Event]) => BeforeAnswer[Event] | void | Promise<BeforeAnswer[Event] | void>
+
+export type SearchOptions = {
+  readonly limit?: number
+  readonly before?: Pick<Message, 'session' | 'id'>
+}
+
+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 SessionSend = {
+  readonly type: typeof Prompt | typeof Note
+  readonly text: string
+  readonly as?: typeof Person | typeof Session
+}
+
+export type TaskStartArgs = {
+  readonly prompt: string
+  readonly agentType?: string
+  readonly model?: string
+  readonly name?: string
+  readonly cwd?: string
+}
+
+export type ToolCallArgs = {
+  readonly name: string
+  readonly input: Readonly<Record<string, unknown>>
+}
+
+export type Session = RecordPart & {
+  readonly id: string
+  readonly title: string
+  readonly project: string
+  readonly agentType?: string
+  readonly model: string
+  readonly cwd: string
+  readonly isRunning: boolean
+  readonly startedAt: string
+  readonly lastAt: string
+  readonly forkedFrom?: string
+  goal(): Promise<Goal>
+  context(): Promise<Context>
+  contexts(): Promise<Context[]>
+  turn(): Promise<Turn | undefined>
+  turns(options?: { readonly last?: number }): Promise<Turn[]>
+  messages(options?: { readonly after?: string; readonly last?: number }): Promise<Message[]>
+  send(message: SessionSend): Promise<void>
+  startTask(task: TaskStartArgs): Promise<Task>
+  callTool(call: ToolCallArgs): Promise<ToolResult>
+  usage(): Promise<Usage>
+  clients(): Promise<Client[]>
+}
+
+export type SessionScope = {
+  readonly running?: boolean
+  readonly since?: string
+  readonly everyProject?: boolean
+}
+
+export type Sessions = Omit<RecordPart, 'search'> & {
+  readonly current: Session
+  list(options?: SessionScope): Promise<Session[]>
+  search(text: string, options?: SessionScope & SearchOptions): Promise<Message[]>
+}

package/src/testing/fake-claude.ts

@@ -1,6 +1,8 @@
-import type { Timer } from 'claude-code'
+import type { EventResult, Timer } from 'claude-code'
+import { isObject } from '../records.js'
 import type { Claude } from '../runtime/claude.js'
 import { elements } from './fake-elements.js'
+import { fakeFiles } from './fake-files.js'
 
 export type TestCall = {
   readonly call: string
@@ -13,8 +15,8 @@ export type Fakes = {
   http: { fetch?: Claude['http']['fetch'] }
   settings: { read?: Claude['settings']['read'] }
   config: { list?: Claude['config']['list'] }
-  ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open']; scroll?: Claude['ui']['scroll'] }
-  session: { messages?: Claude['session']['messages']; append?: Claude['session']['append'] }
+  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'] }
   model: { complete?: Claude['model']['complete'] }
   agent: { list?: Claude['agent']['list']; spawn?: Claude['agent']['spawn'] }
@@ -26,7 +28,6 @@ export type Fakes = {
 export type ShownSchedule = { readonly id: string; readonly cron: string; readonly prompt: string }
 
 export type Shown = {
-  readonly toasts: string[]
   readonly notes: string[]
   readonly prompts: string[]
   readonly logs: string[]
@@ -47,10 +48,16 @@ export type FakeClaude = {
   settle(): Promise<void>
 }
 
+export function calledAnswer(caller: string, answer: EventResult<'cmod.call'>): unknown {
+  if (isObject(answer) && typeof answer['deny'] === 'string') throw new Error(`${caller}: $.cmod.call: ${answer['deny']}`)
+  return isObject(answer) ? answer['value'] : undefined
+}
+
 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 shown: Shown = { toasts: [], notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
+  const emptyDisk = fakeFiles({})
+  const shown: Shown = { notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
   const unplacedPanes = new Set<string>()
   let focusedPane: string | undefined
   const store = new Map<string, unknown>()
@@ -72,7 +79,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
 
   const appendNote: Claude['session']['append'] = async ({ message }) => {
     shown.notes.push(message.content.map((block) => (typeof block['text'] === 'string' ? block['text'] : '')).join(''))
-    return { message, uuid: `note-${shown.notes.length}` } as unknown as Awaited<ReturnType<Claude['session']['append']>>
+    return { message, uuid: `note-${shown.notes.length}` }
   }
   const submitPrompt: Claude['prompt']['submit'] = async ({ text }) => {
     shown.prompts.push(text)
@@ -98,9 +105,6 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
   const claude: Claude = {
     plugin,
     ui: {
-      toast: (text) => {
-        shown.toasts.push(text)
-      },
       status: (text) => {
         shown.statuses.push(text)
       },
@@ -115,6 +119,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
         calls.push({ call: 'ui.open', args: [pane] })
         const answer = fakes.ui.open === undefined ? { isPlaced: true as const } : await fakes.ui.open(pane)
         if (answer.isPlaced) {
+          shown.openPanes.delete(pane.id)
           shown.openPanes.add(pane.id)
           unplacedPanes.delete(pane.id)
           if (pane.focus === true) focusedPane = pane.id
@@ -130,10 +135,12 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
         if (focusedPane === pane.id) focusedPane = undefined
       },
       panes: async () => [
-        ...[...shown.openPanes].map((id) => ({ id, title: id, isShown: true, isFocused: id === focusedPane, isPlaced: true })),
+        ...[...shown.openPanes].map((id) => ({ id, title: id, isShown: id === [...shown.openPanes].at(-1), isFocused: id === focusedPane, isPlaced: true })),
         ...[...unplacedPanes].map((id) => ({ id, title: id, isShown: false, isFocused: false, isPlaced: false })),
       ],
       scroll: rejected('ui.scroll', () => fakes.ui.scroll ?? (async () => ({}))),
+      copy: rejected('ui.copy', () => fakes.ui.copy ?? (async () => ({ isCopied: true as const }))),
+      focus: rejected('ui.focus', () => fakes.ui.focus ?? (async () => ({}))),
       resolve: () => elements,
     },
     process: {
@@ -141,14 +148,14 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       spawn: faked('process.spawn', () => fakes.process.spawn),
     },
     fs: {
-      read: rejected('fs.read', () => fakes.fs.read),
-      write: rejected('fs.write', () => fakes.fs.write),
-      list: rejected('fs.list', () => fakes.fs.list),
-      exists: rejected('fs.exists', () => fakes.fs.exists ?? (async () => false)),
-      stat: rejected('fs.stat', () => fakes.fs.stat),
+      read: rejected('fs.read', () => fakes.fs.read ?? emptyDisk.read),
+      write: rejected('fs.write', () => fakes.fs.write ?? emptyDisk.write),
+      list: rejected('fs.list', () => fakes.fs.list ?? emptyDisk.list),
+      exists: rejected('fs.exists', () => fakes.fs.exists ?? emptyDisk.exists),
+      stat: rejected('fs.stat', () => fakes.fs.stat ?? emptyDisk.stat),
     },
     http: { fetch: rejected('http.fetch', () => fakes.http.fetch) },
-    settings: { read: rejected('settings.read', () => fakes.settings.read) },
+    settings: { read: rejected('settings.read', () => fakes.settings.read ?? (async () => ({}))) },
     config: {
       list: rejected('config.list', () => fakes.config.list ?? (async () => [])),
     },
@@ -176,10 +183,11 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       root: async () => plugin.root,
       cwd: async () => plugin.root,
       model: async () => 'test-model',
-      usage: async () => ({ context: { window: 200000 }, rateLimits: {}, cost: { usd: 0 } }) as unknown as Awaited<ReturnType<Claude['session']['usage']>>,
+      usage: async () => ({ startedAt: Date.parse('2026-01-01T00:00:00.000Z'), context: { window: 200000 }, rateLimits: [], cost: { usd: 0 } }),
       surfaces: async () => ['terminal'],
       messages: rejected('session.messages', () => fakes.session.messages as ((args?: unknown) => Promise<unknown>) | undefined) as Claude['session']['messages'],
       append: rejected('session.append', () => fakes.session.append ?? appendNote),
+      send: rejected('session.send', () => fakes.session.send ?? (async () => ({ isDelivered: true as const }))),
     },
     prompt: { submit: rejected('prompt.submit', () => fakes.prompt.submit ?? submitPrompt) },
     model: { complete: rejected('model.complete', () => fakes.model.complete) },

package/src/testing/fake-elements.ts

@@ -116,8 +116,9 @@ function sideBySide(children: readonly RenderNode[], width: number, gap: number)
 
 function minWidthOf(node: RenderNode): number {
   if (typeof node === 'string') return 0
-  const minWidth = insideOf(node).props['minWidth']
-  return typeof minWidth === 'number' ? minWidth : 0
+  const { props } = insideOf(node)
+  if (props['flexShrink'] === 0) return Number.POSITIVE_INFINITY
+  return typeof props['minWidth'] === 'number' ? props['minWidth'] : 0
 }
 
 function blankRows(count: number): string[] {

package/src/testing/fake-files.ts

@@ -36,7 +36,7 @@ export function fakeFiles(files: Readonly<Record<string, string>>, links: Readon
       modified.set(realPath, writes)
     },
     list: async (path) => {
-      if (path === undefined) throw new Error('fs.list() lists the working folder, which the fake files do not know. Name the folder, such as fs.list(mod.cwd).')
+      if (path === undefined) throw new Error('fs.list() lists the working folder, which the fake files do not know. Name the folder, such as fs.list(sessions.current.cwd).')
       const folder = realPathOf(path)
       if (kindOf(folder) !== 'dir') throw new Error(`ENOENT: no such directory, list '${path}'`)
       const names = new Set(below(folder).map((file) => file.split('/')[0] as string))

package/src/testing/fake-sessions.ts

@@ -0,0 +1,277 @@
+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 { 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'
+import { Reply } from '../session/context/turn/message/reply.js'
+import { Mod, Person, Schedule, type Sender } from '../session/context/turn/message/sender.js'
+import { GoalChange } from '../session/goal/goal.js'
+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 type { Place } from '../runtime/before.js'
+import type { Claude } from '../runtime/claude.js'
+import { conversationMethods, everySession, isHeardBy, resultOf, type Subscription } from '../runtime/sessions.js'
+import { receivedMatcher } from '../utils/matcher.js'
+import { firstLine, messageOf } from '../utils/text.js'
+
+export type MessageDraft =
+  | { readonly type: typeof Prompt; readonly text: string; readonly from?: Sender }
+  | { 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 Skill; readonly name: string; readonly text: string }
+  | { readonly type: typeof Document; readonly path: string; readonly text: string }
+  | { readonly type: typeof Notice; readonly text: string }
+
+export type FakeSession = Partial<Omit<SessionData, 'id'>> & {
+  readonly id: string
+  readonly messages?: readonly MessageDraft[]
+  readonly goal?: string
+}
+
+type Kept = {
+  data: SessionData
+  readonly conversation: Conversation
+  readonly messages: Message[]
+  readonly turns: Map<string, TurnData>
+  readonly contexts: Map<number, ContextData>
+  readonly tasks: Map<string, TaskData>
+}
+
+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[]
+  place(): Place
+  wants(mod: string, event: string): boolean
+  endTurn(): 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 {
+  const kept = new Map<string, Kept>()
+  const heard = new Map<string, Map<string, readonly Heard[]>>()
+  const watches = new Map<string, Map<string, readonly string[]>>()
+  const goals = new Map<string, string>()
+  const sent: FakeSessions['sent'] = []
+  let current = ''
+  let clock = Date.parse('2026-01-01T00:00:00.000Z')
+  let ids = 0
+  const now = () => new Date((clock += 1000)).toISOString()
+
+  const keep = (data: SessionData): Kept => {
+    const session: Kept = { data, conversation: createConversation(emptyConversation(data.id)), messages: [], turns: new Map(), contexts: new Map(), tasks: new Map() }
+    kept.set(data.id, session)
+    return session
+  }
+
+  const record = (session: Kept, changes: readonly SessionChange[]) => {
+    for (const change of changes) {
+      if (change.type === Message) session.messages.push(change.message)
+      if ('turn' in change) session.turns.set(change.turn.prompt.id, change.turn)
+      if ('context' in change) session.contexts.set(change.context.number, change.context)
+      if ('task' in change) session.tasks.set(change.task.id, change.task)
+      session.data = { ...session.data, lastAt: change.type === Message ? change.message.at : session.data.lastAt, ...(session.data.title === '' && change.type === Message && change.message.type === Prompt && change.message.from.type === Person ? { title: firstLine(change.message.text) } : {}) }
+      for (const [mod, sessions] of heard) {
+        if ([...(sessions.get(session.data.id) ?? []), ...(sessions.get(everySession) ?? [])].some(({ event, matcher }) => isHeardBy(event, matcher, change))) push(mod, session.data.id, change)
+      }
+    }
+  }
+
+  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))
+    return session.messages.slice(before)
+  }
+
+  for (const each of given) {
+    const session = keep({ title: '', project: project(), cwd: project(), model: 'test-model', startedAt: now(), lastAt: '', isRunning: false, ...each })
+    for (const draft of each.messages ?? []) add(session, draft)
+    if (each.goal !== undefined) record(session, session.conversation.changeGoal(each.goal))
+  }
+
+  const sessionOf = (id: string) => {
+    const session = kept.get(id)
+    if (session === undefined) throw new Error(`No Claude Code transcript is named ${id}.jsonl. Give it to testMod as { sessions: [{ id: '${id}' }] }.`)
+    return session
+  }
+
+  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 taskOf = (session: Kept, id: string) => {
+    const task = session.tasks.get(id)
+    if (task === undefined) throw new Error(`Session ${session.data.id} has no task ${id}. Start it with tested.startTask.`)
+    return task
+  }
+
+  const turnsOf = (session: Kept, task: unknown) => [...session.turns.values()].filter((turn) => turn.prompt.task === (typeof task === 'string' ? task : undefined))
+
+  const isUnder = (session: Kept | undefined, task: string, ancestor: string) => {
+    for (let at: string | undefined = task, steps = 0; at !== undefined && steps < 64; at = session?.tasks.get(at)?.parent, steps += 1) if (at === ancestor) return true
+    return false
+  }
+
+  const lastOf = <Item>(items: readonly Item[], last: unknown): Item[] => (typeof last === 'number' ? items.slice(-last) : [...items])
+
+  const isInScope = (session: Kept, request: Readonly<Record<string, unknown>>) =>
+    (request['everyProject'] === true || session.data.project === project()) && session.data.lastAt >= (typeof request['since'] === 'string' ? request['since'] : '') && (request['running'] !== true || session.data.isRunning)
+
+  const methods: Readonly<Record<string, (request: Readonly<Record<string, unknown>>, caller: string) => unknown>> = {
+    [conversationMethods.sessions]: (request) =>
+      [...kept.values()]
+        .filter((session) => isInScope(session, request))
+        .map((session) => session.data)
+        .toSorted((first, second) => second.lastAt.localeCompare(first.lastAt)),
+    [conversationMethods.search](request) {
+      const text = String(request['text'])
+      if ([...text].length < 3) throw new Error('cmod history search takes at least 3 characters.')
+      const inRecord = (message: Message) => {
+        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
+        return (request['turn'] === undefined || message.turn === request['turn']) && (request['context'] === undefined || message.context === request['context'])
+      }
+      const found = [...kept.values()]
+        .filter((session) => request['session'] !== undefined || isInScope(session, request))
+        .flatMap((session) => session.messages)
+        .filter((message) => inRecord(message) && searchText(message).toLowerCase().includes(text.toLowerCase()))
+        .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))
+    },
+    [conversationMethods.messages](request) {
+      const session = sessionOf(String(request['session']))
+      const fits = session.messages.filter((message) => message.task === request['task'] && (request['turn'] === undefined || message.turn === request['turn']))
+      const after = typeof request['after'] === 'string' ? fits.findIndex((message) => message.id === request['after']) + 1 : 0
+      return lastOf(fits.slice(after), request['last'])
+    },
+    [conversationMethods.turns]: (request) => lastOf(turnsOf(sessionOf(String(request['session'])), request['task']).filter((turn) => request['context'] === undefined || turn.context === request['context']), request['last']),
+    [conversationMethods.contexts](request) {
+      const session = sessionOf(String(request['session']))
+      if (typeof request['task'] !== 'string') return [...session.contexts.values()]
+      const task = taskOf(session, request['task'])
+      return [{ number: session.conversation.state.tasks[task.id]?.context ?? 1, openedAt: task.openedAt, ...(task.closedAt === undefined ? {} : { closedAt: task.closedAt }) }]
+    },
+    [conversationMethods.tasks]: (request) => [...sessionOf(String(request['session'])).tasks.values()].filter((task) => request['all'] === true || task.parent === request['task']),
+    [conversationMethods.goal](request) {
+      const session = sessionOf(String(request['session']))
+      const task = request['task']
+      if (typeof task !== 'string') return { text: session.conversation.state.goal ?? '' }
+      return { text: goals.get(task) ?? turnsOf(session, task)[0]?.prompt.text ?? '' }
+    },
+    [conversationMethods.updateGoal](request) {
+      const session = sessionOf(String(request['session']))
+      const task = typeof request['task'] === 'string' ? request['task'] : undefined
+      const text = String(request['text'])
+      if (task === undefined) record(session, session.conversation.changeGoal(text))
+      else {
+        goals.set(task, text)
+        record(session, [{ type: GoalChange, goal: { text, task } }])
+      }
+      return null
+    },
+    [conversationMethods.watchBefore](request, caller) {
+      const targets = watches.get(caller) ?? new Map<string, readonly string[]>()
+      targets.set(String(request['session']), (Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []).map(({ event }) => event))
+      watches.set(caller, targets)
+      return null
+    },
+    async [conversationMethods.act](request) {
+      const session = sessionOf(String(request['session']))
+      const action = String(request['action'])
+      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 (!isLive) throw new Error(`session ${task ?? session.data.id} has ended`)
+      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'] } : {}) }
+        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 }
+    },
+    [conversationMethods.subscribe](request, caller) {
+      const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []
+      const sessions = heard.get(caller) ?? new Map<string, readonly Heard[]>()
+      sessions.set(String(request['session']), list.map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : receivedMatcher(matcher) })))
+      heard.set(caller, sessions)
+      return null
+    },
+  }
+
+  return {
+    answer(caller, method, input) {
+      const run = methods[method]
+      if (run === undefined) return undefined
+      try {
+        return { value: run(isObject(input) ? input : {}, caller) }
+      } catch (error) {
+        return { deny: messageOf(error) }
+      }
+    },
+    add: (draft, task) => add(currentSession(), draft, task),
+    place,
+    wants: (mod, event) => [current, everySession].some((target) => (watches.get(mod)?.get(target) ?? []).includes(event)),
+    endTurn() {
+      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: [] }))
+    },
+    compact() {
+      const session = currentSession()
+      record(session, session.conversation.add({ id: `compact-${(ids += 1)}`, at: now(), type: 'system', name: 'compact_boundary', isMeta: false, isSummary: false, content: [] }))
+    },
+    startTask({ title, agentType = 'general-purpose', model, openedBy = '', parent }) {
+      const session = currentSession()
+      const id = `task-${(ids += 1)}`
+      record(session, session.conversation.startTask({ id, title, agentType, openedBy, openedAt: now(), ...(model === undefined ? {} : { model }), ...(parent === undefined ? {} : { parent }) }))
+      return id
+    },
+    start(id) {
+      current = id
+      const session = kept.get(id) ?? keep({ id, title: '', project: project(), cwd: project(), model: 'test-model', startedAt: now(), lastAt: now(), isRunning: true })
+      session.data = { ...session.data, isRunning: true }
+      if (session.conversation.state.context === 0) record(session, session.conversation.startContext(now()))
+    },
+    sent,
+  }
+}
+
+function rowOf(draft: MessageDraft, id: string, at: 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 === 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 }
+  return { ...base, type: 'system', name: 'informational', content: text(draft.text) }
+}