@cmodjs/core 3.0.0 → 4.0.0

package/src/runtime/watches.ts

@@ -0,0 +1,75 @@
+import type { FileChange } from '../mod.js'
+import { ifMissing } from '../utils/paths.js'
+import type { Subscription } from '../utils/subscription.js'
+import type { Claude } from './claude.js'
+import type { Failure } from './toaster.js'
+
+export type Watches = { add(paths: readonly string[], listener: (change: FileChange) => unknown): Subscription }
+
+type Watch = { readonly paths: readonly string[]; readonly listener: (change: FileChange) => unknown; seen: ReadonlyMap<string, number> | undefined }
+
+const watchMs = 500
+
+const watchedFiles = 2000
+
+export function createWatches(claude: Claude, report: (failure: Failure) => void): Watches {
+  const watches = new Set<Watch>()
+  let polling: { cancel(): void } | undefined
+  let isPolling = false
+  const stampsOf = async (paths: readonly string[]): Promise<Map<string, number>> => {
+    const stamps = new Map<string, number>()
+    const visit = async (path: string): Promise<void> => {
+      const stat = await claude.fs.stat(path).catch(ifMissing(undefined))
+      if (stat === undefined) return
+      if (stat.kind !== 'dir') {
+        if (stamps.size === watchedFiles) throw new Error(`fs.onChange watches at most ${watchedFiles} files, and ${paths.join(', ')} holds more, so it stopped. Watch a smaller folder.`)
+        return void stamps.set(path, stat.mtimeMs)
+      }
+      for (const entry of await claude.fs.list(path).catch(ifMissing([]))) await visit(`${path}/${entry.name}`)
+    }
+    for (const path of paths) await visit(path)
+    return stamps
+  }
+  const stop = (watch: Watch) => {
+    watches.delete(watch)
+    if (watches.size > 0) return
+    polling?.cancel()
+    polling = undefined
+  }
+  const stampsOrStop = (watch: Watch) =>
+    stampsOf(watch.paths).catch((error: unknown) => {
+      stop(watch)
+      report({ id: 'fs:onChange', message: 'Could not read the files fs.onChange watches', error })
+      return undefined
+    })
+  const poll = async () => {
+    if (isPolling) return
+    isPolling = true
+    try {
+      for (const watch of watches) {
+        const now = await stampsOrStop(watch)
+        if (now === undefined) continue
+        const before = watch.seen
+        watch.seen = now
+        if (before === undefined) continue
+        const changes: FileChange[] = [
+          ...[...now].filter(([path, at]) => before.has(path) && before.get(path) !== at).map(([path]): FileChange => ({ path, type: 'change' })),
+          ...[...now.keys()].filter((path) => !before.has(path)).map((path): FileChange => ({ path, type: 'add' })),
+          ...[...before.keys()].filter((path) => !now.has(path)).map((path): FileChange => ({ path, type: 'unlink' })),
+        ]
+        for (const change of changes) await Promise.resolve().then(() => watch.listener(change)).catch((error: unknown) => report({ id: 'fs:onChange', message: 'The fs.onChange listener failed', error }))
+      }
+    } finally {
+      isPolling = false
+    }
+  }
+  return {
+    add(paths, listener) {
+      const watch: Watch = { paths, listener, seen: undefined }
+      watches.add(watch)
+      void stampsOrStop(watch).then((stamps) => void (watch.seen ??= stamps))
+      polling ??= claude.clock.every(watchMs, () => void poll())
+      return { remove: () => stop(watch) }
+    },
+  }
+}

package/src/runtime/widgets.ts

@@ -0,0 +1,287 @@
+import type { ElementTable, RenderElement } from 'claude-code'
+import { isObject, widgetsPath } from '../records.js'
+import type { TurnData } from '../session/conversation.js'
+import { AbovePrompt, areas, BelowPrompt, TurnEnd, Working, type Area } from '../ui/areas.js'
+import { Box, drawWith } from '../ui/elements.js'
+import { ifMissing } from '../utils/paths.js'
+import { messageOf } from '../utils/text.js'
+import type { Claude } from './claude.js'
+import { cmodPluginName } from './dependencies.js'
+import type { DrawnParts } from './parts.js'
+import type { Router } from './router.js'
+import { partMethods, type PartsUpdate, type WidgetDeclaration } from './ui.js'
+
+export type WidgetRow = { readonly left: readonly string[]; readonly right: readonly string[] }
+
+export type WidgetLayout = { readonly areas: Readonly<Record<Area, readonly WidgetRow[]>>; readonly hidden: readonly string[] }
+
+export type PlacedWidget = { readonly key: string; readonly mod: string; readonly title: string; readonly areas: readonly Area[] }
+
+export type Move = 'up' | 'down' | 'left' | 'right'
+
+export const claudeHint = 'claude/hint'
+
+export const claudeModes = 'claude/modes'
+
+export const builtInWidgets: readonly PlacedWidget[] = [
+  { key: claudeHint, mod: 'claude', title: "Claude Code's hint", areas: [BelowPrompt] },
+  { key: claudeModes, mod: 'claude', title: "Claude Code's mode labels", areas: [BelowPrompt] },
+]
+
+const promptIndent = 4
+
+const transcriptIndent = 2
+
+const terminalColumns = 80
+
+const separator = ''
+
+export type Widgets = {
+  update(mod: string, update: Pick<PartsUpdate, 'parts' | 'redraw'>): void
+  widgets(): readonly PlacedWidget[]
+  layout(): WidgetLayout
+  change(edit: (layout: WidgetLayout) => WidgetLayout): Promise<void>
+  reload(): Promise<void>
+  recheck(): Promise<void>
+  rows(area: Area, columns: number): RenderElement[]
+  draw(area: Area, table: ElementTable, columns: number, turn?: TurnData): Promise<RenderElement[]>
+}
+
+export function layoutOf(value: unknown): WidgetLayout {
+  const keys = (list: unknown) => (Array.isArray(list) ? list.filter((key): key is string => typeof key === 'string') : [])
+  const rowsOf = (list: unknown): WidgetRow[] => (Array.isArray(list) ? list.filter(isObject).map((row) => ({ ...row, left: keys(row['left']), right: keys(row['right']) })) : [])
+  const stored = isObject(value) && isObject(value['areas']) ? value['areas'] : {}
+  return { areas: Object.fromEntries(areas.map((area) => [area, rowsOf(stored[area])])) as unknown as WidgetLayout['areas'], hidden: isObject(value) ? keys(value['hidden']) : [] }
+}
+
+const stringsIn = (value: unknown): string[] => (typeof value === 'string' ? [value] : Array.isArray(value) ? value.flatMap(stringsIn) : isObject(value) ? Object.values(value).flatMap(stringsIn) : [])
+
+const holds = (row: WidgetRow, key: string) => row.left.includes(key) || row.right.includes(key)
+
+export function placedIn(layout: WidgetLayout, key: string): Area | undefined {
+  return areas.find((area) => layout.areas[area].some((row) => holds(row, key)))
+}
+
+export function toggled(layout: WidgetLayout, key: string): WidgetLayout {
+  return { ...layout, hidden: layout.hidden.includes(key) ? layout.hidden.filter((each) => each !== key) : [...layout.hidden, key] }
+}
+
+export function moved(layout: WidgetLayout, widget: PlacedWidget, move: Move): WidgetLayout {
+  const area = placedIn(layout, widget.key)
+  if (area === undefined) return layout
+  const rows = layout.areas[area]
+  const at = rows.findIndex((row) => holds(row, widget.key))
+  const row = rows[at] as WidgetRow
+  const side = row.left.includes(widget.key) ? 'left' : 'right'
+  const withAreas = (changed: Partial<Record<Area, readonly WidgetRow[]>>): WidgetLayout => ({ ...layout, areas: { ...layout.areas, ...Object.fromEntries(Object.entries(changed).map(([name, list]) => [name, list.filter((each) => stringsIn(each).length > 0)])) } })
+  if (move === 'left' || move === 'right') {
+    const sequence = [...row.left, separator, ...row.right]
+    const from = sequence.indexOf(widget.key)
+    const to = move === 'left' ? from - 1 : from + 1
+    if (to < 0 || to >= sequence.length) return layout
+    ;[sequence[from], sequence[to]] = [sequence[to] as string, widget.key]
+    const split = sequence.indexOf(separator)
+    return withAreas({ [area]: rows.map((each, index) => (index === at ? { ...each, left: sequence.slice(0, split), right: sequence.slice(split + 1) } : each)) })
+  }
+  const without = rows.map((each, index) => (index === at ? { ...each, left: each.left.filter((key) => key !== widget.key), right: each.right.filter((key) => key !== widget.key) } : each))
+  const added = (target: WidgetRow | undefined): WidgetRow => ({ ...target, left: target?.left ?? [], right: target?.right ?? [], [side]: [...(target?.[side] ?? []), widget.key] })
+  const target = at + (move === 'up' ? -1 : 1)
+  if (target >= 0 && target < rows.length) return withAreas({ [area]: without.map((each, index) => (index === target ? added(each) : each)) })
+  if (move === 'down' && row.left.length + row.right.length > 1) return withAreas({ [area]: [...without, added(undefined)] })
+  const next = (move === 'up' ? areas.slice(0, areas.indexOf(area)).reverse() : areas.slice(areas.indexOf(area) + 1)).find((each) => widget.areas.includes(each))
+  if (next === undefined) return layout
+  const nextRows = layout.areas[next]
+  const landing = move === 'up' ? [...nextRows.slice(0, -1), added(nextRows.at(-1))] : [added(nextRows[0]), ...nextRows.slice(1)]
+  return withAreas({ [area]: without, [next]: landing })
+}
+
+function declarationsOf(input: unknown): WidgetDeclaration[] {
+  const listed = isObject(input) && Array.isArray(input['widgets']) ? (input['widgets'] as unknown[]) : []
+  return listed.filter(isObject).flatMap((each) => {
+    const known = Array.isArray(each['areas']) ? (each['areas'] as unknown[]).filter((area): area is Area => (areas as readonly unknown[]).includes(area)) : []
+    return typeof each['id'] === 'string' && typeof each['title'] === 'string' && known.length > 0 ? [{ id: each['id'], title: each['title'], areas: known }] : []
+  })
+}
+
+export function serveWidgets({
+  claude,
+  router,
+  store,
+  report,
+  turnClosedBy,
+  parts,
+}: {
+  readonly claude: Claude
+  readonly router: Router
+  readonly store: string
+  readonly report: (id: string, message: string, error: unknown) => void
+  readonly turnClosedBy: (rowId: string) => TurnData | undefined
+  readonly parts: DrawnParts
+}): Widgets {
+  const path = widgetsPath(store)
+  const declared = new Map<string, readonly WidgetDeclaration[]>()
+  let stored = layoutOf({})
+  let layout = stored
+  let saving: Promise<void> = Promise.resolve()
+
+  let placedKeys: ReadonlySet<string> = new Set()
+
+  const readFile = async () => {
+    const file = JSON.parse(await claude.fs.read(path).catch(ifMissing('{}'))) as unknown
+    placedKeys = new Set(stringsIn(isObject(file) ? file['areas'] : undefined))
+    return file
+  }
+
+  const read = async () => layoutOf(await readFile())
+
+  const redraw = () => claude.ui.invalidate('ui.render')
+
+  const placed = (): PlacedWidget[] => [...builtInWidgets, ...[...declared].flatMap(([mod, list]) => list.map(({ id, title, areas: listed }) => ({ key: `${mod}/${id}`, mod, title, areas: listed })))]
+
+  const change = (edit: (current: WidgetLayout) => WidgetLayout) => {
+    saving = saving
+      .then(async () => {
+        const file = await readFile()
+        stored = layoutOf(file)
+        const current = withNewWidgets(stored)
+        const next = edit(current)
+        if (next !== current) {
+          const kept = isObject(file) ? file : {}
+          await claude.fs.write(path, `${JSON.stringify({ ...kept, ...next, areas: { ...(isObject(kept['areas']) ? kept['areas'] : {}), ...next.areas } }, null, 2)}\n`)
+          stored = next
+        }
+        place()
+      })
+      .catch((error: unknown) => report('widgets:layout', 'Could not save the widget layout', error))
+    return saving
+  }
+
+  const place = () => {
+    layout = withNewWidgets(stored)
+    redraw()
+  }
+
+  const withNewWidgets = (current: WidgetLayout) =>
+    placed()
+      .filter(({ key, mod }) => mod !== 'claude' && placedIn(current, key) === undefined && !placedKeys.has(key))
+      .reduce((next, { key, areas: [area = AbovePrompt] }) => {
+        const [first, ...rest] = next.areas[area]
+        return { ...next, areas: { ...next.areas, [area]: [{ ...first, left: [...(first?.left ?? []), key], right: first?.right ?? [] }, ...rest] } }
+      }, current)
+
+  const ask = async (mod: string) => {
+    try {
+      declared.set(mod, declarationsOf(await claude.cmod.call({ to: mod, method: partMethods.list, input: null })))
+    } catch (error) {
+      declared.delete(mod)
+      claude.ui.log(`cmod: ${mod} did not list its widgets: ${messageOf(error)}`, { to: 'debug' })
+    }
+  }
+
+  const recheck = async () => {
+    const mods = [...declared.keys()]
+    await Promise.all(mods.map(ask))
+    for (const mod of mods) parts.forget(mod)
+    redraw()
+  }
+
+  const reload = async () => {
+    stored = await read()
+    place()
+  }
+
+  saving = (async () => {
+    const recorded = (await claude.fs.list(`${store}/records`).catch(ifMissing([]))).map((entry) => entry.name).filter((name) => name.endsWith('.json')).map((name) => name.slice(0, -'.json'.length))
+    stored = await read().catch((error: unknown) => {
+      report('widgets:layout', 'Could not read the widget layout', error)
+      return stored
+    })
+    const named = areas.flatMap((area) => stored.areas[area].flatMap((row) => [...row.left, ...row.right])).map((key) => key.slice(0, key.indexOf('/')))
+    await Promise.all([...new Set([...recorded, ...named])].filter((mod) => mod !== cmodPluginName && mod !== 'claude' && !declared.has(mod)).map(ask))
+    place()
+  })().catch((error: unknown) => report('widgets:layout', 'Could not list the widgets of the mods', error))
+
+  const widgetOf = (key: string) => placed().find((widget) => widget.key === key)
+
+  const cacheKey = (key: string, area: Area, columns: number, turn: TurnData | undefined) => `${key}\u0000${area}\u0000${columns}\u0000${turn?.prompt.id ?? ''}`
+
+  const nameOf = (widget: PlacedWidget) => `The ${widget.title} widget of ${widget.mod}`
+
+  const fill = (key: string, area: Area, columns: number, turn: TurnData | undefined): Promise<void> | undefined => {
+    const widget = widgetOf(key)
+    if (widget === undefined || !widget.areas.includes(area)) return undefined
+    return parts.fill(widget.mod, cacheKey(key, area, columns, turn), { widget: key.slice(widget.mod.length + 1), area, columns, ...(turn === undefined ? {} : { turn }) }, nameOf(widget))
+  }
+
+  const elementFor = (key: string, area: Area, columns: number, turn: TurnData | undefined): RenderElement | undefined => {
+    const widget = widgetOf(key)
+    return widget === undefined ? undefined : parts.element(widget.mod, cacheKey(key, area, columns, turn), `${key}:`, nameOf(widget), `widget:${key}`)
+  }
+
+  const isHidden = (key: string) => layout.hidden.includes(key)
+
+  const shown = (keys: readonly string[]) => keys.filter((key) => !isHidden(key))
+
+  const rowsNow = (area: Area, columns: number, turn: TurnData | undefined): RenderElement[] =>
+    layout.areas[area].flatMap((row) => {
+      const side = (keys: readonly string[]) => shown(keys).map((key) => elementFor(key, area, columns, turn)).filter((each) => each !== undefined)
+      const left = side(row.left)
+      const right = side(row.right)
+      return left.length + right.length === 0 ? [] : [Box({ justifyContent: 'space-between', width: columns, children: [Box({ gap: 2, children: left }), Box({ gap: 2, children: right })] })]
+    })
+
+  const keysIn = (area: Area) => layout.areas[area].flatMap((row) => shown([...row.left, ...row.right]))
+
+  const draw = async (area: Area, table: ElementTable, columns: number, turn?: TurnData): Promise<RenderElement[]> => {
+    await Promise.all(keysIn(area).map((key) => fill(key, area, columns, turn)))
+    return drawWith(table, () => rowsNow(area, columns, turn))
+  }
+
+  const rows = (area: Area, columns: number): RenderElement[] => {
+    const started = keysIn(area).flatMap((key) => fill(key, area, columns, undefined) ?? [])
+    if (started.length > 0) void Promise.all(started).then(() => claude.ui.invalidate('ui.render'))
+    return rowsNow(area, columns, undefined)
+  }
+
+  const column = (table: ElementTable, children: readonly RenderElement[]) => drawWith(table, () => Box({ flexDirection: 'column', children }))
+
+  const below = (table: ElementTable, above: RenderElement, added: readonly RenderElement[]) => (added.length === 0 ? above : column(table, [above, ...added]))
+
+  router.add('ui.render', async (e, next) => {
+    const table = claude.ui.resolve(e)
+    const columns = (e.viewport?.columns ?? terminalColumns) - transcriptIndent
+    if (e.component === 'AbovePrompt') return e.props.hasSurvey ? next(e) : below(table, await next(e), await draw(AbovePrompt, table, e.props.bodyColumns))
+    if (e.component === 'PromptHint') {
+      const added = await draw(BelowPrompt, table, (e.viewport?.columns ?? terminalColumns) - promptIndent)
+      return isHidden(claudeHint) ? column(table, added) : below(table, await next(e), added)
+    }
+    if (e.component === 'SessionMode') return isHidden(claudeModes) ? column(table, []) : next(e)
+    if (e.component === 'Spinner') return below(table, await next(e), await draw(Working, table, columns))
+    if (e.component === 'TurnDuration') {
+      const turn = turnClosedBy(e.requestId)
+      return below(table, await next(e), turn === undefined ? [] : await draw(TurnEnd, table, columns, turn))
+    }
+    return next(e)
+  })
+
+  return {
+    update(mod, { parts: listing, redraw }) {
+      if (listing === undefined && redraw !== true) return
+      parts.forget(mod)
+      if (listing !== undefined) {
+        const listed = declarationsOf(listing)
+        const isNewList = JSON.stringify(listed) !== JSON.stringify(declared.get(mod) ?? [])
+        declared.set(mod, listed)
+        if (isNewList) place()
+      }
+      claude.ui.invalidate('ui.render')
+    },
+    widgets: placed,
+    layout: () => layout,
+    change,
+    reload,
+    recheck,
+    rows,
+    draw,
+  }
+}

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

@@ -50,6 +50,8 @@ export const skillPrefix = 'Base directory for this skill:'
 
 const rowTypes: readonly string[] = ['user', 'assistant', 'attachment', 'system']
 
+const interruption = /^\[Request interrupted by user( for tool use)?\]$/
+
 const memoryPath = /^Contents of (.+?)(?: \([^)\n]*\))?:\r?$/m
 
 export function instructionPathOf(text: string): string {
@@ -126,9 +128,12 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
   if (text === '') return []
   if (text.startsWith(skillPrefix)) return [{ ...base, type: Skill, name: basename(text.slice(skillPrefix.length).split('\n')[0]?.trim() ?? ''), text }]
   if (text.startsWith('<task-notification')) return [{ ...base, type: Note, text: tagOf(text, 'summary') ?? text, from: { type: Task } }]
-  if (row.isMeta) return [{ ...base, type: Note, text, from: senderOf(row.origin, isInTask) }]
+  if (interruption.test(text)) return []
+  const from = senderOf(row.origin, isInTask)
+  if (row.isMeta) return [{ ...base, type: Note, text, from }]
   const prompt = promptText(text)
-  return prompt === undefined ? [] : [{ ...base, type: Prompt, text: prompt, from: senderOf(row.origin, isInTask) }]
+  const isPluginCommand = from.type === Mod && tagOf(text, 'command-name') !== undefined
+  return prompt === undefined || isPluginCommand ? [] : [{ ...base, type: Prompt, text: prompt, from }]
 }
 
 function isModNotesRow(row: Row): boolean {

package/src/session/session.ts

@@ -1,4 +1,4 @@
-import type { Disposable } from '../utils/disposable.js'
+import type { Subscription } from '../utils/subscription.js'
 import type { Matcher } from '../utils/matcher.js'
 import type { Sender } from './context/turn/message/sender.js'
 import type { Context, ContextEnd, ContextStart } from './context/context.js'
@@ -107,13 +107,13 @@ export type ListenerTime = { readonly deadline: number; readonly signal: AbortSi
 export type Listener<Payload, Answer = void> = (payload: Payload, time: ListenerTime) => Answer | void | Promise<Answer | void>
 
 export type OnMethod<Payload> = {
-  (listener: Listener<Payload, unknown>, options?: ReadOptions): Disposable
-  (matcher: Matcher<Payload>, listener: Listener<Payload, unknown>, options?: ReadOptions): Disposable
+  (listener: Listener<Payload, unknown>, options?: ReadOptions): Subscription
+  (matcher: Matcher<Payload>, listener: Listener<Payload, unknown>, options?: ReadOptions): Subscription
 }
 
 export type BeforeMethod<Payload, Answer> = {
-  (listener: Listener<Payload, Answer>, options?: AnswerOptions): Disposable
-  (matcher: Matcher<Payload>, listener: Listener<Payload, Answer>, options?: AnswerOptions): Disposable
+  (listener: Listener<Payload, Answer>, options?: AnswerOptions): Subscription
+  (matcher: Matcher<Payload>, listener: Listener<Payload, Answer>, options?: AnswerOptions): Subscription
 }
 
 export type OnMethods = { readonly [Name in EventName as `on${Name}`]: OnMethod<PayloadOf<Name>> }
@@ -326,7 +326,11 @@ export type ProcessOnMethods = { readonly [Name in ProcessName as `on${Name}`]:
 
 export type ProcessBeforeMethods = { readonly [Name in keyof ProcessAnswer as `before${Name}`]: BeforeMethod<ProcessAsked[Name], ProcessAnswer[Name]> }
 
-export type CurrentSession = Omit<Session, 'goal'> & ProcessOnMethods & ProcessBeforeMethods & { readonly goal: Goal & Pick<ProcessBeforeMethods, 'beforeSessionStart'> }
+export type CurrentSession = Omit<Session, 'goal'> & ProcessOnMethods & ProcessBeforeMethods & {
+  readonly goal: Goal & Pick<ProcessBeforeMethods, 'beforeSessionStart'>
+  scrollTo(message: Message, options?: { readonly block?: 'start' | 'center' | 'end' | 'nearest' }): Promise<void>
+  caption(toolCall: Message & { readonly type: typeof ToolCall }, text: string | undefined): void
+}
 
 export type SessionScope = {
   readonly running?: boolean

package/src/testing/fake-claude.ts

@@ -1,6 +1,8 @@
 import type { EventResult, Timer } from 'claude-code'
 import { isObject } from '../records.js'
 import type { Claude } from '../runtime/claude.js'
+import { cmodPluginName } from '../runtime/dependencies.js'
+import { partMethods } from '../runtime/ui.js'
 import { untagged } from '../session/context/turn/message/note.js'
 import { elements } from './fake-elements.js'
 import { fakeFiles } from './fake-files.js'
@@ -34,7 +36,6 @@ export type Shown = {
   readonly prompts: string[]
   readonly logs: string[]
   readonly debug: string[]
-  readonly statuses: (string | undefined)[]
   readonly openPanes: Set<string>
   readonly commands: string[]
   readonly tools: string[]
@@ -59,7 +60,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
   const calls: TestCall[] = []
   const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, config: {}, command: {}, ui: {}, session: {}, prompt: {}, model: {}, agent: {}, clock: {}, cmod: {}, tool: {} }
   const emptyDisk = fakeFiles({})
-  const shown: Shown = { notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
+  const shown: Shown = { notes: [], prompts: [], logs: [], debug: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
   const unplacedPanes = new Set<string>()
   let focusedPane: string | undefined
   const store = new Map<string, unknown>()
@@ -79,6 +80,11 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
     return async (...args: Args): Promise<Result> => run(...args)
   }
 
+  const cmodTakesParts: Claude['cmod']['call'] = async (input) => {
+    if (input.to === cmodPluginName && input.method === partMethods.changed) return null
+    throw new Error(`cmod.call(${JSON.stringify(input)}) has no fake answer. Set fakes.cmod.call on the tested mod.`)
+  }
+
   const appendNote: Claude['session']['append'] = async ({ message }) => {
     shown.notes.push(untagged(message.content.map((block) => (typeof block['text'] === 'string' ? block['text'] : '')).join('')))
     return { message, uuid: `note-${shown.notes.length}` }
@@ -107,9 +113,6 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
   const claude: Claude = {
     plugin,
     ui: {
-      status: (text) => {
-        shown.statuses.push(text)
-      },
       log: (text, options) => {
         const lines = options?.to === 'debug' ? shown.debug : shown.logs
         lines.push(text)
@@ -214,7 +217,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       dataHome: async () => undefined,
       configHome: async () => undefined,
     },
-    cmod: { call: rejected('cmod.call', () => fakes.cmod.call) },
+    cmod: { call: rejected('cmod.call', () => fakes.cmod.call ?? cmodTakesParts) },
   }
 
   const settle = async () => {

package/src/testing/fake-elements.ts

@@ -91,8 +91,8 @@ function boxRows({ props, children = [] }: Drawn, width: number): string[] {
   const left = space('Left', 'X')
   const direction = String(props['flexDirection'] ?? 'row')
   const ordered = direction.endsWith('-reverse') ? [...children].reverse() : children
-  const inner = width - left - space('Right', 'X')
-  const rows = direction.startsWith('column') ? stacked(ordered, inner, size('rowGap') ?? size('gap') ?? 0) : sideBySide(ordered, inner, size('columnGap') ?? size('gap') ?? 0)
+  const inner = Math.min(width, size('width') ?? width) - left - space('Right', 'X')
+  const rows = direction.startsWith('column') ? stacked(ordered, inner, size('rowGap') ?? size('gap') ?? 0) : sideBySide(ordered, inner, size('columnGap') ?? size('gap') ?? 0, props['justifyContent'] === 'space-between')
   return [...blankRows(space('Top', 'Y')), ...rows.map((row) => paddedTo(`${' '.repeat(left)}${row}`, size('minWidth') ?? 0)), ...blankRows(space('Bottom', 'Y'))]
 }
 
@@ -101,7 +101,7 @@ function stacked(children: readonly RenderNode[], width: number, gap: number): s
   return blocks.flatMap((block, index) => [...blankRows(index === 0 ? 0 : gap), ...block])
 }
 
-function sideBySide(children: readonly RenderNode[], width: number, gap: number): string[] {
+function sideBySide(children: readonly RenderNode[], width: number, gap: number, isSpread = false): string[] {
   const laid = children
     .map((child) => ({ child, natural: rowsOf(child, Number.POSITIVE_INFINITY) }))
     .filter(({ natural }) => natural.length > 0)
@@ -111,7 +111,10 @@ function sideBySide(children: readonly RenderNode[], width: number, gap: number)
   const blocks = laid.map(({ child, natural, canShrink }) => (overflow <= 0 || !canShrink || total === 0 ? natural : rowsOf(child, widthOf(natural) - Math.ceil((overflow * widthOf(natural)) / total))))
   const height = Math.max(0, ...blocks.map((block) => block.length))
   const columns = blocks.map(widthOf)
-  return Array.from({ length: height }, (_, row) => blocks.map((block, index) => paddedTo(block[row] ?? '', index === blocks.length - 1 ? 0 : (columns[index] ?? 0))).join(' '.repeat(gap)))
+  const spaces = blocks.length - 1
+  const free = isSpread && Number.isFinite(width) ? Math.max(width - columns.reduce((sum, each) => sum + each, 0) - gap * spaces, 0) : 0
+  const gapAfter = (index: number) => gap + Math.floor(free / spaces) + (index < free % spaces ? 1 : 0)
+  return Array.from({ length: height }, (_, row) => blocks.map((block, index) => `${paddedTo(block[row] ?? '', index === spaces ? 0 : (columns[index] ?? 0))}${index === spaces ? '' : ' '.repeat(gapAfter(index))}`).join(''))
 }
 
 function minWidthOf(node: RenderNode): number {

package/src/testing/fake-sessions.ts

@@ -14,7 +14,7 @@ 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, type TurnEnding } from '../session/conversation.js'
 import type { Place } from '../runtime/before.js'
 import type { Claude } from '../runtime/claude.js'
-import { conversationMethods, everySession, isHeardBy, resultOf, type Subscription } from '../runtime/sessions.js'
+import { conversationMethods, everySession, isHeardBy, resultOf, type Listened } from '../runtime/sessions.js'
 import { receivedMatcher } from '../utils/matcher.js'
 import { firstLine, messageOf } from '../utils/text.js'
 
@@ -43,7 +43,7 @@ type Kept = {
   readonly tasks: Map<string, TaskData>
 }
 
-type Heard = { readonly event: Subscription['event']; readonly matcher: unknown }
+type Heard = { readonly event: Listened['event']; readonly matcher: unknown }
 
 
 export type FakeSessions = {
@@ -56,6 +56,7 @@ export type FakeSessions = {
   compact(): void
   startTask(task: { readonly title: string; readonly agentType?: string; readonly model?: string; readonly openedBy?: string; readonly parent?: string }): string
   start(id: string): void
+  lastTurn(): TurnData | undefined
   readonly sent: { readonly session: string; readonly task?: string; readonly type: string; readonly text: string; readonly as?: string }[]
 }
 
@@ -191,7 +192,7 @@ export function fakeSessions({ project, cwd, given, push, callTool }: { readonly
     },
     [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))
+      targets.set(String(request['session']), (Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Listened[]) : []).map(({ event }) => event))
       watches.set(caller, targets)
       return null
     },
@@ -223,7 +224,7 @@ export function fakeSessions({ project, cwd, given, push, callTool }: { readonly
       return { id: '', type: ToolResult, at: now(), session: session.data.id, context: session.conversation.state.context, callId: '', name: '', input: {}, cwd: project(), files: noFiles, output: '', isError: false }
     },
     [conversationMethods.subscribe](request, caller) {
-      const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []
+      const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Listened[]) : []
       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)
@@ -272,6 +273,7 @@ export function fakeSessions({ project, cwd, given, push, callTool }: { readonly
       session.data = { ...session.data, isRunning: true }
       if (session.conversation.state.context === 0) record(session, session.conversation.startContext(now()))
     },
+    lastTurn: () => [...currentSession().turns.values()].filter((turn) => turn.prompt.task === undefined).at(-1),
     sent,
   }
 }