kimaki 1.3.0 → 1.5.0

package/src/slash-commands.test.ts

@@ -47,6 +47,7 @@ test('catalog names are sanitized, keep their suffix, skip collisions and MCP pr
       "fork-subagent",
       "btw",
       "abort",
+      "reset-coordinator",
       "queue",
       "clear-queue",
       "queue-command",
@@ -60,6 +61,7 @@ test('catalog names are sanitized, keep their suffix, skip collisions and MCP pr
       "model",
       "model-variant",
       "verbosity",
+      "toggle-coordinator",
       "routines",
       "command",
       "skill",

package/src/slash-commands.ts

@@ -322,25 +322,27 @@ async function sendInput(
   const target = await resolveTarget(bot, interaction.channelId)
   if (target instanceof Error) return replyError(interaction, target)
   const author = authorOf(interaction)
-  if (target.thread && target.sessionId) {
+  // In a coordinator channel an agent pick starts a new thread: the coordinator keeps its own agent and model.
+  const newThread = route.kind === 'steer' && Boolean(route.agent) && target.conversation !== null && !target.conversation.isThread()
+  if (target.conversation && target.sessionId && !newThread) {
     const reply = await replyWithEcho(interaction, { author, text: echo })
     if (reply instanceof Error) return replyError(interaction, reply)
     if (model && !(route.kind === 'steer' && route.agent)) {
       const switched = await switchModel(bot, { sessionId: target.sessionId, model })
       if (switched instanceof Error) return replyError(interaction, switched)
     }
-    const result = await dispatch(bot, { thread: target.thread, route, author, messageId: reply.id, model })
+    const result = await dispatch(bot, { conversation: target.conversation, route, author, messageId: reply.id, model })
     if (result instanceof Error) return replyError(interaction, result)
     return
   }
-  if (target.thread) {
+  if (target.conversation && !newThread) {
     await interaction.reply({ content: 'Use this command in a thread with a Kimaki session', flags: MessageFlags.Ephemeral })
     return
   }
   await interaction.deferReply()
   const started = await startSession(bot, {
     channelId: target.channelId,
-    directory: target.directory,
+    directory: target.projectDirectory,
     route,
     author,
     messageId: interaction.id,

package/src/sleep.e2e.test.ts

@@ -1,8 +1,10 @@
 // `kimaki sleep` end to end (spec 10.5, 12.1, Phase 8): the agent runs the
 // command through the shim, the bot stores the wake with its clock, the
 // scheduler wakes the same thread, and a user message cancels the sleep.
+// Sleeps of at most 45 minutes keep the prompt cache warm (plugin/coordinator.ts).
 
 import fs from 'node:fs'
+import path from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import type { DeterministicMatcher } from 'opencode-deterministic-provider'
 import { afterAll, beforeAll, expect, test } from 'vitest'
@@ -18,12 +20,15 @@ import {
   tempDataDir,
   textParts,
   toolParts,
+  waitFor,
   waitForFooter,
   warmUp,
   type OpencodeTestServer,
   type TestTwin,
 } from './test/harness.ts'
 
+const WARM_INTERVAL_MS = 200
+
 function sleepTurn({ marker, command }: { marker: string; command: string }): DeterministicMatcher[] {
   const callId = `${marker}-call`
   return [
@@ -44,16 +49,16 @@ let bot: BotHandle
 
 beforeAll(async () => {
   ;[server, twin] = await Promise.all([
-    startOpencodeTestServer({ matchers: [
-      ...sleepTurn({ marker: 'sleep-marker', command: "kimaki sleep --duration 2h --reason 'waiting for the deploy'" }),
-      ...sleepTurn({ marker: 'cancel-marker', command: 'kimaki sleep --until 2030-01-01T12:00:00Z' }),
+    startOpencodeTestServer({ plugins: [path.resolve('src/test/generate-log-plugin')], matchers: [
+      ...sleepTurn({ marker: 'sleep-marker', command: "kimaki sleep --duration 30m --reason 'waiting for the deploy'" }),
+      ...sleepTurn({ marker: 'cancel-marker', command: 'kimaki sleep --until 2030-01-01T10:30:00Z' }),
       { id: 'wake', priority: 200, when: { latestUserTextIncludes: 'Woke after sleeping until' }, then: { parts: textParts('Awake, checking the deploy.') } },
       { id: 'never-mind', priority: 200, when: { latestUserTextIncludes: 'Never mind' }, then: { parts: textParts('Noted, no wake needed.') } },
     ] }),
     startTwin(),
   ])
   await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
-  bot = await startTestBot({ dataDir, twin, server, clock, schedulerIntervalMs: null })
+  bot = await startTestBot({ dataDir, twin, server, clock, schedulerIntervalMs: null, warmupTimers: { intervalMs: WARM_INTERVAL_MS, maxMs: 60_000 } })
   await warmUp({ server })
 }, 60_000)
 
@@ -72,17 +77,26 @@ async function start(prompt: string) {
   return { threadId: thread.id, sessionId: bot.store.getState().roots[thread.id]! }
 }
 
+// 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 sleepRow(sessionId: string) {
   return bot.db.query.session_sleeps.findFirst({ where: { session_id: sessionId } })
 }
 
 test('kimaki sleep wakes the same thread at the clock time', async () => {
   const { threadId, sessionId } = await start('Deploy and then sleep-marker')
-  expect((await sleepRow(sessionId))?.wake_at.toISOString()).toBe('2030-01-01T11:00:00.000Z')
+  expect((await sleepRow(sessionId))?.wake_at.toISOString()).toBe('2030-01-01T09:30:00.000Z')
+  // A 30 minute sleep stays warm until the wake.
+  await waitFor({ label: 'keep-alive while sleeping', check: async () => keepAlives(sessionId) > 0 || null })
 
-  clock.set(Date.parse('2030-01-01T10:59:59Z'))
+  clock.set(Date.parse('2030-01-01T09:29:59Z'))
   await bot.scheduler.runDueTasks()
-  clock.set(Date.parse('2030-01-01T11:00:00Z'))
+  clock.set(Date.parse('2030-01-01T09:30:00Z'))
   await bot.scheduler.runDueTasks()
   await waitForFooter({ discord: twin.discord, threadId, count: 2 })
   expect(await twin.discord.thread(threadId).text()).toMatchInlineSnapshot(`
@@ -95,10 +109,10 @@ test('kimaki sleep wakes the same thread at the clock time', async () => {
     -# ┣ shell _Sleep until the deploy is done_
 
     Sleeping until the deploy is done.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-    -# Woke after sleeping until 2030-01-01 11:00 UTC. Reason: waiting for the deploy
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# Woke after sleeping until 2030-01-01 09:30 UTC. Reason: waiting for the deploy
     Awake, checking the deploy.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   const row = await sleepRow(sessionId)
   expect(row?.status).toBe('consumed')
@@ -116,11 +130,14 @@ test('kimaki sleep wakes the same thread at the clock time', async () => {
 test('a user message cancels the sleep', async () => {
   const { threadId, sessionId } = await start('Deploy and then cancel-marker')
   expect((await sleepRow(sessionId))?.status).toBe('planned')
+  // The clock is at 09:30 after the first test: a 1 hour sleep is too long to keep warm, no keep-alive after a few intervals.
+  await sleep(WARM_INTERVAL_MS * 3)
+  expect(keepAlives(sessionId)).toBe(0)
   await twin.discord.thread(threadId).user(TEST_USER_ID).sendMessage({ content: 'Never mind, it is deployed' })
   await waitForFooter({ discord: twin.discord, threadId, count: 2 })
   expect((await sleepRow(sessionId))?.status).toBe('cancelled')
 
-  clock.set(Date.parse('2030-01-01T12:00:00Z'))
+  clock.set(Date.parse('2030-01-01T10:30:00Z'))
   await bot.scheduler.runDueTasks()
   // Nothing may appear: poll briefly instead of a wait helper.
   for (let attempt = 0; attempt < 10; attempt++) {
@@ -138,11 +155,11 @@ test('a user message cancels the sleep', async () => {
     -# ┣ shell _Sleep until the deploy is done_
 
     Sleeping until the deploy is done.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     --- from: user (tommy)
     Never mind, it is deployed
     --- from: assistant (TestBot)
     Noted, no wake needed.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })

package/src/sleeps.ts

@@ -9,7 +9,7 @@ import crypto from 'node:crypto'
 import * as orm from 'drizzle-orm'
 import dedent from 'string-dedent'
 
-import { fetchThread, threadOfSession, type Bot } from './bot.ts'
+import { fetchConversation, threadOfSession, type Bot } from './bot.ts'
 import { parseDuration } from './duration.ts'
 import { ConfigError, DbError } from './errors.ts'
 import { asSubtext } from './format-parts.ts'
@@ -21,6 +21,8 @@ const logger = createLogger('TASK')
 
 const WAKE_RETRY_MS = 30_000
 const WAKE_MAX_ATTEMPTS = 5
+// Longer sleeps let the prompt cache expire: past ~45 minutes, keep-alives (0.1x input each) cost more than one cache write at the wake (1.25x).
+const WARM_SLEEP_MAX_MS = 45 * 60_000
 
 type SleepRow = typeof schema.session_sleeps.$inferSelect
 
@@ -58,7 +60,7 @@ export function sleepOutput({ wakeAt, reason }: { wakeAt: number; reason: string
   return [
     `Sleeping until ${utcLabel(wakeAt)}.${reason ? ` Reason: ${reason}.` : ''}`,
     'This result is not a wake. Do not continue the waited work. Do not run more commands.',
-    'Reply with one short line that you are waiting until that time, then stop.',
+    'If this turn has no text yet that answers the user, write your full answer now: text you only planned in your reasoning never reaches Discord. Then write one short line that you are waiting until that time, and stop.',
     'The real wake is a later message that starts with "Woke after sleeping until". Only then continue the wait reason.',
     'A new user message in this thread cancels the sleep. If you still need that later wake after answering, run kimaki sleep again with --until set to the same UTC time.',
     'When monitoring something slow (email replies, PR reviews), wait 2h or more and never post a status report on a wake where nothing changed.',
@@ -144,6 +146,19 @@ export async function createSleep(
   return { sessionId: root, threadId, wakeAt: new Date(wakeAt).toISOString(), output: sleepOutput({ wakeAt, reason: why }) }
 }
 
+// The session waits for a wake at most 45 minutes after its sleep started: the plugin
+// keeps its prompt cache warm until then (plugin/coordinator.ts, `session.warmup` route).
+export async function sleepsWarm(bot: Bot, sessionId: string): Promise<DbError | boolean> {
+  const row = await bot.db.query.session_sleeps
+    .findFirst({ where: { session_id: sessionId, status: 'planned' } })
+    .catch((cause) => new DbError({ operation: 'read session_sleeps', cause }))
+  if (row instanceof Error) return row
+  // Sleeps imported from V1 may have no start time.
+  if (!row?.created_at) return false
+  const wakeAt = row.wake_at.getTime()
+  return wakeAt > bot.clock.now() && wakeAt - row.created_at.getTime() <= WARM_SLEEP_MAX_MS
+}
+
 // Delivers a due wake if it is still the planned sleep and its retry delay
 // passed. The prompt ID comes from the delivery ID, so a retried wake cannot
 // deliver twice: OpenCode returns the existing inbox item for a repeated ID
@@ -184,7 +199,7 @@ async function wake(bot: Bot, row: SleepRow): Promise<Error | void> {
       return settle('failed')
     }
     const sent = await (async () => {
-      const thread = await fetchThread(bot, threadId)
+      const thread = await fetchConversation(bot, threadId)
       if (thread instanceof Error) return thread
       return prompt(bot, {
         sessionId,
@@ -196,6 +211,8 @@ async function wake(bot: Bot, row: SleepRow): Promise<Error | void> {
         author: { id: bot.discord.user!.id, username: 'kimaki' },
         messageId: deliveryId,
         id: `msg_sleep_${deliveryId}`,
+        // The session asked for this wake itself.
+        sender: { sessionId },
       })
     })()
     if (!(sent instanceof Error)) return settle('consumed')

package/src/store.ts

@@ -1,5 +1,6 @@
 // The only shared mutable in-memory state of the bot (spec 27.4). One zustand
-// atom. The event loop writes bindings and views; /verbosity writes verbosity.
+// atom. The event loop writes bindings and views; /verbosity writes verbosity,
+// /toggle-coordinator writes coordinator.
 // State private to one module (held events, wizard picks, upload waits) stays
 // in that module's closure.
 
@@ -17,10 +18,12 @@ export type State = {
   threads: Readonly<Record<string, ThreadView>>
   // channelId -> verbosity, from channel_verbosity (SQLite). Missing: the default.
   verbosity: Readonly<Record<string, Verbosity>>
+  // channelId -> coordinator mode, from channel_coordinator (SQLite). Missing: bot.coordinatorDefault.
+  coordinator: Readonly<Record<string, boolean>>
 }
 
 export function createBotStore() {
-  return createStore<State>(() => ({ roots: {}, sessionThreads: {}, threads: {}, verbosity: {} }))
+  return createStore<State>(() => ({ roots: {}, sessionThreads: {}, threads: {}, verbosity: {}, coordinator: {} }))
 }
 
 export type BotStore = ReturnType<typeof createBotStore>