kimaki 1.2.0 → 1.4.0

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,75 @@ 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",
+      ],
+      "ascii-diagrams": [
+        "## diagrams",
+      ],
+      "critique-diffs": [
+        "## showing diffs",
+      ],
+      "cross-project-commands": [
+        "## cross-project commands",
+      ],
+      "discord-callouts": [
+        "## Callouts in Kimaki Discord",
+        "## Tests not fully green",
+      ],
+      "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',
+  'ascii-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/cli/bot.ts

@@ -1,6 +1,6 @@
 // Bot lifecycle and setup: the root command (start + onboarding), provider
 // login, tools (tunnel, tts), and bot status, logs, credentials and keys.
-// main.ts, onboarding.ts, traforo, SQLite and voice are loaded only by the
+// main.ts, onboarding.ts, tunnel.ts, SQLite and voice are loaded only by the
 // commands that run them (see the note in shared.ts).
 
 import { spawn, type ChildProcess } from 'node:child_process'
@@ -8,10 +8,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import dedent from 'string-dedent'
-import type { Goke } from 'goke'
+import { wrapJsonSchema, type Goke } from 'goke'
 
 import { distCliEntry, writeAutostartScript } from '../autostart.ts'
-import { parseDisabledSkills } from '../builtin-skills.ts'
+import { parseDisabledPromptSections, parseDisabledSkills, PROMPT_SECTIONS } from '../builtin-skills.ts'
 import { callBot, DEFAULT_LOCK_PORT, RESTART_EXIT_CODE, startLockServer } from '../lock-server.ts'
 import { parseDuration } from '../duration.ts'
 import { createLogger, setLogFile } from '../logger.ts'
@@ -91,6 +91,7 @@ export function registerStartCommand(cli: Goke) {
     .option('--allow-all-users', 'Every server member can use the bot (role "no-kimaki" still denies; provider login stays admin-only)')
     .option('--voice <name>', 'Voice of voice calls, saved for later starts (e.g. cove, juniper, sol). "default" resets it')
     .option('--disable-skills <list>', 'Built-in Kimaki skills to turn off: "all" or a comma separated list (kimaki-debug,kimaki-tunnel)')
+    .option('--disable-prompt <section>', wrapJsonSchema<string[]>({ type: 'array', items: { type: 'string' }, description: `System prompt section to remove from new sessions (repeatable): ${PROMPT_SECTIONS.join(', ')}` }))
     .option('--no-analytics', 'Disable anonymous usage analytics (same as KIMAKI_STRADA_ENABLED=0)')
     .option('--if-not-running', 'Start only if no bot runs; never stop the running one (used by autostart)')
     .action(async (options) => {
@@ -129,6 +130,8 @@ export function registerStartCommand(cli: Goke) {
       const urls = gatewayUrlsFromEnv()
       const disabledSkills = parseDisabledSkills(options.disableSkills)
       if (disabledSkills instanceof Error) fail(disabledSkills)
+      const disabledPrompt = parseDisabledPromptSections(options.disablePrompt)
+      if (disabledPrompt instanceof Error) fail(disabledPrompt)
       const machine = options.machineName ?? defaultMachineName()
       // Validated before the lock, so a typo never stops the running bot. null: reset to the default.
       const voice = (() => {
@@ -219,6 +222,7 @@ export function registerStartCommand(cli: Goke) {
         autoWorktrees: Boolean(options.worktrees),
         allowAllUsers: Boolean(options.allowAllUsers),
         disabledSkills,
+        disabledPrompt,
       })
       if (bot instanceof Error) failStartup(bot)
       // exit() keeps process.exitCode: the restart route sets RESTART_EXIT_CODE before its SIGTERM.
@@ -248,6 +252,7 @@ export function registerStartCommand(cli: Goke) {
           ...(options.worktrees ? ['--worktrees'] : []),
           ...(options.allowAllUsers ? ['--allow-all-users'] : []),
           ...(options.disableSkills ? ['--disable-skills', options.disableSkills] : []),
+          ...disabledPrompt.flatMap((section) => ['--disable-prompt', section]),
           ...(options.noAnalytics ? ['--no-analytics'] : []),
           ...(options.machineName ? ['--machine-name', options.machineName] : []),
         ] })
@@ -283,9 +288,9 @@ export function registerLoginCommands(cli: Goke) {
 
 // tunnel, tts
 export function registerToolCommands(cli: Goke) {
-  cli.command('tunnel', 'Run a command and expose its local port with a public URL. The child gets TRAFORO_URL')
+  cli.command('tunnel', 'Run a command and expose its local port with a public opentunnel.xyz URL. The child gets KIMAKI_TUNNEL_URL')
     .option('-p, --port <port>', 'Local port (default: read from the command output)')
-    .option('-t, --tunnel-id <id>', 'Fixed tunnel ID (default: random). Only for public-safe services')
+    .option('-t, --tunnel-id <id>', 'Fixed subdomain (default: random). Only for public-safe services')
     .option('--host <host>', 'Local host (default: localhost)')
     .option('-k, --kill', 'Kill the process on --port first')
     .example('kimaki tunnel -- pnpm dev')
@@ -294,8 +299,9 @@ export function registerToolCommands(cli: Goke) {
       const port = options.port ? Number(options.port) : undefined
       if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65_535)) fail(new Error(`Invalid --port ${options.port}`))
       if (!port && command.length === 0) fail(new Error('Pass a command after --, or --port <port>. Example: kimaki tunnel -- pnpm dev'))
-      const { runTunnel } = await import('traforo/run-tunnel')
-      await runTunnel({ port, command: command.length > 0 ? command : undefined, tunnelId: options.tunnelId, localHost: options.host, baseDomain: 'kimaki.dev', kill: options.kill })
+      const { runTunnel } = await import('../tunnel.ts')
+      const result = await runTunnel({ port, command: command.length > 0 ? command : undefined, name: options.tunnelId, host: options.host, kill: options.kill })
+      if (result instanceof Error) fail(result)
     })
 
   cli.command('tts [text]', 'Text to speech with OpenAI or Gemini. Reads stdin if no text is given')

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

@@ -321,9 +321,9 @@ test('CLI help documents the supported P7 commands', async () => {
         -c, --channel <id>              Kimaki voice channel to post in (default in voice calls: KIMAKI_CHANNEL_ID)
 
       Tools:
-      tunnel                            Run a command and expose its local port with a public URL. The child gets TRAFORO_URL
+      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)
-        -t, --tunnel-id <id>            Fixed tunnel ID (default: random). Only for public-safe services
+        -t, --tunnel-id <id>            Fixed subdomain (default: random). Only for public-safe services
         --host <host>                   Local host (default: localhost)
         -k, --kill                      Kill the process on --port first
 
@@ -378,6 +378,7 @@ test('CLI help documents the supported P7 commands', async () => {
       --allow-all-users             Every server member can use the bot (role "no-kimaki" still denies; provider login stays admin-only)
       --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, ascii-diagrams
       --no-analytics                Disable anonymous usage analytics (same as KIMAKI_STRADA_ENABLED=0)
       --if-not-running              Start only if no bot runs; never stop the running one (used by autostart)
       -h, --help                    Display this message

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

@@ -177,6 +177,41 @@ test('message from a user without permission creates no thread', async () => {
   await expectNoNewThread({ channelId, before })
 })
 
+test('another bot needs the Kimaki role, and no-kimaki still denies it', async () => {
+  const { discord, channelId } = twin
+  const helperBotId = '200000000000000050'
+  const guildId = discord.guildId
+  await discord.prisma.user.create({ data: { id: helperBotId, username: 'helper-bot', bot: true } })
+  await discord.prisma.guildMember.create({ data: { guildId, userId: helperBotId } })
+  const member = { guildId_userId: { guildId, userId: helperBotId } }
+  const helper = discord.channel(channelId).user(helperBotId)
+
+  const before = (await discord.channel(channelId).getThreads()).length
+  await helper.sendMessage({ content: 'no role bot-marker hello-marker' })
+  await expectNoNewThread({ channelId, before })
+
+  const guild = await bot.discord.guilds.fetch(guildId)
+  const kimakiRole = await guild.roles.create({ name: 'Kimaki' })
+  const denyRole = await guild.roles.create({ name: 'no-kimaki' })
+  await discord.prisma.guildMember.update({ where: member, data: { roles: JSON.stringify([kimakiRole.id]) } })
+  await helper.sendMessage({ content: 'with role bot-marker hello-marker' })
+  const thread = await discord.channel(channelId).waitForThread({ predicate: (thread) => thread.name?.startsWith('with role bot-marker') ?? false })
+  await waitForFooter({ discord, threadId: thread.id })
+  expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: assistant (helper-bot)
+    with role bot-marker hello-marker
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    Hello from the deterministic model.
+    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+
+  const withRole = (await discord.channel(channelId).getThreads()).length
+  await discord.prisma.guildMember.update({ where: member, data: { roles: JSON.stringify([kimakiRole.id, denyRole.id]) } })
+  await helper.sendMessage({ content: 'denied bot-marker hello-marker' })
+  await expectNoNewThread({ channelId, before: withRole })
+})
+
 test('message in a channel without a project creates no thread', async () => {
   const { discord, unregisteredChannelId } = twin
   await discord.channel(unregisteredChannelId).user(TEST_USER_ID).sendMessage({ content: 'hello-marker' })

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
@@ -66,6 +67,8 @@ function authorCanUseKimaki(bot: Bot, message: Message<true>): Promise<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
@@ -222,8 +225,7 @@ 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(bot, message))) {
@@ -303,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.

package/src/main.ts

@@ -9,6 +9,7 @@ import * as errore from 'errore'
 import { createAgentUi } from './agent-ui.ts'
 import type { Analytics } from './analytics.ts'
 import { oc, type Bot } from './bot.ts'
+import type { PromptSection } from './builtin-skills.ts'
 import { openDb } from './db.ts'
 import { createEffectsRunner } from './effects.ts'
 import { DiscordError } from './errors.ts'
@@ -68,6 +69,8 @@ export type StartBotOptions = {
   allowAllUsers?: boolean
   // Built-in skill ids denied in new sessions (builtin-skills.ts).
   disabledSkills?: readonly string[]
+  // Static instruction parts left out of new sessions (system-prompt.ts).
+  disabledPrompt?: readonly PromptSection[]
 }
 
 export type BotHandle = Bot & {
@@ -185,6 +188,7 @@ export async function startBot(options: StartBotOptions): Promise<Error | BotHan
     autoWorktrees: options.autoWorktrees ?? false,
     allowAllUsers: options.allowAllUsers ?? false,
     disabledSkills: options.disabledSkills ?? [],
+    disabledPrompt: options.disabledPrompt ?? [],
     features: { withSleepLock: createSleepLock(), waitForPlugin: createPluginWait({ opencode }), agentUi, voiceCalls },
   }
   const scheduler = createScheduler({

package/src/markdown/markdown.test.ts

@@ -412,3 +412,14 @@ test('edge cases: 2500-char code line, fence info line inside a fence, oversized
 
   expect(markdownPayloads('<callout accent="#ef4444"></callout>')).toMatchInlineSnapshot(`[]`)
 })
+
+test('empty blockquote lines get a trailing space so Discord keeps the quote', () => {
+  const text = '**1. To a@b.com**\n\n> Hi Mohammad,\n>\n> Your subscription is cancelled.\n>\n> Tommy\n\nDone.'
+  const segments = renderMarkdown(text)
+  expect(segments.map((segment) => ('markdown' in segment ? JSON.stringify(segment.markdown.split('\n')) : segment.kind)))
+    .toMatchInlineSnapshot(`
+      [
+        "["**1. To a@b.com**","","> Hi Mohammad,","> ","> Your subscription is cancelled.","> ","> Tommy","","Done."]",
+      ]
+    `)
+})

package/src/markdown/render-markdown.ts

@@ -5,6 +5,7 @@
 //        ├─ table                ──▶ table segment (Components V2 later)
 //        ├─ heading depth > 3    ──▶ clamped to ###
 //        ├─ list with code items ──▶ code lifted after its item
+//        ├─ blockquote           ──▶ bare ">" lines become "> "
 //        └─ other nodes          ──▶ original source slices, packed into ≤ limit
 //
 // Text is sliced from the original source by node offsets, never
@@ -217,7 +218,8 @@ function nodePieces(source: string, node: RootContent, limit: number): string[]
     return unnestList(source, node, limit).flatMap((piece) => (piece.length <= limit ? [piece] : splitText(piece, limit)))
   }
   if (node.type === 'code') return codePieces(source, node, limit)
-  const text = slice(source, node)
+  // Discord quotes need "> " plus a space; a bare ">" line shows as a literal ">".
+  const text = node.type === 'blockquote' ? slice(source, node).replace(/^( *>)$/gm, '$1 ') : slice(source, node)
   if (text.length <= limit) return [text]
   if (node.type === 'list') {
     const items = node.children.map((item) => slice(source, item))

package/src/plugin/index.ts

@@ -1,4 +1,5 @@
 import { Plugin, Skill } from '@opencode/plugin'
+import type { SessionContext } from '@opencode/plugin/promise/session'
 import { Schema } from 'effect'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
@@ -58,7 +59,10 @@ 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)
     })
-    await ctx.session.hook('context', async (event) => {
+    // Runs for every request kind: turns (context), compaction and generate (OpenCode
+    // `warming` keep-alive requests). All kinds must get the same system text, tools
+    // and messages, or the provider prompt cache misses.
+    const shapeRequest = async (event: SessionContext) => {
       // 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}` })
@@ -88,7 +92,10 @@ export default Plugin.define({
           ...properties,
         } }
       }
-    })
+    }
+    await ctx.session.hook('context', shapeRequest)
+    await ctx.session.hook('compaction', shapeRequest)
+    await ctx.session.hook('generate', shapeRequest)
     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)

package/src/session-events.ts

@@ -110,9 +110,13 @@ export async function resolveSession({
 type Message = Awaited<ReturnType<OpenCodeClient['message']['list']>>['data'][number]
 type Session = Awaited<ReturnType<OpenCodeClient['session']['get']>>
 
+// Long enough for most edits, commands and subagent prompts; huge writes stay short.
+const TOOL_INPUT_LIMIT = 5000
+
 function renderMessage(message: Message, options: { thinking?: boolean; verbose?: boolean }): string {
   const time = new Date(message.time.created).toISOString()
-  if (message.type === 'user') return `## user ${time}\n\n${message.text}`
+  if (message.type === 'user' || message.type === 'synthetic' || message.type === 'system') return `## ${message.type} ${time}\n\n${message.text}`
+  if (message.type === 'compaction' && message.status !== 'failed') return `## compaction ${time}\n\n${message.summary}`
   if (message.type !== 'assistant') return `## ${message.type} ${time}\n\n${JSON.stringify(message)}`
   const header = `## assistant ${time} (${message.agent}, ${message.model.providerID}/${message.model.id})`
   const parts = message.content.map((part) => {
@@ -120,7 +124,7 @@ function renderMessage(message: Message, options: { thinking?: boolean; verbose?
     if (part.type === 'reasoning') return options.thinking ? part.text : ''
     if (part.type === 'tool') {
       const state = part.state
-      const input = options.verbose ? JSON.stringify(state.input ?? {}) : JSON.stringify(state.input ?? {}).slice(0, 500)
+      const input = options.verbose ? JSON.stringify(state.input ?? {}) : JSON.stringify(state.input ?? {}).slice(0, TOOL_INPUT_LIMIT)
       const error = state.status === 'error' ? `\nerror: ${JSON.stringify(state).slice(0, 500)}` : ''
       const output = options.verbose && state.status === 'completed' ? `\n${JSON.stringify(state.content)}` : ''
       return `tool ${part.name} [${state.status}] ${input}${error}${output}`
@@ -158,7 +162,7 @@ function renderSession({ session, messages, thinking, verbose }: { session: Pick
 }
 
 // Transcripts: <dataDir>/transcripts/<sessionId>.md, the `session read` markdown
-// (no thinking, no tool outputs) so agents can search every session with rg.
+// with thinking but no tool outputs, so agents can search every session with rg.
 // The file mtime is the session's time.updated: a file at least that new is current.
 export function transcriptsDir({ dataDir }: { dataDir: string }): string {
   return path.join(dataDir, 'transcripts')
@@ -172,7 +176,7 @@ export async function writeTranscript({ client, dataDir, session }: { client: Op
   const temp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`
   const written = await (async () => {
     await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 })
-    await fs.promises.writeFile(temp, `${renderSession({ session, messages })}\n`, { mode: 0o600 })
+    await fs.promises.writeFile(temp, `${renderSession({ session, messages, thinking: true })}\n`, { mode: 0o600 })
     await fs.promises.utimes(temp, session.time.updated / 1000, session.time.updated / 1000)
     await fs.promises.rename(temp, file)
   })().catch((cause) => new ConfigError({ reason: `Cannot write ${file}`, cause }))

package/src/sessions.ts

@@ -203,6 +203,7 @@ async function putInstructions(
     agents,
     parentSessionId,
     scheduledTask,
+    disabled: bot.disabledPrompt,
   })
   const put = await oc(bot, 'instructions.entry.put', (client) =>
     client.session.instructions.entry.put({ sessionID: sessionId, key: INSTRUCTION_KEY, value }),