kimaki 1.3.0 → 1.5.0

package/src/agent-ui.e2e.test.ts

@@ -1,10 +1,14 @@
 import fs from 'node:fs'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 import { ComponentType } from 'discord.js'
 import { afterAll, beforeAll, expect, test } from 'vitest'
 import type { BotHandle } from './main.ts'
 import { TEST_USER_ID, seedProjectChannel, startOpencodeTestServer, startTestBot, startTwin, tempDataDir, waitFor, waitForFooter, warmUp, toolParts, textParts, type OpencodeTestServer, type TestTwin } from './test/harness.ts'
 import { send, shell } from './prompt.ts'
 
+const exec = promisify(execFile)
 const dataDir = tempDataDir()
 let server: OpencodeTestServer
 let twin: TestTwin
@@ -19,7 +23,6 @@ beforeAll(async () => {
     { id: 'click', priority: 200, when: { latestUserTextIncludes: 'User clicked: Proceed' }, then: { parts: textParts('Proceed accepted.') } },
     { id: 'upload', priority: 100, when: { latestUserTextIncludes: 'upload-marker' }, then: { parts: toolParts({ toolCallId: 'upload-call', toolName: 'shell', input: { command: "kimaki upload-request --prompt 'Send the logo' --max-files 2", timeout: 600000, description: 'Request logo', hasSideEffect: true } }) } },
     { id: 'upload-done', priority: 110, when: { latestUserTextIncludes: 'upload-marker', rawPromptIncludes: 'upload-call' }, then: { parts: textParts('Upload received.') } },
-    { id: 'branch', priority: 200, when: { latestUserTextIncludes: 'git-marker', rawPromptIncludes: '[current git branch is main]' }, then: { parts: textParts('Git context received.') } },
   ] }), startTwin()])
   await seedProjectChannel({ dataDir, channelId: twin.channelId, guildId: twin.discord.guildId, directory: server.projectDirectory })
   bot = await startTestBot({ dataDir, twin, server })
@@ -49,6 +52,11 @@ test('agent shim shows buttons after text and a click resumes the real session',
   const shown = await ui(threadId, 'action_button:')
   await waitForFooter({ discord: twin.discord, threadId })
   const sessionId = bot.store.getState().roots[threadId]!
+  // The turn ended with buttons: `session wait` must say the session waits for a click.
+  const waited = await exec(process.execPath, ['--import', 'tsx', path.resolve('src/cli.ts'), 'session', 'wait', threadId, '--timeout', '8s', '--data-dir', dataDir], {
+    env: { ...process.env, KIMAKI_LOCK_PORT: String(bot.lock.port), KIMAKI_OPENCODE_SERVICE_FILE: server.serviceFile },
+  })
+  expect(waited.stdout.split('\n')[0]).toBe(`=== ${sessionId} is paused: it showed buttons (Proceed, Build) and waits for the user to click one, so its work may not be done ===`)
   const started = shell(bot, { threadId, sessionId, command: 'printf synthetic' })
   if (started instanceof Error) throw started
   await waitFor({ label: 'synthetic shell output', check: async () => (await twin.discord.thread(threadId).text()).includes('```\nsynthetic\n```') })
@@ -56,22 +64,22 @@ test('agent shim shows buttons after text and a click resumes the real session',
   await waitForFooter({ discord: twin.discord, threadId, count: 2 })
   expect(await twin.discord.thread(threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** button-marker
+    -# » **CLI:** button-marker
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     Choose the next action.
 
     -# ┣ shell _Show choices_
-    -# ⬦ clicked "Proceed"
+    -# clicked "Proceed"
 
     Buttons shown.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     -# $ printf synthetic
     \`\`\`
     synthetic
     \`\`\`
 
     Proceed accepted.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   const messages = await twin.discord.thread(threadId).getMessages()
   expect(messages.findIndex((message) => message.content.includes('Choose the next action.'))).toBeLessThan(messages.findIndex((message) => message.id === shown.message.id))
@@ -89,14 +97,14 @@ test('native file upload modal returns local paths to the agent shell', async ()
   await waitForFooter({ discord: twin.discord, threadId })
   expect(await twin.discord.thread(threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** upload-marker
+    -# » **CLI:** upload-marker
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     -# ┣ shell _Request logo_
-    -# ⬦ dismissed
+    -# dismissed
     Uploaded 1 file(s)
 
     Upload received.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   const dirs = fs.readdirSync(`${server.projectDirectory}/uploads`)
   expect(fs.readFileSync(`${server.projectDirectory}/uploads/${dirs[0]}/0-logo.txt`, 'utf8')).toBe('logo')
@@ -106,17 +114,21 @@ test('git context is added only to marked Discord sessions', async () => {
   await waitForFooter({ discord: twin.discord, threadId })
   expect(await twin.discord.thread(threadId).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **CLI:** git-marker
+    -# » **CLI:** git-marker
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
-    Git context received.
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-v2*"
   `)
-  expect((await twin.discord.thread(threadId).text()).includes('Git context received.')).toBe(true)
+  const branchSeen = (requests: typeof server.model.requests) => requests.some((request) => request.latestUserText.includes('git-marker') && request.raw.includes('[current git branch is main]'))
+  expect(branchSeen(server.model.requests)).toBe(true)
   const client = await server.client()
   // The branch is a synthetic message before the prompt, added again only when it changes.
   const sessionId = bot.store.getState().roots[threadId]!
   await client.session.prompt({ sessionID: sessionId, text: 'git-marker again' })
   await client.session.wait({ sessionID: sessionId })
+  // Only a prompt after a reply carries the time since that reply.
+  const gaps = server.model.requests.filter((request) => request.latestUserText.includes('git-marker')).map((request) => /\[\d+s since your last message\]/.test(request.latestUserText))
+  expect([gaps[0], gaps.at(-1)]).toEqual([false, true])
   const history = await client.session.context({ sessionID: sessionId })
   expect(history.flatMap((message) => message.type === 'synthetic' || message.type === 'user' ? [`${message.type}: ${message.text.split('\n')[0]}`] : [])).toMatchInlineSnapshot(`
     [
@@ -128,7 +140,9 @@ test('git context is added only to marked Discord sessions', async () => {
   const plugins = await client.plugin.list({ location: { directory: server.projectDirectory } })
   expect(plugins.data.find((plugin) => plugin.id === 'kimaki')?.state.status).toBe('active')
   const session = await client.session.create({ location: { directory: server.projectDirectory } })
+  const before = server.model.requests.length
   await client.session.prompt({ sessionID: session.id, text: 'git-marker' })
   await client.session.wait({ sessionID: session.id })
-  expect(JSON.stringify(await client.message.list({ sessionID: session.id }))).not.toContain('Git context received.')
+  expect(server.model.requests.length).toBeGreaterThan(before)
+  expect(branchSeen(server.model.requests.slice(before))).toBe(false)
 })

package/src/agent-ui.ts

@@ -206,7 +206,8 @@ async function clickAgentButton(bot: Bot, interaction: ButtonInteraction) {
   const item = prompt.buttons[Number(index)]
   if (!item) return
   bot.eventLoop.dispatch(interaction.channelId, { type: 'kimaki.agent-ui-dismiss', id, result: `clicked "${item.label}"` })
-  const result = await send(bot, { threadId: interaction.channelId, prompt: `User clicked: ${item.label}`, user: [interaction.user.id] })
+  // The dismissed buttons show the click.
+  const result = await send(bot, { threadId: interaction.channelId, prompt: `User clicked: ${item.label}`, user: [interaction.user.id] }, { shownIn: interaction.message.id })
   if (result instanceof Error) await interaction.followUp({ content: result.message, flags: MessageFlags.Ephemeral })
 }
 

package/src/analytics.e2e.test.ts

@@ -42,7 +42,7 @@ beforeAll(async () => {
     const chunks: Buffer[] = []
     request.on('data', (chunk: Buffer) => chunks.push(chunk))
     request.on('end', () => {
-      if (request.url === '/v1/logs') {
+      if (request.url === '/v1/batch') {
         const body = JSON.parse(Buffer.concat(chunks).toString('utf8')) as OtlpLogs
         for (const record of body.resourceLogs.flatMap((logs) => logs.scopeLogs.flatMap((scope) => scope.logRecords))) {
           received.push(Object.fromEntries(record.attributes.map(({ key, value }) => [key, value.stringValue ?? value.boolValue ?? value.doubleValue ?? Number(value.intValue)])))

package/src/autostart.ts

@@ -1,20 +1,22 @@
 // Start the bot when OpenCode starts. The bot writes <dataDir>/autostart.command
-// on every start; the Kimaki OpenCode plugin opens it when no bot answers on
+// on every start; the Kimaki OpenCode plugin opens it when nothing listens on
 // the lock port:
 //
 //   kimaki start ──writes──▶ ~/.kimaki/autostart.command   (exec <bot node> <pkg>/dist/cli.js ...)
 //                                       ▲
-//   OpenCode loads plugin ──no /health on 29988──▶ open -g autostart.command
-//                                                  (default terminal app, in background)
+//   OpenCode loads plugin ──29988 refuses TCP──▶ open -g autostart.command
+//                                                (default terminal app, in background)
 //
 // The script exists only after onboarding succeeded, so a fresh install never
-// opens a terminal with the onboarding prompts. It always runs dist/cli.js,
+// opens a terminal with the onboarding prompts. `kimaki --no-autostart` deletes it
+// on every start instead (bots under launchd, systemd or pm2). It always runs dist/cli.js,
 // also when the bot ran from src: keep dist built. --if-not-running makes a bot that
 // lost the race exit instead of stopping the running one.
 // Imported by the plugin (OpenCode process): no logger, no bot modules.
 
 import { spawn } from 'node:child_process'
 import fs from 'node:fs'
+import net from 'node:net'
 import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -31,6 +33,30 @@ export function distCliEntry(): string {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'dist', 'cli.js')
 }
 
+// process.execPath is the resolved binary, for example Homebrew's
+// Cellar/node/26.12.0/bin/node, which `brew upgrade node` deletes. Prefer a
+// PATH entry that links to the same binary (/opt/homebrew/bin/node): it
+// survives upgrades. Scripts and respawns that outlive this process use it.
+export function stableNodePath(): string {
+  const real = realpath(process.execPath)
+  if (!real) return process.execPath
+  const name = path.basename(process.execPath)
+  for (const directory of (process.env['PATH'] ?? '').split(path.delimiter)) {
+    if (!path.isAbsolute(directory)) continue
+    const candidate = path.join(directory, name)
+    if (realpath(candidate) === real) return candidate
+  }
+  return process.execPath
+}
+
+function realpath(file: string): string | null {
+  try {
+    return fs.realpathSync(file)
+  } catch {
+    return null
+  }
+}
+
 // Windows has no autostart: it would need a .cmd script and `start`.
 export async function writeAutostartScript({ dataDir, args }: { dataDir: string; args: readonly string[] }): Promise<Error | void> {
   if (process.platform === 'win32') return
@@ -45,13 +71,14 @@ export async function writeAutostartScript({ dataDir, args }: { dataDir: string;
     #!/bin/sh
     # Generated by Kimaki on bot start. The Kimaki OpenCode plugin opens it when no bot runs.
     unset KIMAKI_LOCK_PORT KIMAKI_BOT_TOKEN KIMAKI_OPENCODE_SERVICE_FILE KIMAKI_DATA_DIR KIMAKI_SUPERVISED
-    node=${quote(process.execPath)}
+    node=${quote(stableNodePath())}
     [ -x "$node" ] || node=node
     echo 'Kimaki autostart'
-    echo 'OpenCode started and no Kimaki bot answered on port ${DEFAULT_LOCK_PORT}, so the Kimaki'
+    echo 'OpenCode started and no Kimaki bot listened on port ${DEFAULT_LOCK_PORT}, so the Kimaki'
     echo 'OpenCode plugin opened this window to start the Discord bot.'
     echo 'The bot lets you talk to your OpenCode sessions from Discord.'
     echo 'Close this window or press Ctrl+C to stop the bot.'
+    echo 'To turn autostart off, start kimaki once with --no-autostart.'
     echo "Node: $node"
     echo "Script: $0"
     echo
@@ -61,16 +88,34 @@ export async function writeAutostartScript({ dataDir, args }: { dataDir: string;
     .catch((cause: Error) => cause)
 }
 
+export function removeAutostartScript({ dataDir }: { dataDir: string }): Promise<Error | void> {
+  return fs.promises.rm(path.join(dataDir, SCRIPT_NAME), { force: true }).catch((cause: Error) => cause)
+}
+
+// True only when the connect is refused. The kernel accepts into the listen
+// backlog even while the bot's event loop is busy, and a timeout (busy OpenCode
+// start) is not proof of a free port: opening a window then is the bug of #243.
+function lockPortIsFree(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: '127.0.0.1', port })
+    const done = (free: boolean) => {
+      socket.destroy()
+      resolve(free)
+    }
+    socket.setTimeout(5_000, () => done(false))
+    socket.once('connect', () => done(false))
+    socket.once('error', (error) => done(Reflect.get(error, 'code') === 'ECONNREFUSED'))
+  })
+}
+
 // Only the default install: HOME and the default port, never KIMAKI_* env.
 // Agent shells export KIMAKI_DATA_DIR, so test OpenCode servers started from
 // them would otherwise start the real bot. Test servers set HOME to a temp dir.
 async function startIfStopped(): Promise<void> {
   const file = path.join(os.homedir(), '.kimaki', SCRIPT_NAME)
   if (!fs.existsSync(file)) return
-  // Any answer means the port is taken (V2 or V1 bot).
-  const running = await fetch(`http://127.0.0.1:${DEFAULT_LOCK_PORT}/health`, { signal: AbortSignal.timeout(2_000) })
-    .then(() => true, () => false)
-  if (running) return
+  // Any listener means the port is taken (V2 or V1 bot); it could not bind anyway.
+  if (!(await lockPortIsFree(DEFAULT_LOCK_PORT))) return
   // macOS opens .command files in the default terminal app; -g keeps it in the background.
   const [command, args] = process.platform === 'darwin' ? ['open', ['-g', file]] as const : ['sh', [file]] as const
   const child = spawn(command, args, { detached: true, stdio: 'ignore' })

package/src/bot.ts

@@ -11,6 +11,7 @@ import { ChannelType, type Client, type TextChannel, type ThreadChannel } from '
 
 import type { AgentUi } from './agent-ui.ts'
 import type { Analytics } from './analytics.ts'
+import type { PromptSection } from './builtin-skills.ts'
 import type { KimakiDb } from './db.ts'
 import type { EffectsRunner } from './effects.ts'
 import { ConfigError, DbError, DiscordError, OpenCodeError, OpenCodeUnavailableError } from './errors.ts'
@@ -29,6 +30,11 @@ export type Author = { id: string; username: string }
 
 export type PromptFile = { uri: string; name: string }
 
+// Prompt cache warmup windows (plugin/coordinator.ts): a keep-alive every
+// intervalMs while a coordinator's channel is busy (at most maxMs after its
+// last turn) or a session sleeps.
+export type WarmupTimers = { intervalMs: number; maxMs: number }
+
 export type ModelChoice = { providerID: string; id: string; variant: string | null }
 
 // Operations of feature-owned state that non-interaction code needs. Wizard
@@ -69,8 +75,13 @@ export type Bot = {
   allowAllUsers: boolean
   // Built-in skill ids (builtin-skills.ts) denied through the permissions of new sessions.
   disabledSkills: readonly string[]
-  // `kimaki --message-tool`: root sessions also reply through send_message; Discord hides their plain text.
-  messageTool: boolean
+  // `kimaki --disable-prompt`: static instruction parts left out of new sessions.
+  disabledPrompt: readonly PromptSection[]
+  // Default for channels without a channel_coordinator row (`kimaki --coordinator`, on unless false):
+  // project channel messages go to one long coordinator session in the channel.
+  coordinatorDefault: boolean
+  // Short warmup windows (tests), written into session markers; null uses the plugin defaults.
+  warmupTimers: WarmupTimers | null
   features: BotFeatures
 }
 
@@ -101,6 +112,11 @@ export async function sessionDirectory(bot: Pick<Bot, 'opencode'>, sessionId: st
   return info.location.directory
 }
 
+// A project channel in coordinator mode: its /toggle-coordinator choice, else the default.
+export function isCoordinatorChannel(bot: Bot, channelId: string): boolean {
+  return bot.store.getState().coordinator[channelId] ?? bot.coordinatorDefault
+}
+
 export function rootSession(bot: Bot, threadId: string): OpenCodeError | string {
   return bot.store.getState().roots[threadId] ?? new OpenCodeError({ operation: `find the session of thread ${threadId}` })
 }
@@ -112,13 +128,22 @@ export function threadOfSession(bot: Bot, sessionId: string): string | null {
   return threadId && roots[threadId] === sessionId ? threadId : null
 }
 
-export async function fetchThread(bot: Bot, threadId: string): Promise<DiscordError | ConfigError | ThreadChannel> {
+// Where a root session talks to the user: its thread, or a coordinator project
+// channel (the channel itself is the conversation, roots[channelId]).
+export type Conversation = ThreadChannel | TextChannel
+
+// The project channel of a conversation.
+export function projectChannelOf(conversation: Conversation): string | null {
+  return conversation.isThread() ? conversation.parentId : conversation.id
+}
+
+export async function fetchConversation(bot: Bot, id: string): Promise<DiscordError | ConfigError | Conversation> {
   const channel = await bot.discord.channels
-    .fetch(threadId)
-    .catch((cause) => new DiscordError({ operation: `fetch thread ${threadId}`, cause }))
+    .fetch(id)
+    .catch((cause) => new DiscordError({ operation: `fetch conversation ${id}`, cause }))
   if (channel instanceof Error) return channel
-  if (!channel?.isThread()) return new ConfigError({ reason: 'Target is not a thread' })
-  return channel
+  if (channel?.isThread() || channel?.type === ChannelType.GuildText) return channel
+  return new ConfigError({ reason: 'Target is not a thread or a text channel' })
 }
 
 export async function textChannel(bot: Bot, channelId: string): Promise<DiscordError | TextChannel> {
@@ -136,7 +161,6 @@ export type SessionMarker = {
   fields: { readonly [key: string]: JsonValue }
   dataDir: string | null
   lockPort: number | null
-  messageTool: boolean
   // Explicit `kimaki send --parent-session`, so /resume keeps the instruction line.
   parentSessionId: string | null
   // The scheduled run stored at session.create, so /resume keeps the same instruction section.
@@ -150,7 +174,7 @@ function jsonObject(value: JsonValue | undefined): { readonly [key: string]: Jso
 export function readMarker(metadata: SessionMetadata | undefined): SessionMarker | null {
   const fields = jsonObject(metadata?.['kimaki'])
   if (!fields) return null
-  const { dataDir, lockPort, messageTool, parentSessionId } = fields
+  const { dataDir, lockPort, parentSessionId } = fields
   const task = jsonObject(fields['task'])
   const taskId = task?.['id']
   const cronExpr = task?.['cronExpr']
@@ -159,7 +183,6 @@ export function readMarker(metadata: SessionMetadata | undefined): SessionMarker
     fields,
     dataDir: typeof dataDir === 'string' ? dataDir : null,
     lockPort: typeof lockPort === 'number' ? lockPort : null,
-    messageTool: messageTool === true,
     parentSessionId: typeof parentSessionId === 'string' ? parentSessionId : null,
     task: typeof taskId === 'number'
       ? { id: taskId, cronExpr: typeof cronExpr === 'string' ? cronExpr : null, timezone: typeof timezone === 'string' ? timezone : null }
@@ -167,15 +190,9 @@ export function readMarker(metadata: SessionMetadata | undefined): SessionMarker
   }
 }
 
-// The marker fields that follow this bot run: where the agent's `kimaki` calls
-// go, and whether the plugin gives the session send_message.
-export function cliContext(bot: Pick<Bot, 'dataDir' | 'lockPort' | 'messageTool'>) {
-  return { dataDir: bot.dataDir, lockPort: bot.lockPort, messageTool: bot.messageTool }
-}
-
-// False when the session marker was written by another bot run or with another --message-tool.
-export function markerIsCurrent(bot: Pick<Bot, 'dataDir' | 'lockPort' | 'messageTool'>, marker: SessionMarker): boolean {
-  return marker.dataDir === bot.dataDir && marker.lockPort === bot.lockPort && marker.messageTool === bot.messageTool
+// The marker fields that point the agent's `kimaki` calls at this bot.
+export function cliContext(bot: Bot) {
+  return { dataDir: bot.dataDir, lockPort: bot.lockPort }
 }
 
 // Default model of new sessions in channels without their own (/model "All channels").

package/src/btw.e2e.test.ts

@@ -87,14 +87,14 @@ test('. btw forks into a side thread while the source run continues', async () =
     --- from: assistant (TestBot)
     Session forked! Continue in <#THREAD>
     slow-done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(hideIds(await discord.thread(fork.id).text())).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
     Reusing context from <#THREAD> to answer prompt...
     What is 2+2 side-marker
     side answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   const rows = await bot.db.query.thread_sessions.findMany({ where: { thread_id: fork.id } })
   expect(rows.length).toBe(1)
@@ -125,6 +125,6 @@ test('/btw forks from a thread with an idle session', async () => {
     Reusing context from <#THREAD> to answer prompt...
     Side slash-marker
     slash answer
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
 })

package/src/builtin-skills.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from 'vitest'
 
-import { BUILTIN_SKILL_IDS, disabledSkillRules, parseDisabledSkills, readBuiltinSkills } from './builtin-skills.ts'
+import { BUILTIN_SKILL_IDS, disabledSkillRules, parseDisabledPromptSections, parseDisabledSkills, PROMPT_SECTIONS, readBuiltinSkills } from './builtin-skills.ts'
+import { baseInstructions } from './system-prompt.ts'
 
 test('every built-in skill file parses', async () => {
   const skills = await readBuiltinSkills()
@@ -27,3 +28,74 @@ test('--disable-skills accepts all, a list, and rejects unknown ids', () => {
     ]
   `)
 })
+
+test('--disable-prompt removes exactly the headings of each section', () => {
+  expect(parseDisabledPromptSections(['critique-diffs,discord-callouts', 'search-result-urls'])).toEqual(['critique-diffs', 'discord-callouts', 'search-result-urls'])
+  expect(parseDisabledPromptSections(['critique'])).toBeInstanceOf(Error)
+  const input = { sessionId: 'ses_1', threadId: '2', channelId: '3', guildId: '4', userId: '5', dataDir: '/data', channelTopic: null, agents: [], parentSessionId: null }
+  const headings = (text: string) => text.split('\n').filter((line) => line.startsWith('## '))
+  const full = headings(baseInstructions(input))
+  const removed = Object.fromEntries(PROMPT_SECTIONS.map((section) => {
+    const kept = new Set(headings(baseInstructions({ ...input, disabled: [section] })))
+    return [section, full.filter((heading) => !kept.has(heading))]
+  }))
+  expect(removed).toMatchInlineSnapshot(`
+    {
+      "action-buttons": [
+        "## action buttons",
+        "## ending conversations with options",
+      ],
+      "critique-diffs": [
+        "## showing diffs",
+      ],
+      "cross-project-commands": [
+        "## cross-project commands",
+      ],
+      "diagrams": [
+        "## diagrams",
+      ],
+      "discord-callouts": [
+        "## Callouts in Kimaki Discord",
+      ],
+      "discord-permissions": [
+        "## permissions",
+      ],
+      "file-upload-requests": [
+        "## requesting files from the user",
+      ],
+      "kimaki-debugging": [
+        "## debugging kimaki issues",
+      ],
+      "markdown-formatting": [
+        "## markdown formatting",
+      ],
+      "search-result-urls": [
+        "## URLs in search results",
+      ],
+      "session-abort": [
+        "## aborting a session",
+      ],
+      "session-sleep": [
+        "## sleeping the session",
+      ],
+      "waiting-sessions": [
+        "## waiting for a session to finish",
+      ],
+    }
+  `)
+  expect(headings(baseInstructions({ ...input, disabled: [...PROMPT_SECTIONS] }))).toMatchInlineSnapshot(`
+    [
+      "## Discord output",
+      "## shell tool",
+      "## commit messages",
+      "## uploading files to discord",
+      "## generating audio from text",
+      "## archiving the current thread",
+      "## updating the session title",
+      "## discord user mentions",
+      "## starting new sessions from CLI",
+      "## scheduled sends and routines",
+      "## reading other sessions",
+    ]
+  `)
+})

package/src/builtin-skills.ts

@@ -53,6 +53,39 @@ export function parseDisabledSkills(value: string | undefined): ConfigError | Bu
   return items as BuiltinSkillId[]
 }
 
+// Static parts of the session instructions (system-prompt.ts) that
+// `kimaki --disable-prompt <section>` removes. Here, not in system-prompt.ts,
+// so the CLI help can list them without loading zod.
+export const PROMPT_SECTIONS = [
+  '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',
+] as const
+
+export type PromptSection = (typeof PROMPT_SECTIONS)[number]
+
+function isPromptSection(item: string): item is PromptSection {
+  return PROMPT_SECTIONS.some((section) => section === item)
+}
+
+// Repeatable flag; each value can also be a comma separated list.
+export function parseDisabledPromptSections(values: readonly string[] | undefined): ConfigError | PromptSection[] {
+  const items = (values ?? []).flatMap((value) => value.split(',')).map((item) => item.trim()).filter(Boolean)
+  const unknown = items.filter((item) => !isPromptSection(item))
+  if (unknown.length > 0) return new ConfigError({ reason: `Unknown prompt section ${unknown.join(', ')}. Choose from: ${PROMPT_SECTIONS.join(', ')}` })
+  return items.filter(isPromptSection)
+}
+
 // OpenCode hides a skill from the model and the skill tool when its permission is denied.
 export function disabledSkillRules(disabled: readonly string[]) {
   return disabled.map((id) => ({ action: 'skill', resource: id, effect: 'deny' }) as const)

package/src/catalog-refresh.e2e.test.ts

@@ -68,10 +68,10 @@ test('agents loaded after startup get their slash commands', async () => {
   await waitForFooter({ discord, threadId: thread.id })
   expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **tommy:** Go late-marker
+    -# » **tommy:** Go late-marker
     -# *using deterministic-provider/deterministic-v2 ⋅ late*
     late reply
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ late*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ late*"
   `)
 })