@cmodjs/core 1.0.0 → 1.5.1

package/src/session/conversation.ts

@@ -7,6 +7,7 @@ import { ToolResult } from './context/turn/message/tool-result.js'
 import { TurnEnd, TurnStart, type Turn } from './context/turn/turn.js'
 import { GoalChange, type Goal } from './goal/goal.js'
 import { Task, TaskEnd, TaskStart } from './goal/task.js'
+import type { UsageChange, Usage } from './session.js'
 
 export type SessionData = {
   readonly id: string
@@ -18,22 +19,26 @@ export type SessionData = {
   readonly lastAt: string
   readonly forkedFrom?: string
   readonly isRunning: boolean
+  readonly agentType?: string
 }
 
-export type ContextData = Omit<Context, 'turns'>
+export type ContextData = Pick<Context, 'number' | 'openedAt' | 'closedAt' | 'task'>
 
-export type TurnData = Omit<Turn, 'messages'>
+export type TurnData = Pick<Turn, 'prompt' | 'context' | 'openedAt' | 'closedAt'>
 
-export type TaskData = Omit<Task, 'messages' | 'tasks'> & { readonly parent?: string }
+export type TaskData = Pick<Task, 'id' | 'title' | 'openedBy' | 'openedAt' | 'closedAt'> & { readonly agentType: string; readonly model?: string; readonly parent?: string }
 
-export type GoalData = Omit<Goal, 'update' | 'tasks'>
+export type RunningTask = TaskData & { readonly context: number; readonly contextOpenedAt?: string }
+
+export type GoalData = Pick<Goal, 'text'> & { readonly task?: string }
 
 export type SessionChange =
   | { readonly type: typeof Message; readonly message: Message }
   | { readonly type: typeof TurnStart | typeof TurnEnd; readonly turn: TurnData }
   | { readonly type: typeof ContextStart | typeof ContextEnd; readonly context: ContextData }
-  | { readonly type: typeof TaskStart | typeof TaskEnd; readonly task: TaskData & { readonly context: number } }
+  | { readonly type: typeof TaskStart | typeof TaskEnd; readonly task: RunningTask }
   | { readonly type: typeof GoalChange; readonly goal: GoalData }
+  | { readonly type: typeof UsageChange; readonly usage: Usage }
 
 export type ConversationState = {
   readonly session: string
@@ -43,13 +48,13 @@ export type ConversationState = {
   readonly goal?: string
   readonly agentCalls: readonly string[]
   readonly endedCalls: Readonly<Record<string, string>>
-  readonly tasks: Readonly<Record<string, TaskData & { readonly context: number }>>
+  readonly tasks: Readonly<Record<string, RunningTask>>
+  readonly taskTurns: Readonly<Record<string, TurnData>>
 }
 
 export type Conversation = {
   add(row: Row, task?: string): SessionChange[]
   startTask(task: TaskData): SessionChange[]
-  endContext(at: string): SessionChange[]
   startContext(at: string): SessionChange[]
   changeGoal(text: string): SessionChange[]
   readonly state: ConversationState
@@ -62,7 +67,7 @@ const agentTools: readonly string[] = ['Agent', 'Task']
 const asyncLaunch = 'Async agent launched'
 
 export function emptyConversation(session: string): ConversationState {
-  return { session, context: 0, contextOpenedAt: '', agentCalls: [], endedCalls: {}, tasks: {} }
+  return { session, context: 0, contextOpenedAt: '', agentCalls: [], endedCalls: {}, tasks: {}, taskTurns: {} }
 }
 
 export function createConversation(start: ConversationState): Conversation {
@@ -70,6 +75,14 @@ export function createConversation(start: ConversationState): Conversation {
   const agentCalls = new Set(start.agentCalls)
   const endedCalls = new Map(Object.entries(start.endedCalls))
   const tasks = new Map(Object.entries(start.tasks))
+  const taskTurns = new Map(Object.entries(start.taskTurns))
+
+  const endTaskTurn = (task: string, at: string): SessionChange[] => {
+    const open = taskTurns.get(task)
+    if (open === undefined) return []
+    taskTurns.delete(task)
+    return open.closedAt === undefined ? [{ type: TurnEnd, turn: { ...open, closedAt: at } }] : []
+  }
 
   const startContext = (at: string): SessionChange[] => {
     context += 1
@@ -79,6 +92,17 @@ export function createConversation(start: ConversationState): Conversation {
 
   const endContext = (at: string): SessionChange[] => (context === 0 ? [] : [{ type: ContextEnd, context: { number: context, openedAt: contextOpenedAt, closedAt: at } }])
 
+  const compactTask = (task: string, at: string): SessionChange[] => {
+    const owner = tasks.get(task)
+    if (owner === undefined) return []
+    const next = { ...owner, context: owner.context + 1, contextOpenedAt: at }
+    tasks.set(task, next)
+    return [
+      { type: ContextEnd, context: { number: owner.context, openedAt: owner.contextOpenedAt ?? owner.openedAt, closedAt: at, task } },
+      { type: ContextStart, context: { number: next.context, openedAt: at, task } },
+    ]
+  }
+
   const endTurn = (at: string): SessionChange[] => {
     if (turn === undefined) return []
     const ended = { ...turn, closedAt: at }
@@ -86,17 +110,19 @@ export function createConversation(start: ConversationState): Conversation {
     return [{ type: TurnEnd, turn: ended }]
   }
 
-  const endTask = (call: string, at: string): SessionChange[] => {
-    const task = [...tasks.values()].find((each) => each.openedBy === call)
-    if (task === undefined) {
+  const endTask = (call: string, at: string, only?: string): SessionChange[] => {
+    const opened = [...tasks.values()].filter((each) => each.openedBy === call && (only === undefined || each.id === only))
+    if (opened.length === 0) {
       if (agentCalls.has(call)) endedCalls.set(call, at)
       return []
     }
-    if (task.closedAt !== undefined) return []
-    const ended = { ...task, closedAt: at }
-    tasks.set(task.id, ended)
-    agentCalls.delete(call)
-    return [{ type: TaskEnd, task: ended }]
+    if (only === undefined) agentCalls.delete(call)
+    return opened.flatMap((task) => {
+      if (task.closedAt !== undefined) return []
+      const ended = { ...task, closedAt: at }
+      tasks.set(task.id, ended)
+      return [...endTaskTurn(task.id, at), { type: TaskEnd, task: ended }]
+    })
   }
 
   const changeGoal = (text: string): SessionChange[] => {
@@ -109,30 +135,32 @@ export function createConversation(start: ConversationState): Conversation {
       const changes: SessionChange[] = []
       if (task === undefined && context === 0) changes.push(...startContext(row.at))
       if (task === undefined && row.type === 'system' && row.name === 'turn_duration') return [...changes, ...endTurn(row.at)]
-      if (task === undefined && row.type === 'system' && row.name === 'compact_boundary') return [...changes, ...endContext(row.at), ...startContext(row.at)]
+      if (row.type === 'system' && row.name === 'compact_boundary') return [...changes, ...(task === undefined ? [...endContext(row.at), ...startContext(row.at)] : compactTask(task, row.at))]
       const owner = task === undefined ? undefined : tasks.get(task)
+      const placedIn = owner?.context ?? context
       for (const unplaced of messagesOf(row, task !== undefined)) {
-        if (task === undefined && unplaced.type === Prompt) {
-          changes.push(...endTurn(row.at))
-          const opened: TurnData = { prompt: { ...unplaced, session: start.session, context, turn: unplaced.id }, context, openedAt: row.at }
-          turn = opened
+        if (unplaced.type === Prompt) {
+          changes.push(...(task === undefined ? endTurn(row.at) : endTaskTurn(task, row.at)))
+          const opened: TurnData = { prompt: { ...unplaced, session: start.session, context: placedIn, turn: unplaced.id, ...(task === undefined ? {} : { task }) }, context: placedIn, openedAt: row.at, ...(owner?.closedAt === undefined ? {} : { closedAt: owner.closedAt }) }
+          if (task === undefined) turn = opened
+          else taskTurns.set(task, opened)
           changes.push({ type: TurnStart, turn: opened })
-          if (goal === undefined) changes.push(...changeGoal(unplaced.text))
+          if (task === undefined && goal === undefined) changes.push(...changeGoal(unplaced.text))
         }
+        const open = task === undefined ? turn : taskTurns.get(task)
         const placed = {
           ...unplaced,
           session: start.session,
-          context: owner?.context ?? context,
-          ...(task === undefined && turn !== undefined ? { turn: turn.prompt.id } : {}),
+          context: placedIn,
+          ...(open === undefined ? {} : { turn: open.prompt.id }),
           ...(task === undefined ? {} : { task }),
         } as Message
         changes.push({ type: Message, message: placed })
-        if (task !== undefined) continue
         if (placed.type === ToolCall && agentTools.includes(placed.name)) agentCalls.add(placed.callId)
         if (placed.type === ToolResult && agentCalls.has(placed.callId) && !placed.text.startsWith(asyncLaunch)) changes.push(...endTask(placed.callId, row.at))
         if (placed.type === Note && placed.from.type === Task) {
           const call = tagOf(textOf(row.content), 'tool-use-id')
-          if (call !== undefined && agentCalls.has(call)) changes.push(...endTask(call, row.at))
+          if (call !== undefined && agentCalls.has(call)) changes.push(...endTask(call, row.at, tagOf(textOf(row.content), 'task-id')))
         }
       }
       return changes
@@ -144,13 +172,9 @@ export function createConversation(start: ConversationState): Conversation {
       agentCalls.add(data.openedBy)
       const changes: SessionChange[] = [{ type: TaskStart, task: started }]
       const endedAt = endedCalls.get(data.openedBy)
-      if (endedAt !== undefined) {
-        endedCalls.delete(data.openedBy)
-        changes.push(...endTask(data.openedBy, endedAt))
-      }
+      if (endedAt !== undefined) changes.push(...endTask(data.openedBy, endedAt, data.id))
       return changes
     },
-    endContext,
     startContext,
     changeGoal,
     get state() {
@@ -163,6 +187,7 @@ export function createConversation(start: ConversationState): Conversation {
         agentCalls: [...agentCalls],
         endedCalls: Object.fromEntries(endedCalls),
         tasks: Object.fromEntries(tasks),
+        taskTurns: Object.fromEntries(taskTurns),
       }
     },
   }

package/src/session/goal/goal.ts

@@ -1,9 +1,10 @@
+import type { RecordPart } from '../session.js'
 import type { Task } from './task.js'
 
 export const GoalChange = 'goalChange'
 
-export type Goal = {
+export type Goal = RecordPart & {
   readonly text: string
-  update(change: { readonly text: string }): Promise<void>
   tasks(): Promise<Task[]>
+  update(change: { readonly text: string }): Promise<void>
 }

package/src/session/goal/task.ts

@@ -1,4 +1,5 @@
 import type { Message } from '../context/turn/message/message.js'
+import type { RecordPart, Session } from '../session.js'
 
 export const Task = 'task'
 
@@ -6,14 +7,13 @@ export const TaskStart = 'taskStart'
 
 export const TaskEnd = 'taskEnd'
 
-export type Task = {
+export type Task = RecordPart & {
   readonly id: string
   readonly title: string
-  readonly agentType: string
-  readonly model?: string
+  readonly owner: Session
   readonly openedBy: string
   readonly openedAt: string
   readonly closedAt?: string
-  messages(): Promise<Message[]>
   tasks(): Promise<Task[]>
+  messages(): Promise<Message[]>
 }

package/src/session/session.ts

@@ -1,4 +1,4 @@
-import type { Disposable } from '../mod.js'
+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'
@@ -17,7 +17,9 @@ import type { Task, TaskEnd, TaskStart } from './goal/task.js'
 
 export const Session = 'session'
 
-export type SessionEvent = typeof Message | MessageType | typeof ContextStart | typeof ContextEnd | typeof TurnStart | typeof TurnEnd | typeof TaskStart | typeof TaskEnd | typeof GoalChange
+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
@@ -36,16 +38,53 @@ export type SessionPayload = {
   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 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
@@ -60,25 +99,33 @@ export type TaskStartArgs = {
   readonly cwd?: string
 }
 
-export type Session = {
+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 cwd: string
+  readonly agentType?: string
   readonly model: string
+  readonly cwd: string
+  readonly isRunning: boolean
   readonly startedAt: string
   readonly lastAt: string
   readonly forkedFrom?: string
-  readonly isRunning: boolean
-  usage(): Promise<Usage>
-  on<Event extends SessionEvent>(event: Event, listener: Listener<Event>): Disposable
-  on<Event extends SessionEvent>(event: Event, matcher: Matcher<SessionPayload[Event]>, listener: Listener<Event>): Disposable
+  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>
-  messages(options?: { readonly after?: string; readonly last?: number }): Promise<Message[]>
-  turns(options?: { readonly last?: number }): Promise<Turn[]>
-  contexts(): Promise<Context[]>
-  goal(): Promise<Goal>
+  callTool(call: ToolCallArgs): Promise<ToolResult>
+  usage(): Promise<Usage>
+  clients(): Promise<Client[]>
 }
 
 export type SessionScope = {
@@ -87,8 +134,8 @@ export type SessionScope = {
   readonly everyProject?: boolean
 }
 
-export type Sessions = {
+export type Sessions = Omit<RecordPart, 'search'> & {
   readonly current: Session
   list(options?: SessionScope): Promise<Session[]>
-  search(text: string, options?: SessionScope & { readonly limit?: number; readonly before?: Pick<Message, 'session' | 'id'> }): Promise<Message[]>
+  search(text: string, options?: SessionScope & SearchOptions): Promise<Message[]>
 }

package/src/testing/fake-claude.ts

@@ -15,7 +15,7 @@ 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']; copy?: Claude['ui']['copy'] }
+  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'] }
@@ -119,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
@@ -134,11 +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: {

package/src/testing/fake-sessions.ts

@@ -6,12 +6,15 @@ 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 { conversationMethods, isHeardBy, type Subscription } from '../runtime/sessions.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'
 
@@ -46,16 +49,20 @@ 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 }): string
+  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 type: string; readonly text: string; readonly as?: string }[]
+  readonly sent: { readonly session: string; readonly task?: string; readonly type: string; readonly text: string; readonly as?: string }[]
 }
 
-export function fakeSessions({ project, given, push }: { readonly project: () => string; readonly given: readonly FakeSession[]; readonly push: (mod: string, session: string, change: SessionChange) => void }): FakeSessions {
+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')
@@ -76,7 +83,7 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
       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) ?? []).some(({ event, matcher }) => isHeardBy(event, matcher, change))) push(mod, session.data.id, change)
+        if ([...(sessions.get(session.data.id) ?? []), ...(sessions.get(everySession) ?? [])].some(({ event, matcher }) => isHeardBy(event, matcher, change))) push(mod, session.data.id, change)
       }
     }
   }
@@ -101,6 +108,24 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
 
   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>>) =>
@@ -115,10 +140,18 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
     [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) => isInScope(session, request))
+        .filter((session) => request['session'] !== undefined || isInScope(session, request))
         .flatMap((session) => session.messages)
-        .filter((message) => searchText(message).toLowerCase().includes(text.toLowerCase()))
+        .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
@@ -130,15 +163,59 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
       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([...sessionOf(String(request['session'])).turns.values()].filter((turn) => request['context'] === undefined || turn.context === request['context']), request['last']),
-    [conversationMethods.contexts]: (request) => [...sessionOf(String(request['session'])).contexts.values()],
-    [conversationMethods.tasks]: (request) => [...sessionOf(String(request['session'])).tasks.values()].filter((task) => task.parent === request['task']),
-    [conversationMethods.goal]: (request) => ({ text: sessionOf(String(request['session'])).conversation.state.goal ?? '' }),
+    [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']))
-      record(session, session.conversation.changeGoal(String(request['text'])))
+      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[]>()
@@ -146,10 +223,6 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
       heard.set(caller, sessions)
       return null
     },
-    [conversationMethods.send](request) {
-      sent.push({ session: String(request['session']), type: String(request['type']), text: String(request['text']), ...(typeof request['as'] === 'string' ? { as: request['as'] } : {}) })
-      return null
-    },
   }
 
   return {
@@ -163,19 +236,20 @@ export function fakeSessions({ project, given, push }: { readonly project: () =>
       }
     },
     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()
-      const at = now()
-      record(session, [...session.conversation.endContext(at), ...session.conversation.startContext(at)])
+      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 = '' }) {
+    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 }) }))
+      record(session, session.conversation.startTask({ id, title, agentType, openedBy, openedAt: now(), ...(model === undefined ? {} : { model }), ...(parent === undefined ? {} : { parent }) }))
       return id
     },
     start(id) {