kimaki 1.3.0 → 1.5.0

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

@@ -34,16 +34,23 @@ test('CLI send starts and continues a session through the authenticated bot API'
   const first = await cli(['send', '--channel', twin.channelId, '--prompt', 'CLI first'])
   const ids = JSON.parse(first.stdout) as { threadId: string; sessionId: string }
   await waitForFooter({ discord: twin.discord, threadId: ids.threadId })
+  // Follow-ups into an idle thread have no Discord message: the thread must still show them.
   await cli(['send', '--thread', ids.threadId, '--prompt', 'CLI second. queue'])
   await waitForFooter({ discord: twin.discord, threadId: ids.threadId, count: 2 })
+  await cli(['send', '--thread', ids.threadId, '--prompt', 'CLI third'])
+  await waitForFooter({ discord: twin.discord, threadId: ids.threadId, count: 3 })
   expect(await twin.discord.thread(ids.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** CLI first
+    -# » **CLI:** CLI first
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# » **CLI:** CLI second
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# » **CLI:** CLI third
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
   expect(ids.sessionId).toMatch(/^ses_/)
   const tokenFile = path.join(dataDir, 'lock-token')
@@ -57,12 +64,58 @@ test('CLI send starts and continues a session through the authenticated bot API'
   expect(invalid.status).toBe(400)
 })
 
+test('CLI send shows a prompt over 2000 chars in full, split into messages', async () => {
+  const prompt = Array.from({ length: 30 }, (_, index) => `line ${String(index).padStart(2, '0')}: ${'x'.repeat(70)}`).join('\n')
+  const sent = await cli(['send', '--channel', twin.channelId, '--prompt', prompt])
+  const ids = JSON.parse(sent.stdout) as { threadId: string; sessionId: string }
+  await waitForFooter({ discord: twin.discord, threadId: ids.threadId })
+  expect(await twin.discord.thread(ids.threadId).text()).toMatchInlineSnapshot(`
+    "--- from: assistant (TestBot)
+    -# » **CLI:** line 00: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 01: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 02: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 03: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 04: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 05: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 06: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 07: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 08: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 09: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 10: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 11: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 12: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 13: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 14: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 15: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 16: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 17: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 18: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 19: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 20: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 21: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 22: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 23: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 24: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 25: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 26: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 27: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 28: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# line 29: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
+  `)
+  const messages = await twin.discord.thread(ids.threadId).getMessages()
+  expect(messages.every((message) => message.content.length <= 2000)).toBe(true)
+})
+
 test('CLI help documents the supported P7 commands', async () => {
   const output = await cli(['--help'])
   expect(output.stdout).toContain('send')
   expect(output.stdout).toContain('upload-request')
-  expect(output.stdout).toMatchInlineSnapshot(`
-    "kimaki
+  // The header is `kimaki/<version>`; keep the snapshot stable across releases.
+  expect(output.stdout.replace(/^kimaki\/[^\n]+/, 'kimaki/<version>')).toMatchInlineSnapshot(`
+    "kimaki/<version>
 
     Usage:
       $ kimaki [options]
@@ -96,9 +149,9 @@ test('CLI help documents the supported P7 commands', async () => {
         --rebuild                       Write transcripts again, also current ones
         --json                          Output as JSON
 
-      session wait <id>                 Wait until idle or waiting for input, then print the session
+      session wait [...ids]             Wait until every session is idle or waits for the user, then print each one and why it returned
         --data-dir <path>               Data directory (default: ~/.kimaki)
-        --timeout <duration>            Timeout, for example 30m or 2h
+        --timeout <duration>            Timeout, for example 30m or 2h; exit 1 when a session still runs
 
       session editors <file>            List sessions that last edited a file, newest first
         --data-dir <path>               Data directory (default: ~/.kimaki)
@@ -134,6 +187,9 @@ test('CLI help documents the supported P7 commands', async () => {
       session archive [id]              Archive a session thread
         --data-dir <path>               Data directory (default: ~/.kimaki)
 
+      session compact [id]              Summarize the session history after its current turn (default: this session)
+        --data-dir <path>               Data directory (default: ~/.kimaki)
+
       session title <title>             Rename the session and its Discord thread
         --data-dir <path>               Data directory (default: ~/.kimaki)
         -s, --session <id>              Session ID, Discord thread ID or thread URL (default: OPENCODE_SESSION_ID)
@@ -182,7 +238,7 @@ test('CLI help documents the supported P7 commands', async () => {
         --data-dir <path>               Data directory (default: ~/.kimaki)
         -c, --channel <id>              Destination channel (default: channel of the session folder)
 
-      buttons                           Show 1-3 action buttons. Call last, after visible text
+      buttons                           Show 1-3 action buttons. Explain them in your text
         --data-dir <path>               Data directory (default: ~/.kimaki)
         -s, --session <id>              Session ID, Discord thread ID or thread URL (default: OPENCODE_SESSION_ID)
         -b, --button <spec>             Repeatable: Label[:white|blue|green|red]
@@ -212,7 +268,7 @@ test('CLI help documents the supported P7 commands', async () => {
         -d, --project <path>            Project directory of the new thread
         --thread <id>                   Continue this thread (ID or URL)
         -s, --session <id>              Continue this session: session ID, thread ID or thread URL
-        -p, --prompt <text>             Prompt; thread suffixes . queue and . btw are supported
+        -p, --prompt <text>             Prompt; thread suffixes . queue and . btw are supported (required)
         -f, --file <path>               Attach a local file (repeatable)
         -n, --name <text>               Thread name
         --agent <name>                  Agent ID
@@ -224,7 +280,7 @@ test('CLI help documents the supported P7 commands', async () => {
         --parent-session <id>           Record the parent session in session metadata
         --permission <rule>             Repeatable: tool[:pattern]:allow|deny|ask
         --notify-only                   Post a notification thread without a model turn
-        --wait                          Wait until idle or input is needed, then print the session
+        --wait [seconds]                Wait until idle or input is needed (at most this many seconds, default 1 day), then print the session
         --send-at <when>                Schedule: UTC ISO date ending in Z, or cron expression (UTC)
         --pre-run <command>             Scheduled only: run first in the project. Exit 0 starts, stdout is appended
         --allow-concurrency             Scheduled only: allow overlapping runs of this routine
@@ -232,10 +288,11 @@ test('CLI help documents the supported P7 commands', async () => {
       session events <id>               Print the recorded OpenCode events of a thread as JSONL (root + subagents)
         --data-dir <path>               Data directory (default: ~/.kimaki)
 
-      session read <id>                 Print the messages of a session from OpenCode as markdown
+      session read <id>                 Print the prompts and final answers of a session as markdown
         --data-dir <path>               Data directory (default: ~/.kimaki)
-        --thinking                      Include reasoning
-        --verbose                       Include full tool inputs and outputs
+        --full                          Every message with tool calls
+        --thinking                      Full output with reasoning
+        --verbose                       Full output with tool inputs and outputs
         --json                          Print raw OpenCode messages
 
       session cwd [directory]           Show or change the working directory at a native safe boundary
@@ -295,7 +352,7 @@ test('CLI help documents the supported P7 commands', async () => {
       routine run <routineId>           Run a routine now
         --data-dir <path>               Data directory (default: ~/.kimaki)
 
-      sleep                             Wake this session later with a new message in the same thread. Run it last, after your text. To monitor slow events (email replies, PR reviews), wait 2h or more; never poll every few minutes
+      sleep                             Wake this session later with a new message in the same thread. Run it last, after your text. To monitor slow events (email replies, PR reviews), wait 2h or more; never poll every few minutes. When blocked on a user action outside the chat (a sudo or permission dialog, a login), ask for it, assume they will do it, and sleep 5m, then check and continue on your own
         --data-dir <path>               Data directory (default: ~/.kimaki)
         --duration <duration>           Relative wait, e.g. 30m, 2h, 1d
         --until <date>                  UTC ISO date ending in Z
@@ -320,6 +377,10 @@ test('CLI help documents the supported P7 commands', async () => {
         -s, --session <id>              Session ID, Discord thread ID or thread URL (default: OPENCODE_SESSION_ID)
         -c, --channel <id>              Kimaki voice channel to post in (default in voice calls: KIMAKI_CHANNEL_ID)
 
+      diagram <input>                   Render a Mermaid diagram (file path, or - for stdin) to a light themed PNG. Upload it with upload-to-discord
+        -o, --output <path>             PNG file to write (default: input path with .png, or a temp file for stdin)
+        --dark                          Dark theme instead of light
+
       Tools:
       tunnel                            Run a command and expose its local port with a public opentunnel.xyz URL. The child gets KIMAKI_TUNNEL_URL
         -p, --port <port>               Local port (default: read from the command output)
@@ -376,12 +437,15 @@ test('CLI help documents the supported P7 commands', async () => {
       --restart-onboarding          Choose credentials again
       --worktrees                   Use a fresh Git worktree for new sessions unless the channel overrides it
       --allow-all-users             Every server member can use the bot (role "no-kimaki" still denies; provider login stays admin-only)
-      --message-tool                Discord shows only a concise reply the agent sends with a send_message tool; plain text stays visible in the OpenCode TUI
       --voice <name>                Voice of voice calls, saved for later starts (e.g. cove, juniper, sol). "default" resets it
       --disable-skills <list>       Built-in Kimaki skills to turn off: "all" or a comma separated list (kimaki-debug,kimaki-tunnel)
+      --disable-prompt <section>    System prompt section to remove from new sessions (repeatable): discord-permissions, kimaki-debugging, file-upload-requests, action-buttons, session-sleep, session-abort, cross-project-commands, waiting-sessions, critique-diffs, markdown-formatting, discord-callouts, search-result-urls, diagrams
       --no-analytics                Disable anonymous usage analytics (same as KIMAKI_STRADA_ENABLED=0)
+      --coordinator [enabled]       Channel messages go to one long coordinator session that starts threads for the work. "false" turns it off (/toggle-coordinator sets one channel) (default: true)
+      --no-autostart                Do not open a terminal with the bot when OpenCode starts (for bots run by launchd, systemd or pm2)
       --if-not-running              Start only if no bot runs; never stop the running one (used by autostart)
       -h, --help                    Display this message
+      -V, --version                 Display version number
     "
   `)
 })
@@ -408,16 +472,20 @@ test('CLI registry shares thread actions, preferences, title and archive', async
   await cli(['session', 'queue', 'add', 'Registry queued', '--session', started.threadId])
   await expect(cli(['session', 'queue', 'list', '--session', 'not-an-id'])).rejects.toThrow('Not a session ID, Discord thread ID or thread URL: not-an-id')
   await waitForFooter({ discord: twin.discord, threadId: started.threadId, count: 2 })
+  // The deterministic model writes no summary template, so the compaction runs and fails.
+  expect(JSON.parse((await cli(['session', 'compact', started.threadId])).stdout)).toEqual({ sessionId: started.sessionId, queued: true })
   await cli(['session', 'abort', started.sessionId])
   await cli(['session', 'archive', started.threadId])
   expect(await twin.discord.thread(started.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** Registry first
+    -# » **CLI:** Registry first
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# » **CLI:** Registry queued
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2 ⋅ build*
+    ✗ compaction failed: Compaction summary did not match the required template"
   `)
   expect((await twin.discord.channel(twin.channelId).getThreads()).find((thread) => thread.id === started.threadId)?.name).toBe('CLI renamed')
 })
@@ -430,10 +498,10 @@ test('send settings reach native session creation; notifications create no sessi
   await waitForFooter({ discord: twin.discord, threadId: ids.threadId })
   expect(await twin.discord.thread(ids.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** Send settings
+    -# » **CLI:** Send settings
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *subfolder ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *subfolder ⋅ main ⋅ Ns ⋅ deterministic-v2 ⋅ build*"
   `)
   const info = await (await server.client()).session.get({ sessionID: ids.sessionId })
   expect(info.location.directory).toBe(subdir)

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

@@ -43,10 +43,10 @@ test('session read, list, sync, wait, url and events read real session history',
   const events = await cli(['session', 'events', first.sessionId])
   expect(await twin.discord.thread(first.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** Reader content marker
+    -# » **CLI:** Reader content marker
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
   expect(list.stdout).toContain(first.sessionId)
   expect(sync.written + sync.skipped).toBeGreaterThan(0)
@@ -54,6 +54,7 @@ test('session read, list, sync, wait, url and events read real session history',
   expect(fs.readFileSync(path.join(dataDir, 'transcripts', `${first.sessionId}.md`), 'utf8')).toContain('## user')
   expect(fs.readFileSync(path.join(dataDir, 'transcripts', `${first.sessionId}.md`), 'utf8')).toContain('Reader content marker')
   expect(read.stdout).toContain('Reader content marker')
+  expect(read.stdout).toMatch(/\ncontext: \d+k? tokens, last run took \S+( \S+)?, last active \S+( \S+)? ago \(\d{4}-/)
   expect(wait.stdout).toContain('Reader content marker')
   expect(url.stdout).toContain(first.threadId)
   expect(events.stdout).toContain('session.execution.succeeded')
@@ -61,19 +62,27 @@ test('session read, list, sync, wait, url and events read real session history',
   expect(none instanceof Error && none.code).toBe(1)
 })
 
-test('session wait returns for a real pending question; active discovery errors use exit 64', async () => {
-  const first = await send(bot, { channelId: twin.channelId, prompt: 'wait-form-marker', permissions: ['question:allow'] })
-  if (first instanceof Error || !first.sessionId) throw new Error('Expected a session')
-  await waitForSelectMenu({ discord: twin.discord, channelId: first.threadId, prefix: 'form:' })
-  const result = await cli(['session', 'wait', first.sessionId, '--timeout', '3s'])
+test('session wait waits for many sessions and says a question paused one; active discovery errors use exit 64', async () => {
+  const [first, done] = await Promise.all([
+    send(bot, { channelId: twin.channelId, prompt: 'wait-form-marker', permissions: ['question:allow'] }),
+    send(bot, { channelId: twin.channelId, prompt: 'Second waited session' }),
+  ])
+  if (first instanceof Error || !first.sessionId || done instanceof Error || !done.sessionId) throw new Error('Expected sessions')
+  await Promise.all([waitForSelectMenu({ discord: twin.discord, channelId: first.threadId, prefix: 'form:' }), waitForFooter({ discord: twin.discord, threadId: done.threadId })])
+  const result = await cli(['session', 'wait', first.sessionId, done.threadId, '--timeout', '8s'])
   expect(await twin.discord.thread(first.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** wait-form-marker
+    -# » **CLI:** wait-form-marker
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     **Next**
     Continue?"
   `)
   expect(result.stdout).toContain('Continue?')
+  expect(result.stdout.split('\n').filter((line) => line.startsWith('==='))).toEqual([
+    `=== ${first.sessionId} is paused: it waits for the user to answer a question, so its work is not done ===`,
+    `=== ${done.sessionId} was already idle: its last run ended before the wait started ===`,
+  ])
+  expect(result.stdout.indexOf('Second waited session')).toBeGreaterThan(result.stdout.indexOf('Continue?'))
   const failure = await exec(process.execPath, ['--import', 'tsx', path.resolve('src/cli.ts'), 'session', 'list', '--active'], {
     env: { ...process.env, KIMAKI_OPENCODE_SERVICE_FILE: path.join(server.root, 'missing-service.json') },
   }).catch((error: Error & { code: number }) => error)

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

@@ -87,12 +87,13 @@ test('session command, named fork, and resume without a channel use the session
   const resumed = JSON.parse((await cli(['session', 'resume', source.sessionId])).stdout)
   expect(await twin.discord.thread(source.threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** command-source
+    -# » **CLI:** command-source
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# » **CLI:** /review focus --focus security
     reviewed with passthrough
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect((await twin.discord.thread(forked.threadId).getChannel())?.name).toBe('named fork')
   expect(resumed.sessionId).toBe(source.sessionId)

package/src/cli.ts

@@ -4,6 +4,7 @@
 // Startup must stay light: bot modules (main.ts, onboarding.ts, scheduler.ts)
 // are imported lazily inside the commands that need them.
 
+import { createRequire } from 'node:module'
 import { goke } from 'goke'
 
 import { registerBotCommands, registerLoginCommands, registerStartCommand, registerToolCommands } from './cli/bot.ts'
@@ -48,4 +49,5 @@ cli.section('Bot')
 registerBotCommands(cli)
 
 cli.help()
+cli.version(createRequire(import.meta.url)('../package.json').version, '-V, --version')
 void cli.parse()

package/src/commands/preference-commands.ts

@@ -2,7 +2,8 @@
 // session in OpenCode (switchAgent / switchModel, applied from the next
 // step); in a project channel they set the default for new sessions
 // (channel_agents / channel_models). /model can also set the default of
-// channels without their own model (global_models). Verbosity is always per channel.
+// channels without their own model (global_models). Verbosity and coordinator
+// mode are always per channel.
 //
 //   /agent          ─▶ agent select ─▶ session or channel
 //   /<agent>-agent  ─▶ same, without the select
@@ -10,6 +11,7 @@
 //                   └▶ reset buttons: session model ─▶ channel default, channel model ─▶ removed
 //   /model-variant  ─▶ variant of the current model ─▶ scope
 //   /verbosity      ─▶ text | tools for the channel
+//   /toggle-coordinator ─▶ coordinator mode on | off for the channel
 //
 // The /model wizard keeps its picks in the createPreferenceRoutes closure
 // keyed by a short hash (custom IDs max 100 chars), dropped after 10 minutes.
@@ -25,7 +27,7 @@ import {
   type StringSelectMenuInteraction,
 } from 'discord.js'
 
-import { globalModel, oc, parseModel, type Bot, type ModelChoice } from '../bot.ts'
+import { globalModel, isCoordinatorChannel, oc, parseModel, type Bot, type ModelChoice } from '../bot.ts'
 import { verbosityFromV1, verbosityToV1, type Verbosity } from '../db.ts'
 import { ConfigError, DbError } from '../errors.ts'
 import { button, buttonRow, paginate, selectedPage, selectRow, type UiMessage } from '../format-parts.ts'
@@ -111,6 +113,19 @@ export async function setVerbosity(bot: Bot, { channelId, verbosity }: { channel
   bot.store.setState((current) => ({ verbosity: { ...current.verbosity, [channelId]: verbosity } }))
 }
 
+// Coordinator mode of a project channel. Turning it off keeps the coordinator
+// binding: turning it on again resumes that session (/reset-coordinator drops it).
+export async function setCoordinatorMode(bot: Bot, { channelId, enabled }: { channelId: string; enabled: boolean }): Promise<DbError | void> {
+  const value = enabled ? 1 : 0
+  const result = await bot.db
+    .insert(schema.channel_coordinator)
+    .values({ channel_id: channelId, enabled: value })
+    .onConflictDoUpdate({ target: schema.channel_coordinator.channel_id, set: { enabled: value } })
+    .catch((cause) => new DbError({ operation: 'write channel_coordinator', cause }))
+  if (result instanceof Error) return result
+  bot.store.setState((current) => ({ coordinator: { ...current.coordinator, [channelId]: enabled } }))
+}
+
 export async function setChannelAgent(bot: Bot, { channelId, agent }: { channelId: string; agent: string }): Promise<DbError | void> {
   const result = await bot.db
     .insert(schema.channel_agents)
@@ -264,7 +279,7 @@ async function setAgent(bot: Bot, { target, agent, model }: { target: Interactio
   if (before instanceof Error) return before
   const sessionId = target.sessionId
   const selected = sessionId
-    ? await switchAgent(bot, { sessionId, directory: target.directory, agent, model })
+    ? await switchAgent(bot, { sessionId, directory: target.directory, agent, model, reselect: true })
     : await agentSelection(bot, { directory: target.directory, agent })
   if (selected instanceof Error) return selected
   if (!sessionId) {
@@ -479,9 +494,24 @@ async function handleVerbositySelect(bot: Bot, interaction: StringSelectMenuInte
   })
 }
 
+// --- /toggle-coordinator
+
+async function toggleCoordinatorCommand(bot: Bot, interaction: ChatInputCommandInteraction) {
+  const target = await resolveTarget(bot, interaction.channelId)
+  if (target instanceof Error) return replyError(interaction, target)
+  const enabled = !isCoordinatorChannel(bot, target.channelId)
+  const result = await setCoordinatorMode(bot, { channelId: target.channelId, enabled })
+  if (result instanceof Error) return replyError(interaction, result)
+  const resumes = enabled && bot.store.getState().roots[target.channelId] ? ' It continues the coordinator session this channel had before; /reset-coordinator starts a fresh one.' : ''
+  const content = enabled
+    ? `Coordinator mode **on** for this channel. Channel messages go to one long coordinator session that starts threads for the work.${resumes}`
+    : 'Coordinator mode **off** for this channel. Each channel message starts a new thread.'
+  await interaction.reply({ content })
+}
+
 // --- Routes
 
-// /agent, /model, /model-variant, /verbosity and their selects. One per bot:
+// /agent, /model, /model-variant, /verbosity, /toggle-coordinator and their selects. One per bot:
 // the /model wizard picks stay in this closure.
 export function createPreferenceRoutes(): InteractionRoutes {
   const wizards = new Map<string, ModelWizard>()
@@ -592,6 +622,10 @@ export function createPreferenceRoutes(): InteractionRoutes {
         run: variantMenu,
       },
       verbosity: { definition: new SlashCommandBuilder().setName('verbosity').setDescription('Set what the bot shows in this channel'), run: verbosityMenu },
+      'toggle-coordinator': {
+        definition: new SlashCommandBuilder().setName('toggle-coordinator').setDescription('Turn coordinator mode on or off: one long session in this channel that starts threads'),
+        run: toggleCoordinatorCommand,
+      },
     },
     buttons: { [MODEL_RESET_PREFIX]: modelReset },
     selects: { [AGENT_PREFIX]: handleAgentSelect, [MODEL_PREFIX]: modelSelect, [VERBOSITY_PREFIX]: handleVerbositySelect },

package/src/commands/session-commands.ts

@@ -2,7 +2,8 @@
 // /fork, /fork-subagent. Selects carry only the source session ID; the
 // source thread comes from the interaction channel.
 //
-//   /new-session prompt files? agent?  ─▶ startSession (new thread, no start message)
+//   /new-session prompt? files? agent? ─▶ startSession (new thread, no start message;
+//                                         no prompt: run: false, the first thread message runs it)
 //   /resume session (autocomplete)     ─▶ resume (binding moves to the new thread)
 //   /fork ─▶ select a user message      ─▶ fork({ before })
 //   /fork-subagent ─▶ select a child    ─▶ fork(child)
@@ -60,12 +61,13 @@ export function parseFileList({ value, directory }: { value: string; directory:
 async function newSession(bot: Bot, interaction: ChatInputCommandInteraction) {
   const target = await resolveTarget(bot, interaction.channelId)
   if (target instanceof Error) return replyError(interaction, target)
-  const text = interaction.options.getString('prompt', true).trim()
-  if (!text) return replyError(interaction, new ConfigError({ reason: 'Write a prompt for the new session' }))
+  const text = interaction.options.getString('prompt')?.trim() ?? ''
   const files = parseFileList({ value: interaction.options.getString('files') ?? '', directory: target.directory })
   if (files instanceof Error) return replyError(interaction, files)
+  if (!text && files.length > 0) return replyError(interaction, new ConfigError({ reason: 'Write a prompt to attach files' }))
   const agent = interaction.options.getString('agent')?.trim()
   await interaction.deferReply()
+  // No prompt: the session waits in the thread for its first message.
   const started = await startSession(bot, {
     channelId: target.channelId,
     directory: target.directory,
@@ -74,6 +76,7 @@ async function newSession(bot: Bot, interaction: ChatInputCommandInteraction) {
     messageId: interaction.id,
     startMessageId: null,
     files,
+    run: Boolean(text),
   })
   if (started instanceof Error) return replyError(interaction, started)
   await interaction.editReply({ content: `Created new session in <#${started.threadId}>` })
@@ -82,7 +85,7 @@ async function newSession(bot: Bot, interaction: ChatInputCommandInteraction) {
 async function resumeCommand(bot: Bot, interaction: ChatInputCommandInteraction) {
   const target = await resolveTarget(bot, interaction.channelId)
   if (target instanceof Error) return replyError(interaction, target)
-  if (target.thread) {
+  if (target.conversation?.isThread()) {
     return replyError(interaction, new ConfigError({ reason: 'This command can only be used in project channels, not threads' }))
   }
   await interaction.deferReply()
@@ -173,7 +176,7 @@ async function forkSelected(bot: Bot, { interaction, subagents }: { interaction:
   const selected = interaction.values[0]
   const target = await resolveTarget(bot, interaction.channelId)
   if (target instanceof Error) return replyError(interaction, target)
-  if (!selected || !target.thread || target.sessionId !== sourceSessionId) {
+  if (!selected || !target.conversation || target.sessionId !== sourceSessionId) {
     await interaction.update({ content: 'This selection expired. Run the command again.', components: [] })
     return
   }
@@ -186,7 +189,7 @@ async function forkSelected(bot: Bot, { interaction, subagents }: { interaction:
   })()
   if (subagent instanceof Error) return replyError(interaction, subagent)
   const result = await fork(bot, {
-    sourceThread: target.thread,
+    source: target.conversation,
     sessionId: subagents ? selected : sourceSessionId,
     ...(!subagents && { before: selected }),
     ...(subagent && { subagent }),
@@ -258,7 +261,9 @@ export const sessionRoutes: InteractionRoutes = {
       definition: new SlashCommandBuilder()
         .setName('new-session')
         .setDescription('Start a new OpenCode session')
-        .addStringOption((option) => option.setName('prompt').setDescription('Prompt content for the session').setRequired(true))
+        .addStringOption((option) =>
+          option.setName('prompt').setDescription('Prompt content for the session; empty waits for the first message in the thread'),
+        )
         .addStringOption((option) =>
           option.setName('files').setDescription('Files to attach (comma separated; autocomplete)').setAutocomplete(true).setMaxLength(6000),
         )