kimaki 1.1.0 → 1.3.0

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: bots (including ourselves), channel
-// ownership (only channels mapped in this machine's SQLite), permission.
+// and calls actions. Gates, in order: webhooks and our own messages (except
+// remote send envelopes), 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.
 //
 // Messages sent while the bot was offline are not fetched here: gateway-proxy
@@ -39,9 +40,13 @@ import { isVoiceAttachment, parseVoiceMessage, transcribe, voiceMediaType, type
 
 const logger = createLogger('INGRESS')
 
-// Owner, Administrator, Manage Server, or a role named "Kimaki". A role named
-// "no-kimaki" always denies. Missing member data fails closed.
-export async function canUseKimaki({ guild, userId }: { guild: Guild; userId: string }): Promise<boolean> {
+// Owner, Administrator, Manage Server, or a role named "Kimaki"; with
+// --allow-all-users every member. A role named "no-kimaki" always denies.
+// Missing member data fails closed.
+export async function canUseKimaki(
+  bot: Pick<Bot, 'allowAllUsers'>,
+  { guild, userId }: { guild: Guild; userId: string },
+): Promise<boolean> {
   const member = await guild.members.fetch({ user: userId, force: true }).catch((error: Error) => error)
   if (member instanceof Error) {
     // Still denied, but say why: a REST failure must not look like a missing role.
@@ -49,19 +54,22 @@ export async function canUseKimaki({ guild, userId }: { guild: Guild; userId: st
     return false
   }
   if (!(member instanceof GuildMember)) return false
-  return memberCanUseKimaki(member)
+  return memberCanUseKimaki(bot, member)
 }
 
 // MESSAGE_CREATE carries the author's current roles: no REST fetch on the hot path.
 // Discord omits the member only for webhook and ephemeral messages, which never get here.
-function authorCanUseKimaki(message: Message<true>): Promise<boolean> {
-  if (message.member instanceof GuildMember) return Promise.resolve(memberCanUseKimaki(message.member))
-  return canUseKimaki({ guild: message.guild, userId: message.author.id })
+function authorCanUseKimaki(bot: Bot, message: Message<true>): Promise<boolean> {
+  if (message.member instanceof GuildMember) return Promise.resolve(memberCanUseKimaki(bot, message.member))
+  return canUseKimaki(bot, { guild: message.guild, userId: message.author.id })
 }
 
-function memberCanUseKimaki(member: GuildMember): boolean {
+function memberCanUseKimaki(bot: Pick<Bot, 'allowAllUsers'>, member: GuildMember): boolean {
   const roleNames = member.roles.cache.map((role) => role.name.toLowerCase())
   if (roleNames.includes('no-kimaki')) return false
+  // Other bots are opt-in: only the Kimaki role lets them in, never admin rights or --allow-all-users.
+  if (member.user.bot) return roleNames.includes('kimaki')
+  if (bot.allowAllUsers) return true
   if (member.guild.ownerId === member.id) return true
   if (member.permissions.has(PermissionFlagsBits.Administrator)) return true
   if (member.permissions.has(PermissionFlagsBits.ManageGuild)) return true
@@ -208,7 +216,7 @@ async function handleMessage(bot: Bot, message: Message) {
   if (!project) return
   if (project.channel_type === 'voice') {
     // The text chat of the voice channel talks to the running call.
-    if (message.author.bot || thread || !(await authorCanUseKimaki(message))) return
+    if (message.author.bot || thread || !(await authorCanUseKimaki(bot, message))) return
     bot.features.voiceCalls.text(bot, {
       guildId: message.guild.id,
       channelId,
@@ -217,11 +225,10 @@ async function handleMessage(bot: Bot, message: Message) {
     })
     return
   }
-  if (message.author.bot) {
-    if (message.author.id !== bot.discord.user?.id) return
+  if (message.author.id === bot.discord.user?.id) {
     return handleRemoteEnvelope(bot, { message, channelId, threadId: thread?.id ?? null })
   }
-  if (!(await authorCanUseKimaki(message))) {
+  if (!(await authorCanUseKimaki(bot, message))) {
     logger.log(`ignoring ${message.author.username}: no Kimaki permission`)
     return
   }
@@ -298,7 +305,9 @@ export function registerIngress(bot: Bot) {
   }
 
   bot.discord.on(Events.MessageCreate, (message) => {
-    if (message.author.bot && !message.embeds[0]?.footer?.text.startsWith(REMOTE_SEND_PREFIX)) return
+    // 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
     serialize(message.channelId, () => handleMessage(bot, message))
   })
   // Deleting a queued Discord message removes it from the queue.
@@ -317,7 +326,7 @@ export function registerIngress(bot: Bot) {
     serialize(message.channelId, async () => {
       const full = message.partial ? await message.fetch().catch(() => null) : message
       if (!full?.guild || !queuedItemFor(bot, { threadId: full.channelId, messageId: full.id })) return
-      if (!(await canUseKimaki({ guild: full.guild, userId: full.author.id }))) return
+      if (!(await canUseKimaki(bot, { guild: full.guild, userId: full.author.id }))) return
       // The re-queued prompt must carry the message's attachments again.
       const files = await saveAttachments({ dataDir: bot.dataDir, messageId: full.id, attachments: [...full.attachments.values()] })
       if (files instanceof Error) {

package/src/main.ts

@@ -65,8 +65,11 @@ export type StartBotOptions = {
   // How often due tasks and wakes run; null: never (tests call scheduler.runDueTasks).
   schedulerIntervalMs?: number | null
   autoWorktrees?: boolean
+  allowAllUsers?: boolean
   // Built-in skill ids denied in new sessions (builtin-skills.ts).
   disabledSkills?: readonly string[]
+  // `kimaki --message-tool`: agents also reply through send_message; Discord hides their plain text.
+  messageTool?: boolean
 }
 
 export type BotHandle = Bot & {
@@ -145,7 +148,7 @@ 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 eventLoop = createEventLoop({ store, db, discord, effects, recorder, analytics: options.analytics, messageTool: options.messageTool ?? false, onRunEnded: voiceCalls.runEnded, 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.
@@ -182,7 +185,9 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
     transcriptionBaseUrls: options.transcriptionBaseUrls ?? {},
     realtimeBaseUrls: options.realtimeBaseUrls ?? {},
     autoWorktrees: options.autoWorktrees ?? false,
+    allowAllUsers: options.allowAllUsers ?? false,
     disabledSkills: options.disabledSkills ?? [],
+    messageTool: options.messageTool ?? false,
     features: { withSleepLock: createSleepLock(), waitForPlugin: createPluginWait({ opencode }), agentUi, voiceCalls },
   }
   const scheduler = createScheduler({

package/src/message-tool.e2e.test.ts

@@ -0,0 +1,45 @@
+// `kimaki --message-tool`: the plugin gives root sessions a send_message tool
+// and the thread shows only its text. The model's plain text stays hidden.
+
+import fs from 'node:fs'
+import { afterAll, beforeAll, expect, test } from 'vitest'
+
+import type { BotHandle } from './main.ts'
+import { scriptedTurn, seedProjectChannel, startOpencodeTestServer, startTestBot, startTwin, tempDataDir, TEST_USER_ID, waitForFooter, warmUp, type OpencodeTestServer, type TestTwin } from './test/harness.ts'
+
+const dataDir = tempDataDir()
+let server: OpencodeTestServer
+let twin: TestTwin
+let bot: BotHandle
+
+beforeAll(async () => {
+  const matchers = scriptedTurn({
+    marker: 'message-tool-marker',
+    steps: [{ id: 'message-call', tool: 'send_message', input: { text: 'Hello from **send_message**' } }],
+    finalText: 'hidden scratchpad text',
+  })
+  ;[server, twin] = await Promise.all([startOpencodeTestServer({ matchers }), startTwin()])
+  await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
+  bot = await startTestBot({ dataDir, twin, server, messageTool: true })
+  await warmUp({ server })
+}, 60_000)
+
+afterAll(async () => {
+  await bot?.stop()
+  await Promise.all([server?.stop(), twin?.stop()])
+  fs.rmSync(dataDir, { recursive: true, force: true })
+})
+
+test('send_message text shows in Discord, plain text of the same turn does not', async () => {
+  await twin.discord.channel(twin.channelId).user(TEST_USER_ID).sendMessage({ content: 'message-tool-marker' })
+  const thread = await twin.discord.channel(twin.channelId).waitForThread({ timeout: 8_000 })
+  await waitForFooter({ discord: twin.discord, threadId: thread.id })
+  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    message-tool-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    Hello from **send_message**
+    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+})

package/src/plugin/index.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from '@opencode/client'
 import { Plugin, Skill } from '@opencode/plugin'
 import { Schema } from 'effect'
 import { execFile } from 'node:child_process'
@@ -7,7 +8,7 @@ import path from 'node:path'
 import { autostartBot } from '../autostart.ts'
 import { readBuiltinSkills } from '../builtin-skills.ts'
 import { fileEditTool, recordToolEdits } from '../file-edit-log.ts'
-import { turnContext } from '../system-prompt.ts'
+import { MESSAGE_MODE_INSTRUCTIONS, MESSAGE_TOOL, MESSAGE_TOOL_DESCRIPTION, MESSAGE_TOOL_INPUT, turnContext } from '../system-prompt.ts'
 
 const exec = promisify(execFile)
 
@@ -31,17 +32,32 @@ export default Plugin.define({
         }
       })
     }
-    async function marker(sessionID: string) {
+    // metadata.kimaki of the session, or of the thread's root for a subagent (`root: false`).
+    async function marker(sessionID: string): Promise<{ fields: Map<string, JsonValue>; root: boolean } | null> {
       const session = await ctx.session.get({ sessionID }).catch(() => null)
       const value: unknown = session?.metadata?.['kimaki']
       if (!value || typeof value !== 'object' || Array.isArray(value)) return null
       const current = new Map(Object.entries(value))
-      if (!session?.parentID) return current
+      if (!session?.parentID) return { fields: current, root: true }
       const parent = await ctx.session.get({ sessionID: session.parentID }).catch(() => null)
       const parentMarker = parent?.metadata?.['kimaki']
-      if (parentMarker && typeof parentMarker === 'object' && !Array.isArray(parentMarker) && parentMarker['threadId'] === current.get('threadId')) return marker(session.parentID)
-      return current
+      if (parentMarker && typeof parentMarker === 'object' && !Array.isArray(parentMarker) && parentMarker['threadId'] === current.get('threadId')) {
+        const root = await marker(session.parentID)
+        return root && { fields: root.fields, root: false }
+      }
+      return { fields: current, root: true }
     }
+    // Registered for every session; the context hook removes it outside message mode.
+    await ctx.tool.transform((editor) => {
+      editor.add({
+        name: MESSAGE_TOOL,
+        description: MESSAGE_TOOL_DESCRIPTION,
+        input: MESSAGE_TOOL_INPUT,
+        options: { codemode: false },
+        // Discord renders the call input (thread-reducer.ts); the tool itself does nothing.
+        execute: async () => ({ content: 'Message sent to the user.' }),
+      })
+    })
     // The git branch reaches the model as a synthetic message saved right before
     // the user prompt, only when it changed. Text in event.system would change the
     // cached prompt prefix on every branch switch. The prompt hook runs before
@@ -58,11 +74,28 @@ export default Plugin.define({
       if (last?.type === 'synthetic' && last.text === text) return
       await ctx.session.synthetic({ sessionID: event.sessionID, text, delivery: event.delivery, resume: false }).catch(() => undefined)
     })
+    // send_message only for root sessions of a bot started with --message-tool.
+    // Every request kind that carries the tool list gets the same tools and system
+    // text, so the prompt cache keeps hitting and no other session ever sees the tool.
+    async function applyMessageMode(event: { sessionID: string; tools: Record<string, unknown>; system: Array<{ type: 'text'; text: string }> }) {
+      const info = await marker(event.sessionID)
+      const messageMode = info?.root === true && info.fields.get('messageTool') === true
+      if (!messageMode) delete event.tools[MESSAGE_TOOL]
+      else event.system.push({ type: 'text', text: MESSAGE_MODE_INSTRUCTIONS })
+      return info
+    }
+    await ctx.session.hook('compaction', async (event) => {
+      await applyMessageMode(event)
+    })
+    await ctx.session.hook('generate', async (event) => {
+      await applyMessageMode(event)
+    })
     await ctx.session.hook('context', async (event) => {
       // The only prompt change for every session, TUI included. The ID never
       // changes in a session, so the cached prompt prefix stays stable.
       event.system.push({ type: 'text', text: `OpenCode session ID: ${event.sessionID}` })
-      if (!(await marker(event.sessionID))) return
+      const info = await applyMessageMode(event)
+      if (!info) return
       // The <discord-user> context of each prompt, built from its metadata, so the
       // stored text stays clean for the TUI and other clients. Same metadata, same
       // text on every request: the cached prompt prefix stays stable.
@@ -92,8 +125,8 @@ export default Plugin.define({
     await ctx.tool.hook('execute.before', async (event) => {
       if (event.tool !== 'shell' || !event.input || typeof event.input !== 'object' || Array.isArray(event.input)) return
       const info = await marker(event.sessionID)
-      const dataDir = info?.get('dataDir')
-      const lockPort = info?.get('lockPort')
+      const dataDir = info?.fields.get('dataDir')
+      const lockPort = info?.fields.get('lockPort')
       if (typeof dataDir !== 'string' || typeof lockPort !== 'number') return
       if (!('command' in event.input) || typeof event.input.command !== 'string') return
       const quote = (value: string) => `'${value.replaceAll("'", "'\\''")}'`
@@ -102,7 +135,7 @@ export default Plugin.define({
     // File edits feed `kimaki session editors` (v1-compatible JSONL index).
     await ctx.tool.hook('execute.after', async (event) => {
       if (event.status !== 'completed' || !fileEditTool(event.tool)) return
-      const dataDir = (await marker(event.sessionID))?.get('dataDir')
+      const dataDir = (await marker(event.sessionID))?.fields.get('dataDir')
       if (typeof dataDir !== 'string') return
       // Plugins stay silent: a failed append only loses one index entry.
       const recorded = await recordToolEdits({ dataDir, directory: ctx.location.directory, sessionId: event.sessionID, tool: event.tool, input: event.input })

package/src/sessions.ts

@@ -12,6 +12,7 @@ import * as orm from 'drizzle-orm'
 import {
   cliContext,
   globalModel,
+  markerIsCurrent,
   oc,
   parseModel,
   projectOf,
@@ -273,7 +274,7 @@ export async function ensureSessionMarker(
   const info = await oc(bot, `get session ${sessionId}`, (client) => client.session.get({ sessionID: sessionId }))
   if (info instanceof Error) return info
   const marker = readMarker(info.metadata)
-  if (marker && marker.dataDir === bot.dataDir && marker.lockPort === bot.lockPort) return
+  if (marker && markerIsCurrent(bot, marker)) return
   // Instructions first: the marker means "set up", so a failure here is retried on the next input.
   if (!marker) {
     logger.log(`adopting legacy session ${sessionId} of thread ${thread.id}`)
@@ -303,7 +304,7 @@ export async function refreshCliContext(bot: Bot) {
     }
     const marker = readMarker(info.metadata)
     if (!marker) continue
-    if (marker.dataDir === bot.dataDir && marker.lockPort === bot.lockPort) continue
+    if (markerIsCurrent(bot, marker)) continue
     const metadata = { ...info.metadata, kimaki: { ...marker.fields, ...cliContext(bot) } }
     const result = await oc(bot, 'refresh Kimaki CLI context', (client) => client.session.update({ sessionID: sessionId, metadata }))
     if (result instanceof Error) return result

package/src/slash-commands.ts

@@ -461,7 +461,7 @@ export function registerSlashCommands(
     if (project instanceof Error) return logger.warn(project)
     if (!project) return
     const guild = interaction.guild ?? (await discord.guilds.fetch(interaction.guildId).catch(() => null))
-    if (!guild || !(await canUseKimaki({ guild, userId: interaction.user.id }))) {
+    if (!guild || !(await canUseKimaki(bot, { guild, userId: interaction.user.id }))) {
       if (interaction.isAutocomplete()) return respondChoices(interaction, [])
       if (interaction.isRepliable()) {
         await interaction.reply({ content: 'You do not have permission to use Kimaki', flags: MessageFlags.Ephemeral })

package/src/system-prompt.ts

@@ -645,6 +645,44 @@ export function turnContext(metadata: Readonly<Record<string, unknown>> | undefi
   return `${files}<discord-user name="${escapeAttribute(username)}" user-id="${userId}" message-id="${messageId}" thread-id="${threadId}" thread-name="${escapeAttribute(threadName)}" />`
 }
 
+// `kimaki --message-tool`: root sessions get this tool. Discord shows only its text;
+// plain text parts stay visible in the OpenCode TUI and other clients.
+// Wording adapted from Grok Bot's SendMessage tool.
+export const MESSAGE_TOOL = 'send_message'
+
+export const MESSAGE_TOOL_DESCRIPTION = dedent`
+  Send a concise reply to the user in the Discord thread. Discord shows only the text of send_message calls, not your plain text. Keep writing your normal plain text replies: they stay visible in the OpenCode terminal UI. Then repeat the part the Discord user needs as a short send_message, also for short replies like "Done" or "Yes, it does".
+
+  If you end a turn where the user waits on you without calling send_message, Discord shows silence.
+
+  Be very concise. Send meaningful beats only: a real result, a decision, a blocker, a change of plan. Do not narrate routine steps, retries or minor snags. Prefer fewer, higher-signal messages over a play-by-play, but never vanish into a long silent run.
+
+  An opening acknowledgement does not deliver the result. If you ran something for the user, send the actual result before you end the turn.
+
+  \`text\` is Discord markdown, shown like a normal message: headings, lists, code blocks, tables and <callout> blocks work. Send files with \`kimaki upload-to-discord\`, never through this tool. After your final send_message, end the turn.
+`
+
+export const MESSAGE_TOOL_INPUT = {
+  type: 'object',
+  properties: { text: { type: 'string', description: 'Markdown shown to the user in Discord. Keep it short.' } },
+  required: ['text'],
+  additionalProperties: false,
+}
+
+// Same text for the whole session (the prompt cache keeps hitting). It overrides
+// the "Discord output" rules of the instruction entry, which assume Discord shows text parts.
+export const MESSAGE_MODE_INSTRUCTIONS = dedent`
+  ## Discord shows only send_message
+
+  This overrides every rule above about what Discord shows: Discord does NOT show your plain text. Only the \`text\` of \`send_message\` tool calls reaches the Discord thread. The same session can also be open in the OpenCode terminal UI, which shows your plain text normally.
+
+  - Write your plain text replies as usual, in full. They are for the terminal UI.
+  - Then repeat a concise version as send_message, in Discord markdown: every reply, question and final answer, even one word of small talk.
+  - Where these instructions say "write the text first" before \`kimaki buttons\`, \`kimaki upload-request\` or \`kimaki sleep\`, call send_message with that text first.
+  - Never end a turn with a reply only in plain text.
+  - Never mention send_message, tool names or this rule to the user.
+`
+
 export type VoiceCallUser = { id: string; username: string }
 export type VoiceCallProject = { channelId: string; channelName: string; directory: string }
 // skill.list entry of OpenCode's global location; path is the absolute SKILL.md.

package/src/test/harness.ts

@@ -499,6 +499,7 @@ export async function startTestBot({
   analytics,
   clock,
   schedulerIntervalMs,
+  messageTool,
 }: {
   dataDir: string
   twin: TestTwin
@@ -519,6 +520,7 @@ export async function startTestBot({
   // Scheduling tests pass manualClock() and null, then call bot.scheduler.runDueTasks().
   clock?: Clock
   schedulerIntervalMs?: number | null
+  messageTool?: boolean
 }): Promise<BotHandle> {
   // What credential resolution saves in production; `kimaki project add` reads it.
   const credentials: Credentials = twin.discord.botToken.includes(':')
@@ -547,6 +549,7 @@ export async function startTestBot({
     analytics: analytics ?? disabledAnalytics,
     ...(clock && { clock }),
     ...(schedulerIntervalMs !== undefined && { schedulerIntervalMs }),
+    ...(messageTool && { messageTool }),
     ...(realtimeBaseUrls && { realtimeBaseUrls }),
     transcriptionBaseUrls: {
       ...(geminiBaseUrl && { gemini: geminiBaseUrl }),

package/src/test/replay.ts

@@ -28,6 +28,7 @@ export function rootSessionId(events: V2Event[]): string {
 export const DEFAULT_PREFS: Prefs = {
   verbosity: 'tools',
   contextLimits: { 'openai/gpt-6-luna': 400_000 },
+  messageTool: false,
 }
 
 export function replay({

package/src/thread-reducer.fixtures.test.ts

@@ -31,7 +31,7 @@ test('tools: names from tool.input.started, failed tool lines, read-only tools h
 test('tools at text verbosity: text, edits and errors only', () => {
   const { effects } = replay({
     events: loadFixture('tools.events.jsonl'),
-    prefs: { verbosity: 'text', contextLimits: {} },
+    prefs: { verbosity: 'text', contextLimits: {}, messageTool: false },
   })
   expect(effectLines(effects)).toMatchInlineSnapshot(`
     [
@@ -324,7 +324,7 @@ test('permission: two requests, the rejected one fails its tool call', () => {
 test('shell-background: background shell line even without side effects, finished line when its job ends', () => {
   const events = loadFixture('shell-background.events.jsonl')
   const view = emptyView({ sessionId: 'ses_ee56d6caeffech0rMI5NTnkky1', channelId: 'channel', directory: '/project', isNew: false })
-  const { effects, view: end } = replay({ events, view, prefs: { verbosity: 'tools', contextLimits: {} } })
+  const { effects, view: end } = replay({ events, view, prefs: { verbosity: 'tools', contextLimits: {}, messageTool: false } })
   expect(effectLines(effects)).toMatchInlineSnapshot(`
     [
       "» **user:** start a task in background that runs sleep 100",

package/src/thread-reducer.test.ts

@@ -55,6 +55,37 @@ test('text-only turn: banner, text, typing, footer with context percent', () =>
   expect(view.turn).toBe(null)
 })
 
+test('message mode: send_message shows as markdown, plain text only when the turn sent nothing', () => {
+  const turn = loadFixture('tools.events.jsonl').filter((event) => !event.type.startsWith('session.tool.'))
+  const prefs = { ...DEFAULT_PREFS, messageTool: true }
+  const textIndex = turn.findIndex((event) => event.type === 'session.text.ended')
+  const text = turn[textIndex]!
+  if (text.type !== 'session.text.ended') throw new Error('Expected text')
+  const call = { sessionID: text.data.sessionID, assistantMessageID: text.data.assistantMessageID, id: 'call_message' }
+  const durable = { aggregateID: text.data.sessionID, seq: 1, version: 1 as const }
+  const message: V2Event[] = [
+    { id: 'evt_message_input', created: text.created, durable, type: 'session.tool.input.started', data: { ...call, name: 'send_message' } },
+    { id: 'evt_message_called', created: text.created, durable, type: 'session.tool.called', data: { ...call, executed: false, input: { text: 'Visible **reply**' } } },
+  ]
+  const sent = replay({ prefs, events: [...turn.slice(0, textIndex), ...message, ...turn.slice(textIndex)] })
+  const silent = replay({ prefs, events: turn })
+  const lines = (effects: typeof sent.effects) => effectLines(effects).filter((line) => !line.startsWith('»') && !line.startsWith('[typing'))
+  expect({ sent: lines(sent.effects), silent: lines(silent.effects) }).toMatchInlineSnapshot(`
+    {
+      "sent": [
+        "-# *using openai/gpt-6-luna low ⋅ build*",
+        "Visible **reply**",
+        "-# *project ⋅ main ⋅ 17s ⋅ 6% ⋅ gpt-6-luna*",
+      ],
+      "silent": [
+        "-# *using openai/gpt-6-luna low ⋅ build*",
+        "Done. \`tmp-events/hello.txt\` contains \`hello world\`.",
+        "-# *project ⋅ main ⋅ 17s ⋅ 6% ⋅ gpt-6-luna*",
+      ],
+    }
+  `)
+})
+
 test('kimaki sleep in a turn makes its footer silent, the next turn notifies again', () => {
   const turn = loadFixture('tools.events.jsonl').filter((event) => !event.type.startsWith('session.tool.'))
   const end = turn.findIndex((event) => event.type === 'session.execution.succeeded')

package/src/thread-reducer.ts

@@ -55,6 +55,7 @@ import {
 import { closePermission, hydratePermissions, showPermission, STATUS, type PendingPermission } from './permissions.ts'
 import { closeForm, formatAnswer, hydrateForms, showForm, withAnswer, type PendingForm } from './questions.ts'
 import { cancelQueued, deliverQueued, enqueueInput, hydrateQueue, promoteQueued, queuedItems, type PendingInput } from './queue.ts'
+import { MESSAGE_TOOL } from './system-prompt.ts'
 
 export type Turn = {
   startedAt: number
@@ -64,6 +65,14 @@ export type Turn = {
   tokens: number
   // `kimaki sleep` ran in this turn: the session wakes later, so the footer is silent.
   slept: boolean
+  // Message mode (Prefs.messageTool): a send_message call was shown in this turn.
+  messaged: boolean
+  // Message mode: the last hidden text, shown at the end if the turn sent no message.
+  unsent: string | null
+}
+
+function newTurn(at: number): Turn {
+  return { startedAt: at, model: null, agent: null, tokens: 0, slept: false, messaged: false, unsent: null }
 }
 
 export type Child = {
@@ -186,6 +195,8 @@ export type Prefs = {
   verbosity: Verbosity
   // "providerID/modelID" -> context window size in tokens.
   contextLimits: Readonly<Record<string, number>>
+  // `kimaki --message-tool`: Discord hides root plain text (kept for the TUI), only send_message shows.
+  messageTool: boolean
 }
 
 const RETRY_NOTICE_INTERVAL_MS = 10_000
@@ -281,6 +292,9 @@ function contextPercent({ turn, prefs }: { turn: Draft<Turn>; prefs: Prefs }): n
 
 // The footer closing the answer of `turn` at `at`.
 function emitFooter({ draft, prefs, emit, turn, at, notify }: Context & { turn: Draft<Turn>; at: number; notify: boolean }) {
+  // Message mode: a model that never called send_message would leave the user in silence.
+  if (!turn.messaged && turn.unsent) emit({ type: 'markdown', text: turn.unsent, blankLineBefore: draft.lastKind === 'tool' })
+  turn.unsent = null
   // No model step ran (a compaction-only execution): nothing to summarize.
   if (!turn.model) return
   // A child still runs: the answer comes later.
@@ -346,11 +360,11 @@ function applyRoot(context: Context & { event: V2Event }) {
       emit({ type: 'send', text: asSubtext(`Working directory changed to ${event.data.location.directory}`) })
       return
     case 'session.execution.started':
-      draft.turn ??= { startedAt: event.created, model: null, agent: null, tokens: 0, slept: false }
+      draft.turn ??= newTurn(event.created)
       return
     case 'session.step.started': {
       const model = { providerID: event.data.model.providerID, id: event.data.model.id }
-      draft.turn ??= { startedAt: event.created, model: null, agent: null, tokens: 0, slept: false }
+      draft.turn ??= newTurn(event.created)
       draft.turn.model = model
       draft.turn.agent = event.data.agent
       if (draft.bannerPending) emit({ type: 'send', text: formatBanner({ model: event.data.model, agent: event.data.agent }) })
@@ -373,6 +387,10 @@ function applyRoot(context: Context & { event: V2Event }) {
     case 'session.text.ended': {
       const text = event.data.text.trim()
       if (!text) return
+      if (prefs.messageTool && draft.turn) {
+        draft.turn.unsent = text
+        return
+      }
       emit({ type: 'markdown', text, blankLineBefore: draft.lastKind === 'tool' })
       draft.lastKind = 'text'
       return
@@ -434,6 +452,7 @@ function applyRoot(context: Context & { event: V2Event }) {
         emitFooter({ ...context, turn: draft.turn, at: event.created, notify: false })
         draft.turn.startedAt = event.created
         draft.turn.slept = false
+        draft.turn.messaged = false
         draft.lastKind = null
       }
       return deliverQueued({ draft, emit, inboxID: event.data.inboxID })
@@ -494,6 +513,15 @@ function applyTool(context: Context & { event: V2Event; label: string | undefine
         if (reused) Object.assign(reused, { ...call, agent: call.agent || reused.agent })
       }
       draft.tools[key] = tool
+      // The plugin offers send_message to root sessions only (MESSAGE_TOOL).
+      if (name === MESSAGE_TOOL && label === undefined) {
+        const text = stringInput(input, 'text').trim()
+        if (draft.turn) draft.turn.messaged = true
+        if (!text) return
+        context.emit({ type: 'markdown', text, blankLineBefore: draft.lastKind === 'tool' })
+        draft.lastKind = 'text'
+        return
+      }
       if (render && isToolVisible({ name, input }, prefs.verbosity)) toolLine(context, formatToolLine({ name, input }, { label }))
       return
     }
@@ -613,7 +641,7 @@ function applyKimaki({ draft, event, prefs, emit }: Context & { event: KimakiEve
       const active = new Set(event.activeSessionIds)
       for (const [id, child] of Object.entries(draft.children)) child.running = active.has(id)
       if (!active.has(draft.sessionId)) draft.turn = null
-      else draft.turn ??= { startedAt: event.at, model: null, agent: null, tokens: 0, slept: false }
+      else draft.turn ??= newTurn(event.at)
       // Nothing runs: tool calls whose end was missed while disconnected are over.
       if (!isBusy(draft)) draft.tools = {}
       for (const session of event.sessions) {
@@ -645,9 +673,13 @@ export function replayEffects({
   const blocks = messages.flatMap((message): Block[] => {
     if (message.type !== 'assistant') return []
     return message.content.flatMap((part): Block[] => {
-      if (part.type === 'text') return part.text.trim() ? [{ kind: 'text', text: part.text.trim() }] : []
+      if (part.type === 'text') return part.text.trim() && !prefs.messageTool ? [{ kind: 'text', text: part.text.trim() }] : []
       if (part.type !== 'tool' || part.state.status === 'streaming') return []
       const { input, metadata } = part.state
+      if (part.name === MESSAGE_TOOL) {
+        const text = stringInput(input, 'text').trim()
+        return text ? [{ kind: 'text', text }] : []
+      }
       const isExecute = part.name === 'execute'
       const lines = [{ name: part.name, input }, ...(isExecute ? executeCalls(metadata) : [])]
         .filter((call) => isToolVisible(call, prefs.verbosity))

package/src/tunnel.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from 'vitest'
+import { detectPortFromText, routeName } from './tunnel.ts'
+
+test('detects the dev server port and skips noise lines', () => {
+  const vite = '\u001b[33mPort 5173 is in use, trying another one...\u001b[39m\n  ➜  Local:   \u001b[36mhttp://localhost:\u001b[1m5174\u001b[22m/\u001b[39m\n'
+  expect({
+    vite: detectPortFromText(vite),
+    next: detectPortFromText('   - Local:        http://127.0.0.1:3000'),
+    bare: detectPortFromText('Server running at 0.0.0.0:4321'),
+    inspector: detectPortFromText('Debugger listening on ws://127.0.0.1:9229/abc\nready on http://localhost:4173'),
+    outOfRange: detectPortFromText('listening on localhost:70000'),
+    portOnly: detectPortFromText('Port 5173 is in use'),
+  }).toMatchInlineSnapshot(`
+    {
+      "bare": 4321,
+      "inspector": 4173,
+      "next": 3000,
+      "outOfRange": null,
+      "portOnly": null,
+      "vite": 5174,
+    }
+  `)
+})
+
+test('route name: explicit, then tuistory session, then random', () => {
+  expect({
+    explicit: routeName({ name: 'docs', tuistorySessionId: 'abc123' }),
+    invalid: String(routeName({ name: 'Bad_Name' })),
+    tuistory: routeName({ tuistorySessionId: 'ABC123' }),
+    random: String(routeName({})).length,
+  }).toMatchInlineSnapshot(`
+    {
+      "explicit": "docs",
+      "invalid": "Error: Invalid tunnel ID "Bad_Name": use lowercase letters, digits and dashes",
+      "random": 16,
+      "tuistory": "abc123",
+    }
+  `)
+})