kimaki 1.3.0 → 1.5.0

package/src/session-commands.e2e.test.ts

@@ -32,6 +32,7 @@ function reply(marker: string, text: string, extra: DeterministicMatcher['when']
 const matchers: DeterministicMatcher[] = [
   reply('new-marker', 'saw the file', { rawPromptIncludes: 'file-body-marker' }),
   reply('first-marker', 'first answer'),
+  reply('empty-marker', 'started on the first message'),
   reply('second-marker', 'second answer', {}, 510),
   reply('tui-marker', 'tui answer'),
   reply('resumed-marker', 'resumed answer'),
@@ -137,16 +138,42 @@ test('/new-session starts a thread with attached files and an agent', async () =
   `)
   expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **tommy:** Read it new-marker
-    Files: notes.txt
+    -# » **tommy:** Read it new-marker
+    -# Files: notes.txt
     -# *using deterministic-provider/deterministic-v2 ⋅ plan*
     saw the file
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ plan*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ plan*"
   `)
   // A slash command thread has no start message: the user must be added explicitly.
   expect(await discord.channel(thread.id).getMemberIds()).toContain(TEST_USER_ID)
 })
 
+test('/new-session without a prompt waits for the first thread message', async () => {
+  const { discord, channelId } = twin
+  const user = discord.channel(channelId).user(TEST_USER_ID)
+  const client = await server.client()
+  const thread = await newThread(() =>
+    user.runSlashCommand({ name: 'new-session', options: [{ name: 'agent', type: 3, value: 'plan' }] }),
+  )
+  await waitFor({ label: 'ready note', check: async () => (await discord.thread(thread.id).text()).includes('Send a message') })
+  const sessionId = bot.store.getState().roots[thread.id]
+  if (!sessionId) throw new Error('thread has no session')
+  expect((await client.message.list({ sessionID: sessionId, order: 'asc', limit: 10 })).data).toEqual([])
+  await discord.thread(thread.id).user(TEST_USER_ID).sendMessage({ content: 'Go empty-marker' })
+  await waitForFooter({ discord, threadId: thread.id })
+  expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: assistant (TestBot)
+    Send a message to start working.
+    --- from: user (tommy)
+    Go empty-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ plan*
+    started on the first message
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ plan*"
+  `)
+  expect(thread.name).toBe('Kimaki session')
+})
+
 test('/resume binds an existing session to a new thread and moves the binding', async () => {
   const { discord, channelId } = twin
   // A session started outside Discord (for example in the TUI).
@@ -180,10 +207,10 @@ test('/resume binds an existing session to a new thread and moves the binding',
     Go on resumed-marker
     --- from: assistant (TestBot)
     resumed answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-    » **user:** Back in the TUI tui-marker
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# » **user:** Back in the TUI tui-marker
     tui answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 
   // Resuming again moves the session: the old thread stops following it.
@@ -229,7 +256,7 @@ test('/fork forks before a user message into a new thread', async () => {
     Check fork-check
     --- from: assistant (TestBot)
     fork has only the first message
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(hide(await discord.thread(source.id).text())).toMatchInlineSnapshot(`
     "--- from: user (tommy)
@@ -237,12 +264,12 @@ test('/fork forks before a user message into a new thread', async () => {
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     first answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     --- from: user (tommy)
     Then second-marker
     --- from: assistant (TestBot)
     second answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     Session forked! Continue in <#THREAD>"
   `)
 })
@@ -296,7 +323,7 @@ test('/fork-subagent forks a subagent session into a new thread', async () => {
     More child-followup
     --- from: assistant (TestBot)
     child fork continues
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ general*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ general*"
   `)
 })
 
@@ -321,6 +348,6 @@ test('/resume of a session waiting on a question shows the question in the new t
     Which color?
     ✓ _Red_
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
 })

package/src/session-events.ts

@@ -14,7 +14,7 @@
 import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
-import type { OpenCodeClient } from '@opencode/client'
+import type { OpenCodeClient, V2Event } from '@opencode/client'
 
 import type { KimakiDb } from './db.ts'
 import { ConfigError, DbError, OpenCodeError } from './errors.ts'
@@ -107,12 +107,16 @@ export async function resolveSession({
   return { threadId: row.thread_id, sessionId: row.session_id }
 }
 
-type Message = Awaited<ReturnType<OpenCodeClient['message']['list']>>['data'][number]
+export type Message = Awaited<ReturnType<OpenCodeClient['message']['list']>>['data'][number]
 type Session = Awaited<ReturnType<OpenCodeClient['session']['get']>>
 
+// Long enough for most edits, commands and subagent prompts; huge writes stay short.
+const TOOL_INPUT_LIMIT = 5000
+
 function renderMessage(message: Message, options: { thinking?: boolean; verbose?: boolean }): string {
   const time = new Date(message.time.created).toISOString()
-  if (message.type === 'user') return `## user ${time}\n\n${message.text}`
+  if (message.type === 'user' || message.type === 'synthetic' || message.type === 'system') return `## ${message.type} ${time}\n\n${message.text}`
+  if (message.type === 'compaction' && message.status !== 'failed') return `## compaction ${time}\n\n${message.summary}`
   if (message.type !== 'assistant') return `## ${message.type} ${time}\n\n${JSON.stringify(message)}`
   const header = `## assistant ${time} (${message.agent}, ${message.model.providerID}/${message.model.id})`
   const parts = message.content.map((part) => {
@@ -120,10 +124,12 @@ function renderMessage(message: Message, options: { thinking?: boolean; verbose?
     if (part.type === 'reasoning') return options.thinking ? part.text : ''
     if (part.type === 'tool') {
       const state = part.state
-      const input = options.verbose ? JSON.stringify(state.input ?? {}) : JSON.stringify(state.input ?? {}).slice(0, 500)
+      const input = options.verbose ? JSON.stringify(state.input ?? {}) : JSON.stringify(state.input ?? {}).slice(0, TOOL_INPUT_LIMIT)
       const error = state.status === 'error' ? `\nerror: ${JSON.stringify(state).slice(0, 500)}` : ''
       const output = options.verbose && state.status === 'completed' ? `\n${JSON.stringify(state.content)}` : ''
-      return `tool ${part.name} [${state.status}] ${input}${error}${output}`
+      // Without --verbose tool outputs are hidden, but uploaded media stays findable.
+      const media = options.verbose ? '' : mediaBlock(uploadedMedia(part))
+      return `tool ${part.name} [${state.status}] ${input}${error}${output}${media && `\n${media}`}`
     }
     return ''
   })
@@ -131,34 +137,139 @@ function renderMessage(message: Message, options: { thinking?: boolean; verbose?
   return `${header}\n\n${parts.join('\n\n')}${finish}`
 }
 
+export function formatDuration(ms: number): string {
+  if (ms < 1_000) return '<1s'
+  const seconds = Math.floor(ms / 1_000)
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`
+}
+
+export function formatTokens(tokens: number): string {
+  return tokens < 1_000 ? String(tokens) : `${Math.round(tokens / 1_000)}k`
+}
+
+export type SessionUsage = { contextTokens: number; runMs: number | null; endedAt: number }
+
+// Context size of the latest step, length of the latest run and when it ended. Oldest-first input.
+// Agents use it to judge if a follow-up would rewrite a big, expired prompt cache.
+export function sessionUsage(messages: readonly Message[]): SessionUsage | null {
+  const lastIndex = messages.findLastIndex((message) => message.type === 'assistant')
+  const last = messages[lastIndex]
+  if (last?.type !== 'assistant') return null
+  const step = messages.findLast((message) => message.type === 'assistant' && !!message.tokens)
+  const tokens = step?.type === 'assistant' ? step.tokens : undefined
+  const contextTokens = tokens ? tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write : 0
+  // A run starts at a user prompt. Synthetic items also arrive mid-run (subagent results), so they count only without one.
+  const before = messages.slice(0, lastIndex)
+  const start = before.findLast((message) => message.type === 'user') ?? before.findLast((message) => message.type === 'synthetic')
+  const endedAt = last.time.completed ?? last.time.created
+  return { contextTokens, runMs: start ? endedAt - start.time.created : null, endedAt }
+}
+
+function usageLine(usage: SessionUsage | null, now: number): string {
+  if (!usage) return ''
+  const run = usage.runMs === null ? '' : `, last run took ${formatDuration(usage.runMs)}`
+  return `\n\ncontext: ${formatTokens(usage.contextTokens)} tokens${run}, last active ${formatDuration(now - usage.endedAt)} ago (${new Date(usage.endedAt).toISOString()})`
+}
+
+// The text of the last assistant message that has text, like OpenCode's
+// subagent completion (session/subagent-completion.ts). Oldest-first input.
+export function finalAnswer(messages: readonly Message[]): string | null {
+  for (const message of [...messages].reverse()) {
+    if (message.type === 'user') return null
+    if (message.type !== 'assistant') continue
+    const text = message.content.flatMap((part) => (part.type === 'text' && part.text.trim() ? [part.text.trim()] : [])).join('\n\n')
+    if (text) return text
+  }
+  return null
+}
+
+type MessagePart = Extract<Message, { type: 'assistant' }>['content'][number]
+
+const UPLOAD_RESULT_PREFIX = '{"uploaded":'
+// `"url":"..."` of each file in that JSON line (upload in prompt.ts). A regex, not zod:
+// this module loads on every CLI start. Discord URLs have no quotes or backslashes.
+const UPLOAD_URL = /"url":"([^"\\]+)"/g
+
+// Discord URLs of the files a `kimaki upload-to-discord` call posted, from the result
+// line it printed into the shell output (the system prompt says never to pipe it).
+// The session history holds them, so this needs no Discord read and survives restarts.
+function uploadedMedia(part: MessagePart): string[] {
+  if (part.type !== 'tool' || part.state.status !== 'completed') return []
+  return part.state.content
+    .flatMap((content) => (content.type === 'text' ? content.text.split('\n') : []))
+    .filter((line) => line.startsWith(UPLOAD_RESULT_PREFIX))
+    .flatMap((line) => [...line.matchAll(UPLOAD_URL)].map((match) => match[1]!))
+}
+
+function mediaBlock(urls: readonly string[]): string {
+  return urls.length === 0 ? '' : `Media uploaded to Discord:\n${urls.map((url) => `- ${url}`).join('\n')}`
+}
+
+// Inputs and the final answer of each turn, no tool calls: what agents read most often.
+function renderAnswers({ session, messages, usage = '' }: { session: Pick<Session, 'id' | 'title' | 'location'>; messages: Message[]; usage?: string }): string {
+  const title = `# ${session.title} (${session.id})\n\ndirectory: ${session.location.directory}${usage}`
+  const blocks: string[] = []
+  let turn: Message[] = []
+  const flush = () => {
+    const answer = finalAnswer(turn)
+    const last = turn.findLast((message) => message.type === 'assistant')
+    const media = mediaBlock(turn.flatMap((message) => (message.type === 'assistant' ? message.content.flatMap(uploadedMedia) : [])))
+    if (answer && last?.type === 'assistant') blocks.push(`## assistant ${new Date(last.time.created).toISOString()} (${last.agent}, ${last.model.providerID}/${last.model.id})\n\n${answer}${media && `\n\n${media}`}`)
+    turn = []
+  }
+  for (const message of messages) {
+    if (message.type === 'assistant') {
+      turn.push(message)
+      continue
+    }
+    flush()
+    if (message.type === 'user' || message.type === 'synthetic') blocks.push(`## ${message.type} ${new Date(message.time.created).toISOString()}\n\n${message.text}`)
+    if (message.type === 'compaction' && message.status !== 'failed') blocks.push(`## compaction ${new Date(message.time.created).toISOString()}\n\n${message.summary}`)
+  }
+  // A turn without an answer yet (running, or waiting on a question): show its tool calls.
+  if (turn.length > 0 && !finalAnswer(turn)) blocks.push(...turn.map((message) => renderMessage(message, {})))
+  else flush()
+  const more = `Only prompts and final answers are shown. Every tool call and the reasoning: kimaki session read ${session.id} --thinking`
+  return [title, ...blocks, more].join('\n\n')
+}
+
 // Oldest first, as markdown. OpenCode returns the newest first.
+// Default: prompts and final answers. `full`: every message with tool calls.
 export async function readSessionMarkdown({
   client,
   sessionId,
+  full,
   thinking,
   verbose,
 }: {
   client: OpenCodeClient
   sessionId: string
+  full?: boolean
   thinking?: boolean
   verbose?: boolean
 }): Promise<OpenCodeError | string> {
-  const session = await client.session
-    .get({ sessionID: sessionId })
-    .catch((e) => new OpenCodeError({ operation: 'session.get', cause: e }))
+  const [session, messages] = await Promise.all([
+    client.session.get({ sessionID: sessionId }).catch((e) => new OpenCodeError({ operation: 'session.get', cause: e })),
+    allMessages({ client, sessionId }),
+  ])
   if (session instanceof Error) return session
-  const messages = await allMessages({ client, sessionId })
   if (messages instanceof Error) return messages
-  return renderSession({ session, messages, thinking, verbose })
+  const usage = usageLine(sessionUsage(messages), Date.now())
+  if (!full && !thinking && !verbose) return renderAnswers({ session, messages, usage })
+  return renderSession({ session, messages, thinking, verbose, usage })
 }
 
-function renderSession({ session, messages, thinking, verbose }: { session: Pick<Session, 'id' | 'title' | 'location'>; messages: Message[]; thinking?: boolean; verbose?: boolean }): string {
-  const title = `# ${session.title} (${session.id})\n\ndirectory: ${session.location.directory}`
+// Transcripts pass no usage: their "ago" would be stale on disk.
+function renderSession({ session, messages, thinking, verbose, usage = '' }: { session: Pick<Session, 'id' | 'title' | 'location'>; messages: Message[]; thinking?: boolean; verbose?: boolean; usage?: string }): string {
+  const title = `# ${session.title} (${session.id})\n\ndirectory: ${session.location.directory}${usage}`
   return [title, ...messages.map((message) => renderMessage(message, { thinking, verbose }))].join('\n\n')
 }
 
 // Transcripts: <dataDir>/transcripts/<sessionId>.md, the `session read` markdown
-// (no thinking, no tool outputs) so agents can search every session with rg.
+// with thinking but no tool outputs, so agents can search every session with rg.
 // The file mtime is the session's time.updated: a file at least that new is current.
 export function transcriptsDir({ dataDir }: { dataDir: string }): string {
   return path.join(dataDir, 'transcripts')
@@ -172,7 +283,7 @@ export async function writeTranscript({ client, dataDir, session }: { client: Op
   const temp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`
   const written = await (async () => {
     await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 })
-    await fs.promises.writeFile(temp, `${renderSession({ session, messages })}\n`, { mode: 0o600 })
+    await fs.promises.writeFile(temp, `${renderSession({ session, messages, thinking: true })}\n`, { mode: 0o600 })
     await fs.promises.utimes(temp, session.time.updated / 1000, session.time.updated / 1000)
     await fs.promises.rename(temp, file)
   })().catch((cause) => new ConfigError({ reason: `Cannot write ${file}`, cause }))
@@ -260,14 +371,34 @@ export function allMessages({ client, sessionId, type }: { client: OpenCodeClien
   })
 }
 
-export function allSessions({ client, directory }: { client: OpenCodeClient; directory?: string }) {
+export function allSessions({ client, project }: { client: OpenCodeClient; project?: string }) {
   return collectPages({
     operation: 'session.list',
-    page: (cursor) => client.session.list({ directory, limit: 200, ...(cursor ? { cursor } : { order: 'desc' as const }) }),
+    page: (cursor) => client.session.list({ project, limit: 200, ...(cursor ? { cursor } : { order: 'desc' as const }) }),
   })
 }
 
-export async function waitForSessionReady({ client, sessionId, signal }: { client: OpenCodeClient; sessionId: string; signal?: AbortSignal }): Promise<OpenCodeError | void> {
+// Why `kimaki session wait` returned for a session. `idle`: no run was in progress
+// when the wait started. `running`: the timeout ended the wait first.
+export type WaitStatus = 'finished' | 'failed' | 'interrupted' | 'idle' | 'question' | 'permission' | 'running'
+
+function eventStatus(event: V2Event): { sessionId: string; status: WaitStatus } | null {
+  if (event.type === 'form.created') return { sessionId: event.data.form.sessionID, status: 'question' }
+  if (event.type === 'permission.asked') return { sessionId: event.data.sessionID, status: 'permission' }
+  if (event.type === 'session.execution.succeeded') return { sessionId: event.data.sessionID, status: 'finished' }
+  if (event.type === 'session.execution.failed') return { sessionId: event.data.sessionID, status: 'failed' }
+  if (event.type === 'session.execution.interrupted') return { sessionId: event.data.sessionID, status: 'interrupted' }
+  return null
+}
+
+// Waits until every session ended its run or paused for the user, on one event stream.
+// When `signal` ends the wait, the sessions not done yet get `running`.
+export async function waitForSessions({ client, sessionIds, signal }: { client: OpenCodeClient; sessionIds: readonly string[]; signal?: AbortSignal }): Promise<OpenCodeError | Map<string, WaitStatus>> {
+  const statuses = new Map<string, WaitStatus>()
+  const settle = (sessionId: string, status: WaitStatus) => {
+    if (sessionIds.includes(sessionId) && !statuses.has(sessionId)) statuses.set(sessionId, status)
+  }
+  const done = () => statuses.size === new Set(sessionIds).size
   const controller = new AbortController()
   const subscriptionSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal
   const iterator = client.event.subscribe({ signal: subscriptionSignal })[Symbol.asyncIterator]()
@@ -275,27 +406,39 @@ export async function waitForSessionReady({ client, sessionId, signal }: { clien
     const first = await iterator.next().catch((cause) => new OpenCodeError({ operation: 'event.subscribe', cause }))
     if (first instanceof Error) return first
     if (first.done || first.value.type !== 'server.connected') return new OpenCodeError({ operation: 'connect session wait stream' })
+    // Subscribed before hydrating, so no run can end unseen in between.
     const consume = (async () => {
       while (!subscriptionSignal.aborted) {
         const next = await iterator.next().catch((cause) => new OpenCodeError({ operation: 'event.subscribe', cause }))
         if (next instanceof Error) return next
         if (next.done) return new OpenCodeError({ operation: 'session wait stream ended' })
-        const event = next.value
-        if (event.type === 'form.created' && event.data.form.sessionID === sessionId) return
-        if (event.type === 'permission.asked' && event.data.sessionID === sessionId) return
-        if ((event.type === 'session.execution.succeeded' || event.type === 'session.execution.failed' || event.type === 'session.execution.interrupted') && event.data.sessionID === sessionId) return
+        const ended = eventStatus(next.value)
+        if (ended) settle(ended.sessionId, ended.status)
+        if (done()) return
       }
       return new OpenCodeError({ operation: 'session wait cancelled' })
     })()
     const hydrated = await Promise.all([
-      client.session.active(), client.session.form.list({ sessionID: sessionId }), client.permission.list({ sessionID: sessionId }),
+      client.session.active({ signal: subscriptionSignal }),
+      Promise.all(sessionIds.map((sessionID) => Promise.all([
+        client.session.form.list({ sessionID }, { signal: subscriptionSignal }),
+        client.permission.list({ sessionID }, { signal: subscriptionSignal }),
+      ]))),
     ]).catch((cause) => new OpenCodeError({ operation: 'hydrate session wait', cause }))
     if (hydrated instanceof Error) return hydrated
-    const [active, forms, permissions] = hydrated
-    if (!(sessionId in active) || forms.length > 0 || permissions.length > 0) return
+    const [active, pending] = hydrated
+    for (const [index, sessionId] of sessionIds.entries()) {
+      const [forms, permissions] = pending[index] ?? [[], []]
+      if (forms.length > 0) settle(sessionId, 'question')
+      if (permissions.length > 0) settle(sessionId, 'permission')
+      if (!active[sessionId]) settle(sessionId, 'idle')
+    }
+    if (done()) return
     return consume
   })()
   controller.abort()
   await iterator.return?.(undefined).catch(() => undefined)
-  return result
+  if (result instanceof Error && !signal?.aborted) return result
+  for (const sessionId of sessionIds) settle(sessionId, 'running')
+  return statuses
 }

package/src/session-ops.e2e.test.ts

@@ -16,6 +16,7 @@ import {
   startTwin,
   tempDataDir,
   textParts,
+  waitFor,
   waitForBotMessageContaining,
   waitForFooter,
   warmUp,
@@ -32,6 +33,21 @@ const matchers: DeterministicMatcher[] = [
     then: { parts: textParts('## Objective\n- Test compaction') },
   },
   { id: 'usage', priority: 500, when: { latestUserTextIncludes: 'usage-marker' }, then: { parts: textParts('counted') } },
+  // A reasoning block that stays open long enough to run /context-usage inside it.
+  {
+    id: 'slow-thinking',
+    priority: 500,
+    when: { latestUserTextIncludes: 'thinking-marker' },
+    then: {
+      parts: [
+        { type: 'reasoning-start', id: 'r1' },
+        { type: 'reasoning-delta', id: 'r1', delta: 'pondering' },
+        { type: 'reasoning-end', id: 'r1' },
+        ...textParts('thought it through'),
+      ],
+      partDelaysMs: [0, 0, 2_500, 0, 0, 0, 0],
+    },
+  },
   ...scriptedTurn({
     marker: 'write-marker',
     steps: [{ id: 'call-write-1', tool: 'write', input: { path: 'undo.txt', content: 'written by the agent\n' } }],
@@ -75,40 +91,77 @@ async function command(threadId: string, name: string, text: string) {
   return waitForBotMessageContaining({ discord: twin.discord, threadId, text })
 }
 
+// /context-usage status durations depend on timing.
+function stableDurations(text: string) {
+  return text.replace(/<1s|\b\d+m \d+s\b|\b\d+s\b/g, 'Ns')
+}
+
 test('/diff with a clean working tree and /context-usage after a turn', async () => {
   const thread = await newThread('Hello usage-marker')
   await command(thread.id, 'diff', 'No changes')
   await command(thread.id, 'context-usage', 'Context usage')
-  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+  expect(stableDurations(await twin.discord.thread(thread.id).text())).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Hello usage-marker
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     counted
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     No changes to show
     **Context usage:** 0%, 2 / 200,000 tokens
-    **Model:** deterministic-provider/deterministic-v2"
+    **Model:** deterministic-provider/deterministic-v2
+    **Status:** idle for Ns"
+  `)
+})
+
+test('/context-usage while the model thinks shows the run and what it does', async () => {
+  const { discord, channelId } = twin
+  const before = new Set((await discord.channel(channelId).getThreads()).map((thread) => thread.id))
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Ponder this thinking-marker' })
+  const thread = await discord.channel(channelId).waitForThread({ timeout: 8_000, predicate: (candidate) => !before.has(candidate.id) })
+  const client = await server.client()
+  await waitFor({
+    label: 'open reasoning block',
+    check: async () => {
+      const sessionId = bot.store.getState().roots[thread.id]
+      if (!sessionId) return null
+      const messages = await client.message.list({ sessionID: sessionId, type: 'assistant', order: 'desc', limit: 1 })
+      return messages.data.some((message) => message.type === 'assistant' && message.content.some((part) => part.type === 'reasoning')) || null
+    },
+  })
+  await command(thread.id, 'context-usage', 'Status:')
+  await waitForFooter({ discord, threadId: thread.id })
+  expect(stableDurations(await discord.thread(thread.id).text())).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Ponder this thinking-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    Token usage not available for this session yet
+    **Status:** running for Ns, thinking for Ns
+    **Last activity:** Ns ago, thinking
+    thought it through
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })
 
 test('/compact summarizes the history without a footer', async () => {
   const thread = await newThread('Something to compact')
   await command(thread.id, 'compact', 'Compacting')
-  await waitForBotMessageContaining({ discord: twin.discord, threadId: thread.id, text: 'context compacted' })
+  const sessionId = bot.store.getState().roots[thread.id]!
+  const client = await server.client()
+  await waitFor({
+    label: 'compaction message',
+    check: async () => (await client.message.list({ sessionID: sessionId, order: 'asc' })).data.some((message) => message.type === 'compaction') || null,
+  })
   expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Something to compact
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
-    Compacting the session context
-    -# ⬦ context compacted"
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    Compacting the session context"
   `)
-  const sessionId = bot.store.getState().roots[thread.id]!
-  const messages = await (await server.client()).message.list({ sessionID: sessionId, order: 'asc' })
-  expect(messages.data.map((message) => message.type)).toContain('compaction')
 })
 
 test('/undo hides the last turn but keeps its files, /redo restores the turn', async () => {
@@ -133,7 +186,7 @@ test('/undo hides the last turn but keeps its files, /redo restores the turn', a
     -# ◼︎ write *undo.txt* (2 lines)
 
     wrote undo.txt
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     Undone - removed the last turn from the session. File changes were kept
     Restored - session fully back to its previous state
     Nothing to redo - no previous undo found"