kimaki 1.4.0 → 1.5.0

package/src/preference-commands.e2e.test.ts

@@ -9,6 +9,7 @@ import { ComponentType } from 'discord-api-types/v10'
 import { afterAll, beforeAll, expect, onTestFinished, test } from 'vitest'
 
 import type { BotHandle } from './main.ts'
+import { send } from './prompt.ts'
 import * as schema from './schema.ts'
 import {
   TEST_USER_ID,
@@ -19,6 +20,7 @@ import {
   startTwin,
   tempDataDir,
   waitFor,
+  waitForBotMessageContaining,
   waitForFooter,
   waitForSelectMenu,
   warmUp,
@@ -144,14 +146,15 @@ test('/agent switches the session agent in a thread and the default in a channel
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
     Switched to **plan** agent for this session
     The agent changes from the next step.
+    -# Switched agent to Plan
     --- from: user (tommy)
     Next message
     --- from: assistant (TestBot)
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2 ⋅ plan*"
+    -# *main ⋅ Ns ⋅ deterministic-v2 ⋅ plan*"
   `)
   expect((await sessionModel(thread.id)).agent).toBe('plan')
 
@@ -228,26 +231,29 @@ test('/model switches the session model from the next step, /model-variant its t
       "variant": "low",
     }
   `)
+  await waitForBotMessageContaining({ discord, threadId: thread.id, text: 'Switched model to Thinker (low)' })
   expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Model thread
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
     Model set for this session:
     **Deterministic Provider** / **deterministic-thinker** (high)
     \`deterministic-provider/deterministic-thinker (high)\`
     Applies from the next step.
+    -# Switched model to Thinker (high)
     --- from: user (tommy)
     With the new model
     --- from: assistant (TestBot)
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker*
+    -# *main ⋅ Ns ⋅ deterministic-thinker*
     Model set for this session:
     **Deterministic Provider** / **deterministic-thinker** (low)
     \`deterministic-provider/deterministic-thinker (low)\`
-    Applies from the next step."
+    Applies from the next step.
+    -# Switched model to Thinker (low)"
   `)
 
   await user.runSlashCommand({ name: 'model' })
@@ -256,7 +262,8 @@ test('/model switches the session model from the next step, /model-variant its t
       "Reset session model",
     ]
   `)
-  expect((await discord.thread(thread.id).getMessages()).at(-1)?.content).toMatchInlineSnapshot(`
+  await waitForBotMessageContaining({ discord, threadId: thread.id, text: 'Switched model to deterministic-v2' })
+  expect((await discord.thread(thread.id).getMessages()).at(-2)?.content).toMatchInlineSnapshot(`
     "Session model reset to the channel default:
     \`deterministic-provider/deterministic-v2\`
     Applies from the next step."
@@ -294,7 +301,7 @@ test('/model with channel scope sets the model of new sessions', async () => {
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-thinker ⋅ plan*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker ⋅ plan*"
+    -# *main ⋅ Ns ⋅ deterministic-thinker*"
   `)
   const row = await bot.db.query.channel_models.findFirst({ where: { channel_id: channelId } })
   expect({ model: row?.model_id, variant: row?.variant }).toMatchInlineSnapshot(`
@@ -348,12 +355,12 @@ test('/verbosity applies to running sessions of the channel at once', async () =
     -# ┣ shell _Say hi_
 
     tools done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
     --- from: user (tommy)
     Again tools-marker
     --- from: assistant (TestBot)
     tools done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(await discord.channel(channelId).text()).toMatchInlineSnapshot(`
     "--- from: user (tommy)
@@ -411,10 +418,12 @@ test('/<agent>-agent variant: sets the thinking level with the agent, per sessio
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
-    » **tommy:** (plan, deep) Think hard
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# » **tommy:** (plan, deep) Think hard
+    -# Switched model to deterministic-v2 (deep)
+    -# Switched agent to Plan
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2 ⋅ plan*
+    -# *main ⋅ Ns ⋅ deterministic-v2 ⋅ plan*
     \`deterministic-provider/deterministic-v2\` has no thinking level \`nope\`. Available: \`fast\`, \`deep\`"
   `)
 
@@ -454,16 +463,20 @@ test('agent selection replaces a stale model and uses the agent model for varian
   await client.session.switchModel({ sessionID, model: { providerID: 'missing', id: 'stale-model' } })
   await user.runSlashCommand({ name: 'agent' })
   await pick({ channelId: thread.id, prefix: 'agent:', value: 'thinker' })
+  await waitForBotMessageContaining({ discord, threadId: thread.id, text: 'Switched agent from Build to Thinker' })
   expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Agent model thread
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 fast ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# Switched model to missing/stale-model
     Switched to **thinker** agent for this session (was **build**)
     Model: \`deterministic-provider/deterministic-thinker (high)\`
-    The agent changes from the next step."
+    The agent changes from the next step.
+    -# Switched model to Thinker (high)
+    -# Switched agent from Build to Thinker"
   `)
   expect((await sessionModel(thread.id)).model).toEqual({ providerID: 'deterministic-provider', id: 'deterministic-thinker', variant: 'high' })
 
@@ -482,15 +495,21 @@ test('agent selection replaces a stale model and uses the agent model for varian
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 fast ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# Switched model to missing/stale-model
     Switched to **thinker** agent for this session (was **build**)
     Model: \`deterministic-provider/deterministic-thinker (high)\`
     The agent changes from the next step.
+    -# Switched model to Thinker (high)
+    -# Switched agent from Build to Thinker
     Switched to **build** agent for this session (was **thinker**)
     The agent changes from the next step.
-    » **tommy:** (thinker, low) Use the agent model
+    -# Switched agent from Thinker to Build
+    -# » **tommy:** (thinker, low) Use the agent model
+    -# Switched model to Thinker (low)
+    -# Switched agent from Build to Thinker
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*"
+    -# *main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*"
   `)
   expect((await sessionModel(thread.id)).model).toEqual({ providerID: 'deterministic-provider', id: 'deterministic-thinker', variant: 'low' })
 
@@ -502,15 +521,22 @@ test('agent selection replaces a stale model and uses the agent model for varian
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 fast ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-v2*
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# Switched model to missing/stale-model
     Switched to **thinker** agent for this session (was **build**)
     Model: \`deterministic-provider/deterministic-thinker (high)\`
     The agent changes from the next step.
+    -# Switched model to Thinker (high)
+    -# Switched agent from Build to Thinker
     Switched to **build** agent for this session (was **thinker**)
     The agent changes from the next step.
-    » **tommy:** (thinker, low) Use the agent model
+    -# Switched agent from Thinker to Build
+    -# » **tommy:** (thinker, low) Use the agent model
+    -# Switched model to Thinker (low)
+    -# Switched agent from Build to Thinker
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*
+    -# *main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*
+    -# Switched model to Thinker (high)
     Using **thinker** agent for this session
     Model: \`deterministic-provider/deterministic-thinker (high)\`
     The agent changes from the next step."
@@ -525,7 +551,7 @@ test('agent selection replaces a stale model and uses the agent model for varian
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-thinker high ⋅ thinker*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*"
+    -# *main ⋅ Ns ⋅ deterministic-thinker*"
   `)
   expect((await sessionModel(fresh.id)).model).toEqual({ providerID: 'deterministic-provider', id: 'deterministic-thinker', variant: 'high' })
 
@@ -538,7 +564,7 @@ test('agent selection replaces a stale model and uses the agent model for varian
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-thinker low ⋅ thinker*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*"
+    -# *main ⋅ Ns ⋅ deterministic-thinker*"
   `)
   expect((await sessionModel(low.id)).model).toEqual({ providerID: 'deterministic-provider', id: 'deterministic-thinker', variant: 'low' })
 })
@@ -576,7 +602,7 @@ test('/model with all channels scope sets the model of channels without their ow
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-thinker low ⋅ build*
     ok
-    -# *project ⋅ main ⋅ Ns ⋅ deterministic-thinker*"
+    -# *main ⋅ Ns ⋅ deterministic-thinker*"
   `)
   expect((await sessionModel(thread.id)).model).toMatchInlineSnapshot(`
     {
@@ -595,3 +621,57 @@ test('/model with all channels scope sets the model of channels without their ow
     Select a provider:"
   `)
 })
+
+// https://github.com/remorses/kimaki/issues/245: agents pass --agent <current_agent> on every send.
+test('naming the current agent again keeps the session model, and --model wins over the agent model', async () => {
+  const { discord, channelId } = twin
+  const thread = await newThread(channelId, 'Model kept thread')
+  const sessionId = bot.store.getState().roots[thread.id]!
+  const sendAndWait = async (input: { prompt: string; agent: string; model?: string }, count: number) => {
+    const sent = await send(bot, { sessionId, ...input })
+    if (sent instanceof Error) throw sent
+    await waitForFooter({ discord, threadId: thread.id, count })
+    return sessionModel(thread.id)
+  }
+  const explicit = await sendAndWait({ prompt: 'Explicit model', agent: 'thinker', model: 'deterministic-provider/deterministic-v2' }, 2)
+  // Like /model in the thread.
+  await (await server.client()).session.switchModel({ sessionID: sessionId, model: { providerID: 'deterministic-provider', id: 'deterministic-thinker', variant: 'low' } })
+  const kept = await sendAndWait({ prompt: 'Same agent again', agent: 'thinker' }, 3)
+  expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Model kept thread
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-v2*
+    -# Switched model to deterministic-v2
+    -# Switched agent to Thinker
+    -# » **CLI:** Explicit model
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-v2 ⋅ thinker*
+    -# Switched model to Thinker (low)
+    -# » **CLI:** Same agent again
+    ok
+    -# *main ⋅ Ns ⋅ deterministic-thinker ⋅ thinker*"
+  `)
+  expect({ explicit, kept }).toMatchInlineSnapshot(`
+    {
+      "explicit": {
+        "agent": "thinker",
+        "model": {
+          "id": "deterministic-v2",
+          "providerID": "deterministic-provider",
+          "variant": "default",
+        },
+      },
+      "kept": {
+        "agent": "thinker",
+        "model": {
+          "id": "deterministic-thinker",
+          "providerID": "deterministic-provider",
+          "variant": "low",
+        },
+      },
+    }
+  `)
+})

package/src/prompt.ts

@@ -15,13 +15,14 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { Events, MessageFlags, type Message, type ThreadChannel } from 'discord.js'
+import { Events, MessageFlags, type Message } from 'discord.js'
 import * as errore from 'errore'
 
 import {
-  fetchThread,
+  fetchConversation,
   oc,
   parseModel,
+  projectChannelOf,
   projectOf,
   rootSession,
   routeText,
@@ -29,6 +30,7 @@ import {
   threadOfSession,
   type Author,
   type Bot,
+  type Conversation,
   type ModelChoice,
   type PromptFile,
 } from './bot.ts'
@@ -37,11 +39,11 @@ import { ConfigError, DbError, DiscordError, OpenCodeError, OpenCodeUnavailableE
 import { formatError, NOTIFY_MESSAGE_FLAGS } from './format-parts.ts'
 import { createLogger } from './logger.ts'
 import type { SendInput } from './lock-routes.ts'
-import { formatEcho } from './queue.ts'
+import { discordMessageId, formatEcho } from './queue.ts'
 import { noAnswerError, parseRemoteResult, remoteEnvelope, promptFilePath, REMOTE_TIMEOUT_MS, type RemoteResult } from './remote-send.ts'
 import { parseTextMessage, type Route } from './routes.ts'
 import { allMessages } from './session-events.ts'
-import { ensureSessionMarker, forkBtw, startSession, switchAgent, threadProject } from './sessions.ts'
+import { ensureSessionMarker, forkBtw, startSession, switchAgent, conversationProject } from './sessions.ts'
 import { cancelSleep } from './sleeps.ts'
 import type { ScheduledRun } from './system-prompt.ts'
 import { attachmentsBlock, type PromptAttachment, type TurnContext } from './system-prompt.ts'
@@ -51,6 +53,16 @@ import { resolveWorkingDirectory } from './worktrees.ts'
 const logger = createLogger('PROMPT')
 
 
+// Who sent a prompt that no person typed in Discord: `kimaki send`, routines,
+// remote sends, sleep wakes. Stored in the prompt metadata; at the run end
+// coordinator.ts reads it: only a run a coordinator prompted wakes that coordinator.
+export type Sender = {
+  // The session whose shell ran `kimaki send` (OPENCODE_SESSION_ID).
+  sessionId?: string
+  // `kimaki send --wait`: until this time (epoch ms) the sender waits for the result itself, so a run that ends before it sends no note.
+  waitUntil?: number
+}
+
 // Prompt IDs map a Discord message to its inbox item without stored state (spec 9.2.2).
 export function promptIdForMessage(messageId: string): string {
   return `msg_discord_${messageId}`
@@ -70,6 +82,7 @@ export async function prompt(
     skills = [],
     id = promptIdForMessage(messageId),
     echo,
+    sender,
   }: {
     sessionId: string
     threadId: string
@@ -86,6 +99,8 @@ export async function prompt(
     // Line the thread shows when OpenCode takes the prompt (queue.ts), for
     // inputs that have no Discord message: wakes, scheduled runs.
     echo?: string
+    // Unset: a person typed it in Discord.
+    sender?: Sender
   },
 ): Promise<OpenCodeUnavailableError | OpenCodeError | void> {
   const { attached, attachments } = await splitPromptFiles(files)
@@ -100,7 +115,7 @@ export async function prompt(
       files: attached,
       ...(skills.length > 0 && { skills: skills.map((skill) => ({ id: skill })) }),
       delivery,
-      metadata: { discord: { ...discord, ...(echo && { echo }) } },
+      metadata: { discord: { ...discord, ...(echo && { echo }) }, ...(sender && { sender }) },
     }),
   )
   if (result instanceof Error) return result
@@ -163,6 +178,7 @@ export async function steer(
     files?: readonly PromptFile[]
     skills?: readonly string[]
     echo?: string
+    sender?: Sender
   },
 ): Promise<OpenCodeUnavailableError | OpenCodeError | void> {
   const cancelled = await cancelPendingUi(bot, input.threadId)
@@ -283,6 +299,7 @@ async function command(
     author: Author
     messageId: string
     files: readonly PromptFile[]
+    echo?: string
   },
 ): Promise<OpenCodeUnavailableError | OpenCodeError | void> {
   const { route } = input
@@ -301,7 +318,7 @@ async function command(
   }
   const { attached, attachments } = await splitPromptFiles(input.files)
   const block = attachmentsBlock(attachments)
-  bot.eventLoop.dispatch(input.threadId, { type: 'kimaki.command', text: typed, username: input.author.username })
+  bot.eventLoop.dispatch(input.threadId, { type: 'kimaki.command', text: typed, username: input.author.username, messageId: discordMessageId(input.messageId), echo: input.echo ?? null })
   const result = await oc(bot, 'session.command', (client) =>
     client.session.command({
       sessionID: input.sessionId,
@@ -330,6 +347,7 @@ export async function runInSession(
     messageId,
     files,
     echo,
+    sender,
     model,
   }: {
     sessionId: string
@@ -341,10 +359,11 @@ export async function runInSession(
     messageId: string
     files: readonly PromptFile[]
     echo?: string
+    sender?: Sender
     model?: ModelChoice | null
   },
 ) {
-  const base = { sessionId, threadId, threadName, author, messageId, files, echo }
+  const base = { sessionId, threadId, threadName, author, messageId, files, echo, sender }
   switch (route.kind) {
     case 'shell':
       return shell(bot, { threadId, sessionId, command: route.command })
@@ -371,32 +390,37 @@ export async function runInSession(
 export async function dispatch(
   bot: Bot,
   {
-    thread,
+    conversation,
     route,
     author,
     messageId,
     files = [],
     echo,
+    sender,
     model,
+    parentSessionId,
   }: {
-    thread: ThreadChannel
+    conversation: Conversation
     route: Route
     author: Author
     messageId: string
     files?: readonly PromptFile[]
     echo?: string
+    sender?: Sender
     model?: ModelChoice | null
+    // `kimaki send --parent-session`: only a btw fork records it, the session itself exists.
+    parentSessionId?: string
   },
 ) {
-  const sessionId = rootSession(bot, thread.id)
+  const sessionId = rootSession(bot, conversation.id)
   if (sessionId instanceof Error) return sessionId
   // New input supersedes a pending `kimaki sleep` of this session.
   await cancelSleep(bot, sessionId)
-  const project = await threadProject(bot, thread)
+  const project = await conversationProject(bot, conversation)
   if (project instanceof Error) return project
   const marked = await ensureSessionMarker(bot, {
     sessionId,
-    thread,
+    conversation,
     channelId: project.channelId,
     directory: project.directory,
     userId: author.id,
@@ -404,9 +428,9 @@ export async function dispatch(
   if (marked instanceof Error) return marked
   switch (route.kind) {
     case 'btw':
-      return forkBtw(bot, { sourceThread: thread, text: route.text, author, messageId, files, agent: route.agent })
+      return forkBtw(bot, { source: conversation, text: route.text, author, messageId, files, agent: route.agent, parentSessionId, sender })
     case 'new-session':
-      // A fresh thread in the same channel, with no history.
+      // A fresh conversation in the same channel, with no history.
       return startSession(bot, {
         channelId: project.channelId,
         directory: project.directory,
@@ -415,20 +439,26 @@ export async function dispatch(
         messageId,
         startMessageId: null,
         files,
+        sender,
       })
-    default:
+    default: {
+      // The coordinator keeps its agent and model: a worker's `kimaki send --agent <current_agent>` names the worker's agent.
+      const coordinator = !conversation.isThread()
+      if (coordinator && route.kind === 'steer' && route.agent) logger.log(`ignoring agent ${route.agent} of a prompt to coordinator ${conversation.id}`)
       return runInSession(bot, {
         sessionId,
-        threadId: thread.id,
-        threadName: thread.name,
+        threadId: conversation.id,
+        threadName: conversation.name,
         directory: project.directory,
-        route,
+        route: coordinator && route.kind === 'steer' ? { kind: 'steer', text: route.text } : route,
         author,
         messageId,
         files,
         echo,
-        model,
+        sender,
+        model: coordinator ? null : model,
       })
+    }
   }
 }
 
@@ -528,7 +558,13 @@ async function remoteSend(bot: Bot, input: SendInput) {
 
 // `localOnly`: never forward to another machine (remote envelopes, scheduled runs).
 // `task`: a scheduled run; its input shows as "» routine #N: prompt".
-export async function send(bot: Bot, input: SendInput, { localOnly = false, task }: { localOnly?: boolean; task?: ScheduledRun } = {}) {
+// `shownIn`: a Discord message that already shows the prompt (remote envelope, clicked buttons).
+// Without it the thread shows the prompt as an echo.
+export async function send(
+  bot: Bot,
+  input: SendInput,
+  { localOnly = false, task, shownIn }: { localOnly?: boolean; task?: ScheduledRun; shownIn?: string } = {},
+) {
   if (input.worktree !== undefined && (input.cwd || input.threadId || input.sessionId || input.notifyOnly)) {
     return new ConfigError({ reason: '--worktree requires a new session without --cwd or --notify-only.' })
   }
@@ -538,11 +574,16 @@ export async function send(bot: Bot, input: SendInput, { localOnly = false, task
   }
   const userIds = (input.user ?? []).map((user) => user.replace(/[<@!>]/g, ''))
   const author = { id: userIds[0] ?? bot.discord.user!.id, username: task ? `routine #${task.id}` : 'CLI' }
-  // Every --user joins the thread; startSession adds the author of a new session itself.
-  const addMembers = async (thread: ThreadChannel, ids: readonly string[]) => {
-    for (const id of ids) await thread.members.add(id).catch((error: Error) => logger.warn(`add thread member ${id}`, error))
+  // Every --user joins the thread; startSession adds them to a new session itself.
+  // Not awaited: the prompt does not wait for Discord round trips.
+  const addMembers = (thread: Conversation, ids: readonly string[]) => {
+    // A coordinator channel has no thread members to add.
+    if (!thread.isThread()) return
+    for (const id of ids) void thread.members.add(id).catch((error: Error) => logger.warn(`add thread member ${id}`, error))
   }
-  const messageId = crypto.randomUUID()
+  const messageId = shownIn ?? crypto.randomUUID()
+  // Also set without a session (routines, a terminal): it marks the prompt as not typed by a person.
+  const sender: Sender = { ...(input.senderSessionId && { sessionId: input.senderSessionId }), ...(input.wait !== undefined && { waitUntil: Date.now() + input.wait * 1000 }) }
   const route = parseTextMessage({ content: input.prompt })
   if (!route) return new ConfigError({ reason: 'Prompt is empty' })
   if (input.agent && (route.kind === 'steer' || route.kind === 'btw')) route.agent = input.agent
@@ -550,23 +591,28 @@ export async function send(bot: Bot, input: SendInput, { localOnly = false, task
   if (input.sessionId || input.threadId) {
     const threadId = input.threadId ?? threadOfSession(bot, input.sessionId!)
     if (!threadId) return new ConfigError({ reason: 'No local thread for this session. Use --thread on its owning machine.' })
-    const thread = await fetchThread(bot, threadId)
+    const thread = await fetchConversation(bot, threadId)
     if (thread instanceof Error) return thread
     const sessionId = bot.store.getState().roots[thread.id]
     if (!sessionId) {
-      const project = thread.parentId ? await projectOf(bot, thread.parentId) : null
+      const channelId = projectChannelOf(thread)
+      const project = channelId ? await projectOf(bot, channelId) : null
       if (project instanceof Error) return project
       return !project && !localOnly ? remoteSend(bot, input) : new ConfigError({ reason: 'No local session for this thread' })
     }
-    await addMembers(thread, userIds)
-    if (input.model) {
-      const model = parseModel(input.model, null)
-      if (!model) return new ConfigError({ reason: 'Use --model provider/model' })
-      const switched = await switchModel(bot, { sessionId, model: { ...model, variant: null } })
+    addMembers(thread, userIds)
+    const explicit = input.model ? parseModel(input.model, null) : null
+    if (input.model && !explicit) return new ConfigError({ reason: 'Use --model provider/model' })
+    // The coordinator keeps its model; /model in its channel changes it.
+    const model = explicit && thread.isThread() ? { ...explicit, variant: null } : null
+    if (explicit && !model) logger.log(`ignoring --model ${input.model} of a prompt to coordinator ${thread.id}`)
+    if (model) {
+      const switched = await switchModel(bot, { sessionId, model })
       if (switched instanceof Error) return switched
     }
-    const echo = task ? formatEcho({ username: author.username, text: routeText(route) }) : undefined
-    const result = await dispatch(bot, { thread, route, author, messageId, files: input.files, echo })
+    const echo = shownIn ? undefined : formatEcho({ username: author.username, text: routeText(route) })
+    // --model reaches the agent switch too, so an agent with its own model cannot replace it.
+    const result = await dispatch(bot, { conversation: thread, route, author, messageId, files: input.files, echo, sender, parentSessionId: input.parentSessionId, model })
     if (result instanceof Error) return result
     return result ?? { threadId, sessionId: bot.store.getState().roots[threadId]! }
   }
@@ -593,7 +639,7 @@ export async function send(bot: Bot, input: SendInput, { localOnly = false, task
       })
       .catch((cause) => new DiscordError({ operation: 'post notification', cause }))
     if (shown instanceof Error) return shown
-    await addMembers(thread, userIds)
+    addMembers(thread, userIds)
     return { threadId: thread.id, sessionId: null }
   }
 
@@ -618,27 +664,24 @@ export async function send(bot: Bot, input: SendInput, { localOnly = false, task
     : task && input.worktree
       ? `${input.worktree.slice(0, 40)}-${crypto.randomBytes(4).toString('hex')}`
       : input.worktree
-  const started = await startSession(bot, {
+  return startSession(bot, {
     channelId: project.channel_id,
     directory,
     route: first,
     author,
+    members: userIds.slice(1),
     messageId,
     startMessageId: null,
     threadName: input.name,
     files: input.files,
     permissions,
     parentSessionId: input.parentSessionId,
+    sender,
     task,
     worktree,
     baseBranch: input.baseBranch,
     ...(model && { model: { ...model, variant: null } }),
   })
-  if (started instanceof Error || userIds.length < 2) return started
-  const thread = await fetchThread(bot, started.threadId)
-  if (thread instanceof Error) logger.warn(`add thread members`, thread)
-  else await addMembers(thread, userIds.slice(1))
-  return started
 }
 
 // `kimaki upload-to-discord`: posts local files into the session's thread (or the voice channel chat),
@@ -658,7 +701,8 @@ export async function upload(bot: Bot, { id, files }: { id: string; files: Array
     if (!stat?.isFile()) return new ConfigError({ reason: `File not found: ${file.path}` })
     sized.push({ ...file, size: stat.size })
   }
-  const error = await new Promise<Error | null>((settle) => bot.effects.run(threadId, [{ type: 'attachments', files: sized, settle }]))
-  if (error) return error
-  return { uploaded: files.map((file) => file.name) }
+  const urls = await new Promise<Error | string[]>((settle) => bot.effects.run(threadId, [{ type: 'attachments', files: sized, settle }]))
+  if (urls instanceof Error) return urls
+  // Discord keeps attachments in upload order. The URLs let a coordinator repost the files.
+  return { uploaded: files.map((file, index) => ({ name: file.name, url: urls[index] ?? null })) }
 }