@cmodjs/core 1.0.0 → 1.5.0

package/src/runtime/toaster.ts

@@ -1,30 +1,46 @@
 import type { ElementTable, RenderElement, RenderPropsOf, Timer } from 'claude-code'
-import type { Mod, Toast, ToastId, ToastOptions, ToastType } from '../mod.js'
-import { Box, Button, drawWith, Text } from '../ui/elements.js'
-import { coreVersion } from '../records.js'
+import type { Toast, ToastId, ToastOptions, ToastType } from '../mod.js'
+import { Box, Button, drawWith, Link, Text } from '../ui/elements.js'
+import { coreVersion, isObject } from '../records.js'
 import { firstLine, messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
 
 export type ShownToast = { readonly type: ToastType; readonly message: string; readonly description?: string }
 
-export type Failure = { readonly id: string; readonly message: string; readonly error?: unknown; readonly description?: string }
+export type Failure = { readonly id: string; readonly message: string; readonly error?: unknown; readonly description?: string; readonly retry?: () => unknown }
 
 export type Toaster = {
   readonly toast: Toast
   copy(text: string): Promise<void>
+  fail(failure: Failure): ToastId
   readonly shown: readonly ShownToast[]
-  draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt']): RenderElement
+  draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt'], bandId: string): RenderElement
 }
 
+type Action = { readonly label: string; readonly onClick: () => unknown }
+
+type Contact = { readonly kind: 'github'; readonly repository: string } | { readonly kind: 'email'; readonly address: string }
+
+type Reporting = { readonly contact: Contact | undefined; readonly details: string; readonly status?: string }
+
 type Entry = {
   readonly id: ToastId
   readonly type: ToastType
   readonly message: string
   readonly options: ToastOptions
+  readonly actions: readonly Action[]
+  readonly hides?: string
   isOpen: boolean
+  reporting?: Reporting | undefined
   timer: Timer | undefined
 }
 
+const githubRepository = /^https:\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:\/issues)?\/?$/
+
+const linkLimit = 2048
+
+const hiddenKey = 'cmod:hidden-failures'
+
 const defaultDuration = 4000
 const visibleToasts = 3
 const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const
@@ -37,13 +53,22 @@ const icons: Record<Exclude<ToastType, 'loading'>, { readonly glyph: string; rea
   error: { glyph: '✗', color: 'error' },
 }
 
-export function createToaster(claude: Claude, name: string): Toaster {
+export function createToaster(claude: Claude, name: string, version: () => string | undefined): Toaster {
   const entries = new Map<ToastId, Entry>()
+  const hidden = new Map<string, string>()
+  void claude.store.get(hiddenKey).then(
+    (saved) => {
+      if (typeof saved !== 'object' || saved === null) return
+      for (const [id, hides] of Object.entries(saved)) if (typeof hides === 'string' && !hidden.has(id)) hidden.set(id, hides)
+    },
+    (error: unknown) => claude.ui.log(`${name}: could not read the failures you hid: ${messageOf(error)}`, { to: 'debug' }),
+  )
   let lastId = 0
   let frame = 0
   let spinning: Timer | undefined
   let isHeld = false
   let showsAll = false
+  let bandId: string | undefined
 
   const changed = () => {
     const isLoading = [...entries.values()].some((entry) => entry.type === 'loading')
@@ -85,18 +110,29 @@ export function createToaster(claude: Claude, name: string): Toaster {
     changed()
   }
 
+  const put = (type: ToastType, message: string, options: ToastOptions, actions: readonly Action[], hides?: string): ToastId => {
+    const id = options.id ?? (lastId += 1)
+    const previous = entries.get(id)
+    if (previous !== undefined) disarm(previous)
+    const reporting = hides !== undefined && previous?.hides === hides ? previous.reporting : undefined
+    const entry: Entry = { id, type, message, options, actions, ...(hides === undefined ? {} : { hides }), isOpen: previous?.isOpen ?? false, reporting, timer: undefined }
+    if (type === 'error' && previous?.message !== message) claude.ui.log(`${name}: ${message}${typeof options.description === 'string' ? `: ${options.description}` : ''}`, { to: 'debug' })
+    entries.set(id, entry)
+    changed()
+    return id
+  }
+
   const show =
     (type: ToastType) =>
-    (message: string, options: ToastOptions = {}): ToastId => {
-      const id = options.id ?? (lastId += 1)
-      const previous = entries.get(id)
-      if (previous !== undefined) disarm(previous)
-      const entry: Entry = { id, type, message, options, isOpen: previous?.isOpen ?? false, timer: undefined }
-      if (type === 'error' && previous?.message !== message) claude.ui.log(`${name}: ${message}${typeof options.description === 'string' ? `: ${options.description}` : ''}`, { to: 'debug' })
-      entries.set(id, entry)
-      changed()
-      return id
-    }
+    (message: string, options: ToastOptions = {}): ToastId =>
+      put(type, message, options, options.action === undefined ? [] : [options.action])
+
+  const hide = (entry: Entry) => {
+    dismiss(entry.id)
+    if (entry.hides === undefined) return
+    hidden.set(String(entry.id), entry.hides)
+    void claude.store.set(hiddenKey, Object.fromEntries(hidden)).catch((error: unknown) => claude.ui.log(`${name}: could not remember the failure you hid: ${messageOf(error)}`, { to: 'debug' }))
+  }
 
   const toast: Toast = Object.assign(show('default'), {
     success: show('success'),
@@ -132,7 +168,33 @@ export function createToaster(claude: Claude, name: string): Toaster {
   const press = (entry: Entry, run: () => unknown) => () =>
     void Promise.resolve()
       .then(run)
-      .catch((error: unknown) => showFailure({ name, claude, ui: { toast, copy } }, { id: `press:${entry.id}`, message: `${entry.message}: the press failed`, error }))
+      .catch((error: unknown) => fail({ id: `press:${entry.id}`, message: `${entry.message}: the press failed`, error }))
+
+  const fail = ({ id, message, error, description = error === undefined ? undefined : describe(error), retry }: Failure): ToastId => {
+    const hides = `${version() ?? ''}\n${message}\n${error === undefined ? '' : describe(error)}`
+    if (hidden.get(id) === hides) return id
+    hidden.delete(id)
+    const stack = error instanceof Error && error.stack !== undefined ? `\n\n${error.stack}` : ''
+    const details = async () => {
+      const modVersion = await claude.fs
+        .read(`${claude.plugin.root}/.claude-plugin/plugin.json`)
+        .then((text) => String((JSON.parse(text) as { version?: unknown }).version))
+        .catch((failure: unknown) => `unknown (${messageOf(failure)})`)
+      return `${name} ${modVersion}, @cmodjs/core ${coreVersion}\n${message}${description === undefined ? '' : `\n${description}`}${stack}`
+    }
+    const startReporting = async () => {
+      const shown = entries.get(id)
+      if (shown === undefined) return
+      shown.reporting = { contact: await contactOf(claude), details: await details() }
+      disarm(shown)
+      changed()
+      if (bandId === undefined) return
+      const focused = await claude.ui.focus({ requestId: bandId, key: `toast:${id}:ask-claude` })
+      if ('deny' in focused) claude.ui.log(`${name}: the Report choices did not take the keys: ${String(focused.deny)}`, { to: 'debug' })
+    }
+    const actions = [...(retry === undefined ? [] : [{ label: 'Retry', onClick: retry }]), { label: 'Report', onClick: startReporting }]
+    return put('error', message, { id, ...(description === undefined ? {} : { description }), duration: Infinity }, actions, hides)
+  }
 
   const toggle = (entry: Entry) => () => {
     entry.isOpen = !entry.isOpen
@@ -141,31 +203,70 @@ export function createToaster(claude: Claude, name: string): Toaster {
   }
 
   const row = (entry: Entry): RenderElement => {
-    const { description, action } = entry.options
+    const { description } = entry.options
     const isText = typeof description === 'string'
     const icon = entry.type === 'loading' ? { glyph: spinner[frame % spinner.length] as string, color: 'claude' } : icons[entry.type]
     const message = isText ? Button({ plain: true, key: `toast:${entry.id}:open`, label: entry.message, onPress: toggle(entry) }) : Text({ children: entry.message })
     const details = !isText ? description : Text({ dimColor: true, wrap: entry.isOpen ? 'wrap' : 'truncate-end', children: entry.isOpen ? description : firstLine(description) })
     const fixed = (child: RenderElement) => Box({ flexShrink: 0, children: child })
+    const close = Button({ plain: true, dimColor: true, key: `toast:${entry.id}:close`, label: entry.hides === undefined ? '✕' : 'Hide', onPress: () => hide(entry) })
+    const actions = entry.actions.map((action, index) => Button({ plain: true, key: `toast:${entry.id}:${index === 0 ? 'action' : `action-${index}`}`, label: action.label, onPress: press(entry, action.onClick) }))
+    const text = details === undefined ? [message] : [message, details]
+    const under = entry.reporting === undefined ? [Box({ gap: 2, flexWrap: 'wrap', children: [...actions, close] })] : reportChoices(entry, entry.reporting)
     return Box({
       gap: 2,
       children: [
         fixed(Text({ ...(icon.color === undefined ? {} : { color: icon.color }), children: icon.glyph })),
         fixed(Text({ dimColor: true, children: name })),
-        Box({ flexDirection: 'column', flexGrow: 1, flexShrink: 1, children: details === undefined ? [message] : [message, details] }),
-        ...(action === undefined ? [] : [fixed(Button({ plain: true, key: `toast:${entry.id}:action`, label: action.label, onPress: press(entry, action.onClick) }))]),
-        fixed(Button({ plain: true, dimColor: true, key: `toast:${entry.id}:close`, label: '✕', onPress: () => dismiss(entry.id) })),
+        Box({ flexDirection: 'column', flexGrow: 1, flexShrink: 1, children: entry.hides === undefined ? text : [...text, ...under] }),
+        ...(entry.hides === undefined ? [...actions.map(fixed), fixed(close)] : []),
       ],
     })
   }
 
+  const reportChoices = (entry: Entry, { contact, details, status }: Reporting): RenderElement[] => {
+    const say = (said: string) => {
+      entry.reporting = { contact, details, status: said }
+      changed()
+    }
+    const back = () => {
+      entry.reporting = undefined
+      changed()
+    }
+    const askClaude = async () => {
+      await claude.prompt.submit({ text: reportPrompt(name, contact, details), asUser: true })
+      back()
+    }
+    const copyError = async () => {
+      const copied = await claude.ui.copy({ text: details })
+      say(copied.isCopied ? 'Copied the error.' : `Could not copy it: ${copied.reason}`)
+    }
+    const report = contact === undefined ? [] : [Link({ href: reportLink(contact, name, entry.message, details), label: contact.kind === 'github' ? 'Report it on GitHub (opens your browser)' : 'Email the author (opens your mail app)' })]
+    return [
+      Text({ dimColor: true, children: 'Claude writes up the problem and files it with your tools. You approve each step before anything is posted.' }),
+      Box({
+        gap: 2,
+        flexWrap: 'wrap',
+        children: [
+          Button({ plain: true, key: `toast:${entry.id}:ask-claude`, label: 'Ask Claude to report it', onPress: press(entry, askClaude) }),
+          ...report,
+          Button({ plain: true, key: `toast:${entry.id}:copy`, label: 'Copy the error', onPress: press(entry, copyError) }),
+          Button({ plain: true, dimColor: true, key: `toast:${entry.id}:back`, label: 'Back', onPress: back }),
+        ],
+      }),
+      ...(status === undefined ? [] : [Text({ dimColor: true, children: status })]),
+    ]
+  }
+
   return {
     toast,
     copy,
+    fail,
     get shown() {
       return [...entries.values()].map(({ type, message, options }) => ({ type, message, ...(typeof options.description === 'string' ? { description: options.description } : {}) }))
     },
-    draw(drawn, table, band) {
+    draw(drawn, table, band, drawnIn) {
+      bandId = drawnIn
       isHeld = band.hasSurvey === true
       if (isHeld || entries.size === 0) return drawn
       const all = [...entries.values()]
@@ -186,28 +287,6 @@ export function createToaster(claude: Claude, name: string): Toaster {
   }
 }
 
-export type FailureTarget = {
-  readonly name: string
-  readonly ui: Pick<Mod['ui'], 'toast' | 'copy'>
-  readonly claude: { readonly plugin: Claude['plugin']; readonly fs: Pick<Claude['fs'], 'read'> }
-}
-
-export function showFailure({ name, ui, claude }: FailureTarget, { id, message, error, description = describe(error) }: Failure): ToastId {
-  const stack = error instanceof Error && error.stack !== undefined ? `\n\n${error.stack}` : ''
-  const show = (label: string): ToastId => ui.toast.error(message, { id, description, duration: Infinity, action: { label, onClick: copy } })
-  const copy = async (): Promise<ToastId> => {
-    const modVersion = await claude.fs
-      .read(`${claude.plugin.root}/.claude-plugin/plugin.json`)
-      .then((text) => String((JSON.parse(text) as { version?: unknown }).version))
-      .catch((failure: unknown) => `unknown (${messageOf(failure)})`)
-    return ui.copy(`${name} ${modVersion}, @cmodjs/core ${coreVersion}\n${message}\n${description}${stack}`).then(
-      () => show('Copied'),
-      (failure: unknown) => show(`Copy failed: ${messageOf(failure)}`),
-    )
-  }
-  return show('Copy')
-}
-
 function describe(error: unknown): string {
   const messages: string[] = []
   for (let cause = error; cause !== undefined; cause = cause instanceof Error ? cause.cause : undefined) {
@@ -216,3 +295,40 @@ function describe(error: unknown): string {
   }
   return messages.join('\n')
 }
+
+async function contactOf(claude: Claude): Promise<Contact | undefined> {
+  const manifest: Record<string, unknown> = await claude.fs
+    .read(`${claude.plugin.root}/.claude-plugin/plugin.json`)
+    .then((text) => JSON.parse(text) as Record<string, unknown>)
+    .catch((error: unknown) => {
+      claude.ui.log(`${claude.plugin.name}: could not read whom to report to: ${messageOf(error)}`, { to: 'debug' })
+      return {}
+    })
+  const repositoryUrl = isObject(manifest['repository']) ? manifest['repository']['url'] : manifest['repository']
+  const repository = [manifest['supportUrl'], repositoryUrl].map((url) => (typeof url === 'string' ? githubRepository.exec(url)?.[1] : undefined)).find((found) => found !== undefined)
+  if (repository !== undefined) return { kind: 'github', repository }
+  const author = manifest['author']
+  const address = isObject(author) ? author['email'] : undefined
+  return typeof address === 'string' && address !== '' ? { kind: 'email', address } : undefined
+}
+
+function reportLink(contact: Contact, name: string, message: string, details: string): string {
+  const title = `${name}: ${message}`.slice(0, 120)
+  const linkOf = (body: string) =>
+    contact.kind === 'github'
+      ? `https://github.com/${contact.repository}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`
+      : `mailto:${contact.address}?subject=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`
+  let body = details
+  while (linkOf(body).length > linkLimit && body.length > 0) body = `${body.slice(0, Math.floor(body.length * 0.8))}…`
+  return linkOf(body)
+}
+
+function reportPrompt(name: string, contact: Contact | undefined, details: string): string {
+  const where =
+    contact === undefined
+      ? `${name} names no place to report it, so find its author from its plugin.json or its marketplace.`
+      : contact.kind === 'github'
+        ? `Report it as an issue on https://github.com/${contact.repository}.`
+        : `Email it to ${contact.address}.`
+  return `The ${name} mod failed. Report it to its author. ${where} First check whether it is reported already, and add to that report instead of filing a new one. Show me the report before you post it.\n\n${details}`
+}

package/src/runtime/ui.ts

@@ -107,6 +107,15 @@ export function createUi<State extends object>({ name, claude, router, toaster,
   const panes = new Map<string, Pane<State>>()
   const paneLogs = new Map<string, (failure: string) => void>()
   const openPanes = new Set<string>()
+  const paneStates = new Map<string, { readonly isShown: boolean; readonly isFocused: boolean }>()
+  const syncPanes = async () => {
+    for (const open of await claude.ui.panes()) {
+      if (!panes.has(open.id)) continue
+      if (open.isPlaced) openPanes.add(open.id)
+      paneStates.set(open.id, { isShown: open.isShown, isFocused: open.isFocused })
+    }
+  }
+  const readPanes = () => void syncPanes().catch((error: unknown) => claude.ui.log(`${name} keeps its panes' shown and focused state from before: ${messageOf(error)}`, { to: 'debug' }))
   const requestedSizes = new Map<string, PaneSize>()
   const renders = new Set<string>()
   const markdownRenders = new Map<string, MarkdownRender>()
@@ -197,6 +206,8 @@ export function createUi<State extends object>({ name, claude, router, toaster,
       const pane = panes.get(e.requestId)
       if (pane === undefined || e.component !== 'Pane') return next(e)
       openPanes.add(pane.id)
+      paneStates.set(pane.id, { isShown: true, isFocused: e.props.isFocused })
+      readPanes()
       const table = claude.ui.resolve(e)
       try {
         return drawWith(table, () => pane.render(mod(), e.props), markdownIn(table))
@@ -214,6 +225,8 @@ export function createUi<State extends object>({ name, claude, router, toaster,
     })
     router.add('ui.close', async (e, next) => {
       openPanes.delete(e.id)
+      paneStates.delete(e.id)
+      readPanes()
       const closed = await next(e)
       const pane = panes.get(e.id)
       if (pane?.onClose !== undefined) await handle(pane, 'onClose', () => pane.onClose?.(mod(), e))
@@ -241,13 +254,22 @@ export function createUi<State extends object>({ name, claude, router, toaster,
           get isOpen() {
             return openPanes.has(pane.id)
           },
+          get isShown() {
+            return paneStates.get(pane.id)?.isShown ?? false
+          },
+          get isFocused() {
+            return paneStates.get(pane.id)?.isFocused ?? false
+          },
           async open(options) {
             const { isPlaced } = await openAt(pane, paneSize(pane, mod().state), options?.focus)
             if (isPlaced) openPanes.add(pane.id)
+            await syncPanes()
           },
           async close() {
             await claude.ui.close({ id: pane.id })
             openPanes.delete(pane.id)
+            paneStates.delete(pane.id)
+            await syncPanes()
           },
           toggle: (options) => (openPanes.has(pane.id) ? handle.close() : handle.open(options)),
         }
@@ -316,10 +338,7 @@ export function createUi<State extends object>({ name, claude, router, toaster,
       })
     },
     async restorePanes() {
-      if (panes.size === 0) return
-      for (const open of await claude.ui.panes()) {
-        if (open.isPlaced && panes.has(open.id)) openPanes.add(open.id)
-      }
+      if (panes.size > 0) await syncPanes()
     },
   }
 }

package/src/session/context/context.ts

@@ -1,12 +1,14 @@
+import type { RecordPart } from '../session.js'
 import type { Turn } from './turn/turn.js'
 
 export const ContextStart = 'contextStart'
 
 export const ContextEnd = 'contextEnd'
 
-export type Context = {
+export type Context = RecordPart & {
   readonly number: number
   readonly openedAt: string
   readonly closedAt?: string
+  readonly task?: string
   turns(): Promise<Turn[]>
 }

package/src/session/context/turn/message/message.ts

@@ -112,7 +112,7 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
     })
   }
   if (row.isSummary) return []
-  const results = row.content.filter((block) => isObject(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string') as Readonly<Record<string, unknown>>[]
+  const results = row.content.filter(isToolResultBlock)
   if (results.length > 0) return results.map((block) => ({ ...base, type: ToolResult, callId: block['tool_use_id'] as string, text: textOf(block['content']), isError: block['is_error'] === true }))
   if (text === '') return []
   if (text.startsWith(skillPrefix)) return [{ ...base, type: Skill, name: basename(text.slice(skillPrefix.length).split('\n')[0]?.trim() ?? ''), text }]
@@ -122,6 +122,44 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
   return prompt === undefined ? [] : [{ ...base, type: Prompt, text: prompt, from: senderOf(row.origin, isInTask) }]
 }
 
+export function withTexts(row: Row, texts: ReadonlyMap<number, string>): readonly unknown[] {
+  if (row.type === 'assistant') {
+    let index = -1
+    return row.content.map((block) => {
+      if (!isObject(block)) return block
+      const isText = block['type'] === 'text' && typeof block['text'] === 'string' && block['text'].trim() !== ''
+      const isCall = block['type'] === 'tool_use' && typeof block['id'] === 'string' && typeof block['name'] === 'string'
+      if (!isText && !isCall) return block
+      index += 1
+      const text = texts.get(index)
+      return isText && text !== undefined ? { ...block, text } : block
+    })
+  }
+  if (row.type === 'user' && row.content.some(isToolResultBlock)) {
+    let index = -1
+    return row.content.map((block) => {
+      if (!isToolResultBlock(block)) return block
+      index += 1
+      const text = texts.get(index)
+      if (text === undefined) return block
+      return { ...block, content: Array.isArray(block['content']) ? keepingMedia(block['content'], text) : text }
+    })
+  }
+  const text = texts.get(0)
+  if (text === undefined) return row.content
+  const whole = textOf(row.content)
+  if (whole.trim().startsWith('<task-notification') && tagOf(whole, 'summary') !== undefined) return keepingMedia(row.content, whole.replace(/<summary>[\s\S]*?<\/summary>/, () => `<summary>${text}</summary>`))
+  return keepingMedia(row.content, text)
+}
+
+function keepingMedia(content: readonly unknown[], text: string): unknown[] {
+  return [{ type: 'text', text }, ...content.filter((block) => !isObject(block) || block['type'] !== 'text')]
+}
+
+function isToolResultBlock(block: unknown): block is Readonly<Record<string, unknown>> {
+  return isObject(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string'
+}
+
 export function textOf(content: unknown): string {
   if (typeof content === 'string') return content
   if (!Array.isArray(content)) return ''

package/src/session/context/turn/turn.ts

@@ -1,3 +1,4 @@
+import type { RecordPart } from '../../session.js'
 import type { Message } from './message/message.js'
 import type { Prompt } from './message/prompt.js'
 
@@ -5,7 +6,7 @@ export const TurnStart = 'turnStart'
 
 export const TurnEnd = 'turnEnd'
 
-export type Turn = {
+export type Turn = RecordPart & {
   readonly prompt: Prompt
   readonly context: number
   readonly openedAt: string

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>
 }