kimaki 1.4.0 → 1.6.0

package/src/harness.e2e.test.ts

@@ -90,7 +90,7 @@ test('a second bot on the same lock port stops the running one and takes over',
     import { disabledAnalytics } from ${JSON.stringify(path.resolve('src/analytics.ts'))}
     const lock = await startLockServer({ port: ${port}, dataDir: ${JSON.stringify(otherData)} })
     if (lock instanceof Error) throw lock
-    const result = await startBot({ analytics: disabledAnalytics, lock, ...${JSON.stringify({ dataDir: otherData, token: twin.discord.botToken, appId: twin.discord.botUserId, discordRestUrl: twin.discord.restUrl, opencodeServiceFile: server.serviceFile, opencodeConfigDir: server.configDir, opencodeDbFile: server.dbFile, ensureOpencode: false, kimakiCommand: 'kimaki' })} })
+    const result = await startBot({ analytics: disabledAnalytics, lock, ...${JSON.stringify({ dataDir: otherData, token: twin.discord.botToken, appId: twin.discord.botUserId, discordRestUrl: twin.discord.restUrl, opencodeServiceFile: server.serviceFile, opencodeConfigDir: server.configDir, opencodeDbFile: server.dbFile, ensureOpencode: false, kimakiArgv: ['kimaki'] })} })
     if (result instanceof Error) throw result
     process.send({ ready: true })
     process.once('SIGTERM', async () => { await result.stop(); process.exit(0) })
@@ -119,6 +119,6 @@ test('a second bot on the same lock port stops the running one and takes over',
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
 })

package/src/hello-thread.e2e.test.ts

@@ -29,6 +29,8 @@ let bot: BotHandle
 let dataDir: string
 let helloThreadId: string
 
+const MEDIA_URL = 'https://cdn.discordapp.com/attachments/1012345678900020080/1234567891233211234/shot.png?ex=65d903de&is=65c68ede&hm=2481f30d&'
+
 beforeAll(async () => {
   dataDir = tempDataDir()
   ;[server, twin] = await Promise.all([
@@ -60,6 +62,19 @@ beforeAll(async () => {
             ],
           },
         },
+        {
+          id: 'media',
+          priority: 10,
+          when: { latestUserTextIncludes: 'media-marker' },
+          then: {
+            parts: [
+              { type: 'text-start', id: 't3' },
+              { type: 'text-delta', id: 't3', delta: `Here is the screenshot: ${MEDIA_URL}` },
+              { type: 'text-end', id: 't3' },
+              { type: 'finish', finishReason: 'stop', usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 } },
+            ],
+          },
+        },
       ],
     }),
     startTwin(),
@@ -106,12 +121,12 @@ test('channel message creates a thread with reply and footer, follow-up continue
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     Hello from the deterministic model.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     --- from: user (tommy)
     Again please second-marker
     --- from: assistant (TestBot)
     Second answer, same session.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(thread.name).toBe('Say hello hello-marker')
 
@@ -139,7 +154,7 @@ test('channel message creates a thread with reply and footer, follow-up continue
       {
         "silent": false,
         "suppressEmbeds": true,
-        "text": "-# *project ⋅ main ⋅",
+        "text": "-# *main ⋅ <1s ⋅ 0% ",
       },
       {
         "silent": true,
@@ -149,7 +164,7 @@ test('channel message creates a thread with reply and footer, follow-up continue
       {
         "silent": false,
         "suppressEmbeds": true,
-        "text": "-# *project ⋅ main ⋅",
+        "text": "-# *main ⋅ <1s ⋅ 0% ",
       },
     ]
   `)
@@ -170,6 +185,45 @@ test('channel message creates a thread with reply and footer, follow-up continue
   expect(session.time.idle).toBeGreaterThan(0)
 })
 
+test('a reply with a Discord media URL keeps its embed, other lines stay suppressed', async () => {
+  const { discord, channelId } = twin
+  await discord.channel(channelId).user(TEST_USER_ID).sendMessage({ content: 'Show the shot media-marker' })
+  const thread = await discord.channel(channelId).waitForThread({ predicate: (thread) => thread.name?.startsWith('Show the shot') ?? false })
+  await waitForFooter({ discord, threadId: thread.id })
+  expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Show the shot media-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    Here is the screenshot: https://cdn.discordapp.com/attachments/1012345678900020080/1234567891233211234/shot.png?ex=65d903de&is=65c68ede&hm=2481f30d&
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+
+  const messages = await discord.thread(thread.id).getMessages()
+  const flags = messages
+    .filter((message) => message.author.bot)
+    .map((message) => ({
+      text: message.content.slice(0, 20),
+      suppressEmbeds: Boolean((message.flags ?? 0) & MessageFlags.SuppressEmbeds),
+    }))
+  expect(flags).toMatchInlineSnapshot(`
+    [
+      {
+        "suppressEmbeds": true,
+        "text": "-# *using determinis",
+      },
+      {
+        "suppressEmbeds": false,
+        "text": "Here is the screensh",
+      },
+      {
+        "suppressEmbeds": true,
+        "text": "-# *main ⋅ <1s ⋅ 0% ",
+      },
+    ]
+  `)
+})
+
 test('message from a user without permission creates no thread', async () => {
   const { discord, channelId } = twin
   const before = (await discord.channel(channelId).getThreads()).length
@@ -203,7 +257,7 @@ test('another bot needs the Kimaki role, and no-kimaki still denies it', async (
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     Hello from the deterministic model.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 
   const withRole = (await discord.channel(channelId).getThreads()).length

package/src/ingress.ts

@@ -1,6 +1,7 @@
 // Discord ingress (spec 4): gates every messageCreate, parses it into a Route
 // and calls actions. Gates, in order: webhooks and our own messages (except
-// remote send envelopes), channel ownership (only channels mapped in this
+// remote send envelopes), system messages (a thread rename only sets the
+// session title), channel ownership (only channels mapped in this
 // machine's SQLite), permission (other bots need the Kimaki role).
 // Messages of one channel are handled in arrival order, after OpenCode is ready.
 //
@@ -17,9 +18,11 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import {
+  ChannelType,
   Events,
   GuildMember,
   MessageFlags,
+  MessageType,
   PermissionFlagsBits,
   type Attachment,
   type Guild,
@@ -27,18 +30,20 @@ import {
 } from 'discord.js'
 import * as errore from 'errore'
 
-import { projectOf, sessionDirectory, type Bot, type PromptFile } from './bot.ts'
+import { isCoordinatorChannel, oc, projectOf, sessionDirectory, type Bot, type PromptFile } from './bot.ts'
 import { formatError, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './format-parts.ts'
 import { createLogger } from './logger.ts'
 import { parseInput, sendInput } from './lock-routes.ts'
 import { cancelQueuedPrompt, dispatch, requeueEdited, send } from './prompt.ts'
 import { REMOTE_PROMPT_FILE, REMOTE_RESULT_PREFIX, REMOTE_SEND_PREFIX } from './remote-send.ts'
-import { formatEcho, queuedItemFor } from './queue.ts'
+import { echoPayloads, formatEcho, queuedItemFor } from './queue.ts'
 import { parseTextMessage, type Route } from './routes.ts'
-import { primaryAgents, startSession } from './sessions.ts'
+import { primaryAgents, startCoordinator, startSession } from './sessions.ts'
 import { isVoiceAttachment, parseVoiceMessage, transcribe, voiceMediaType, type AttachmentLike } from './voice.ts'
 
 const logger = createLogger('INGRESS')
+// Later messages of the channel wait for downloads (registerIngress).
+const DOWNLOAD_TIMEOUT_MS = 60_000
 
 // Owner, Administrator, Manage Server, or a role named "Kimaki"; with
 // --allow-all-users every member. A role named "no-kimaki" always denies.
@@ -114,14 +119,14 @@ class AttachmentError extends errore.createTaggedError({
 }) {}
 
 async function remotePromptText(url: string) {
-  const response = await fetch(url).catch((cause) => new AttachmentError({ file: REMOTE_PROMPT_FILE, cause }))
+  const response = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }).catch((cause) => new AttachmentError({ file: REMOTE_PROMPT_FILE, cause }))
   if (response instanceof Error) return response
   if (!response.ok) return new AttachmentError({ file: REMOTE_PROMPT_FILE, cause: new Error(`HTTP ${response.status}`) })
   return response.text().catch((cause) => new AttachmentError({ file: REMOTE_PROMPT_FILE, cause }))
 }
 
 async function download(url: string): Promise<AttachmentError | Buffer> {
-  const response = await fetch(url).catch((e) => new AttachmentError({ file: url, cause: e }))
+  const response = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }).catch((e) => new AttachmentError({ file: url, cause: e }))
   if (response instanceof Error) return response
   if (!response.ok) return new AttachmentError({ file: `${url} (HTTP ${response.status})` })
   const body = await response.arrayBuffer().catch((e) => new AttachmentError({ file: url, cause: e }))
@@ -192,7 +197,7 @@ async function handleRemoteEnvelope(bot: Bot, { message, channelId, threadId }:
   const input = prompt instanceof Error ? prompt : parseInput(sendInput, { ...value.options, ...target, prompt })
   const attachments = [...message.attachments.values()].filter((attachment) => attachment !== promptAttachment)
   const files = await saveAttachments({ dataDir: bot.dataDir, messageId: message.id, attachments })
-  const result = input instanceof Error ? input : files instanceof Error ? files : await send(bot, { ...input, files }, { localOnly: true })
+  const result = input instanceof Error ? input : files instanceof Error ? files : await send(bot, { ...input, files }, { localOnly: true, shownIn: message.id })
   const answer = JSON.stringify(result instanceof Error ? { error: result.message } : result)
   await message
     .reply({
@@ -232,7 +237,9 @@ async function handleMessage(bot: Bot, message: Message) {
     logger.log(`ignoring ${message.author.username}: no Kimaki permission`)
     return
   }
-  const sessionId = thread ? bot.store.getState().roots[thread.id] : undefined
+  // A coordinator channel has its root session under the channel ID.
+  const coordinator = !thread && isCoordinatorChannel(bot, channelId)
+  const sessionId = bot.store.getState().roots[thread?.id ?? (coordinator ? channelId : '')]
   if (thread && !sessionId) return
   const author = { id: message.author.id, username: message.author.username }
   const reportError = async (error: Error) => {
@@ -259,8 +266,35 @@ async function handleMessage(bot: Bot, message: Message) {
   const attached = files.length > 0 ? `, ${files.length} file(s)` : ''
   logger.log(`${route.kind}${detail} from ${author.username} in ${thread ? `thread ${thread.id}` : `channel ${channelId}`}${attached}`)
   // The transcription is not visible anywhere else.
-  if (voice && thread && route.kind !== 'shell' && route.kind !== 'command' && route.kind !== 'skill') {
-    await message.reply({ content: formatEcho({ username: author.username, text: route.text }), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
+  if (voice && (thread || coordinator) && route.kind !== 'shell' && route.kind !== 'command' && route.kind !== 'skill') {
+    // A long transcript continues in more messages after the reply.
+    for (const [index, payload] of echoPayloads(formatEcho({ username: author.username, text: route.text })).entries()) {
+      const options = { ...payload, allowedMentions: { parse: [] }, flags: ('flags' in payload ? payload.flags : 0) | SILENT_MESSAGE_FLAGS }
+      if (index === 0) await message.reply(options)
+      else if (channel.isSendable()) await channel.send(options)
+    }
+  }
+
+  // Coordinator: the channel is the conversation of one long session.
+  if (coordinator && channel.type === ChannelType.GuildText) {
+    // A spoken agent is for a new thread: the coordinator keeps its own agent and model.
+    const result = route.kind === 'new-session' || (route.kind === 'steer' && route.agent)
+      ? await startSession(bot, { channelId, directory: project.directory, route: { kind: 'steer', text: route.text, ...(route.agent && { agent: route.agent }) }, author, messageId: message.id, startMessageId: null, files })
+      : bot.store.getState().roots[channel.id]
+        ? await dispatch(bot, { conversation: channel, route, author, messageId: message.id, files })
+        : await startCoordinator(bot, {
+            channel,
+            // Queue and btw need a session to wait for or fork from: the first input is a plain prompt.
+            route: route.kind === 'shell' || route.kind === 'command' || route.kind === 'skill' || route.kind === 'steer' ? route : { kind: 'steer', text: route.text },
+            author,
+            messageId: message.id,
+            files,
+          })
+    if (result instanceof Error) return reportError(result)
+    if (!result || result.threadId === channel.id) return
+    const note = route.kind === 'btw' ? `Session forked! Continue in <#${result.threadId}>` : `Started a new session in <#${result.threadId}>`
+    await message.reply({ content: note, allowedMentions: { repliedUser: false }, flags: SILENT_MESSAGE_FLAGS }).catch(() => undefined)
+    return
   }
 
   if (!thread) {
@@ -280,7 +314,7 @@ async function handleMessage(bot: Bot, message: Message) {
     return
   }
 
-  const result = await dispatch(bot, { thread, route, author, messageId: message.id, files })
+  const result = await dispatch(bot, { conversation: thread, route, author, messageId: message.id, files })
   if (result instanceof Error) return reportError(result)
   if (!result) return
   const note =
@@ -288,7 +322,20 @@ async function handleMessage(bot: Bot, message: Message) {
   await message.reply({ content: note, allowedMentions: { repliedUser: false }, flags: SILENT_MESSAGE_FLAGS }).catch(() => undefined)
 }
 
-// Registers the message listeners. Messages of one channel are handled in arrival order.
+// A rename in the Discord UI posts a CHANNEL_NAME_CHANGE message with the new
+// name as content (issue #258): the session title follows it, nothing is prompted.
+async function handleThreadRename(bot: Bot, message: Message) {
+  if (!message.inGuild() || !message.channel.isThread()) return
+  const sessionId = bot.store.getState().roots[message.channel.id]
+  if (!sessionId || !(await authorCanUseKimaki(bot, message))) return
+  const title = message.content
+  const renamed = await oc(bot, 'session.update', (client) => client.session.update({ sessionID: sessionId, title }))
+  if (renamed instanceof Error) return logger.warn(`title of ${sessionId} from thread rename`, renamed)
+  logger.log(`session ${sessionId} renamed to "${title}" by ${message.author.username}`)
+}
+
+// Registers the message listeners. Messages of one channel are handled in arrival order:
+// a text sent while a voice message is transcribed waits for it (voice-attachments.e2e.test.ts).
 export function registerIngress(bot: Bot) {
   const chains = new Map<string, Promise<void>>()
 
@@ -308,6 +355,9 @@ export function registerIngress(bot: Bot) {
     // Webhooks have no member to check. Own messages only matter as remote send envelopes.
     if (message.webhookId) return
     if (message.author.id === bot.discord.user?.id && !message.embeds[0]?.footer?.text.startsWith(REMOTE_SEND_PREFIX)) return
+    if (message.type === MessageType.ChannelNameChange) return serialize(message.channelId, () => handleThreadRename(bot, message))
+    // Pins, joins, boosts and other system messages are never prompts.
+    if (message.type !== MessageType.Default && message.type !== MessageType.Reply) return
     serialize(message.channelId, () => handleMessage(bot, message))
   })
   // Deleting a queued Discord message removes it from the queue.

package/src/interaction-context.ts

@@ -16,14 +16,13 @@ import {
   type ModalSubmitInteraction,
   type RESTPostAPIChatInputApplicationCommandsJSONBody,
   type StringSelectMenuInteraction,
-  type ThreadChannel,
 } from 'discord.js'
 
-import { projectOf, sessionDirectory, type Author, type Bot } from './bot.ts'
+import { isCoordinatorChannel, projectOf, sessionDirectory, type Author, type Bot, type Conversation } from './bot.ts'
 import { ConfigError, DiscordError } from './errors.ts'
 import { formatError, SILENT_MESSAGE_FLAGS } from './format-parts.ts'
 import { createLogger } from './logger.ts'
-import { formatEcho } from './queue.ts'
+import { formatEchoReply } from './queue.ts'
 
 const logger = createLogger('COMMANDS')
 
@@ -51,11 +50,11 @@ export type InteractionRoutes = {
 // --- Context
 
 // Where an interaction happens: the project channel and, in a session
-// thread, the thread and its root session.
+// thread or a coordinator channel, that conversation and its root session.
 export type InteractionTarget = {
   channelId: string
   directory: string
-  thread: ThreadChannel | null
+  conversation: Conversation | null
   sessionId: string | null
   projectDirectory: string
 }
@@ -76,13 +75,15 @@ export async function resolveTarget(bot: Bot, channelId: string | null): Promise
   const row = await projectOf(bot, projectChannelId)
   if (row instanceof Error) return row
   if (!row) return new ConfigError({ reason: 'This channel is not configured with a project directory' })
-  const sessionId = thread ? (bot.store.getState().roots[thread.id] ?? null) : null
+  // A coordinator channel is the conversation of its root session. With coordinator mode off its binding is ignored, like in ingress.
+  const conversation = thread ?? (channel?.type === ChannelType.GuildText && isCoordinatorChannel(bot, channel.id) && bot.store.getState().roots[channel.id] ? channel : null)
+  const sessionId = conversation ? (bot.store.getState().roots[conversation.id] ?? null) : null
   const directory = sessionId ? await sessionDirectory(bot, sessionId) : row.directory
   if (directory instanceof Error) return directory
-  return { channelId: projectChannelId, directory, projectDirectory: row.directory, thread, sessionId }
+  return { channelId: projectChannelId, directory, projectDirectory: row.directory, conversation, sessionId }
 }
 
-export type SessionTarget = InteractionTarget & { thread: ThreadChannel; sessionId: string }
+export type SessionTarget = InteractionTarget & { conversation: Conversation; sessionId: string }
 
 // The session thread of a command, or null after a reply saying where it works.
 export async function sessionTarget(bot: Bot, interaction: ChatInputCommandInteraction): Promise<SessionTarget | null> {
@@ -91,11 +92,11 @@ export async function sessionTarget(bot: Bot, interaction: ChatInputCommandInter
     await replyError(interaction, target)
     return null
   }
-  if (!target.thread || !target.sessionId) {
+  if (!target.conversation || !target.sessionId) {
     await interaction.reply({ content: 'Use this command in a thread with a Kimaki session', flags: MessageFlags.Ephemeral })
     return null
   }
-  return { ...target, thread: target.thread, sessionId: target.sessionId }
+  return { ...target, conversation: target.conversation, sessionId: target.sessionId }
 }
 
 // --- Replies
@@ -116,7 +117,7 @@ export async function replyError(
 
 // The visible reply stands in for the user message: acks and prompts point at its ID.
 export async function replyWithEcho(interaction: ChatInputCommandInteraction, { author, text }: { author: Author; text: string }) {
-  await interaction.reply({ content: formatEcho({ username: author.username, text }), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
+  await interaction.reply({ content: formatEchoReply({ username: author.username, text }), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
   return interaction.fetchReply().catch((e: Error) => e)
 }
 

package/src/interrupt.e2e.test.ts

@@ -97,7 +97,7 @@ test('plain message interrupts the run and is answered', async () => {
     Stop and do this steer-marker
     --- from: assistant (TestBot)
     steer ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   await expectNever({ threadId: thread.id, text: 'slow-done' })
 })
@@ -112,7 +112,7 @@ test('/abort stops the run and clears the queue', async () => {
   await waitForBotMessageContaining({ discord: twin.discord, threadId: thread.id, text: 'Removed from queue' })
   await expectNever({ threadId: thread.id, text: 'slow-done' })
   await expectNever({ threadId: thread.id, text: 'queued one ok' })
-  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+  expect(await twin.discord.thread(thread.id).text({ showReplies: true })).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Abort me slow-marker
     --- from: assistant (TestBot)
@@ -120,6 +120,7 @@ test('/abort stops the run and clears the queue', async () => {
     --- from: user (tommy)
     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"
   `)
@@ -134,7 +135,7 @@ test('a restarted bot still echoes and runs the queue it did not see', async ()
   bot = await startTestBot({ dataDir, twin, server })
   await waitForBotMessageContaining({ discord: twin.discord, threadId: thread.id, text: 'queued one ok' })
   await waitForFooter({ discord: twin.discord, threadId: thread.id })
-  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+  expect(await twin.discord.thread(thread.id).text({ showReplies: true })).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Restart during queue slow-marker
     --- from: assistant (TestBot)
@@ -142,10 +143,12 @@ test('a restarted bot still echoes and runs the queue it did not see', async ()
     --- from: user (tommy)
     Survives restart queued-one. queue
     --- from: assistant (TestBot)
+    [reply to tommy: Survives restart queued-one. queue]
     -# Queued at position 1. Delete the original message to remove it, or use /clear-queue position:1
     slow-done
-    » **tommy:** Survives restart queued-one
+    [reply to tommy: Survives restart queued-one. queue]
+    -# Queued message sent
     queued one ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })

package/src/legacy.e2e.test.ts

@@ -82,7 +82,7 @@ test('bot starts on a V1 database and answers in an old thread with the old sess
     hello again after the upgrade
     --- from: assistant (TestBot)
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
 
   const messages = await client.message.list({ sessionID: session.id })

package/src/lock-routes.ts

@@ -13,7 +13,7 @@ import * as orm from 'drizzle-orm'
 import { z } from 'zod'
 
 import { parseButton } from './agent-ui.ts'
-import { fetchThread, oc, parseModel, projectOf, type Bot } from './bot.ts'
+import { fetchConversation, isCoordinatorChannel, oc, parseModel, projectOf, type Bot } from './bot.ts'
 import { credential, loginCli } from './commands/login-commands.ts'
 import { setChannelAgent, setChannelModel, setGlobalModel, setVerbosity } from './commands/preference-commands.ts'
 import { channelWorktrees, manageWorktree, newWorktree, setAutoWorktrees } from './commands/worktree-commands.ts'
@@ -23,7 +23,8 @@ import { abort, cancelQueuedPrompt, clearQueue, send, shell, upload } from './pr
 import { createTask, deleteTask, editTask, runTaskNow } from './scheduler.ts'
 import * as schema from './schema.ts'
 import { channelForDirectory, channelForSession, fork, resume, sessionCwd } from './sessions.ts'
-import { createSleep } from './sleeps.ts'
+import { createSleep, sleepsWarm } from './sleeps.ts'
+import { conversationTyping, workersTyping } from './thread-reducer.ts'
 import { worktreeName } from './worktrees.ts'
 
 type LockRoute<S extends z.ZodType, R> = {
@@ -82,6 +83,10 @@ const sendFields = {
   // '' asks for an automatic name.
   worktree: z.string({ error: 'worktree must be a name or an empty string for an automatic name' }).optional(),
   notifyOnly: z.boolean({ error: 'notifyOnly must be boolean' }).optional(),
+  // Seconds the CLI waits for the run (`--wait [seconds]`): a run that ends within them sends no coordinator note.
+  wait: z.number({ error: 'wait must be a number of seconds' }).positive({ error: 'wait must be a positive number of seconds' }).optional(),
+  // OPENCODE_SESSION_ID of the shell that ran `kimaki send`: a coordinator wakes when the runs it prompted end.
+  senderSessionId: text('senderSessionId').optional(),
   permissions: z.array(z.string(), { error: 'Permission rules must be strings' }).optional(),
   prompt: text('prompt'),
   files: z.array(z.object({ uri: z.string(), name: z.string() }), { error: 'files must contain uri and name strings' }).optional(),
@@ -265,6 +270,19 @@ async function snapshotHeap({ dataDir }: { dataDir: string }) {
   return { path: written }
 }
 
+// The coordinator or a thread of its channel runs, from the thread views.
+function coordinatorBusy(bot: Bot, sessionId: string): boolean {
+  const { sessionThreads, roots, threads } = bot.store.getState()
+  // A coordinator's conversation is its channel. A replaced one (/reset-coordinator), one of a
+  // channel with coordinator mode off, or a thread session is never busy.
+  const channelId = sessionThreads[sessionId]
+  if (!channelId || roots[channelId] !== sessionId || !isCoordinatorChannel(bot, channelId)) return false
+  const view = threads[channelId]
+  // An idle coordinator has no view after a bot restart; its threads do.
+  if (!view) return workersTyping({ threads, channelId })
+  return view.coordinator && conversationTyping({ threads, threadId: channelId })
+}
+
 const loginField = z.string({ error: 'Login fields must be non-empty strings' }).min(1, { error: 'Login fields must be non-empty strings' }).optional()
 
 export const lockRoutes = {
@@ -297,6 +315,16 @@ export const lockRoutes = {
       }
     },
   }),
+  // The plugin keeps a session's prompt cache warm while its coordinator channel is busy
+  // or it sleeps (plugin/coordinator.ts).
+  'session.warmup': route({
+    input: z.object({ sessionId: text('sessionId') }),
+    run: async (bot, { sessionId }) => {
+      const sleeping = await sleepsWarm(bot, sessionId)
+      if (sleeping instanceof Error) return sleeping
+      return { busy: coordinatorBusy(bot, sessionId), sleeping }
+    },
+  }),
   restart: route({
     input: z.object({}),
     run: async (bot) => {
@@ -371,6 +399,17 @@ export const lockRoutes = {
       return bot.features.agentUi.request({ ...input, sessionId, content: { buttons }, signal })
     },
   }),
+  // Labels of buttons each session showed and the user did not click yet (`kimaki session wait`).
+  'session.buttons': route({
+    input: z.object({ sessionIds: z.array(text('sessionId'), { error: 'sessionIds must be an array' }) }),
+    run: async (bot, { sessionIds }) => {
+      const prompts = Object.values(bot.store.getState().threads).flatMap((view) => view.agentUi)
+      return Object.fromEntries(sessionIds.map((sessionId) => [
+        sessionId,
+        prompts.flatMap((prompt) => prompt.sessionId === sessionId ? (prompt.buttons ?? []).map((item) => item.label) : []),
+      ]))
+    },
+  }),
   'upload-request': route({
     input: z.object({
       ...agentUiFields,
@@ -493,9 +532,9 @@ export const lockRoutes = {
     run: async (bot, input) => {
       const target = localSession(bot, input)
       if (target instanceof Error) return target
-      const thread = await fetchThread(bot, target.threadId)
+      const thread = await fetchConversation(bot, target.threadId)
       if (thread instanceof Error) return thread
-      return sessionCwd(bot, { thread, directory: input.directory })
+      return sessionCwd(bot, { conversation: thread, directory: input.directory })
     },
   }),
   'session.title': route({
@@ -506,8 +545,10 @@ export const lockRoutes = {
       const title = input.text
       const renamed = await oc(bot, 'session.update', (client) => client.session.update({ sessionID: target.sessionId, title }))
       if (renamed instanceof Error) return renamed
-      const thread = await fetchThread(bot, target.threadId)
+      const thread = await fetchConversation(bot, target.threadId)
       if (thread instanceof Error) return thread
+      // A coordinator channel keeps its project name.
+      if (!thread.isThread()) return { title }
       const updated = await thread.setName(title.slice(0, 100)).catch((cause) => new DiscordError({ operation: 'rename thread', cause }))
       if (updated instanceof Error) return updated
       return { title }
@@ -518,8 +559,9 @@ export const lockRoutes = {
     run: async (bot, input) => {
       const target = localSession(bot, input)
       if (target instanceof Error) return target
-      const thread = await fetchThread(bot, target.threadId)
+      const thread = await fetchConversation(bot, target.threadId)
       if (thread instanceof Error) return thread
+      if (!thread.isThread()) return new ConfigError({ reason: 'A coordinator channel cannot be archived' })
       const archived = await thread.setArchived(true).catch((cause) => new DiscordError({ operation: 'archive thread', cause }))
       if (archived instanceof Error) return archived
       return { archived: true }
@@ -533,15 +575,27 @@ export const lockRoutes = {
       return abort(bot, { threadId: target.threadId })
     },
   }),
+  'session.compact': route({
+    input: sessionInput({}),
+    run: async (bot, input) => {
+      const target = localSession(bot, input)
+      if (target instanceof Error) return target
+      // Queued, so an agent compacting its own session finishes its turn first.
+      const sessionID = input.sessionId ?? target.sessionId
+      const compaction = await oc(bot, 'session.compact', (client) => client.session.compact({ sessionID, delivery: 'queue' }))
+      if (compaction instanceof Error) return compaction
+      return { sessionId: sessionID, queued: true }
+    },
+  }),
   'session.fork': route({
     input: sessionInput({ before: text('before').optional(), name: text('name').optional() }),
     run: async (bot, input) => {
       const target = localSession(bot, input)
       if (target instanceof Error) return target
-      const thread = await fetchThread(bot, target.threadId)
+      const thread = await fetchConversation(bot, target.threadId)
       if (thread instanceof Error) return thread
       // A child session ID forks that child, not the root.
-      return fork(bot, { sourceThread: thread, sessionId: input.sessionId ?? target.sessionId, before: input.before, name: input.name, author: cliAuthor(bot) })
+      return fork(bot, { source: thread, sessionId: input.sessionId ?? target.sessionId, before: input.before, name: input.name, author: cliAuthor(bot) })
     },
   }),
   'session.command': route({

package/src/lock-server.ts

@@ -28,17 +28,33 @@ export { DEFAULT_LOCK_PORT }
 // Exit code that tells the supervisor of the root `kimaki` command (cli/bot.ts) to start the bot again.
 export const RESTART_EXIT_CODE = 75
 
-export async function installShim({ dataDir, command }: { dataDir: string; command: string }): Promise<ConfigError | void> {
+export function shellQuote(arg: string): string {
+  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`
+}
+
+// cmd.exe quoting for batch files: Windows paths cannot contain `"`, and `%` expands variables.
+function cmdQuote(arg: string): string {
+  return `"${arg.replaceAll('%', '%%')}"`
+}
+
+// Writes `<dataDir>/bin/kimaki`, which runs `argv` (this Kimaki install). On Windows also
+// `kimaki.cmd` for PowerShell and cmd.exe; Git Bash only finds the extensionless sh script.
+export async function installShim({ dataDir, argv }: { dataDir: string; argv: readonly string[] }): Promise<ConfigError | void> {
   const directory = path.join(dataDir, 'bin')
   const created = await fs.promises.mkdir(directory, { recursive: true }).catch((cause) => new ConfigError({ reason: 'Cannot create Kimaki shim directory', cause }))
   if (created instanceof Error) return created
-  const file = path.join(directory, process.platform === 'win32' ? 'kimaki.cmd' : 'kimaki')
+  const windows = process.platform === 'win32'
   // Bind the shim to its data dir through the env: not every command takes --data-dir.
-  const script = process.platform === 'win32'
-    ? `@echo off\r\nset "KIMAKI_DATA_DIR=${dataDir}"\r\n${command} %*\r\n`
-    : `#!/bin/sh\nexport KIMAKI_DATA_DIR='${dataDir.replaceAll("'", "'\\''")}'\nexec ${command} "$@"\n`
-  return fs.promises.writeFile(file, script, { mode: 0o700 }).then(() => fs.promises.chmod(file, 0o700))
-    .catch((cause) => new ConfigError({ reason: 'Cannot install Kimaki command shim', cause }))
+  // MSYS sh runs `C:/...` paths; backslashes in a Windows path are not portable there.
+  const posixArgv = windows ? argv.map((arg) => arg.replaceAll('\\', '/')) : argv
+  const shims = [{ file: 'kimaki', script: `#!/bin/sh\nexport KIMAKI_DATA_DIR='${dataDir.replaceAll("'", "'\\''")}'\nexec ${posixArgv.map(shellQuote).join(' ')} "$@"\n` }]
+  if (windows) shims.push({ file: 'kimaki.cmd', script: `@echo off\r\nset "KIMAKI_DATA_DIR=${dataDir.replaceAll('%', '%%')}"\r\n${argv.map(cmdQuote).join(' ')} %*\r\n` })
+  for (const shim of shims) {
+    const file = path.join(directory, shim.file)
+    const written = await fs.promises.writeFile(file, shim.script, { mode: 0o700 }).then(() => fs.promises.chmod(file, 0o700))
+      .catch((cause) => new ConfigError({ reason: 'Cannot install Kimaki command shim', cause }))
+    if (written instanceof Error) return written
+  }
 }
 
 export type LockServer = {