kimaki 1.4.0 → 1.5.0

package/src/coordinator-idle.e2e.test.ts

@@ -0,0 +1,122 @@
+// The coordinator plugin warmup (plugin/coordinator.ts) with a short window: an idle
+// coordinator with no running threads ends its warmup at the first check and is compacted.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterAll, beforeAll, expect, test } from 'vitest'
+
+import type { BotHandle } from './main.ts'
+import {
+  TEST_MODEL,
+  TEST_USER_ID,
+  seedProjectChannel,
+  startOpencodeTestServer,
+  startTestBot,
+  startTwin,
+  tempDataDir,
+  textParts,
+  waitFor,
+  waitForFooter,
+  warmUp,
+  type OpencodeTestServer,
+  type TestTwin,
+} from './test/harness.ts'
+
+let server: OpencodeTestServer
+let twin: TestTwin
+let bot: BotHandle
+const dataDir = tempDataDir()
+// A large context, so the compaction is worth it (plugin/coordinator.ts MIN_COMPACT_TOKENS),
+// in a 1M window like Claude Opus: only 12% of it, far below automatic compaction.
+const bigUsage = { inputTokens: 120_000, outputTokens: 1, totalTokens: 120_001 }
+
+beforeAll(async () => {
+  ;[server, twin] = await Promise.all([
+    startOpencodeTestServer({
+      models: { [TEST_MODEL]: { name: TEST_MODEL, limit: { context: 1_000_000, output: 32_000 } } },
+      matchers: [
+        // OpenCode rejects a summary without the template headings.
+        { id: 'compaction-summary', priority: 900, when: { latestUserTextIncludes: 'You MUST use this format for your response' }, then: { parts: textParts('## Objective\n- Keep coordinating') } },
+        {
+          id: 'hello',
+          priority: 100,
+          when: { latestUserTextIncludes: 'idle-marker' },
+          then: { parts: [{ type: 'text-start', id: 't' }, { type: 'text-delta', id: 't', delta: 'Hi there.' }, { type: 'text-end', id: 't' }, { type: 'finish', finishReason: 'stop', usage: bigUsage }] },
+        },
+      ],
+    }),
+    startTwin(),
+  ])
+  await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
+  await warmUp({ server })
+  bot = await startTestBot({ dataDir, twin, server, coordinator: true, warmupTimers: { intervalMs: 1_200, maxMs: 60_000 } })
+}, 60_000)
+
+afterAll(async () => {
+  await bot?.stop()
+  await twin?.stop()
+  await server?.stop()
+  fs.rmSync(dataDir, { recursive: true, force: true })
+})
+
+test('an idle coordinator gets compacted when its warmup ends', async () => {
+  const { discord, channelId } = twin
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Hello idle-marker' })
+  await waitForFooter({ discord, threadId: channelId })
+  const client = await server.client()
+  const root = bot.store.getState().roots[channelId]!
+  await waitFor({
+    label: 'compaction of the idle coordinator',
+    check: async () => (await client.message.list({ sessionID: root, order: 'desc', limit: 10 })).data.some((message) => message.type === 'compaction') || null,
+  })
+
+  expect(await discord.channel(channelId).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Hello idle-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    -# Coordinator mode is on: this channel is one session that starts and manages project threads for you. Use /new-session for a thread without it. Turn it off with /toggle-coordinator or start kimaki with \`--coordinator false\`.
+    Hi there.
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+  const messages = await client.message.list({ sessionID: root, order: 'asc', limit: 20 })
+  expect(messages.data.map((message) => message.type)).toMatchInlineSnapshot(`
+    [
+      "synthetic",
+      "synthetic",
+      "user",
+      "assistant",
+      "idle",
+      "compaction",
+      "idle",
+    ]
+  `)
+})
+
+// OpenCode reloads the plugin when its files change (every Kimaki build or upgrade).
+test('a plugin reload keeps the pending compaction', async () => {
+  const { discord, channelId } = twin
+  const client = await server.client()
+  const root = bot.store.getState().roots[channelId]!
+  const compactions = async () => (await client.message.list({ sessionID: root, order: 'desc', limit: 20 })).data.filter((message) => message.type === 'compaction').length
+  expect(await compactions()).toBe(1)
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Again idle-marker' })
+  await waitForFooter({ discord, threadId: channelId, count: 2 })
+  fs.appendFileSync(path.join(server.configDir, 'plugins', 'kimaki', 'index.js'), '// reload\n')
+  await waitFor({ label: 'compaction after the plugin reload', check: async () => (await compactions()) === 2 || null })
+
+  const messages = await client.message.list({ sessionID: root, order: 'asc', limit: 30 })
+  const firstCompaction = messages.data.findIndex((message) => message.type === 'compaction')
+  expect(messages.data.slice(firstCompaction + 1).map((message) => message.type)).toMatchInlineSnapshot(`
+    [
+      "idle",
+      "synthetic",
+      "synthetic",
+      "user",
+      "assistant",
+      "idle",
+      "compaction",
+      "idle",
+    ]
+  `)
+})

package/src/coordinator-queue.e2e.test.ts

@@ -0,0 +1,279 @@
+// The queue in a coordinator channel: the channel itself is the conversation, so
+// acks and "Queued message sent" replies land in the channel. Every queued
+// prompt that got an ack is marked when it starts, also when the coordinator
+// answers IDLE; its answer is then not a second reply to the same message.
+
+import { execFile } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import type { DeterministicMatcher } from 'opencode-deterministic-provider'
+import { afterAll, beforeAll, expect, test } from 'vitest'
+
+import type { BotHandle } from './main.ts'
+import {
+  TEST_USER_ID,
+  isFooter,
+  seedProjectChannel,
+  slowTextMatcher,
+  startOpencodeTestServer,
+  startTestBot,
+  startTwin,
+  tempDataDir,
+  textParts,
+  waitFor,
+  waitForBotMessageContaining,
+  waitForFooter,
+  warmUp,
+  type OpencodeTestServer,
+  type TestTwin,
+} from './test/harness.ts'
+
+const exec = promisify(execFile)
+
+function reply(marker: string, text: string): DeterministicMatcher {
+  return { id: marker, priority: 50, when: { latestUserTextIncludes: marker }, then: { parts: textParts(text) } }
+}
+
+const matchers: DeterministicMatcher[] = [
+  slowTextMatcher({ marker: 'slow-marker', text: 'slow-done', delayMs: 1_200 }),
+  reply('queued-idle', 'IDLE'),
+  reply('queued-one', 'queued one ok'),
+  reply('queued-two', 'queued two ok'),
+  reply('steer-marker', 'steer ok'),
+  reply('idle-marker', 'idle ok'),
+  reply('hello-marker', 'hello'),
+]
+
+let server: OpencodeTestServer
+let twin: TestTwin
+let bot: BotHandle
+const dataDir = tempDataDir()
+
+beforeAll(async () => {
+  ;[server, twin] = await Promise.all([startOpencodeTestServer({ matchers }), startTwin()])
+  await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
+  await warmUp({ server })
+  bot = await startTestBot({ dataDir, twin, server, coordinator: true })
+  // The coordinator session exists before any test: its banner is not part of one test's snapshot.
+  await twin.discord.channel(twin.channelId).user(TEST_USER_ID).sendMessage({ content: 'Start hello-marker' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId })
+}, 60_000)
+
+afterAll(async () => {
+  await bot?.stop()
+  await twin?.stop()
+  await server?.stop()
+  fs.rmSync(dataDir, { recursive: true, force: true })
+})
+
+// The channel holds every test's turns: the text from the user message that starts with `content`.
+async function channelTextFrom(content: string): Promise<string> {
+  const text = await twin.discord.channel(twin.channelId).text({ showReplies: true })
+  return text.slice(text.lastIndexOf('--- from:', text.lastIndexOf(`\n${content}`)))
+}
+
+function footers(): Promise<number> {
+  return twin.discord.channel(twin.channelId).getMessages().then((messages) => messages.filter(isFooter).length)
+}
+
+// Sends a slow prompt and waits until the coordinator runs it.
+async function startSlowTurn(content: string) {
+  const channel = twin.discord.channel(twin.channelId)
+  channel.clearTypingEvents()
+  await channel.user(TEST_USER_ID).sendMessage({ content: `${content} slow-marker` })
+  await channel.waitForTypingEvent()
+}
+
+async function waitForIdle() {
+  await waitFor({ label: 'coordinator idle', check: async () => !bot.store.getState().threads[twin.channelId]?.turn || null })
+}
+
+function rootSession(): string {
+  const sessionID = bot.store.getState().roots[twin.channelId]
+  if (!sessionID) throw new Error('no coordinator session')
+  return sessionID
+}
+
+test('. queue in a busy coordinator: each queued message gets a reply when it starts, also when it answers IDLE', async () => {
+  const before = await footers()
+  await startSlowTurn('First a long one')
+  const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
+  const silent = await user.sendMessage({ content: 'Start a worker queued-idle. queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  const answered = await user.sendMessage({ content: 'Then answer queued-two. queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'queued two ok' })
+  // The IDLE turn posts no footer: slow-done and queued two get one each.
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 2 })
+  expect(await channelTextFrom('First a long one')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    First a long one slow-marker
+    Start a worker queued-idle. queue
+    --- from: assistant (TestBot)
+    [reply to tommy: Start a worker queued-idle. queue]
+    -# Queued
+    --- from: user (tommy)
+    Then answer queued-two. queue
+    --- from: assistant (TestBot)
+    [reply to tommy: Then answer queued-two. queue]
+    -# Queued
+    [reply to tommy: First a long one slow-marker]
+    slow-done
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to tommy: Start a worker queued-idle. queue]
+    -# Queued message sent
+    [reply to tommy: Then answer queued-two. queue]
+    -# Queued message sent
+    queued two ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+  const messages = await twin.discord.channel(twin.channelId).getMessages()
+  const sent = messages.filter((message) => message.content === '-# Queued message sent')
+  expect(sent.map((message) => message.message_reference?.message_id)).toEqual([silent.id, answered.id])
+})
+
+test('/queue and /clear-queue in a coordinator', async () => {
+  const before = await footers()
+  await startSlowTurn('Slash queue here')
+  const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
+  await user.runSlashCommand({ name: 'queue', options: [{ name: 'message', type: 3, value: 'Slash queued-one' }] })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  await user.runSlashCommand({ name: 'queue', options: [{ name: 'message', type: 3, value: 'Slash queued-two' }] })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 2' })
+  await user.runSlashCommand({ name: 'clear-queue', options: [{ name: 'position', type: 4, value: 1 }] })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'queued two ok' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 2 })
+  expect(await channelTextFrom('Slash queue here')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Slash queue here slow-marker
+    --- from: assistant (TestBot)
+    -# » **tommy:** Slash queued-one
+    [reply to TestBot: -# » **tommy:** Slash queued-one]
+    -# Removed from queue
+    -# » **tommy:** Slash queued-two
+    [reply to TestBot: -# » **tommy:** Slash queued-two]
+    -# Queued
+    -# Cleared 1 queued message
+    [reply to tommy: Slash queue here slow-marker]
+    slow-done
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to TestBot: -# » **tommy:** Slash queued-two]
+    -# Queued message sent
+    queued two ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})
+
+test('deleting a queued coordinator message removes it from the queue', async () => {
+  const before = await footers()
+  await startSlowTurn('Delete in coordinator')
+  const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
+  const queued = await user.sendMessage({ content: 'Never mind queued-one. queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  await user.deleteMessage({ messageId: queued.id })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'Removed from queue' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 1 })
+  await waitForIdle()
+  expect(await channelTextFrom('Delete in coordinator')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Delete in coordinator slow-marker
+    --- from: assistant (TestBot)
+    [reply to unknown message]
+    -# Removed from queue
+    [reply to tommy: Delete in coordinator slow-marker]
+    slow-done
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})
+
+test('kimaki send . queue and a TUI prompt queued on the coordinator show their text, then a reply when they run', async () => {
+  const before = await footers()
+  await startSlowTurn('Other sources')
+  await exec(process.execPath, ['--import', 'tsx', path.resolve('src/cli.ts'), 'send', '--session', rootSession(), '--prompt', 'From the CLI queued-one. queue', '--data-dir', dataDir], {
+    env: { ...process.env, KIMAKI_LOCK_PORT: String(bot.lock.port) },
+  })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  await (await server.client()).session.prompt({ sessionID: rootSession(), text: 'From the TUI queued-two', delivery: 'queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'queued two ok' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 3 })
+  expect(await channelTextFrom('Other sources')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Other sources slow-marker
+    --- from: assistant (TestBot)
+    -# » **CLI:** From the CLI queued-one
+    -# » **user:** From the TUI queued-two
+    [reply to tommy: Other sources slow-marker]
+    slow-done
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to TestBot: -# » **CLI:** From the CLI queued-one]
+    -# Queued message sent
+    queued one ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to TestBot: -# » **user:** From the TUI queued-two]
+    -# Queued message sent
+    queued two ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})
+
+test('a plain message in a busy coordinator runs first, then the queued one gets its reply', async () => {
+  const before = await footers()
+  await startSlowTurn('Steer the coordinator')
+  const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
+  await user.sendMessage({ content: 'Afterwards queued-one. queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  await user.sendMessage({ content: 'Right now steer-marker' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'queued one ok' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 2 })
+  expect(await channelTextFrom('Steer the coordinator')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Steer the coordinator slow-marker
+    Afterwards queued-one. queue
+    --- from: assistant (TestBot)
+    [reply to tommy: Afterwards queued-one. queue]
+    -# Queued
+    --- from: user (tommy)
+    Right now steer-marker
+    --- from: assistant (TestBot)
+    [reply to tommy: Right now steer-marker]
+    steer ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to tommy: Afterwards queued-one. queue]
+    -# Queued message sent
+    queued one ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})
+
+test('/abort in a coordinator stops the run and clears the queue', async () => {
+  await startSlowTurn('Abort the coordinator')
+  const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
+  await user.sendMessage({ content: 'Never runs queued-one. queue' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'position 1' })
+  await user.runSlashCommand({ name: 'abort' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: twin.channelId, text: 'Removed from queue' })
+  await waitForIdle()
+  expect(await channelTextFrom('Abort the coordinator')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Abort the coordinator slow-marker
+    Never runs queued-one. queue
+    --- from: assistant (TestBot)
+    [reply to tommy: Never runs queued-one. queue]
+    -# Removed from queue
+    Request **aborted**, cleared 1 queued message"
+  `)
+})
+
+test('. queue on an idle coordinator runs at once: the answer replies to the message', async () => {
+  const before = await footers()
+  await twin.discord.channel(twin.channelId).user(TEST_USER_ID).sendMessage({ content: 'Nothing waits idle-marker. queue' })
+  await waitForFooter({ discord: twin.discord, threadId: twin.channelId, count: before + 1 })
+  expect(await channelTextFrom('Nothing waits idle-marker')).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Nothing waits idle-marker. queue
+    --- from: assistant (TestBot)
+    [reply to tommy: Nothing waits idle-marker. queue]
+    idle ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})

package/src/coordinator-warmup.e2e.test.ts

@@ -0,0 +1,158 @@
+// The coordinator warmup (plugin/coordinator.ts) with short windows: keep-alives while
+// a worker thread runs, compaction when the channel is idle again, and the cap
+// that stops the warmup while a worker is stuck.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterAll, beforeAll, expect, test } from 'vitest'
+
+import type { BotHandle } from './main.ts'
+import {
+  TEST_MODEL,
+  TEST_USER_ID,
+  seedProjectChannel,
+  startOpencodeTestServer,
+  startTestBot,
+  startTwin,
+  tempDataDir,
+  textParts,
+  toolParts,
+  waitFor,
+  waitForFooter,
+  warmUp,
+  type OpencodeTestServer,
+  type TestTwin,
+} from './test/harness.ts'
+
+let server: OpencodeTestServer
+let twin: TestTwin
+let bot: BotHandle
+const dataDir = tempDataDir()
+// Big enough to be worth compacting (plugin/coordinator.ts MIN_COMPACT_TOKENS).
+const bigUsage = { inputTokens: 120_000, outputTokens: 1, totalTokens: 120_001 }
+const WARM_INTERVAL_MS = 400
+const WARM_MAX_MS = 1_500
+
+function bigText(text: string) {
+  return [
+    { type: 'text-start', id: 't' },
+    { type: 'text-delta', id: 't', delta: text },
+    { type: 'text-end', id: 't' },
+    { type: 'finish', finishReason: 'stop', usage: bigUsage },
+  ] as const
+}
+
+// The coordinator starts a worker thread, then answers IDLE.
+function delegate({ marker, worker, channelId }: { marker: string; worker: string; channelId: string }) {
+  const command = `kimaki send --channel ${channelId} --name 'Worker ${worker}' --prompt '${worker} run' --parent-session "$OPENCODE_SESSION_ID"`
+  return [
+    {
+      id: `${marker}-send`,
+      priority: 100,
+      when: { latestUserTextIncludes: marker },
+      then: { parts: toolParts({ toolCallId: `${marker}-call`, toolName: 'shell', input: { command, description: 'Start the worker', hasSideEffect: true } }) },
+    },
+    { id: `${marker}-idle`, priority: 101, when: { latestUserTextIncludes: marker, rawPromptIncludes: `${marker}-call` }, then: { parts: [...bigText('IDLE')] } },
+  ]
+}
+
+beforeAll(async () => {
+  twin = await startTwin()
+  server = await startOpencodeTestServer({
+    plugins: [path.resolve('src/test/generate-log-plugin')],
+    models: { [TEST_MODEL]: { name: TEST_MODEL, limit: { context: 1_000_000, output: 32_000 } } },
+    matchers: [
+      // OpenCode rejects a summary without the template headings.
+      { id: 'compaction-summary', priority: 900, when: { latestUserTextIncludes: 'You MUST use this format for your response' }, then: { parts: textParts('## Objective\n- Keep coordinating') } },
+      ...delegate({ marker: 'keepwarm-marker', worker: 'quickjob-marker', channelId: twin.channelId }),
+      ...delegate({ marker: 'capped-marker', worker: 'stuckjob-marker', channelId: twin.channelId }),
+      { id: 'quickjob', priority: 100, when: { latestUserTextIncludes: 'quickjob-marker' }, then: { parts: textParts('Quick job done.'), partDelaysMs: [0, 1_200, 0, 0] } },
+      { id: 'stuckjob', priority: 100, when: { latestUserTextIncludes: 'stuckjob-marker' }, then: { parts: textParts('Stuck job done.'), partDelaysMs: [0, 3_000, 0, 0] } },
+      { id: 'woken', priority: 300, when: { latestUserTextIncludes: '<session-finished' }, then: { parts: [...bigText('The worker finished.')] } },
+    ],
+  })
+  await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
+  await warmUp({ server })
+  bot = await startTestBot({ dataDir, twin, server, coordinator: true, warmupTimers: { intervalMs: WARM_INTERVAL_MS, maxMs: WARM_MAX_MS } })
+}, 60_000)
+
+afterAll(async () => {
+  await bot?.stop()
+  await twin?.stop()
+  await server?.stop()
+  fs.rmSync(dataDir, { recursive: true, force: true })
+})
+
+// Keep-alive requests of a session, from the test plugin.
+function keepAlives(sessionId: string): number {
+  const file = path.join(server.root, 'generate.log')
+  if (!fs.existsSync(file)) return 0
+  return fs.readFileSync(file, 'utf8').split('\n').filter((line) => line === sessionId).length
+}
+
+async function compactions(sessionId: string): Promise<number> {
+  const client = await server.client()
+  const messages = await client.message.list({ sessionID: sessionId, order: 'desc', limit: 50 })
+  return messages.data.filter((message) => message.type === 'compaction').length
+}
+
+test('the coordinator stays warm while its worker runs, then compacts', async () => {
+  const { discord, channelId } = twin
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Start keepwarm-marker' })
+  const root = await waitFor({ label: 'coordinator session', check: async () => bot.store.getState().roots[channelId] })
+  await waitForFooter({ discord, threadId: channelId })
+  await waitFor({ label: 'compaction after the wake', check: async () => (await compactions(root)) === 1 || null })
+
+  expect(await discord.channel(channelId).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Start keepwarm-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    -# Coordinator mode is on: this channel is one session that starts and manages project threads for you. Use /new-session for a thread without it. Turn it off with /toggle-coordinator or start kimaki with \`--coordinator false\`.
+    -# ┣ shell _Start the worker_
+    The worker finished.
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+  // The worker runs 1.2s, a keep-alive is due every 0.4s.
+  expect(keepAlives(root)).toBeGreaterThan(0)
+  const client = await server.client()
+  const messages = await client.message.list({ sessionID: root, order: 'asc', limit: 30 })
+  // No compaction before the wake: the channel was busy.
+  expect(messages.data.map((message) => message.type)).toMatchInlineSnapshot(`
+    [
+      "synthetic",
+      "synthetic",
+      "user",
+      "assistant",
+      "assistant",
+      "idle",
+      "synthetic",
+      "assistant",
+      "idle",
+      "compaction",
+      "idle",
+    ]
+  `)
+})
+
+test('a stuck worker stops the warmup at the cap', async () => {
+  const { discord, channelId } = twin
+  const root = bot.store.getState().roots[channelId]!
+  const before = keepAlives(root)
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Start capped-marker' })
+  const worker = await waitFor({
+    label: 'stuck worker thread',
+    check: async () => (await discord.channel(channelId).getThreads()).find((thread) => thread.name?.includes('stuckjob')),
+  })
+  // The cap ends the warmup while the worker still runs: compaction, no footer in the worker yet.
+  await waitFor({ label: 'compaction at the cap', check: async () => (await compactions(root)) === 2 || null })
+  const workerText = await discord.thread(worker.id).text()
+  const atCap = keepAlives(root)
+  await waitForFooter({ discord, threadId: worker.id })
+
+  expect(workerText).not.toContain('-# *main')
+  // 1.5s cap, one keep-alive every 0.4s: at most 3, none after the cap.
+  expect(atCap - before).toBeGreaterThan(0)
+  expect(atCap - before).toBeLessThanOrEqual(3)
+  expect(keepAlives(root)).toBe(atCap)
+})