@cmodjs/core 4.0.3 → 4.1.1

package/src/runtime/sessions.ts

@@ -7,7 +7,7 @@ import { Person, senderOf } from '../session/context/turn/message/sender.js'
 import { ToolCall } from '../session/context/turn/message/tool-call.js'
 import { ToolResult } from '../session/context/turn/message/tool-result.js'
 import { TurnEnd, TurnStart, type Turn } from '../session/context/turn/turn.js'
-import { searchLimit, type ContextData, type GoalData, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
+import { forkAgentType, searchLimit, type ContextData, type GoalData, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
 import { GoalChange, type Goal } from '../session/goal/goal.js'
 import { TaskEnd, TaskStart, type Task } from '../session/goal/task.js'
 import { beforeEvents, processEvents, Session, sessionEvents, type BeforeEvent, type Placement, type BeforeMethods, type Surface, type OnMethods, type ProcessBeforeMethods, type ProcessName, type ProcessOnMethods, type RecordPart, type SearchOptions, type SessionEvent, type SessionScope, type SessionSend, type Sessions, type TaskOwner, type TaskStartArgs, type ToolCallArgs, type Usage } from '../session/session.js'
@@ -39,11 +39,21 @@ export const conversationMethods = {
   act: 'cmod:act',
   changed: 'cmod:changed',
   before: 'cmod:before',
+  sessionColor: 'cmod:sessionColor',
 } as const
 
-export type Act = 'send' | 'startTask' | 'callTool' | 'usage' | 'surfaces' | 'abort'
+export type SessionColor = { readonly session: string; readonly color?: string }
 
-const actPermissions: Readonly<Record<Exclude<Act, 'callTool'>, string>> = { send: 'prompt', startTask: 'tasks', usage: 'conversation', surfaces: 'conversation', abort: 'prompt' }
+const resetColors: readonly string[] = ['default', 'reset', 'none', 'gray', 'grey']
+
+export function pickedColor(args: string): string | undefined {
+  const picked = args.trim().toLowerCase()
+  return resetColors.includes(picked) ? undefined : picked
+}
+
+export type Act = 'send' | 'startTask' | 'fork' | 'clone' | 'startBackgroundTask' | 'callTool' | 'usage' | 'surfaces' | 'abort'
+
+const actPermissions: Readonly<Record<Exclude<Act, 'callTool'>, string>> = { send: 'prompt', startTask: 'tasks', fork: 'tasks', clone: 'tasks', startBackgroundTask: 'tasks', usage: 'conversation', surfaces: 'conversation', abort: 'prompt' }
 
 const startsTurns: readonly string[] = ['CronCreate']
 
@@ -51,6 +61,11 @@ const ownSchedule: readonly string[] = ['CronDelete', 'CronList']
 
 export const beforePermission = (event: BeforeEvent): string => (event === 'toolCall' ? 'tools' : event === TaskStart ? 'tasks' : 'prompt')
 
+const answerPermissions = (event: BeforeEvent, answer: Partial<Answers>): string[] => [
+  ...(Object.keys(answer).some((key) => key !== 'note') ? [beforePermission(event)] : []),
+  ...(answer.note === undefined ? [] : ['prompt']),
+]
+
 export const isAct = (action: string): action is Act => action === 'callTool' || action in actPermissions
 
 export function toolPermission(tool: string): string | undefined {
@@ -72,7 +87,8 @@ export type SessionsClient = {
   listen(method: string, args: readonly unknown[]): Subscription
   turn(data: TurnData): Turn
   /** An empty title keeps the title the session already has. */
-  follow(current: Omit<SessionData, 'isRunning' | 'lastAt'>): void
+  follow(current: Omit<SessionData, 'isRunning' | 'lastAt' | 'color'>): void
+  recolor(told: SessionColor): void
 }
 
 type Listening = { scope: Scope; readonly event: SessionEvent; readonly method: string; readonly matcher: unknown; readonly listener: (payload: never, time: ListenTime) => unknown; readonly options: ListenOptions }
@@ -82,7 +98,8 @@ type Owned = { readonly session: string; readonly task: string }
 export async function usageOf(claude: Pick<Claude, 'session'>): Promise<Usage> {
   const [model, usage] = await Promise.all([claude.session.model(), claude.session.usage()])
   const { tokens, window, percent } = usage.context
-  return { model, contextWindow: { ...(tokens === undefined ? {} : { tokenCount: tokens }), size: window, ...(percent === undefined ? {} : { percent }) }, ...(usage.cost === undefined ? {} : { cost: { usd: usage.cost.usd } }) }
+  const rateLimits = usage.rateLimits.map(({ kind, percentUsed, resetsAt }) => ({ type: kind, percent: percentUsed, ...(resetsAt === undefined ? {} : { resetsAt }) }))
+  return { model, contextWindow: { ...(tokens === undefined ? {} : { tokenCount: tokens }), size: window, ...(percent === undefined ? {} : { percent }) }, rateLimits, ...(usage.cost === undefined ? {} : { cost: { usd: usage.cost.usd } }) }
 }
 
 export function payloadOf(change: SessionChange): unknown {
@@ -90,8 +107,9 @@ export function payloadOf(change: SessionChange): unknown {
   if ('turn' in change) return change.turn
   if ('context' in change) return change.context
   if ('task' in change) {
-    const { id, title, agentType, model, openedBy, openedAt, closedAt } = change.task
-    return { id, title, openedBy, openedAt, ...(closedAt === undefined ? {} : { closedAt }), owner: { id, title, agentType, ...(model === undefined ? {} : { model }), startedAt: openedAt } }
+    const { id, title, agentType, model, openedBy, openedAt, closedAt, isBackground, forkedFrom } = change.task
+    const owner = { id, title, ...(agentType === undefined ? {} : { agentType }), ...(model === undefined ? {} : { model }), ...(forkedFrom === undefined ? {} : { forkedFrom }), startedAt: openedAt }
+    return { id, title, openedBy, openedAt, ...(closedAt === undefined ? {} : { closedAt }), ...(isBackground === true ? { isBackground } : {}), owner }
   }
   if ('usage' in change) return change.usage
   return change.goal
@@ -149,6 +167,9 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
   const parents = new Map<string, Map<string, string | undefined>>()
   const known = new Map<string, SessionData>()
   let current: SessionData = { id: '', title: '', project: '', cwd: '', model: '', startedAt: '', lastAt: '', isRunning: true }
+  let told: SessionColor = { session: '' }
+
+  const colored = ({ color: _color, ...data }: SessionData): SessionData => (told.session === data.id && told.color !== undefined ? { ...data, color: told.color } : data)
 
   const keyOf = (scope: Scope) => scope.session ?? everySession
 
@@ -224,8 +245,10 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
         if (!decides(entry, session, latest)) return undefined
         const payload = await payloadFor(session, latest)
         const answer = await invoke(entry.method, entry.options, async (time) => takenAnswer(entry.method, beforeAnswerKeys[event], await entry.listener(payload as never, time)), beforeAnswerKeys[event])
-        if (answer === undefined || answer === null || (typeof answer === 'object' && 'refuse' in answer) || isGranted(beforePermission(event))) return answer
-        throw new Error(`Its ${entry.method} answer changes nothing until you grant ${name} "${permissionWords(beforePermission(event))}". ${grantFix}`)
+        if (answer === undefined || answer === null || (typeof answer === 'object' && 'refuse' in answer)) return answer
+        const missing = answerPermissions(event, answer as Partial<Answers>).find((permission) => !isGranted(permission))
+        if (missing === undefined) return answer
+        throw new Error(`Its ${entry.method} answer changes nothing until you grant ${name} "${permissionWords(missing)}". ${grantFix}`)
       })
     const answer = await foldBefore(event, change, askers, (error) => report(`session:${methodOf('before', event)}`, `The ${methodOf('before', event)} listener failed`, error))
     return answer?.note === undefined ? answer : { ...answer, note: modNote(name, answer.note) }
@@ -293,17 +316,25 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
     }
   }
 
-  const taskOf = (session: string, data: TaskData): Task => ({
-    id: data.id,
-    title: data.title,
-    openedBy: data.openedBy,
-    openedAt: data.openedAt,
-    ...(data.closedAt === undefined ? {} : { closedAt: data.closedAt }),
-    owner: ownerOf(session, data),
-    ...recordPart({ session, task: data.id }),
-    tasks: async () => (await call<TaskData[]>(conversationMethods.tasks, { session, task: data.id })).map((task) => taskOf(session, task)),
-    messages: () => messagesFrom(conversationMethods.messages, { session, task: data.id }),
-  })
+  const taskOf = (session: string, data: TaskData): Task => {
+    const record = data.isBackground === true ? { session: data.id } : { session, task: data.id }
+    return {
+      id: data.id,
+      title: data.title,
+      openedBy: data.openedBy,
+      openedAt: data.openedAt,
+      ...(data.closedAt === undefined ? {} : { closedAt: data.closedAt }),
+      ...(data.status === undefined ? {} : { status: data.status }),
+      ...(data.name === undefined ? {} : { name: data.name }),
+      ...(data.spawnedBy === undefined ? {} : { spawnedBy: data.spawnedBy }),
+      ...(data.isBackground === true ? { isBackground: true } : {}),
+      owner: ownerOf(session, data),
+      ...recordPart({ session, task: data.id }),
+      search: (text: string, matcher?: unknown) => searched({ text, ...record }, matcher),
+      tasks: async () => (await call<TaskData[]>(conversationMethods.tasks, record)).map((task) => taskOf(record.session, task)),
+      messages: () => messagesFrom(conversationMethods.messages, record),
+    }
+  }
 
   const goalOf = (where: () => Scope): Goal =>
     ({
@@ -345,11 +376,9 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
     if ('drop' in submitted && typeof submitted.drop === 'string') throw new Error(`${name}: Claude Code dropped the prompt: ${submitted.drop}`)
   }
 
-  const startHere = async (task: TaskStartArgs): Promise<Task> => taskOf(current.id, await spawnTask(claude, task).catch((error: unknown) => Promise.reject(new Error(`${name}: ${messageOf(error)}`))))
-
   const surfacesHere = async (): Promise<Surface[]> => [...(await claude.session.surfaces())]
 
-  const sessionOf = (read: () => SessionData, owned?: Owned) => {
+  const sessionOf = (read: () => SessionData, owned?: Owned, isOwner = owned !== undefined) => {
     const id = () => read().id
     const isHere = () => owned === undefined && id() === current.id
     const scope = (): Scope => (owned === undefined ? { session: id(), isAgent: true } : { session: owned.session, task: owned.task, isAgent: true })
@@ -363,6 +392,9 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
       get title() {
         return read().title
       },
+      get color() {
+        return read().color
+      },
       get project() {
         return read().project
       },
@@ -411,32 +443,34 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
         await act(id(), 'send', message, owned)
       },
     }
-    if (owned !== undefined) return session as unknown as Sessions['current']
+    if (isOwner) return session as unknown as Sessions['current']
+    const started = async (starting: Promise<TaskData>): Promise<Task> => taskOf(id(), await starting.catch((error: unknown) => Promise.reject(new Error(`${name}: ${messageOf(error)}`))))
     return Object.assign(session, {
-      async startTask(task: TaskStartArgs): Promise<Task> {
-        if (isHere()) return startHere(task)
-        const started = await act<TaskData>(id(), 'startTask', task)
-        return taskOf(id(), started)
-      },
+      startTask: (task: TaskStartArgs): Promise<Task> => started(task.isBackground === true ? act<TaskData>(id(), 'startBackgroundTask', task) : isHere() ? spawnTask(claude, task) : act<TaskData>(id(), 'startTask', task)),
+      fork: (task: Pick<TaskStartArgs, 'prompt' | 'title'>): Promise<Task> => started(isHere() ? spawnTask(claude, task, current.id) : act<TaskData>(id(), 'fork', task)),
+      clone: (task: Pick<TaskStartArgs, 'prompt' | 'title'>): Promise<Task> => started(act<TaskData>(id(), 'clone', task)),
       callTool: async (toolCall: ToolCallArgs): Promise<ToolResult> => (await withFiles(await act<ToolResult>(id(), 'callTool', toolCall))) as ToolResult,
     }) as unknown as Sessions['current']
   }
 
   const ownerOf = (session: string, data: TaskData): TaskOwner => {
     const parent = session === current.id ? current : known.get(session)
+    const isBackground = data.isBackground === true
     return sessionOf(
       () => ({
         id: data.id,
         title: data.title,
         project: parent?.project ?? '',
-        agentType: data.agentType,
+        ...(data.agentType === undefined ? {} : { agentType: data.agentType }),
         model: data.model ?? '',
         cwd: parent?.cwd ?? '',
-        isRunning: data.closedAt === undefined && (parent?.isRunning ?? true),
+        isRunning: data.closedAt === undefined && (isBackground || (parent?.isRunning ?? true)),
         startedAt: data.openedAt,
         lastAt: data.closedAt ?? data.openedAt,
+        ...(data.forkedFrom === undefined ? {} : { forkedFrom: data.forkedFrom }),
       }),
-      { session, task: data.id },
+      isBackground ? undefined : { session, task: data.id },
+      true,
     )
   }
 
@@ -494,7 +528,11 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
     }
     const event: { readonly on: string; readonly before?: string } = processEvents[named as ProcessName]
     const hook = (isBefore ? event.before : undefined) ?? event.on
-    if (method === 'beforeSessionStart') routeOn('session.compact', compactionNote)
+    if (method === 'beforeSessionStart') routeOn('session.compact', trackCompaction)
+    if (method === 'beforeModelChange') hookOn(event.on, () => {
+      const notes = modelNotes.splice(0)
+      return notes.length === 0 ? undefined : { additionalContext: notes }
+    })
     const failed = (input: unknown, error: Error) => {
       const refusal = refusalFor(method, processPayloadOf(named as ProcessFieldsName, input), error)
       return refusal === undefined ? undefined : hookAnswerOf(name, named, refusal)
@@ -504,35 +542,38 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
       async (input: unknown) => {
         const payload = processPayloadOf(named as ProcessFieldsName, input)
         if (named === 'SessionStart' && payload['source'] === 'compact') {
-          const started = isBefore ? compactionStarts.shift() : undefined
-          return started === undefined ? undefined : hookAnswerOf(name, named, started)
+          if (!isBefore) return undefined
+          const task = compacting?.agentId
+          const model = task === undefined ? await claude.session.model() : undefined
+          const answer = await raise(method, { ...payload, ...defined({ task, model, title: current.title || undefined }) })
+          if (answer === undefined) return undefined
+          return hookAnswerOf(name, named, task === undefined ? answer : defined({ note: answer['note'] }))
         }
         if (!isBefore) {
           void raise(method, payload)
           return undefined
         }
+        if (named === 'ModelChange') modelNotes.splice(0)
         const answer = await raise(method, payload)
-        return answer === undefined ? undefined : hookAnswerOf(name, named, answer)
+        if (answer === undefined) return undefined
+        if (named === 'ModelChange' && typeof answer['note'] === 'string' && answer['refuse'] === undefined) modelNotes.push(modNote(name, answer['note']))
+        return hookAnswerOf(name, named, answer)
       },
       isBefore ? failed : undefined,
     )
   }
 
-  const compactionStarts: HookFields[] = []
-
-  const compactionNote = async (e: Args<'session.compact'>, next: (e: Args<'session.compact'>) => Promise<SessionCompactResult>): Promise<SessionCompactResult> => {
-    const compacted = await next(e)
-    if (e.trigger === 'precompute' || compacted.skip !== undefined) return compacted
-    const model = e.agentId === undefined ? await claude.session.model() : undefined
-    const answer = await raise('beforeSessionStart', { session: current.id, cwd: current.cwd, ...defined({ task: e.agentId, model, title: current.title || undefined, contextTokenCount: compacted.tokensAfter }), source: 'compact' })
-    const { note, ...started } = answer ?? {}
-    if (Object.keys(started).length > 0) compactionStarts.push(started)
-    if (typeof note !== 'string') return compacted
-    if (!isGranted('prompt')) {
-      report('session:beforeSessionStart', 'The beforeSessionStart listener failed', new Error(`${name}: its note adds text Claude reads, which needs the prompt permission.`))
-      return compacted
+  const modelNotes: string[] = []
+
+  let compacting: Args<'session.compact'> | undefined
+
+  const trackCompaction = async (e: Args<'session.compact'>, next: (e: Args<'session.compact'>) => Promise<SessionCompactResult>): Promise<SessionCompactResult> => {
+    compacting = e
+    try {
+      return await next(e)
+    } finally {
+      if (compacting === e) compacting = undefined
     }
-    return { ...compacted, messages: [...compacted.messages, { role: 'user', text: modNote(name, note), toolUses: [] }] }
   }
 
   const listen = (method: string, args: readonly unknown[], isEveryAgent = false): Subscription => {
@@ -608,7 +649,7 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
     follow(next) {
       const moved = next.id !== current.id && current.id !== ''
       const previous = current.id
-      current = { ...next, title: next.title || (next.id === current.id ? current.title : ''), isRunning: true, lastAt: new Date().toISOString() }
+      current = colored({ ...next, title: next.title || (next.id === current.id ? current.title : ''), isRunning: true, lastAt: new Date().toISOString() })
       if (!moved) return
       for (const into of [listening, deciding]) {
         const kept = into.get(previous)
@@ -621,6 +662,10 @@ export function createSessionsClient({ name, claude, report, isGranted, hookOn,
       subscribe(previous)
       subscribe(current.id)
     },
+    recolor(next) {
+      told = next
+      current = colored(current)
+    },
   }
 }
 
@@ -654,9 +699,9 @@ const modelChangeOf = (input: HookFields) => ({
 
 const answerKeys: Readonly<Record<string, readonly string[]>> = {
   Run: ['args', 'note', 'result', 'exitCode', 'refuse'],
-  ProjectSetup: [],
+  ProjectSetup: ['note'],
   SessionStart: ['note', 'title', 'reloadSkills', 'firstPrompt'],
-  ModelChange: ['ask', 'refuse'],
+  ModelChange: ['ask', 'refuse', 'note'],
   WorktreeCreate: ['result'],
   Elicitation: ['refuse'],
   ElicitationResponse: ['refuse'],
@@ -706,19 +751,20 @@ const processFields: { readonly [Name in ProcessFieldsName]: (input: HookFields)
   ReplyDisplay: (input) => ({ replyId: input['message_id'], index: input['index'], isLast: input['final'], text: input['delta'] }),
 }
 
-export async function spawnTask(claude: Pick<Claude, 'agent'>, task: TaskStartArgs): Promise<TaskData> {
+export async function spawnTask(claude: Pick<Claude, 'agent'>, task: TaskStartArgs, forkedFrom?: string): Promise<TaskData> {
   if (task.title.trim() === '') throw new Error('a task needs a title.')
+  const { name, agentType, model, cwd }: TaskStartArgs = forkedFrom === undefined ? task : { prompt: task.prompt, title: task.title, agentType: forkAgentType }
   const started = await claude.agent.spawn({
     prompt: task.prompt,
     description: task.title,
-    ...(task.name === undefined ? {} : { name: task.name }),
-    ...(task.agentType === undefined ? {} : { subagentType: task.agentType }),
-    ...(task.model === undefined ? {} : { model: task.model }),
-    ...(task.cwd === undefined ? {} : { cwd: task.cwd }),
+    ...(name === undefined ? {} : { name }),
+    ...(agentType === undefined ? {} : { subagentType: agentType }),
+    ...(model === undefined ? {} : { model }),
+    ...(cwd === undefined ? {} : { cwd }),
   })
   if (started.deny !== undefined) throw new Error(`Claude Code refused the task: ${started.deny}`)
   if (started.agentId === undefined) throw new Error('Claude Code answered without starting a task.')
-  return { id: started.agentId, title: task.title, agentType: task.agentType ?? 'general-purpose', model: started.model, openedBy: '', openedAt: new Date().toISOString() }
+  return { id: started.agentId, title: task.title, ...(forkedFrom === undefined ? { agentType: agentType ?? 'general-purpose' } : { forkedFrom }), model: started.model, openedBy: '', openedAt: new Date().toISOString() }
 }
 
 export function processPayloadOf(named: ProcessFieldsName, input: unknown): HookFields {
@@ -734,6 +780,7 @@ function hookAnswerOf(name: string, named: string, answer: HookFields): HookFiel
     if (refuse !== undefined) return { permissionDecision: 'deny', permissionDecisionReason: refuse }
     return typeof answer['ask'] === 'string' ? { permissionDecision: 'ask', permissionDecisionReason: answer['ask'] } : undefined
   }
+  if (named === 'ProjectSetup') return defined({ additionalContext: note })
   if (named === 'WorktreeCreate') return defined({ worktreePath: answer['result'] })
   if (named === 'PermissionDenial') return answer['retry'] === true ? { retry: true } : undefined
   if (named === 'ToolBatch') return defined({ additionalContext: note })

package/src/runtime/toaster.ts

@@ -30,9 +30,11 @@ type Entry = {
   readonly options: ToastOptions
   readonly actions: readonly Action[]
   readonly hides?: string
+  at: Date
   isOpen: boolean
   reporting?: Reporting | undefined
   trying?: string | RenderElement | undefined
+  spinsFrom?: number | undefined
   timer: Timer | undefined
 }
 
@@ -46,6 +48,8 @@ const defaultDuration = 4000
 const visibleToasts = 3
 const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const
 const spinnerMs = 100
+const spinFrames = 10_000 / spinnerMs
+const still = '…'
 const icons: Record<Exclude<ToastType, 'loading'>, { readonly glyph: string; readonly color?: string }> = {
   default: { glyph: ' ' },
   success: { glyph: '✓', color: 'success' },
@@ -71,15 +75,20 @@ export function createToaster(claude: Claude, name: string, version: () => strin
   let showsAll = false
   let bandId: string | undefined
 
+  const isLoading = (entry: Entry) => entry.type === 'loading' || entry.trying !== undefined
+
+  const isSpinning = (entry: Entry) => entry.spinsFrom !== undefined && frame - entry.spinsFrom < spinFrames
+
   const changed = () => {
-    const isLoading = [...entries.values()].some((entry) => entry.type === 'loading' || entry.trying !== undefined)
-    if (isLoading && spinning === undefined) {
+    for (const entry of entries.values()) entry.spinsFrom = isLoading(entry) ? (entry.spinsFrom ?? frame) : undefined
+    const spins = [...entries.values()].some(isSpinning)
+    if (spins && spinning === undefined) {
       spinning = claude.clock.every(spinnerMs, () => {
         frame += 1
-        claude.ui.invalidate('ui.render')
+        changed()
       })
     }
-    if (!isLoading && spinning !== undefined) {
+    if (!spins && spinning !== undefined) {
       spinning.cancel()
       spinning = undefined
     }
@@ -121,7 +130,7 @@ export function createToaster(claude: Claude, name: string, version: () => strin
     }
     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 }
+    const entry: Entry = { id, type, message, options, actions, ...(hides === undefined ? {} : { hides }), at: new Date(), 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()
@@ -181,14 +190,19 @@ export function createToaster(claude: Claude, name: string, version: () => strin
     if (hidden.get(id) === hides) return id
     hidden.delete(id)
     const shown = entries.get(id)
-    if (shown?.hides === hides && shown.trying === undefined && shown.options.description === description) return id
+    if (shown?.hides === hides && shown.trying === undefined && shown.options.description === description) {
+      const previous = clockTime(shown.at)
+      shown.at = new Date()
+      if (clockTime(shown.at) !== previous) changed()
+      return 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}`
+      return `${name} ${modVersion}, @cmodjs/core ${coreVersion}, at ${(entries.get(id)?.at ?? new Date()).toISOString()}\n${message}${description === undefined ? '' : `\n${description}`}${stack}`
     }
     const startReporting = async () => {
       const shown = entries.get(id)
@@ -233,13 +247,13 @@ export function createToaster(claude: Claude, name: string, version: () => strin
   const row = (entry: Entry): RenderElement => {
     const { description } = entry.options
     const isText = typeof description === 'string'
-    const icon = entry.type === 'loading' || entry.trying !== undefined ? { glyph: spinner[frame % spinner.length] as string, color: 'claude' } : icons[entry.type]
+    const icon = entry.type === 'loading' || entry.trying !== undefined ? { glyph: isSpinning(entry) ? (spinner[frame % spinner.length] as string) : still, 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 buttons = Box({ gap: 2, flexWrap: 'wrap', children: [...actions, close] })
+    const buttons = Box({ gap: 2, flexWrap: 'wrap', children: [...actions, close, Text({ dimColor: true, children: clockTime(entry.at) })].map(fixed) })
     const trying = entry.trying === undefined ? undefined : Box({ gap: 1, children: [Text({ dimColor: true, children: 'Trying again:' }), typeof entry.trying === 'string' ? Text({ dimColor: true, wrap: 'truncate-end', children: entry.trying }) : entry.trying] })
     const text = details === undefined ? [message] : [message, trying ?? details]
     const under = trying !== undefined && details === undefined ? [trying] : entry.reporting === undefined ? [buttons] : reportChoices(entry, entry.reporting)
@@ -362,3 +376,7 @@ function reportPrompt(name: string, contact: Contact | undefined, details: strin
         : `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}`
 }
+
+function clockTime(at: Date): string {
+  return `${String(at.getHours()).padStart(2, '0')}:${String(at.getMinutes()).padStart(2, '0')}`
+}