kimaki 1.3.0 → 1.5.0

package/src/effects.ts

@@ -25,9 +25,10 @@ import {
   type SendableChannels,
 } from 'discord.js'
 
-import { formatFooter, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, type UiMessage } from './format-parts.ts'
+import { DISCORD_MEDIA_URL, embedFlags, formatFooter, SILENT_MESSAGE_FLAGS, type UiMessage } from './format-parts.ts'
 import { createLogger } from './logger.ts'
-import { segmentPayloads, type DiscordPayload } from './markdown/components.ts'
+import { echoPayloads } from './queue.ts'
+import { markdownPayloads, segmentPayloads, type DiscordPayload } from './markdown/components.ts'
 import { DISCORD_TEXT_LIMIT, renderMarkdown } from './markdown/render-markdown.ts'
 import { DiscordError } from './errors.ts'
 import type { Effect, UploadFile } from './thread-reducer.ts'
@@ -42,10 +43,45 @@ async function gitBranch(directory: string): Promise<string | null> {
   return result?.stdout.trim() || null
 }
 
-async function footerText(effect: Extract<Effect, { type: 'footer' }>): Promise<string> {
-  const { directory, durationMs, contextPercent, model, agent } = effect
-  const branch = await gitBranch(directory)
-  return formatFooter({ folder: path.basename(directory), branch, durationMs, contextPercent, model, agent })
+async function readDefaultBranch(directory: string): Promise<string | null> {
+  const git = (args: string[]) => execFileAsync('git', args, { cwd: directory, timeout: 5_000 }).then((r) => r.stdout.trim(), () => '')
+  const remoteHead = await git(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])
+  if (remoteHead) return remoteHead.replace(/^origin\//, '')
+  // No origin/HEAD (repo never cloned, or no remote): fall back to a local main or master.
+  const local = await git(['for-each-ref', '--format=%(refname:short)', 'refs/heads/main', 'refs/heads/master'])
+  return local.split('\n')[0] || null
+}
+
+// Directory -> default branch, read once per process: it almost never changes.
+const defaultBranches = new Map<string, Promise<string | null>>()
+
+function defaultBranch(directory: string): Promise<string | null> {
+  const cached = defaultBranches.get(directory)
+  if (cached) return cached
+  const lookup = readDefaultBranch(directory)
+  defaultBranches.set(directory, lookup)
+  return lookup
+}
+
+// Project folder and default agent of a channel, read when a footer is posted. null: not a project channel.
+export type FooterDefaults = (channelId: string) => Promise<Error | null | { projectDirectory: string; defaultAgent: string | null }>
+
+async function footerText({ effect, footerDefaults }: { effect: Extract<Effect, { type: 'footer' }>; footerDefaults: FooterDefaults }): Promise<string> {
+  const { channelId, directory, durationMs, contextPercent, model, agent } = effect
+  const [branch, mainBranch, defaults] = await Promise.all([gitBranch(directory), defaultBranch(directory), footerDefaults(channelId)])
+  if (defaults instanceof Error) logger.warn(`footer defaults of channel ${channelId} failed`, defaults)
+  const known = defaults instanceof Error ? null : defaults
+  return formatFooter({
+    directory,
+    projectDirectory: known?.projectDirectory ?? null,
+    branch,
+    defaultBranch: mainBranch,
+    durationMs,
+    contextPercent,
+    model,
+    agent,
+    defaultAgent: known?.defaultAgent ?? null,
+  })
 }
 
 // post() adds the notification flags to the payload's own flag.
@@ -119,6 +155,16 @@ function uploadMessage({ files, first, numbered }: { files: readonly UploadFile[
   return { files: attachments, components, flags: MessageFlags.IsComponentsV2 | SILENT_MESSAGE_FLAGS }
 }
 
+// Components V2 messages come back with an empty `attachments` list: Discord
+// resolves each attachment:// URL inside the components instead, in upload order.
+function mediaUrls(components: readonly APIMessageTopLevelComponent[]): string[] {
+  return components.flatMap((component) => {
+    if (component.type === ComponentType.MediaGallery) return component.items.map((item) => item.media.url)
+    if (component.type === ComponentType.File) return [component.file.url]
+    return []
+  })
+}
+
 // Effects that will never run: an upload still waits for its answer.
 function drop(effects: readonly Effect[]) {
   for (const effect of effects) {
@@ -128,7 +174,7 @@ function drop(effects: readonly Effect[]) {
 
 export type MarkViewed = (input: { sessionId: string; idle: number }) => Promise<Error | void>
 
-export function createEffectsRunner({ discord, markViewed }: { discord: Client; markViewed: MarkViewed }) {
+export function createEffectsRunner({ discord, markViewed, footerDefaults }: { discord: Client; markViewed: MarkViewed; footerDefaults: FooterDefaults }) {
   const workers = new Map<string, ThreadWorker>()
   // After stop(): no more sends or typing, even from effects already queued.
   const lifecycle = { closed: false }
@@ -164,20 +210,23 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
     thread.typing = null
   }
 
-  async function post({ threadId, options, notify }: { threadId: string; options: PostOptions; notify: boolean }) {
+  // `mentions: false` for user text (prompt echoes): it must never ping.
+  async function post({ threadId, options, notify, mentions = true }: { threadId: string; options: PostOptions; notify: boolean; mentions?: boolean }) {
     if (lifecycle.closed) return null
     const channel = await sendableChannel(threadId)
     if (!channel || lifecycle.closed) return null
-    const flags = (options.flags ?? 0) | (notify ? NOTIFY_MESSAGE_FLAGS : SILENT_MESSAGE_FLAGS)
-    const sent = await channel.send({ ...options, flags, allowedMentions: { parse: ['users'] } }).catch((e: Error) => e)
+    const flags = (options.flags ?? 0) | embedFlags(options.content) | (notify ? 0 : MessageFlags.SuppressNotifications)
+    // Replies never ping their author: the footer is what notifies.
+    const sent = await channel.send({ ...options, flags, allowedMentions: { parse: mentions ? ['users'] : [], repliedUser: false } }).catch((e: Error) => e)
     if (!(sent instanceof Error)) return sent.id
     logger.error(`send failed in ${threadId}`, sent)
     return null
   }
 
   // Unlike post(), the error goes back to the agent that uploaded.
-  async function postFiles(threadId: string, files: readonly UploadFile[]): Promise<Error | null> {
+  async function postFiles(threadId: string, files: readonly UploadFile[]): Promise<Error | string[]> {
     let first = 1
+    const urls: string[] = []
     for (const batch of uploadBatches(files)) {
       if (lifecycle.closed) return new DiscordError({ operation: 'upload (bot stopped)' })
       const channel = await sendableChannel(threadId)
@@ -186,14 +235,15 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
         .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
+      urls.push(...mediaUrls(sent.components.map((component) => component.toJSON())))
       first += batch.length
     }
-    return null
+    return urls
   }
 
   async function edit({ channel, messageId, message }: { channel: SendableChannels; messageId: string; message: UiMessage }) {
     const edited = await channel.messages
-      .edit(messageId, { content: message.content, components: [...message.components] })
+      .edit(messageId, { content: message.content, components: [...message.components], flags: DISCORD_MEDIA_URL.test(message.content) ? [] : MessageFlags.SuppressEmbeds })
       .catch((e: Error) => e)
     if (edited instanceof Error) logger.warn(`edit of ${messageId} failed`, edited)
   }
@@ -228,15 +278,19 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
       return
     }
     if (effect.type === 'edit') {
-      const ids = thread.prompts.get(effect.key)
+      const ids = thread.prompts.get(effect.key) ?? []
       thread.prompts.delete(effect.key)
-      if (!ids || ids.length === 0) return
-      const channel = await sendableChannel(threadId)
-      if (!channel || lifecycle.closed) return
+      const channel = ids.length > 0 ? await sendableChannel(threadId) : null
+      if (lifecycle.closed) return
       for (const [index, messageId] of ids.entries()) {
         const message = effect.messages[index] ?? effect.messages[effect.messages.length - 1]
-        if (message) await edit({ channel, messageId, message })
+        if (channel && message) await edit({ channel, messageId, message })
       }
+      if (effect.reply === undefined) return
+      // A key from before a restart: the reply still marks the moment, without a reference.
+      const replyTo = effect.replyTo ?? ids[0]
+      await post({ threadId, options: { content: effect.reply, ...(replyTo && { reply: { messageReference: replyTo, failIfNotExists: false } }) }, notify: false })
+      await refreshTyping(threadId)
       return
     }
     if (effect.type === 'show') {
@@ -251,6 +305,7 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
             ...(replyTo && { reply: { messageReference: replyTo, failIfNotExists: false } }),
           },
           notify: effect.notify,
+          mentions: !effect.echo,
         })
         if (id) ids.push(id)
       }
@@ -258,8 +313,9 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
       await refreshTyping(threadId)
       return
     }
-    for (const payload of markdownMessages(effect)) {
-      await post({ threadId, options: payload, notify: false })
+    for (const [index, payload] of markdownMessages(effect).entries()) {
+      const replyTo = index === 0 ? effect.replyTo : null
+      await post({ threadId, options: { ...payload, ...(replyTo && { reply: { messageReference: replyTo, failIfNotExists: false } }) }, notify: false })
     }
     await refreshTyping(threadId)
   }
@@ -270,13 +326,16 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
     const thread = worker(threadId)
     const generation = thread.generation
     const live = () => thread.generation === generation
-    // A merged message notifies when any of its lines does.
-    let lines: { text: string; notify: boolean } | null = null
+    // A merged message notifies when any of its lines does. Echoes and
+    // bot lines never merge, so an echo never pings and a bot line can.
+    // Lines with Discord media only merge with each other: their message
+    // shows embeds, so other links merged in would unfurl too.
+    let lines: { text: string; notify: boolean; mentions: boolean; media: boolean } | null = null
     const flush = async () => {
       const pending = lines
       lines = null
       if (pending === null || !live()) return
-      await post({ threadId, options: { content: pending.text }, notify: pending.notify })
+      await post({ threadId, options: { content: pending.text }, notify: pending.notify, mentions: pending.mentions })
       await refreshTyping(threadId)
     }
     for (const [index, effect] of batch.entries()) {
@@ -287,15 +346,28 @@ export function createEffectsRunner({ discord, markViewed }: { discord: Client;
         await runOne(threadId, effect)
         continue
       }
-      const text = effect.type === 'send' ? effect.text : await footerText(effect)
+      const text = effect.type === 'send' ? effect.text : await footerText({ effect, footerDefaults })
       const notify = effect.notify === true
+      const echo = effect.type === 'send' && effect.echo === true
+      const mentions = !echo
+      // A line over the limit (a long prompt echo) is split like model markdown.
+      if (text.length > DISCORD_TEXT_LIMIT) {
+        await flush()
+        for (const payload of echo ? echoPayloads(text) : markdownPayloads(text)) {
+          if (!live()) return drop(batch.slice(index + 1))
+          await post({ threadId, options: payload, notify, mentions })
+        }
+        await refreshTyping(threadId)
+        continue
+      }
+      const media = DISCORD_MEDIA_URL.test(text)
       const joined: string | null = lines === null ? null : `${lines.text}\n${text}`
-      if (lines !== null && joined !== null && joined.length <= DISCORD_TEXT_LIMIT) {
-        lines = { text: joined, notify: lines.notify || notify }
+      if (lines !== null && joined !== null && lines.mentions === mentions && lines.media === media && joined.length <= DISCORD_TEXT_LIMIT) {
+        lines = { text: joined, notify: lines.notify || notify, mentions, media }
         continue
       }
       await flush()
-      lines = { text, notify }
+      lines = { text, notify, mentions, media }
     }
     await flush()
   }

package/src/event-loop.ts

@@ -14,24 +14,26 @@
 //   cold thread      a bound thread without a view yet (bound in an earlier
 //                    bot run): read its project channel and directory once.
 
-import { DiscordAPIError, RESTJSONErrorCodes, type Client } from 'discord.js'
+import { ChannelType, DiscordAPIError, RESTJSONErrorCodes, type Client } from 'discord.js'
 
 import type { Analytics } from './analytics.ts'
 import { verbosityFromV1, type KimakiDb } from './db.ts'
 import type { EffectsRunner } from './effects.ts'
 import { DbError, DiscordError, OpenCodeError } from './errors.ts'
-import { formatDuration } from './format-parts.ts'
 import { createLogger } from './logger.ts'
 import type { ConnectContext, OpenCodeClient, V2Event } from './opencode-server.ts'
-import type { EventRecorder } from './session-events.ts'
+import { formatDuration, type EventRecorder } from './session-events.ts'
 import { queuedItems } from './queue.ts'
-import type { BotStore } from './store.ts'
+import type { BotStore, State } from './store.ts'
 import {
+  conversationTyping,
   emptyView,
   eventSessionId,
   isKimakiEvent,
   reduce,
+  type Effect,
   type KimakiEvent,
+  type Prefs,
   type SessionSnapshot,
   type ThreadEvent,
 } from './thread-reducer.ts'
@@ -67,7 +69,6 @@ export function createEventLoop({
   effects,
   recorder,
   analytics,
-  messageTool,
   onRunEnded,
   onTranscriptDue,
 }: {
@@ -77,8 +78,6 @@ export function createEventLoop({
   effects: EffectsRunner
   recorder: EventRecorder
   analytics: Analytics
-  // `kimaki --message-tool`: plain text of root sessions stays hidden (Prefs.messageTool).
-  messageTool: boolean
   // 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.
@@ -86,49 +85,66 @@ export function createEventLoop({
 }) {
   // The client of the current connection, set before hydration starts.
   const connection: { client: OpenCodeClient | null } = { client: null }
-  // Context window sizes ("providerID/modelID" -> tokens) by directory.
+  // Model names and context window sizes ("providerID/modelID" -> info) by directory.
   // Cleared on connect; reloaded when the catalog changes (a /login adds a
-  // provider). `limits` is null while the first load runs; a reload keeps the
-  // old limits until it finishes. Failed loads are removed so the next call retries.
-  const modelLimits = new Map<string, { load: Promise<void>; limits: Readonly<Record<string, number>> | null }>()
+  // provider). `models` is null while the first load runs; a reload keeps the
+  // old models until it finishes. Failed loads are removed so the next call retries.
+  const modelCatalog = new Map<string, { load: Promise<void>; models: Prefs['models'] | null }>()
   const coldThreads = new Map<string, Held>()
   const unknownSessions = new Map<string, Held>()
   const ignoredSessions = new Set<string>()
 
-  // Resolves when the limits of `directory` are known (or failed to load).
+  // Resolves when the models of `directory` are known (or failed to load).
   // `reload`: read them again even when cached or loading.
-  function loadModelLimits(directory: string, { reload = false } = {}): Promise<void> {
+  function loadModels(directory: string, { reload = false } = {}): Promise<void> {
     const client = connection.client
     if (!client) return Promise.resolve()
-    const existing = modelLimits.get(directory)
+    const existing = modelCatalog.get(directory)
     if (existing && !reload) return existing.load
     const models = client.model.list({ location: { directory } }).catch((e) => new OpenCodeError({ operation: 'model.list', cause: e }))
     const load = models.then((result) => {
       // A reconnect or a newer reload replaced this load: its result is stale.
-      if (modelLimits.get(directory)?.load !== load) return
+      if (modelCatalog.get(directory)?.load !== load) return
       if (result instanceof Error) {
-        modelLimits.delete(directory)
+        modelCatalog.delete(directory)
         logger.warn(result)
         return
       }
-      const limits = Object.fromEntries(result.data.map((model) => [`${model.providerID}/${model.id}`, model.limit.context]))
-      modelLimits.set(directory, { load, limits })
+      const models = Object.fromEntries(result.data.map((model) => [`${model.providerID}/${model.id}`, { name: model.name, context: model.limit.context }]))
+      modelCatalog.set(directory, { load, models })
     })
-    modelLimits.set(directory, { load, limits: existing?.limits ?? null })
+    modelCatalog.set(directory, { load, models: existing?.models ?? null })
     return load
   }
 
+  // Every change of thread views goes through here. The reducer's typing only
+  // sees its own view; typing follows conversationTyping instead, which also
+  // changes in the coordinator of the thread's channel.
+  function commit({ threadId, effects: produced = [], update }: { threadId: string; effects?: readonly Effect[]; update: (state: State) => Partial<State> }) {
+    const before = store.getState().threads
+    store.setState(update)
+    const after = store.getState().threads
+    const typing = (id: string): Effect[] => {
+      const on = conversationTyping({ threads: after, threadId: id })
+      return conversationTyping({ threads: before, threadId: id }) === on ? [] : [{ type: 'typing', on }]
+    }
+    // A removed view: effects.dispose() already stopped its typing.
+    if (after[threadId]) effects.run(threadId, [...typing(threadId), ...produced.filter((effect) => effect.type !== 'typing')])
+    const channelId = (after[threadId] ?? before[threadId])?.channelId
+    if (channelId && channelId !== threadId) effects.run(channelId, typing(channelId))
+  }
+
   // Folds one event into a loaded view.
   function fold(threadId: string, event: ThreadEvent) {
     const state = store.getState()
     const view = state.threads[threadId]
     if (!view) return
     const verbosity = state.verbosity[view.channelId] ?? verbosityFromV1(null)
-    const contextLimits = modelLimits.get(view.directory)?.limits ?? {}
-    const result = reduce({ view, event, prefs: { verbosity, contextLimits, messageTool } })
-    if (result.view !== view) store.setState((current) => ({ threads: { ...current.threads, [threadId]: result.view } }))
-    effects.run(threadId, result.effects)
-    if (event.type === 'session.moved' && event.data.sessionID === view.sessionId) void loadModelLimits(event.data.location.directory)
+    const models = modelCatalog.get(view.directory)?.models ?? {}
+    const result = reduce({ view, event, prefs: { verbosity, models } })
+    if (result.view === view) effects.run(threadId, result.effects)
+    else commit({ threadId, effects: result.effects, update: (current) => ({ threads: { ...current.threads, [threadId]: result.view } }) })
+    if (event.type === 'session.moved' && event.data.sessionID === view.sessionId) void loadModels(event.data.location.directory)
   }
 
   // One line per run start and end of a root session, so the log shows what each thread did.
@@ -187,7 +203,8 @@ export function createEventLoop({
       if (!sessionId) return null
       const thread = await discord.channels.fetch(threadId).catch((e) => e instanceof DiscordAPIError && e.code === RESTJSONErrorCodes.UnknownChannel ? null : new DiscordError({ operation: `fetch thread ${threadId}`, cause: e }))
       if (thread instanceof Error) return thread
-      const channelId = thread?.isThread() ? thread.parentId : null
+      // A coordinator channel is its own conversation.
+      const channelId = thread?.isThread() ? thread.parentId : thread?.type === ChannelType.GuildText ? thread.id : null
       if (!channelId) return null
       const project = await db.query.channel_directories.findFirst({ where: { channel_id: channelId } }).catch((e) => new DbError({ operation: 'read channel_directories', cause: e }))
       if (project instanceof Error) return project
@@ -196,7 +213,7 @@ export function createEventLoop({
       if (!client) return new OpenCodeError({ operation: 'load session directory while disconnected' })
       const info = await client.session.get({ sessionID: sessionId }).catch((cause) => new OpenCodeError({ operation: 'read session directory', cause }))
       if (info instanceof Error) return info
-      await loadModelLimits(info.location.directory)
+      await loadModels(info.location.directory)
       return { channelId, directory: info.location.directory }
     })()
     entry.loading = false
@@ -214,8 +231,8 @@ export function createEventLoop({
       return
     }
     if (!store.getState().threads[threadId]) {
-      const view = emptyView({ sessionId, channelId: loaded.channelId, directory: loaded.directory, isNew: false })
-      store.setState((current) => ({ threads: { ...current.threads, [threadId]: view } }))
+      const view = emptyView({ sessionId, channelId: loaded.channelId, directory: loaded.directory, isNew: false, coordinator: threadId === loaded.channelId })
+      commit({ threadId, update: (current) => ({ threads: { ...current.threads, [threadId]: view } }) })
     }
     for (const event of entry.events) fold(threadId, event)
   }
@@ -321,7 +338,7 @@ export function createEventLoop({
         const failed = sessions.find((session) => session instanceof Error)
         if (failed instanceof Error) return failed
         const directory = info?.location.directory ?? null
-        if (directory) await loadModelLimits(directory)
+        if (directory) await loadModels(directory)
         const event: ThreadSnapshot['event'] = {
           type: 'kimaki.snapshot',
           at,
@@ -351,19 +368,22 @@ export function createEventLoop({
   }
 
   return {
-    // Bindings and channel verbosity from SQLite. Several bindings can share a
+    // Bindings, channel verbosity and coordinator mode from SQLite. Several bindings can share a
     // session after V1 /resume; the most recently updated one wins.
     async load(): Promise<DbError | void> {
-      const [rows, verbosity] = await Promise.all([
+      const [rows, verbosity, coordinator] = await Promise.all([
         db.query.thread_sessions.findMany({ orderBy: { updated_at: 'asc' } }).catch((e) => new DbError({ operation: 'read thread_sessions', cause: e })),
         db.query.channel_verbosity.findMany().catch((e) => new DbError({ operation: 'read channel_verbosity', cause: e })),
+        db.query.channel_coordinator.findMany().catch((e) => new DbError({ operation: 'read channel_coordinator', cause: e })),
       ])
       if (rows instanceof Error) return rows
       if (verbosity instanceof Error) return verbosity
+      if (coordinator instanceof Error) return coordinator
       store.setState({
         roots: Object.fromEntries(rows.map((row) => [row.thread_id, row.session_id])),
         sessionThreads: Object.fromEntries(rows.map((row) => [row.session_id, row.thread_id])),
         verbosity: Object.fromEntries(verbosity.map((row) => [row.channel_id, verbosityFromV1(row.verbosity)])),
+        coordinator: Object.fromEntries(coordinator.map((row) => [row.channel_id, row.enabled === 1])),
       })
     },
 
@@ -388,26 +408,32 @@ export function createEventLoop({
     }): Promise<void> {
       ignoredSessions.delete(sessionId)
       coldThreads.delete(threadId)
-      store.setState((current) => ({
-        roots: { ...current.roots, [threadId]: sessionId },
-        sessionThreads: { ...current.sessionThreads, [sessionId]: threadId },
-        threads: { ...current.threads, [threadId]: emptyView({ sessionId, channelId, directory, isNew }) },
-      }))
+      commit({
+        threadId,
+        update: (current) => ({
+          roots: { ...current.roots, [threadId]: sessionId },
+          sessionThreads: { ...current.sessionThreads, [sessionId]: threadId },
+          threads: { ...current.threads, [threadId]: emptyView({ sessionId, channelId, directory, isNew, coordinator: threadId === channelId }) },
+        }),
+      })
       // Same synchronous turn as the routing change: no live event can come first.
       for (const event of first) deliver(threadId, event)
       // Before the first prompt, so its footer can show the context percent.
-      await loadModelLimits(directory)
+      await loadModels(directory)
     },
 
     // A thread loses its session (`/resume` moved the session to a new thread).
     unbind(threadId: string): void {
       coldThreads.delete(threadId)
       effects.dispose(threadId)
-      store.setState((current) => {
-        const { [threadId]: _root, ...roots } = current.roots
-        const { [threadId]: _view, ...threads } = current.threads
-        const sessionThreads = Object.fromEntries(Object.entries(current.sessionThreads).filter(([, mapped]) => mapped !== threadId))
-        return { roots, threads, sessionThreads }
+      commit({
+        threadId,
+        update: (current) => {
+          const { [threadId]: _root, ...roots } = current.roots
+          const { [threadId]: _view, ...threads } = current.threads
+          const sessionThreads = Object.fromEntries(Object.entries(current.sessionThreads).filter(([, mapped]) => mapped !== threadId))
+          return { roots, threads, sessionThreads }
+        },
       })
     },
 
@@ -429,7 +455,7 @@ export function createEventLoop({
     async onConnect({ client, signal }: ConnectContext): Promise<OpenCodeError | void> {
       connection.client = client
       // A new connection may bring new providers, and old unrelated sessions are gone.
-      modelLimits.clear()
+      modelCatalog.clear()
       ignoredSessions.clear()
       const result = await snapshots({ client, signal })
       if (result instanceof Error) return result
@@ -444,9 +470,9 @@ export function createEventLoop({
     onEvent(event: V2Event): void {
       if (CATALOG_EVENTS.has(event.type)) {
         // Credential events have no location: they can change every directory.
-        const directories = event.location ? [event.location.directory] : [...modelLimits.keys()]
+        const directories = event.location ? [event.location.directory] : [...modelCatalog.keys()]
         for (const directory of directories) {
-          if (modelLimits.has(directory)) void loadModelLimits(directory, { reload: true })
+          if (modelCatalog.has(directory)) void loadModels(directory, { reload: true })
         }
         return
       }

package/src/format-parts.ts

@@ -16,12 +16,24 @@ import {
 import { z } from 'zod'
 
 import type { Verbosity } from './db.ts'
+import { formatDuration, formatTokens } from './session-events.ts'
 
-// Bot messages never show link previews. Only messages that need the user
+// Bot messages hide link previews (session output: see embedFlags). Only messages that need the user
 // (errors, prompts, the end of a turn) skip SuppressNotifications.
 export const SILENT_MESSAGE_FLAGS = MessageFlags.SuppressEmbeds | MessageFlags.SuppressNotifications
 export const NOTIFY_MESSAGE_FLAGS = MessageFlags.SuppressEmbeds
 
+// Discord CDN links (attachments from other threads, avatars, emojis) only
+// show the media through their embed. Signed attachment URLs (?ex=&is=&hm=)
+// are refreshed by the Discord client, so old ones still render.
+// https://docs.discord.com/developers/reference#signed-attachment-cdn-urls
+export const DISCORD_MEDIA_URL = /https:\/\/(?:cdn\.discordapp\.com|media\.discordapp\.net)\/\S/
+
+// Session output hides link previews, except in messages with Discord media.
+export function embedFlags(content: string | undefined): MessageFlags.SuppressEmbeds | 0 {
+  return content && DISCORD_MEDIA_URL.test(content) ? 0 : MessageFlags.SuppressEmbeds
+}
+
 export function asSubtext(text: string): string {
   return `-# ${text}`
 }
@@ -108,45 +120,59 @@ export function selectedPage(value: string): number | null {
   return Number(value.slice(PAGE_PREFIX.length)) || 0
 }
 
-export function formatDuration(ms: number): string {
-  if (ms < 1_000) return '<1s'
-  const seconds = Math.floor(ms / 1_000)
-  if (seconds < 60) return `${seconds}s`
-  const minutes = Math.floor(seconds / 60)
-  if (minutes < 60) return `${minutes}m ${seconds % 60}s`
-  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`
-}
-
 export type ModelRef = { providerID: string; id: string }
 
-export function formatBanner({ model, agent }: { model: ModelRef & { variant?: string }; agent: string }): string {
+const COORDINATOR_NOTICE = 'Coordinator mode is on: this channel is one session that starts and manages project threads for you. Use /new-session for a thread without it. Turn it off with /toggle-coordinator or start kimaki with `--coordinator false`.'
+
+export function formatBanner({ model, agent, coordinator = false }: { model: ModelRef & { variant?: string }; agent: string; coordinator?: boolean }): string {
   // OpenCode reports `default` when no variant is selected.
   const variant = model.variant && model.variant !== 'default' ? ` ${model.variant}` : ''
-  return asSubtext(`*using ${model.providerID}/${model.id}${variant} ⋅ ${agent}*`)
+  const banner = asSubtext(`*using ${model.providerID}/${model.id}${variant} ⋅ ${agent}*`)
+  return coordinator ? `${banner}\n${asSubtext(COORDINATOR_NOTICE)}` : banner
 }
 
+// "Switched model to Claude Opus 5.5 (high)", for a root session switch after its banner.
+export function formatModelSwitched({ name, variant }: { name: string; variant?: string }): string {
+  return asSubtext(`Switched model to ${name}${variant && variant !== 'default' ? ` (${variant})` : ''}`)
+}
+
+const agentLabel = (agent: string) => agent.charAt(0).toUpperCase() + agent.slice(1)
+
+export function formatAgentSwitched({ agent, previous }: { agent: string; previous?: string }): string {
+  return asSubtext(`Switched agent ${previous ? `from ${agentLabel(previous)} ` : ''}to ${agentLabel(agent)}`)
+}
+
+// The folder, branch and agent only show when they differ from the defaults.
+// `projectDirectory` / `defaultBranch` / `defaultAgent`: null when unknown, then they show.
 export function formatFooter({
-  folder,
+  directory,
+  projectDirectory,
   branch,
+  defaultBranch,
   durationMs,
   contextPercent,
   model,
   agent,
+  defaultAgent,
 }: {
-  folder: string
+  directory: string
+  projectDirectory: string | null
   branch: string | null
+  defaultBranch: string | null
   durationMs: number
   contextPercent: number | null
   model: ModelRef | null
   agent: string | null
+  defaultAgent: string | null
 }): string {
+  const inProject = projectDirectory !== null && path.resolve(directory) === path.resolve(projectDirectory)
   const parts = [
-    folder,
-    branch,
+    inProject ? null : path.basename(directory),
+    branch === defaultBranch ? null : branch,
     formatDuration(durationMs),
     contextPercent === null ? null : `${contextPercent}%`,
     model?.id ?? null,
-    agent && agent !== 'build' ? agent : null,
+    agent && agent.toLowerCase() !== defaultAgent?.toLowerCase() ? agent : null,
   ].filter((part): part is string => Boolean(part))
   return asSubtext(`*${parts.join(' ⋅ ')}*`)
 }
@@ -162,12 +188,17 @@ export function formatError(message: string): string {
 // The provider error is the whole point: "retrying" alone says nothing.
 export function formatRetry({ attempt, delayMs, message }: { attempt: number; delayMs: number; message: string }): string {
   const seconds = Math.max(1, Math.ceil(delayMs / 1_000))
-  return asSubtext(`⬦ retrying in ${seconds}s (attempt ${attempt}): ${inline(message, 200)}`)
+  return asSubtext(`retrying in ${seconds}s (attempt ${attempt}): ${inline(message, 200)}`)
+}
+
+// `tokens`: prompt size of the first step after the compaction, null when no step ran yet (`/compact`).
+export function formatCompacted({ tokens, percent }: { tokens: number | null; percent: number | null }): string {
+  if (tokens === null) return asSubtext('context compacted')
+  return asSubtext(`context compacted to ${formatTokens(tokens)} tokens${percent === null ? '' : ` (${percent}%)`}`)
 }
 
 export function formatCacheMiss({ read, expected, idleMs }: { read: number; expected: number; idleMs: number }): string {
-  const k = (tokens: number) => (tokens < 1_000 ? String(tokens) : `${Math.round(tokens / 1_000)}k`)
-  return asSubtext(`⬦ prompt cache miss: ${k(read)} of ${k(expected)} tokens cached, ${formatDuration(idleMs)} after the last request`)
+  return asSubtext(`prompt cache miss: ${formatTokens(read)} of ${formatTokens(expected)} tokens cached, ${formatDuration(idleMs)} after the last request`)
 }
 
 // One line, no markdown control characters, so `_x_` and `*x*` stay intact.
@@ -350,7 +381,7 @@ export function formatToolFailed({ name, message, label }: { name: string; messa
 }
 
 export function formatSubagentFinished({ agent, description }: { agent: string; description: string }): string {
-  return asSubtext(`⬦ ${inline(agent)} finished: ${inline(description)}`)
+  return asSubtext(`${inline(agent)} finished: ${inline(description)}`)
 }
 
 // `state` is OpenCode's job state; any value other than "completed" is shown.
@@ -370,7 +401,7 @@ export function formatShellFinished({
     state && state !== 'completed' ? inline(state) : null,
     exit !== null && exit !== 0 ? `exit ${exit}` : null,
   ].filter((note) => note !== null)
-  return asSubtext(`⬦ ${prefix}background shell finished${description ? `: _${inline(description)}_` : ''}${notes.length > 0 ? ` (${notes.join(', ')})` : ''}`)
+  return asSubtext(`${prefix}background shell finished${description ? `: _${inline(description)}_` : ''}${notes.length > 0 ? ` (${notes.join(', ')})` : ''}`)
 }
 
 const SHELL_OUTPUT_LIMIT = 1_800