kimaki 1.4.0 → 1.6.0

package/src/main.ts

@@ -8,21 +8,22 @@ import * as errore from 'errore'
 
 import { createAgentUi } from './agent-ui.ts'
 import type { Analytics } from './analytics.ts'
-import { oc, type Bot } from './bot.ts'
+import { oc, type Bot, type WarmupTimers } from './bot.ts'
 import type { PromptSection } from './builtin-skills.ts'
 import { openDb } from './db.ts'
 import { createEffectsRunner } from './effects.ts'
 import { DiscordError } from './errors.ts'
-import { createEventLoop } from './event-loop.ts'
+import { createEventLoop, type RunEnded } from './event-loop.ts'
 import { registerIngress } from './ingress.ts'
 import { runLockRoute } from './lock-routes.ts'
 import { installShim, type LockServer } from './lock-server.ts'
 import { createLogger } from './logger.ts'
+import { createCoordinatorNotes } from './coordinator.ts'
 import { installPluginShim, watchOpencode, type OpencodeEndpoint } from './opencode-server.ts'
 import { countUserProjects } from './project.ts'
 import { createScheduler, systemClock, type Clock } from './scheduler.ts'
 import { createEventRecorder, syncSessionTranscript } from './session-events.ts'
-import { createPluginWait, refreshCliContext } from './sessions.ts'
+import { channelDefaults, createPluginWait, refreshCliContext } from './sessions.ts'
 import { createInteractionRegistry, registerSlashCommands } from './slash-commands.ts'
 import { createSleepLock } from './sleeps.ts'
 import { createBotStore } from './store.ts'
@@ -53,8 +54,9 @@ export type StartBotOptions = {
   // OpenCode's SQLite file (opencodeDbFile()): voice transcription reads the ChatGPT credential from it.
   // Required, so tests never read the developer's real credentials.
   opencodeDbFile: string
-  // Shell command that runs this Kimaki install (given to agents), from kimakiShellCommand().
-  kimakiCommand: string
+  // Command that runs this Kimaki install, for the <dataDir>/bin/kimaki shim agents call.
+  // No --data-dir: the shim sets KIMAKI_DATA_DIR, and not every command takes the flag.
+  kimakiArgv: readonly string[]
   // Product analytics sink (createAnalytics or disabledAnalytics).
   analytics: Analytics
   // Voice transcription API base URLs; tests point Gemini at a local fake.
@@ -71,6 +73,10 @@ export type StartBotOptions = {
   disabledSkills?: readonly string[]
   // Static instruction parts left out of new sessions (system-prompt.ts).
   disabledPrompt?: readonly PromptSection[]
+  // `--coordinator`: coordinator mode for channels without a /toggle-coordinator choice (ingress.ts). Default: on.
+  coordinator?: boolean
+  // Default: the plugin's prompt cache warmup windows (plugin/coordinator.ts). Tests pass short ones.
+  warmupTimers?: WarmupTimers
 }
 
 export type BotHandle = Bot & {
@@ -141,6 +147,7 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
       const result = await oc({ opencode }, 'mark session viewed', (client) => client.session.view({ sessionID: sessionId, idle }))
       if (result instanceof Error) return result
     },
+    footerDefaults: (channelId) => channelDefaults({ db, opencode }, channelId),
   })
   cleanup.defer(() => effects.stop())
   const voiceCalls = createVoiceCalls({ opencodeConfigDir: options.opencodeConfigDir })
@@ -149,7 +156,12 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
       if (result instanceof Error) logger.warn(`transcript of ${sessionId} not synced`, result)
     })
   }
-  const eventLoop = createEventLoop({ store, db, discord, effects, recorder, analytics: options.analytics, onRunEnded: voiceCalls.runEnded, onTranscriptDue })
+  const coordinatorNotes = createCoordinatorNotes()
+  const onRunEnded = (run: RunEnded) => {
+    voiceCalls.runEnded(run)
+    coordinatorNotes.runEnded(run)
+  }
+  const eventLoop = createEventLoop({ store, db, discord, effects, recorder, analytics: options.analytics, onRunEnded, onTranscriptDue })
   const loaded = await eventLoop.load()
   if (loaded instanceof Error) return loaded
   // Before the service is used, so a service started by ensure() loads it at once.
@@ -163,7 +175,7 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
     onDisconnect: eventLoop.onDisconnect,
   })
   cleanup.defer(() => opencode.stop())
-  const shim = await installShim({ dataDir: options.dataDir, command: options.kimakiCommand })
+  const shim = await installShim({ dataDir: options.dataDir, argv: options.kimakiArgv })
   if (shim instanceof Error) return shim
   // The features that non-interaction code reaches through bot.features.
   const agentUi = createAgentUi({ store, eventLoop, opencode })
@@ -189,6 +201,8 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
     allowAllUsers: options.allowAllUsers ?? false,
     disabledSkills: options.disabledSkills ?? [],
     disabledPrompt: options.disabledPrompt ?? [],
+    coordinatorDefault: options.coordinator ?? true,
+    warmupTimers: options.warmupTimers ?? null,
     features: { withSleepLock: createSleepLock(), waitForPlugin: createPluginWait({ opencode }), agentUi, voiceCalls },
   }
   const scheduler = createScheduler({
@@ -201,6 +215,7 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
   // Before login: gateway-proxy replays missed messages right after READY.
   registerIngress(bot)
   voiceCalls.register(bot)
+  coordinatorNotes.register(bot)
   // Before discord.destroy() (registered earlier, so disposed later): leaving voice needs the gateway.
   cleanup.defer(() => voiceCalls.stop(bot))
 

package/src/markdown/markdown.test.ts

@@ -344,10 +344,10 @@ test('long paragraph splits by sentences, tight paragraph-list spacing is kept',
   const text = `Steps:\n- one\n- two\n\n${sentence.repeat(30)}`
   expect(renderMarkdown(text, { limit: 500 }).map((segment) => segment.kind === 'text' && segment.markdown.length)).toMatchInlineSnapshot(`
     [
-      499,
-      479,
-      479,
-      479,
+      500,
+      480,
+      480,
+      480,
       480,
     ]
   `)

package/src/markdown/render-markdown.ts

@@ -11,7 +11,7 @@
 // Text is sliced from the original source by node offsets, never
 // re-serialized, so the model's markdown reaches Discord unchanged. Only
 // oversized nodes are split: code by lines (each piece a valid fence), lists
-// by items, paragraphs by sentences, then words.
+// by items, paragraphs by lines, sentences, then words.
 
 import type { Code, List, ListItem, Root, RootContent, Table } from 'mdast'
 import { fromMarkdown } from 'mdast-util-from-markdown'
@@ -163,16 +163,17 @@ function codePieces(source: string, code: Code, limit: number): string[] {
   return codeBlocks({ fence, lang: code.lang ?? '', value: code.value, limit })
 }
 
-// Sentences first, then words, then a hard cut.
+// Lines first, then sentences, then words, then a hard cut.
 function splitText(text: string, limit: number): string[] {
   if (text.length <= limit) return [text]
-  const units = text.split(/(?<=[.!?])\s+/)
-  const byWords = units.flatMap((unit) => (unit.length <= limit ? [unit] : unit.split(/(?<=\s)/)))
+  // Every unit keeps its trailing whitespace, so packing joins them as they were.
+  const units = text.split(/(?<=\n)/).flatMap((line) => (line.length <= limit ? [line] : line.split(/(?<=[.!?]\s+)(?=\S)/)))
+  const byWords = units.flatMap((unit) => (unit.length <= limit ? [unit] : unit.split(/(?<=\s)(?=\S)/)))
   const parts = byWords.flatMap((unit) => {
     if (unit.length <= limit) return [unit]
     return Array.from({ length: Math.ceil(unit.length / limit) }, (_, index) => unit.slice(index * limit, (index + 1) * limit))
   })
-  return pack(parts, limit, ' ')
+  return pack(parts, limit, '')
 }
 
 function pack(parts: string[], limit: number, separator: string): string[] {

package/src/onboarding-cli.e2e.test.ts

@@ -161,15 +161,16 @@ test('kimaki --gateway without a TTY installs, onboards and reports ready on std
   `)
 
   const kimakiChannel = channels.find((channel) => channel.name === 'kimaki')!
-  const thread = await twin.discord.channel(kimakiChannel.id).waitForThread({ timeout: 8_000 })
-  await waitForFooter({ discord: twin.discord, threadId: thread.id })
-  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+  // Coordinator mode is on by default: onboarding answers in the channel.
+  await waitForFooter({ discord: twin.discord, threadId: kimakiChannel.id })
+  expect(await twin.discord.channel(kimakiChannel.id).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    **Kimaki** lets you code from Discord. Each project channel is linked to a folder on your computer. A message there starts an AI coding session in that folder.
-    Reply in the thread below to add channels for your projects. <@200000000000000001>
+    **Kimaki** lets you code from Discord. Each project channel is linked to a folder on your computer. Write in the channel: one long session answers there and starts threads for the work.
+    Reply here to add channels for your projects. <@200000000000000001>
     -# *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\`.
     Want channels for your projects?
-    -# *kimaki ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 
   // `kimaki restart`: the supervisor starts a new bot process, which reports ready again.

package/src/onboarding.e2e.test.ts

@@ -13,7 +13,8 @@ import { ChannelType } from 'discord.js'
 import { afterAll, beforeAll, expect, test } from 'vitest'
 
 import type { BotHandle } from './main.ts'
-import { kimakiShellCommand, runOnboarding } from './onboarding.ts'
+import { shellQuote } from './lock-server.ts'
+import { runOnboarding } from './onboarding.ts'
 import {
   TEST_USER_ID,
   scriptedTurn,
@@ -40,9 +41,7 @@ beforeAll(async () => {
   dataDir = tempDataDir()
   twin = await startTwin({ gateway: true })
   const require = createRequire(import.meta.url)
-  kimaki = kimakiShellCommand({
-    command: [process.execPath, require.resolve('tsx/cli'), path.join(import.meta.dirname, 'cli.ts')],
-  })
+  kimaki = [process.execPath, require.resolve('tsx/cli'), path.join(import.meta.dirname, 'cli.ts')].map(shellQuote).join(' ')
   otherProject = path.join(dataDir, 'other-project')
   fs.mkdirSync(otherProject)
   execFileSync('git', ['init', '-q'], { cwd: otherProject })
@@ -90,7 +89,7 @@ async function guildChannels() {
 test('onboarding thread adds a project channel through the kimaki CLI, which answers at once', async () => {
   const { discord } = twin
   const guild = bot.discord.guilds.cache.get(discord.guildId)!
-  const onboarded = await runOnboarding({ bot, dataDir, guild, kimaki, gateway: true, installerId: TEST_USER_ID, machine: 'test-machine' })
+  const onboarded = await runOnboarding({ bot, dataDir, guild, gateway: true, installerId: TEST_USER_ID, machine: 'test-machine' })
   if (!onboarded || onboarded instanceof Error) throw new Error(`onboarding failed: ${onboarded?.message}`, { cause: onboarded })
   await waitForFooter({ discord, threadId: onboarded.threadId })
 
@@ -108,14 +107,14 @@ test('onboarding thread adds a project channel through the kimaki CLI, which ans
     Reply in the thread below to add channels for your projects. <@200000000000000001>
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     Want channels for your projects? I can search for git repositories.
-    -# *kimaki ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     --- from: user (tommy)
     yes, add-other-project
     --- from: assistant (TestBot)
     -# ┣ shell _add project channel_
 
     Added the channel for other-project.
-    -# *kimaki ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(await guildChannels()).toMatchInlineSnapshot(`
     [
@@ -143,7 +142,7 @@ test('onboarding thread adds a project channel through the kimaki CLI, which ans
   await waitForFooter({ discord, threadId: thread.id })
 
   // Second start: nothing is created again.
-  expect(await runOnboarding({ bot, dataDir, guild, kimaki, gateway: true, machine: 'test-machine' })).toBe(null)
+  expect(await runOnboarding({ bot, dataDir, guild, gateway: true, machine: 'test-machine' })).toBe(null)
   await waitFor({ label: 'no extra channels', check: async () => (await guildChannels()).length === 6 })
 
   // An empty default channel means an earlier onboarding failed: retry in the same channel.
@@ -151,7 +150,7 @@ test('onboarding thread adds a project channel through the kimaki CLI, which ans
   const channel = await bot.discord.channels.fetch(defaultChannel.channel_id)
   if (channel?.type !== ChannelType.GuildText) throw new Error('default channel is not a text channel')
   for (const message of (await channel.messages.fetch()).values()) await message.delete()
-  const retried = await runOnboarding({ bot, dataDir, guild, kimaki, gateway: true, installerId: TEST_USER_ID, machine: 'test-machine' })
+  const retried = await runOnboarding({ bot, dataDir, guild, gateway: true, installerId: TEST_USER_ID, machine: 'test-machine' })
   if (retried instanceof Error || !retried) throw new Error(`expected a retried onboarding, got ${retried}`)
   expect(retried.channelId).toBe(defaultChannel.channel_id)
   await waitForFooter({ discord, threadId: retried.threadId })
@@ -163,7 +162,6 @@ test('an upgraded setup with project mappings skips onboarding without selecting
   expect(await runOnboarding({
     bot,
     dataDir: path.join(dataDir, 'upgraded-layout'),
-    kimaki,
     gateway: true,
     machine: 'test-machine',
   })).toBe(null)

package/src/onboarding.ts

@@ -25,8 +25,8 @@ import { ConfigError, DbError, DiscordError, OpenCodeMissingError, type OpenCode
 import { NOTIFY_MESSAGE_FLAGS } from './format-parts.ts'
 import { createLogger } from './logger.ts'
 import { checkOpencode, findOpencodeBinary, installedOpencodeBinary, OPENCODE_INSTALL_COMMAND } from './opencode-server.ts'
-import type { Bot } from './bot.ts'
-import { startSession } from './sessions.ts'
+import { isCoordinatorChannel, type Bot } from './bot.ts'
+import { startCoordinator, startSession } from './sessions.ts'
 import { addProjectChannel, defaultChannelName, defaultProjectDirectory } from './project.ts'
 
 const logger = createLogger('ONBOARD')
@@ -130,11 +130,7 @@ export function startCaffeinate(): void {
   child.unref()
 }
 
-export function shellQuote(arg: string): string {
-  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`
-}
-
-export function onboardingPrompt({ kimaki }: { kimaki: string }): string {
+export function onboardingPrompt(): string {
   return dedent`
     This is the Kimaki onboarding thread. Kimaki maps Discord channels to project folders on this computer:
     a message in a project channel starts a coding session in that folder.
@@ -145,21 +141,15 @@ export function onboardingPrompt({ kimaki }: { kimaki: string }): string {
        searching for git repositories on this computer.
     2. If they agree, search. Only list folders that exist, most recently changed first, at most 15:
        \`find ~/Documents ~/Projects ~/projects ~/code ~/dev ~/src ~/repos ~/GitHub ~/github -maxdepth 3 -name .git -prune 2>/dev/null\`
-       Skip folders that already have a channel: \`${kimaki} project list\`
+       Skip folders that already have a channel: \`kimaki project list\`
     3. Show the folders as a numbered list and ask the user to reply with the numbers to add.
-    4. Add each chosen folder with its absolute path: \`${kimaki} project add <absolute-directory>\`
+    4. Add each chosen folder with its absolute path: \`kimaki project add <absolute-directory>\`
        The command prints the new channel as a mention like <#123>. Reply with the list of new channels.
 
     Never add a channel the user did not choose. Keep every message short.
   `
 }
 
-// The shell command the agent runs to call this Kimaki install.
-// No --data-dir: agent shells get KIMAKI_DATA_DIR from the plugin, and not every command takes the flag.
-export function kimakiShellCommand({ command }: { command: readonly string[] }): string {
-  return command.map(shellQuote).join(' ')
-}
-
 class GitInitError extends errore.createTaggedError({
   name: 'GitInitError',
   message: 'Could not create $directory',
@@ -191,7 +181,6 @@ export async function runOnboarding({
   guild,
   guildId,
   installUrl,
-  kimaki,
   gateway,
   installerId,
   machine,
@@ -201,8 +190,6 @@ export async function runOnboarding({
   guild?: Guild
   guildId?: string
   installUrl?: string
-  // Shell command for `kimaki`, from kimakiShellCommand().
-  kimaki: string
   gateway: boolean
   // --machine-name, else defaultMachineName().
   machine: string
@@ -266,11 +253,12 @@ export async function runOnboarding({
     .fetch(installerId ?? selectedGuild.ownerId)
     .catch((e) => new DiscordError({ operation: 'fetch installer', cause: e }))
   if (owner instanceof Error) return owner
+  const coordinator = isCoordinatorChannel(bot, channel.channelId)
   const welcome = await textChannel
     .send({
       content: dedent`
-        **Kimaki** lets you code from Discord. Each project channel is linked to a folder on your computer. A message there starts an AI coding session in that folder.
-        Reply in the thread below to add channels for your projects. <@${owner.id}>
+        **Kimaki** lets you code from Discord. Each project channel is linked to a folder on your computer. ${coordinator ? 'Write in the channel: one long session answers there and starts threads for the work.' : 'A message there starts an AI coding session in that folder.'}
+        Reply ${coordinator ? 'here' : 'in the thread below'} to add channels for your projects. <@${owner.id}>
       `,
       allowedMentions: { users: [owner.id] },
       flags: NOTIFY_MESSAGE_FLAGS,
@@ -278,15 +266,11 @@ export async function runOnboarding({
     .catch((e) => new DiscordError({ operation: 'send welcome message', cause: e }))
   if (welcome instanceof Error) return welcome
 
-  const session = await startSession(bot, {
-    channelId: channel.channelId,
-    directory,
-    route: { kind: 'steer', text: onboardingPrompt({ kimaki }) },
-    author: { id: owner.id, username: owner.user.username },
-    messageId: welcome.id,
-    threadName: 'Kimaki onboarding',
-    worktree: false,
-  })
+  const author = { id: owner.id, username: owner.user.username }
+  const route = { kind: 'steer' as const, text: onboardingPrompt() }
+  const session = coordinator
+    ? await startCoordinator(bot, { channel: textChannel, route, author, messageId: welcome.id })
+    : await startSession(bot, { channelId: channel.channelId, directory, route, author, messageId: welcome.id, threadName: 'Kimaki onboarding', worktree: false })
   if (session instanceof Error) {
     // Leaves the channel empty, so the next start onboards again.
     await welcome.delete().catch((e) => logger.warn('delete welcome message', e))

package/src/permissions.e2e.test.ts

@@ -132,7 +132,7 @@ test('Accept runs the command', async () => {
     ✓ _Accepted_
 
     accept turn done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })
 
@@ -163,7 +163,7 @@ test('Deny stops the run, the next message is answered', async () => {
     Go on after-deny
     --- from: assistant (TestBot)
     continued after deny
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })
 
@@ -186,6 +186,6 @@ test('a subagent permission shows in the parent thread', async () => {
     ✓ _Accepted always_
 
     parent done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })