kimaki 1.0.0 → 1.2.0

package/src/autostart.ts

@@ -2,7 +2,7 @@
 // on every start; the Kimaki OpenCode plugin opens it when no bot answers on
 // the lock port:
 //
-//   kimaki start ──writes──▶ ~/.kimaki/autostart.command   (exec node <pkg>/dist/cli.js ...)
+//   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)
@@ -37,13 +37,25 @@ export async function writeAutostartScript({ dataDir, args }: { dataDir: string;
   const file = path.join(dataDir, SCRIPT_NAME)
   const cli = distCliEntry()
   if (!fs.existsSync(cli)) return fs.promises.rm(file, { force: true }).catch((cause: Error) => cause)
-  const command = [process.execPath, cli, '--if-not-running', '--data-dir', dataDir, ...args].map(quote).join(' ')
+  const command = [cli, '--if-not-running', '--data-dir', dataDir, ...args].map(quote).join(' ')
+  // OpenCode is a compiled Bun binary with no Node inside, so reuse the Node that ran
+  // this bot. Fall back to PATH when a version manager removed that Node.
   // The bot inherits the OpenCode (or Terminal) env: drop overrides that would change its port, token or service.
   const script = dedent`
     #!/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
-    exec ${command}
+    node=${quote(process.execPath)}
+    [ -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 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 "Node: $node"
+    echo "Script: $0"
+    echo
+    exec "$node" ${command}
   ` + '\n'
   return fs.promises.writeFile(file, script, { mode: 0o755 }).then(() => fs.promises.chmod(file, 0o755))
     .catch((cause: Error) => cause)

package/src/bot.ts

@@ -65,6 +65,10 @@ export type Bot = {
   realtimeBaseUrls: RealtimeBaseUrls
   // Default for channels without a channel_worktrees row.
   autoWorktrees: boolean
+  // --allow-all-users: every guild member can use the bot (canUseKimaki). Admin-only commands stay admin-only.
+  allowAllUsers: boolean
+  // Built-in skill ids (builtin-skills.ts) denied through the permissions of new sessions.
+  disabledSkills: readonly string[]
   features: BotFeatures
 }
 

package/src/builtin-skills.test.ts

@@ -0,0 +1,29 @@
+import { expect, test } from 'vitest'
+
+import { BUILTIN_SKILL_IDS, disabledSkillRules, parseDisabledSkills, readBuiltinSkills } from './builtin-skills.ts'
+
+test('every built-in skill file parses', async () => {
+  const skills = await readBuiltinSkills()
+  if (skills instanceof Error) throw skills
+  expect(skills.map((skill) => skill.id)).toEqual([...BUILTIN_SKILL_IDS])
+  for (const skill of skills) {
+    expect(skill.description, skill.id).toContain('Only for Kimaki Discord sessions')
+    expect(skill.content.startsWith('# '), skill.id).toBe(true)
+  }
+})
+
+test('--disable-skills accepts all, a list, and rejects unknown ids', () => {
+  expect(parseDisabledSkills(undefined)).toEqual([])
+  expect(parseDisabledSkills('kimaki-tunnel, kimaki-debug')).toEqual(['kimaki-tunnel', 'kimaki-debug'])
+  expect(parseDisabledSkills('all')).toEqual([...BUILTIN_SKILL_IDS])
+  expect(parseDisabledSkills('tunnel')).toBeInstanceOf(Error)
+  expect(disabledSkillRules(['kimaki-tunnel'])).toMatchInlineSnapshot(`
+    [
+      {
+        "action": "skill",
+        "effect": "deny",
+        "resource": "kimaki-tunnel",
+      },
+    ]
+  `)
+})

package/src/builtin-skills.ts

@@ -0,0 +1,59 @@
+// Opt-out skills Kimaki ships in skills/<id>/SKILL.md (debug, tunnel). They are
+// not in the system prompt, which keeps the rest of the CLI reference.
+//
+//   plugin (OpenCode process) ──▶ readBuiltinSkills ──▶ ctx.skill.transform(add)
+//   bot ──▶ --disable-skills ──▶ session permissions `skill:<id>` deny
+//
+// Plugin files must not pull in discord.js or SQLite: keep this module plain fs.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { ConfigError, FilesystemError } from './errors.ts'
+
+export const BUILTIN_SKILL_IDS = ['kimaki-debug', 'kimaki-tunnel'] as const
+
+export type BuiltinSkillId = (typeof BUILTIN_SKILL_IDS)[number]
+
+export function isBuiltinSkill(id: string): boolean {
+  return (BUILTIN_SKILL_IDS as readonly string[]).includes(id)
+}
+
+// src/ and dist/ both sit next to skills/.
+const SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'skills')
+
+export type BuiltinSkill = { id: string; name: string; description: string; path: string; content: string }
+
+function frontmatterValue(frontmatter: string, key: string): string | undefined {
+  return new RegExp(`^${key}:\\s*(.+)$`, 'm').exec(frontmatter)?.[1]?.trim()
+}
+
+export async function readBuiltinSkills(): Promise<FilesystemError | BuiltinSkill[]> {
+  const skills: BuiltinSkill[] = []
+  for (const id of BUILTIN_SKILL_IDS) {
+    const file = path.join(SKILLS_DIR, id, 'SKILL.md')
+    const text = await fs.promises.readFile(file, 'utf8').catch((cause) => new FilesystemError({ operation: `read ${file}`, cause }))
+    if (text instanceof Error) return text
+    const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text)
+    const description = match?.[1] ? frontmatterValue(match[1], 'description') : undefined
+    if (!match || !description) return new FilesystemError({ operation: `parse ${file}: missing frontmatter description` })
+    // Virtual path: OpenCode has no file to scan for these (same as its /builtin skills).
+    skills.push({ id, name: id, description, path: `/kimaki/${id}.md`, content: match[2]!.trim() })
+  }
+  return skills
+}
+
+// `all` or a comma separated list of built-in skill ids.
+export function parseDisabledSkills(value: string | undefined): ConfigError | BuiltinSkillId[] {
+  const items = (value ?? '').split(',').map((item) => item.trim()).filter(Boolean)
+  if (items.includes('all')) return [...BUILTIN_SKILL_IDS]
+  const unknown = items.filter((item) => !isBuiltinSkill(item))
+  if (unknown.length > 0) return new ConfigError({ reason: `Unknown built-in skill ${unknown.join(', ')}. Choose from: all, ${BUILTIN_SKILL_IDS.join(', ')}` })
+  return items as BuiltinSkillId[]
+}
+
+// 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

@@ -11,6 +11,7 @@ import dedent from 'string-dedent'
 import type { Goke } from 'goke'
 
 import { distCliEntry, writeAutostartScript } from '../autostart.ts'
+import { parseDisabledSkills } 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'
@@ -87,7 +88,9 @@ export function registerStartCommand(cli: Goke) {
     .option('--machine-name <name>', 'Name in this machine\'s category "Kimaki <name>" (default: hostname)')
     .option('--restart-onboarding', 'Choose credentials again')
     .option('--worktrees', 'Use a fresh Git worktree for new sessions unless the channel overrides it')
+    .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('--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) => {
@@ -124,6 +127,8 @@ export function registerStartCommand(cli: Goke) {
       }
       const dataDir = dataDirOrDefault(options.dataDir)
       const urls = gatewayUrlsFromEnv()
+      const disabledSkills = parseDisabledSkills(options.disableSkills)
+      if (disabledSkills instanceof Error) fail(disabledSkills)
       const machine = options.machineName ?? defaultMachineName()
       // Validated before the lock, so a typo never stops the running bot. null: reset to the default.
       const voice = (() => {
@@ -212,6 +217,8 @@ export function registerStartCommand(cli: Goke) {
         opencodeDbFile: opencodeDbFile(),
         analytics: createAnalytics({ dataDir, botMode: credentials.mode, enabled: !options.noAnalytics }),
         autoWorktrees: Boolean(options.worktrees),
+        allowAllUsers: Boolean(options.allowAllUsers),
+        disabledSkills,
       })
       if (bot instanceof Error) failStartup(bot)
       // exit() keeps process.exitCode: the restart route sets RESTART_EXIT_CODE before its SIGTERM.
@@ -239,6 +246,8 @@ export function registerStartCommand(cli: Goke) {
       if (lock.port === DEFAULT_LOCK_PORT) {
         const autostart = await writeAutostartScript({ dataDir, args: [
           ...(options.worktrees ? ['--worktrees'] : []),
+          ...(options.allowAllUsers ? ['--allow-all-users'] : []),
+          ...(options.disableSkills ? ['--disable-skills', options.disableSkills] : []),
           ...(options.noAnalytics ? ['--no-analytics'] : []),
           ...(options.machineName ? ['--machine-name', options.machineName] : []),
         ] })

package/src/cli/discord.ts

@@ -99,7 +99,7 @@ export function registerDiscordCommands(cli: Goke) {
       printRows({ json: options.json, rows: users, line: (user) => `${user.id} ${user.username}${user.name ? ` (${user.name})` : ''}` })
     })
 
-  cli.command('upload-to-discord <...files>', 'Attach local files to a session thread or the Kimaki voice channel chat')
+  cli.command('upload-to-discord <...files>', 'Attach local files to a session thread or the Kimaki voice channel chat. Pass many files in one call: Discord shows them numbered in argument order')
     .option('--data-dir <path>', DATA_DIR_HELP)
     .option('-s, --session <id>', SESSION_HELP)
     .option('-c, --channel <id>', 'Kimaki voice channel to post in (default in voice calls: KIMAKI_CHANNEL_ID)')

package/src/cli/session.ts

@@ -11,7 +11,7 @@ import { wrapJsonSchema, type Goke } from 'goke'
 import { parseDuration } from '../duration.ts'
 import { OpenCodeError } from '../errors.ts'
 import { editorsForFile, loadFileEditEvents } from '../file-edit-log.ts'
-import { allMessages, allSessions, readSessionMarkdown, sessionEventsFile } from '../session-events.ts'
+import { allMessages, allSessions, readSessionMarkdown, sessionEventsFile, syncTranscripts, transcriptsDir } from '../session-events.ts'
 import {
   action,
   DATA_DIR_HELP,
@@ -31,7 +31,7 @@ import {
 
 const execFileAsync = promisify(execFile)
 
-// list, search, wait, editors, diff, url
+// list, sync, wait, editors, diff, url
 export function registerSessionQueryCommands(cli: Goke) {
   cli.command('session list', 'List sessions with native status and token counts')
     .option('--data-dir <path>', DATA_DIR_HELP)
@@ -65,54 +65,21 @@ export function registerSessionQueryCommands(cli: Goke) {
       if (options.active && rows.length === 0) process.exitCode = 1
     })
 
-  cli.command('session search <query>', 'Search titles, then real message content')
+  cli.command('session sync', 'Write session transcripts to <data-dir>/transcripts for rg; skips current ones')
     .option('--data-dir <path>', DATA_DIR_HELP)
-    .option('--project <path>', 'Project (default: current directory)')
-    .option('-c, --channel <id>', 'Project of this Discord channel')
-    .option('--all', 'All projects')
-    .option('--days <n>', 'Recent days (default: 14; 0 = all)')
+    .option('--days <n>', 'Sessions updated in the last n days (default: 14)')
+    .option('--all', 'All sessions, any age')
+    .option('--rebuild', 'Write transcripts again, also current ones')
     .option('--json', 'Output as JSON')
-    .action(async (query, options) => {
-      const client = await readClient()
-      const directory = options.all ? undefined : await projectDirectory({ project: options.project, channel: options.channel, dataDir: options.dataDir })
-      const sessions = await allSessions({ client, directory })
-      if (sessions instanceof Error) fail(sessions)
-      // `/pattern/flags` is a regular expression, anything else a case-insensitive substring.
-      const pattern = query.match(/^\/(.*)\/([dgimsuvy]*)$/)
-      const expression = pattern ? new RegExp(pattern[1]!, pattern[2]) : null
-      const matches = (text: string) => {
-        if (!expression) return text.toLowerCase().includes(query.toLowerCase())
-        expression.lastIndex = 0
-        return expression.test(text)
-      }
-      const days = Number(options.days ?? 14)
+    .action(async (options) => {
+      const days = options.all ? 0 : Number(options.days ?? 14)
       if (!Number.isFinite(days) || days < 0) fail(new Error('--days must be a non-negative number'))
-      const recent = sessions.filter((session) => !days || session.time.updated >= Date.now() - days * 86400000)
-      // OpenCode has no content search API: scan pages newest first, stop at the first hit.
-      const hit = async (session: (typeof sessions)[number]) => {
-        if (matches(session.title ?? '')) return true
-        const scan = async (cursor: string | undefined): Promise<OpenCodeError | boolean> => {
-          const page = await client.message.list({ sessionID: session.id, limit: 200, ...(cursor ? { cursor } : { order: 'desc' as const }) })
-            .catch((cause) => new OpenCodeError({ operation: 'message.list', cause }))
-          if (page instanceof Error) return page
-          if (page.data.some((message) => matches(message.type === 'user' ? message.text : JSON.stringify(message)))) return true
-          return page.cursor.next ? scan(page.cursor.next) : false
-        }
-        return scan(undefined)
-      }
-      // 8 sessions at a time.
-      const results: boolean[] = new Array(recent.length)
-      const next = { index: 0 }
-      await Promise.all(Array.from({ length: Math.min(8, recent.length) }, async () => {
-        while (next.index < recent.length) {
-          const index = next.index++
-          const result = await hit(recent[index]!)
-          if (result instanceof Error) fail(result)
-          results[index] = result
-        }
-      }))
-      const found = recent.filter((_, index) => results[index])
-      printRows({ json: options.json, rows: found, line: (session) => `${session.id} ${session.title}` })
+      const dataDir = dataDirOrDefault(options.dataDir)
+      const result = await syncTranscripts({ client: await readClient(), dataDir, days, rebuild: Boolean(options.rebuild) })
+      if (result instanceof Error) fail(result)
+      if (result.failed > 0) process.exitCode = 1
+      if (options.json) return printJson({ dir: transcriptsDir({ dataDir }), ...result })
+      process.stdout.write(`${transcriptsDir({ dataDir })}: ${result.written} written, ${result.skipped} skipped, ${result.failed} failed\n`)
     })
 
   cli.command('session wait <id>', 'Wait until idle or waiting for input, then print the session')

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

@@ -37,6 +37,10 @@ test('independent Discord CLI lists threads and users, uploads a file, and reads
   const threads = await cli(['thread', 'list', '--channel', twin.channelId, '--json'])
   const users = await cli(['user', 'list', '--guild', twin.discord.guildId, '--query', 'tommy', '--json'])
   await cli(['upload-to-discord', path.join(server.root, 'report.txt'), '--session', started.sessionId])
+  // Many files keep argument order, numbered, images and files mixed.
+  fs.mkdirSync(path.join(server.root, 'other'), { recursive: true })
+  for (const name of ['b.png', 'my shot.png', 'other/b.png']) fs.writeFileSync(path.join(server.root, name), 'png')
+  await cli(['upload-to-discord', ...['b.png', 'report.txt', 'my shot.png', 'other/b.png'].map((name) => path.join(server.root, name)), '--session', started.sessionId])
   // The agent learns that nothing was posted.
   const missing = await cli(['upload-to-discord', path.join(server.root, 'missing.png'), '--session', started.sessionId]).catch((error: { stderr: string }) => error)
   expect(missing.stderr.replace(server.root, '<root>')).toMatchInlineSnapshot(`
@@ -51,7 +55,20 @@ test('independent Discord CLI lists threads and users, uploads a file, and reads
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
     -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
-    [attachment: report.txt]"
+    [file: attachment://report.txt]
+    [attachment: report.txt]
+    -# 1. \`b.png\`
+    [media: attachment://b.png]
+    -# 2. \`report.txt\`
+    [file: attachment://report.txt]
+    -# 3. \`my shot.png\`
+    [media: attachment://my_shot.png]
+    -# 4. \`b.png\`
+    [media: attachment://4-b.png]
+    [attachment: b.png]
+    [attachment: report.txt]
+    [attachment: my_shot.png]
+    [attachment: 4-b.png]"
   `)
   expect(threads.stdout).toContain(started.threadId)
   expect(users.stdout).toContain(TEST_USER_ID)

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

@@ -89,12 +89,11 @@ test('CLI help documents the supported P7 commands', async () => {
         --exclude <id>                  Exclude session (repeatable)
         --json                          Output as JSON
 
-      session search <query>            Search titles, then real message content
+      session sync                      Write session transcripts to <data-dir>/transcripts for rg; skips current ones
         --data-dir <path>               Data directory (default: ~/.kimaki)
-        --project <path>                Project (default: current directory)
-        -c, --channel <id>              Project of this Discord channel
-        --all                           All projects
-        --days <n>                      Recent days (default: 14; 0 = all)
+        --days <n>                      Sessions updated in the last n days (default: 14)
+        --all                           All sessions, any age
+        --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
@@ -316,7 +315,7 @@ test('CLI help documents the supported P7 commands', async () => {
         -q, --query <text>              Name filter
         --json                          Output as JSON
 
-      upload-to-discord <...files>      Attach local files to a session thread or the Kimaki voice channel chat
+      upload-to-discord <...files>      Attach local files to a session thread or the Kimaki voice channel chat. Pass many files in one call: Discord shows them numbered in argument order
         --data-dir <path>               Data directory (default: ~/.kimaki)
         -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)
@@ -376,7 +375,9 @@ test('CLI help documents the supported P7 commands', async () => {
       --machine-name <name>         Name in this machine's category "Kimaki <name>" (default: hostname)
       --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)
       --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)
       --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/cli-read.e2e.test.ts

@@ -28,13 +28,15 @@ function cli(args: string[]) {
     cwd: process.cwd(), env: { ...process.env, KIMAKI_LOCK_PORT: String(bot.lock.port), KIMAKI_OPENCODE_SERVICE_FILE: server.serviceFile, KIMAKI_DISCORD_REST_URL: twin.discord.restUrl },
   })
 }
-test('session read, list, search, wait, url and events read real session history', async () => {
+test('session read, list, sync, wait, url and events read real session history', async () => {
   const first = await send(bot, { channelId: twin.channelId, prompt: 'Reader content marker' })
   if (first instanceof Error) throw first
   if (!first.sessionId) throw new Error('Expected an AI session')
   await waitForFooter({ discord: twin.discord, threadId: first.threadId })
   const list = await cli(['session', 'list', '--project', server.projectDirectory, '--json'])
-  const search = await cli(['session', 'search', 'Reader content', '--project', server.projectDirectory, '--json'])
+  const sync = JSON.parse((await cli(['session', 'sync', '--days', '1', '--json'])).stdout)
+  const again = JSON.parse((await cli(['session', 'sync', '--days', '1', '--json'])).stdout)
+  const rebuilt = JSON.parse((await cli(['session', 'sync', '--days', '1', '--rebuild', '--json'])).stdout)
   const read = await cli(['session', 'read', first.threadId])
   const wait = await cli(['session', 'wait', first.sessionId, '--timeout', '10s'])
   const url = await cli(['session', 'url', first.sessionId])
@@ -47,7 +49,10 @@ test('session read, list, search, wait, url and events read real session history
     -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*"
   `)
   expect(list.stdout).toContain(first.sessionId)
-  expect(search.stdout).toContain(first.sessionId)
+  expect(sync.written + sync.skipped).toBeGreaterThan(0)
+  expect([again.written, again.failed, rebuilt.skipped, rebuilt.failed]).toEqual([0, 0, 0, 0])
+  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(wait.stdout).toContain('Reader content marker')
   expect(url.stdout).toContain(first.threadId)

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

@@ -1,4 +1,4 @@
-// CLI session commands: editors, search by channel, command, named fork, resume by folder.
+// CLI session commands: editors, command, named fork, resume by folder.
 
 import fs from 'node:fs'
 import path from 'node:path'
@@ -68,16 +68,14 @@ test('session diff prints critique output for the session folder', async () => {
   expect(diff.stdout).toContain('No changes to display')
 })
 
-test('session editors lists sessions that wrote a file, skips failed tool calls; search accepts a channel', async () => {
+test('session editors lists sessions that wrote a file, skips failed tool calls', async () => {
   const writer = await newSession('editor-marker write')
   // An edit of a missing file fails and must not be recorded.
   await newSession('fail-marker edit')
   const written = await cli(['session', 'editors', 'edited.txt', '--json'])
   const failed = await cli(['session', 'editors', path.join(server.projectDirectory, 'missing.txt')]).catch((error: Error & { code: number }) => error)
-  const searched = await cli(['session', 'search', 'editor-marker', '--channel', twin.channelId])
   expect(JSON.parse(written.stdout).map((row: { sessionId: string }) => row.sessionId)).toEqual([writer.sessionId])
   expect(failed instanceof Error && failed.code).toBe(1)
-  expect(searched.stdout).toContain(writer.sessionId)
 })
 
 test('session command, named fork, and resume without a channel use the session folder', async () => {

package/src/commands/preference-commands.ts

@@ -15,6 +15,7 @@
 // keyed by a short hash (custom IDs max 100 chars), dropped after 10 minutes.
 
 import crypto from 'node:crypto'
+import { setTimeout as sleep } from 'node:timers/promises'
 import * as orm from 'drizzle-orm'
 import {
   SlashCommandBuilder,
@@ -139,7 +140,11 @@ async function current(bot: Bot, target: InteractionTarget) {
   if (model) return { scope: 'channel' as const, modelScope: 'channel' as const, agent, model }
   const global = await globalModel(bot)
   if (global instanceof Error) return global
-  return { scope: 'channel' as const, modelScope: 'global' as const, agent, model: global }
+  if (global) return { scope: 'channel' as const, modelScope: 'global' as const, agent, model: global }
+  const fallback = await oc(bot, 'model.default', (client) => client.model.default({ location: { directory: target.directory } }))
+  if (fallback instanceof Error) return fallback
+  const defaultModel = fallback.data ? { providerID: fallback.data.providerID, id: fallback.data.id, variant: null } : null
+  return { scope: 'channel' as const, modelScope: 'OpenCode default' as const, agent, model: defaultModel }
 }
 
 // The model a new session of the channel starts with, like startSession:
@@ -193,10 +198,18 @@ async function resetButtons(bot: Bot, { target, hash }: { target: InteractionTar
 
 async function enabledModels(bot: Bot, directory: string) {
   const location = { directory }
-  const [models, providers] = await Promise.all([
-    oc(bot, 'model.list', (client) => client.model.list({ location })),
-    oc(bot, 'provider.list', (client) => client.provider.list({ location })),
-  ])
+  const load = () =>
+    Promise.all([
+      oc(bot, 'model.list', (client) => client.model.list({ location })),
+      oc(bot, 'provider.list', (client) => client.provider.list({ location })),
+    ])
+  let [models, providers] = await load()
+  // TODO: drop the retry once OpenCode awaits location load. model.list and provider.list return
+  // empty data on the first call for a cold location (reproduced on v2.0.26 with a fresh directory).
+  for (let attempt = 0; attempt < 5 && !(models instanceof Error) && models.data.length === 0; attempt++) {
+    await sleep(300)
+    ;[models, providers] = await load()
+  }
   if (models instanceof Error) return models
   if (providers instanceof Error) return providers
   const names = new Map(providers.data.map((provider) => [provider.id, provider.name]))
@@ -363,7 +376,7 @@ async function renderStep(
     const [now, resets] = await Promise.all([current(bot, wizard.target), resetButtons(bot, { target: wizard.target, hash })])
     if (now instanceof Error) return replyError(interaction, now)
     if (resets instanceof Error) return replyError(interaction, resets)
-    const currentText = now.model ? `**Current (${now.modelScope}):** \`${modelLabel(now.model)}\`` : '**Current:** OpenCode default'
+    const currentText = now.model ? `**Current (${now.modelScope}):** \`${modelLabel(now.model)}\`` : '**Current:** none configured'
     return reply(
       `${header}\n${currentText}\nSelect a provider:`,
       providers.map(([id, name]) => {

package/src/effects.ts

@@ -16,7 +16,14 @@
 import { execFile } from 'node:child_process'
 import path from 'node:path'
 import { promisify } from 'node:util'
-import { type Client, type MessageCreateOptions, type MessageFlags, type SendableChannels } from 'discord.js'
+import {
+  ComponentType,
+  MessageFlags,
+  type APIMessageTopLevelComponent,
+  type Client,
+  type MessageCreateOptions,
+  type SendableChannels,
+} from 'discord.js'
 
 import { formatFooter, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, type UiMessage } from './format-parts.ts'
 import { createLogger } from './logger.ts'
@@ -83,6 +90,35 @@ function uploadBatches(files: readonly UploadFile[]): UploadFile[][] {
   return batches.map((batch) => batch.files)
 }
 
+// Media Gallery takes images and videos; everything else is a File component.
+const GALLERY_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.mp4', '.webm', '.mov'])
+
+// Plain `files` let the Discord client group images into a mosaic apart from
+// other files. Components V2 place each file explicitly, so the thread shows
+// them in argument order. With several files each one gets a numbered label,
+// so the user and the agent can point at "file 3".
+// https://docs.discord.com/developers/components/reference#media-gallery
+function uploadMessage({ files, first, numbered }: { files: readonly UploadFile[]; first: number; numbered: boolean }) {
+  const used = new Set<string>()
+  const components: APIMessageTopLevelComponent[] = []
+  const attachments = files.map((file, index) => {
+    const number = first + index
+    // attachment:// needs a unique name Discord keeps as is.
+    const safe = file.name.replace(/[^\w.-]/g, '_') || 'file'
+    const name = used.has(safe) ? `${number}-${safe}` : safe
+    used.add(name)
+    if (numbered) components.push({ type: ComponentType.TextDisplay, content: `-# ${number}. \`${file.name}\`` })
+    const media = { url: `attachment://${name}` }
+    components.push(
+      GALLERY_EXTENSIONS.has(path.extname(name).toLowerCase())
+        ? { type: ComponentType.MediaGallery, items: [{ media }] }
+        : { type: ComponentType.File, file: media },
+    )
+    return { attachment: file.path, name }
+  })
+  return { files: attachments, components, flags: MessageFlags.IsComponentsV2 | SILENT_MESSAGE_FLAGS }
+}
+
 // Effects that will never run: an upload still waits for its answer.
 function drop(effects: readonly Effect[]) {
   for (const effect of effects) {
@@ -141,18 +177,16 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
 
   // Unlike post(), the error goes back to the agent that uploaded.
   async function postFiles(threadId: string, files: readonly UploadFile[]): Promise<Error | null> {
+    let first = 1
     for (const batch of uploadBatches(files)) {
       if (lifecycle.closed) return new DiscordError({ operation: 'upload (bot stopped)' })
       const channel = await sendableChannel(threadId)
       if (!channel) return new DiscordError({ operation: `upload to thread ${threadId}` })
       const sent = await channel
-        .send({
-          files: batch.map((file) => ({ attachment: file.path, name: file.name })),
-          flags: SILENT_MESSAGE_FLAGS,
-          allowedMentions: { parse: [] },
-        })
+        .send({ ...uploadMessage({ files: batch, first, numbered: files.length > 1 }), allowedMentions: { parse: [] } })
         .catch((cause: Error) => new DiscordError({ operation: `upload of ${batch.map((file) => file.name).join(', ')} (${cause.message})`, cause }))
       if (sent instanceof Error) return sent
+      first += batch.length
     }
     return null
   }

package/src/errors.ts

@@ -20,7 +20,7 @@ export class OpenCodeMissingError extends errore.createTaggedError({
 // Both install commands put OpenCode 2 at `opencode`.
 export class OpenCodeV1Error extends errore.createTaggedError({
   name: 'OpenCodeV1Error',
-  message: 'Kimaki now requires OpenCode 2, but $binary is OpenCode $version. Install OpenCode 2 with: $install (or: npm i -g @opencode/cli). Then run kimaki again',
+  message: 'Kimaki now requires OpenCode 2, but $binary is OpenCode $version. Install OpenCode 2 with: $install (or: npm i -g @opencode/cli). Then run kimaki again. To keep using OpenCode 1, run the older Kimaki instead: npx kimaki@0',
 }) {}
 
 export class OpenCodeVersionError extends errore.createTaggedError({

package/src/event-loop.ts

@@ -68,6 +68,7 @@ export function createEventLoop({
   recorder,
   analytics,
   onRunEnded,
+  onTranscriptDue,
 }: {
   store: BotStore
   db: KimakiDb
@@ -77,6 +78,8 @@ export function createEventLoop({
   analytics: Analytics
   // Every finished or failed run of a thread's root session (voice call notifications).
   onRunEnded: (run: RunEnded) => void
+  // A root session stopped running (also after an interrupt): its transcript file is stale.
+  onTranscriptDue: (sessionId: string) => void
 }) {
   // The client of the current connection, set before hydration starts.
   const connection: { client: OpenCodeClient | null } = { client: null }
@@ -159,6 +162,12 @@ export function createEventLoop({
     if ((event.type === 'session.execution.succeeded' || event.type === 'session.execution.failed') && store.getState().roots[threadId] === event.data.sessionID) {
       onRunEnded({ threadId, sessionId: event.data.sessionID, error: event.type === 'session.execution.failed' ? event.data.error.message : null })
     }
+    if (
+      (event.type === 'session.execution.succeeded' || event.type === 'session.execution.failed' || event.type === 'session.execution.interrupted') &&
+      store.getState().roots[threadId] === event.data.sessionID
+    ) {
+      onTranscriptDue(event.data.sessionID)
+    }
     if (store.getState().threads[threadId] && !coldThreads.has(threadId)) return fold(threadId, event)
     hold(coldThreads, threadId, event)
     void loadView(threadId)