kimaki 1.3.0 → 1.5.0

package/dist/sessions.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import * as orm from 'drizzle-orm';
-import { cliContext, globalModel, markerIsCurrent, oc, parseModel, projectOf, readMarker, rootSession, routeText, sessionDirectory, textChannel, } from "./bot.js";
+import { cliContext, globalModel, oc, parseModel, projectChannelOf, projectOf, readMarker, rootSession, routeText, sessionDirectory, textChannel, } from "./bot.js";
 import { ConfigError, DbError, DiscordError, OpenCodeError, OpenCodeUnavailableError } from "./errors.js";
 import { SILENT_MESSAGE_FLAGS } from "./format-parts.js";
 import { createLogger } from "./logger.js";
@@ -34,17 +34,17 @@ export function btwPrompt({ text, parentSessionId, sourceThreadId, sessionId, th
         text,
     ].join('\n');
 }
-// Project channel, project directory and current cwd of a session thread.
-export async function threadProject(bot, thread) {
-    const channelId = thread.parentId;
+// Project channel, project directory and current cwd of a conversation's root session.
+export async function conversationProject(bot, conversation) {
+    const channelId = projectChannelOf(conversation);
     if (!channelId)
-        return new DiscordError({ operation: `find the channel of thread ${thread.id}` });
+        return new DiscordError({ operation: `find the channel of conversation ${conversation.id}` });
     const row = await projectOf(bot, channelId);
     if (row instanceof Error)
         return row;
     if (!row)
         return new DiscordError({ operation: `find the project of channel ${channelId}` });
-    const sessionId = rootSession(bot, thread.id);
+    const sessionId = rootSession(bot, conversation.id);
     if (sessionId instanceof Error)
         return sessionId;
     const directory = await sessionDirectory(bot, sessionId);
@@ -54,8 +54,8 @@ export async function threadProject(bot, thread) {
 }
 // /cwd and `kimaki session cwd`: show the cwd, or move the session to a
 // project subfolder or linked worktree.
-export async function sessionCwd(bot, { thread, directory }) {
-    const project = await threadProject(bot, thread);
+export async function sessionCwd(bot, { conversation, directory }) {
+    const project = await conversationProject(bot, conversation);
     if (project instanceof Error)
         return project;
     if (!directory)
@@ -69,7 +69,7 @@ export async function sessionCwd(bot, { thread, directory }) {
     const plugin = await bot.features.waitForPlugin(destination);
     if (plugin instanceof Error)
         return plugin;
-    const sessionId = rootSession(bot, thread.id);
+    const sessionId = rootSession(bot, conversation.id);
     if (sessionId instanceof Error)
         return sessionId;
     const moved = await oc(bot, 'session.move', (client) => client.session.move({ sessionID: sessionId, directory: destination, delivery: 'steer' }));
@@ -95,7 +95,8 @@ export async function catalogReady(bot, directory) {
     if (ready instanceof Error)
         return ready;
 }
-// Agents a session may switch to (not subagents, not hidden ones).
+// Agents a session may switch to (not subagents, not hidden ones). OpenCode lists
+// its default agent (`default_agent`, else build) first: core/src/agent.ts `list`.
 export async function primaryAgents(bot, directory) {
     const ready = await catalogReady(bot, directory);
     if (ready instanceof Error)
@@ -105,6 +106,22 @@ export async function primaryAgents(bot, directory) {
         return agents;
     return agents.data.filter((agent) => agent.mode !== 'subagent' && !agent.hidden);
 }
+// What a new session of the channel starts with: its project folder, and the channel agent or OpenCode's default agent.
+export async function channelDefaults(bot, channelId) {
+    const row = await bot.db.query.channel_directories
+        .findFirst({ where: { channel_id: channelId }, with: { channel_agent: true } })
+        .catch((cause) => new DbError({ operation: 'read channel defaults', cause }));
+    if (row instanceof Error)
+        return row;
+    if (!row)
+        return null;
+    if (row.channel_agent)
+        return { projectDirectory: row.directory, defaultAgent: row.channel_agent.agent_name };
+    const agents = await primaryAgents(bot, row.directory);
+    if (agents instanceof Error)
+        return agents;
+    return { projectDirectory: row.directory, defaultAgent: agents[0]?.id ?? null };
+}
 export async function agentSelection(bot, { directory, agent }) {
     const agents = await primaryAgents(bot, directory);
     if (agents instanceof Error)
@@ -116,10 +133,17 @@ export async function agentSelection(bot, { directory, agent }) {
     return { agent: selected.id, model };
 }
 // OpenCode switches the agent and model separately, including the configured variant.
-export async function switchAgent(bot, { sessionId, directory, agent, model }) {
+export async function switchAgent(bot, { sessionId, directory, agent, model, reselect = false, }) {
     const selected = await agentSelection(bot, { directory, agent });
     if (selected instanceof Error)
         return selected;
+    // naming the session's current agent again (agents pass --agent <current_agent>
+    // on every send) keeps the model the session runs on, e.g. one set with /model.
+    if (!model && !reselect) {
+        const info = await oc(bot, 'session.get', (client) => client.session.get({ sessionID: sessionId }));
+        if (!(info instanceof Error) && info.agent === selected.agent)
+            return { ...selected, model: null };
+    }
     const choice = model ?? selected.model;
     if (choice) {
         const switched = await oc(bot, 'session.switchModel', (client) => client.session.switchModel({
@@ -135,8 +159,8 @@ export async function switchAgent(bot, { sessionId, directory, agent, model }) {
     return { ...selected, model: choice };
 }
 // The one durable system instruction of a session (spec 5.4).
-async function putInstructions(bot, { sessionId, thread, channel, directory, userId, parentSessionId = null, scheduledTask = null, }) {
-    // The agent list is optional prompt context: a failure must not strand the thread.
+async function putInstructions(bot, { sessionId, conversation, channel, directory, userId, parentSessionId = null, scheduledTask = null, }) {
+    // The agent list is optional prompt context: a failure must not strand the conversation.
     const found = await primaryAgents(bot, directory);
     if (found instanceof Error)
         logger.warn(`agent list for instructions failed`, found);
@@ -144,7 +168,7 @@ async function putInstructions(bot, { sessionId, thread, channel, directory, use
     const agents = found instanceof Error ? [] : found.map((agent) => ({ name: agent.id, description: agent.description ?? '' }));
     const value = baseInstructions({
         sessionId,
-        threadId: thread.id,
+        threadId: conversation.id,
         channelId: channel.id,
         guildId: channel.guildId,
         userId,
@@ -153,6 +177,9 @@ async function putInstructions(bot, { sessionId, thread, channel, directory, use
         agents,
         parentSessionId,
         scheduledTask,
+        // Derived from where the session lives, never from bindings that can be stale.
+        coordinator: conversation.id === channel.id,
+        disabled: bot.disabledPrompt,
     });
     const put = await oc(bot, 'instructions.entry.put', (client) => client.session.instructions.entry.put({ sessionID: sessionId, key: INSTRUCTION_KEY, value }));
     if (put instanceof Error)
@@ -171,6 +198,7 @@ export function createPluginWait(bot) {
             return;
         const location = { directory };
         const deadline = Date.now() + 10_000;
+        let loadError;
         while (Date.now() < deadline) {
             const endpoint = bot.opencode.endpoint;
             if (!endpoint)
@@ -190,8 +218,18 @@ export function createPluginWait(bot) {
                 active.set(endpoint, (active.get(endpoint) ?? new Set()).add(directory));
                 return;
             }
+            // A plugin that fails to load has no ID: find the shim directory by its path.
+            const failed = plugins.data.find((plugin) => plugin.source.type === 'local' && path.basename(plugin.source.path) === 'kimaki');
+            loadError = failed?.state.status === 'failed' ? (failed.state.ref ?? failed.state.error) : undefined;
             await sleep(200);
         }
+        if (loadError) {
+            // TODO: remove the restart hint once OpenCode's Bun evicts failed ESM loads; Bun 1.4.4 keeps
+            // them forever, so a reload during `pnpm build` stays broken after the build ends.
+            return new ConfigError({
+                reason: `Kimaki plugin failed to load in OpenCode (${loadError}); the OpenCode log has the cause. If it names code that no longer exists, OpenCode kept a stale failed load: run \`opencode service restart\``,
+            });
+        }
         return new ConfigError({
             reason: `Kimaki plugin is not active in OpenCode for ${directory}. Kimaki writes it to <OpenCode config dir>/plugins/kimaki/ on start; check \`opencode plugin list\` and the OpenCode logs`,
         });
@@ -202,7 +240,7 @@ export function createPluginWait(bot) {
 // entry; sessions of an older bot run point at its old lock port. Checked
 // on each input instead of for every binding at startup (a V1 install has
 // thousands of bindings).
-export async function ensureSessionMarker(bot, { sessionId, thread, channelId, directory, userId, }) {
+export async function ensureSessionMarker(bot, { sessionId, conversation, channelId, directory, userId, }) {
     const plugin = await bot.features.waitForPlugin(directory);
     if (plugin instanceof Error)
         return plugin;
@@ -210,19 +248,19 @@ export async function ensureSessionMarker(bot, { sessionId, thread, channelId, d
     if (info instanceof Error)
         return info;
     const marker = readMarker(info.metadata);
-    if (marker && markerIsCurrent(bot, marker))
+    if (marker && marker.dataDir === bot.dataDir && marker.lockPort === bot.lockPort)
         return;
     // Instructions first: the marker means "set up", so a failure here is retried on the next input.
     if (!marker) {
-        logger.log(`adopting legacy session ${sessionId} of thread ${thread.id}`);
+        logger.log(`adopting legacy session ${sessionId} of conversation ${conversation.id}`);
         const channel = await textChannel(bot, channelId);
         if (channel instanceof Error)
             return channel;
-        const instructions = await putInstructions(bot, { sessionId, thread, channel, directory, userId });
+        const instructions = await putInstructions(bot, { sessionId, conversation, channel, directory, userId });
         if (instructions instanceof Error)
             return instructions;
     }
-    const kimaki = { ...marker?.fields, source: 'discord', ...cliContext(bot), threadId: thread.id, channelId };
+    const kimaki = { ...marker?.fields, source: 'discord', ...cliContext(bot), threadId: conversation.id, channelId };
     const updated = await oc(bot, 'session.update', (client) => client.session.update({ sessionID: sessionId, metadata: { ...info.metadata, kimaki } }));
     if (updated instanceof Error)
         return updated;
@@ -243,7 +281,7 @@ export async function refreshCliContext(bot) {
         const marker = readMarker(info.metadata);
         if (!marker)
             continue;
-        if (markerIsCurrent(bot, marker))
+        if (marker.dataDir === bot.dataDir && marker.lockPort === bot.lockPort)
             continue;
         const metadata = { ...info.metadata, kimaki: { ...marker.fields, ...cliContext(bot) } };
         const result = await oc(bot, 'refresh Kimaki CLI context', (client) => client.session.update({ sessionID: sessionId, metadata }));
@@ -251,7 +289,24 @@ export async function refreshCliContext(bot) {
             return result;
     }
 }
-export async function startSession(bot, { channelId, directory: requestedDirectory, route, author, messageId, startMessageId = messageId, showInput = startMessageId === null, threadName: explicitName, files = [], model: explicitModel, permissions, parentSessionId, task, worktree, baseBranch, run = true, }) {
+// Agent and model of a new session: an agent the input asked for, else the
+// channel agent; the model from the input, that agent, the channel, the global default.
+async function agentAndModel(bot, { defaults, route, directory, explicitModel }) {
+    const requestedAgent = (route.kind === 'steer' && route.agent) || defaults?.channel_agent?.agent_name;
+    const selected = requestedAgent ? await agentSelection(bot, { directory, agent: requestedAgent }) : null;
+    if (selected instanceof Error)
+        return selected;
+    const agentModel = route.kind === 'steer' && route.agent ? selected?.model : null;
+    const global = await globalModel(bot);
+    if (global instanceof Error)
+        return global;
+    const choice = explicitModel ?? agentModel ?? parseModel(defaults?.channel_model?.model_id, defaults?.channel_model?.variant) ?? selected?.model ?? global;
+    const model = choice
+        ? { providerID: choice.providerID, id: choice.id, ...(choice.variant && { variant: choice.variant }) }
+        : undefined;
+    return { model, agent: selected?.agent };
+}
+export async function startSession(bot, { channelId, directory: requestedDirectory, route, author, members = [], messageId, startMessageId = messageId, showInput = startMessageId === null, threadName: explicitName, files = [], model: explicitModel, permissions, parentSessionId, sender, task, worktree, baseBranch, run = true, }) {
     const defaults = await bot.db.query.channel_directories
         .findFirst({ where: { channel_id: channelId }, with: { channel_model: true, channel_agent: true, channel_worktree: true } })
         .catch((cause) => new DbError({ operation: 'read channel defaults', cause }));
@@ -262,7 +317,7 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
     const useWorktree = typeof worktree === 'string' || (worktree !== false && channelWorktrees);
     const textSlug = text.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40).replace(/^-|-$/g, '') || 'session';
     const slug = typeof worktree === 'string' && worktree ? worktree : `${textSlug}-${crypto.randomBytes(4).toString('hex')}`;
-    const threadName = explicitName ?? (useWorktree ? `⬦ ${slug}` : text.replace(/\s+/g, ' ').slice(0, 80) || 'Kimaki session');
+    const threadName = explicitName ?? (useWorktree ? slug : text.replace(/\s+/g, ' ').slice(0, 80) || 'Kimaki session');
     // The thread shows in Discord while the checkout, plugin, agent and model are resolved.
     const creating = (async () => {
         const channel = await textChannel(bot, channelId);
@@ -273,9 +328,12 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
             .catch((cause) => new DiscordError({ operation: 'create thread', cause }));
         if (thread instanceof Error)
             return thread;
-        // Discord only adds the thread creator (the bot); the user must be added to see it in the sidebar.
-        if (author.id !== bot.discord.user?.id)
-            await thread.members.add(author.id).catch((e) => logger.warn(`add member`, e));
+        // Discord only adds the thread creator (the bot); users must be added to see it in the sidebar.
+        // Not awaited: the session does not need them, and each add is a Discord round trip.
+        for (const id of new Set([author.id, ...members])) {
+            if (id !== bot.discord.user?.id)
+                void thread.members.add(id).catch((e) => logger.warn(`add member ${id}`, e));
+        }
         return { channel, thread };
     })();
     const setup = await (async () => {
@@ -288,19 +346,10 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
         const plugin = await bot.features.waitForPlugin(directory);
         if (plugin instanceof Error)
             return plugin;
-        const requestedAgent = (route.kind === 'steer' && route.agent) || defaults?.channel_agent?.agent_name;
-        const selected = requestedAgent ? await agentSelection(bot, { directory, agent: requestedAgent }) : null;
-        if (selected instanceof Error)
-            return selected;
-        const agentModel = route.kind === 'steer' && route.agent ? selected?.model : null;
-        const global = await globalModel(bot);
-        if (global instanceof Error)
-            return global;
-        const choice = explicitModel ?? agentModel ?? parseModel(defaults?.channel_model?.model_id, defaults?.channel_model?.variant) ?? selected?.model ?? global;
-        const model = choice
-            ? { providerID: choice.providerID, id: choice.id, ...(choice.variant && { variant: choice.variant }) }
-            : undefined;
-        return { checkout, directory, model, agent: selected?.agent };
+        const chosen = await agentAndModel(bot, { defaults, route, directory, explicitModel });
+        if (chosen instanceof Error)
+            return chosen;
+        return { checkout, directory, ...chosen };
     })();
     const created = await creating;
     if (created instanceof Error)
@@ -316,6 +365,7 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
         channelId,
         source: task ? 'task' : 'discord',
         ...(task && { taskId: task.id, task }),
+        ...(bot.warmupTimers && { warmup: bot.warmupTimers }),
         ...cliContext(bot),
         ...(parentSessionId && { parentSessionId }),
     };
@@ -332,7 +382,7 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
     bot.analytics.track('session_created', { has_worktree: Boolean(checkout), source: 'discord' });
     const instructions = await putInstructions(bot, {
         sessionId: session.id,
-        thread,
+        conversation: thread,
         channel,
         directory,
         userId: author.id,
@@ -345,9 +395,10 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
     if (bound instanceof Error)
         return bound;
     if (!run) {
+        const ready = checkout ? `Worktree ready: \`${directory}\`\nBranch: \`${checkout.branch ?? 'detached'}\`\n` : '';
         const posted = await thread
             .send({
-            content: `Worktree ready: \`${directory}\`\nBranch: \`${checkout?.branch ?? 'detached'}\`\nSend a message to start working.`,
+            content: `${ready}Send a message to start working.`,
             allowedMentions: { parse: [] },
             flags: SILENT_MESSAGE_FLAGS,
         })
@@ -359,26 +410,78 @@ export async function startSession(bot, { channelId, directory: requestedDirecto
     if (showInput) {
         const names = files.map((file) => file.name).join(', ');
         const shown = names ? `${text}\nFiles: ${names}` : text;
-        const echo = await thread
-            .send({ content: formatEcho({ username: author.username, text: shown }), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
-            .catch((cause) => new DiscordError({ operation: 'send first input', cause }));
-        if (echo instanceof Error)
-            return echo;
+        // Through the thread's effect queue, so the prompt does not wait for Discord,
+        // the echo comes before the session output and a long prompt is split.
+        bot.effects.run(thread.id, [{ type: 'send', text: formatEcho({ username: author.username, text: shown }), echo: true }]);
     }
-    const first = route.kind === 'steer' ? { kind: 'steer', text: route.text } : route;
+    const base = { sessionId: session.id, threadId: thread.id, threadName, author, messageId, files, sender };
+    // A new session has no run, question or permission to cancel: prompt directly instead of steer().
+    const sent = route.kind === 'steer'
+        ? await prompt(bot, { ...base, text: route.text, delivery: 'steer' })
+        : await runInSession(bot, { ...base, directory, route });
+    if (sent instanceof Error)
+        return sent;
+    return { threadId: thread.id, sessionId: session.id };
+}
+// The first message of a coordinator channel: one long session that lives in the
+// channel itself, bound like a thread with the channel ID as its conversation.
+export async function startCoordinator(bot, { channel, route, author, messageId, files = [], }) {
+    const defaults = await bot.db.query.channel_directories
+        .findFirst({ where: { channel_id: channel.id }, with: { channel_model: true, channel_agent: true } })
+        .catch((cause) => new DbError({ operation: 'read channel defaults', cause }));
+    if (defaults instanceof Error)
+        return defaults;
+    if (!defaults)
+        return new ConfigError({ reason: 'This channel is not configured with a project directory' });
+    const directory = defaults.directory;
+    const plugin = await bot.features.waitForPlugin(directory);
+    if (plugin instanceof Error)
+        return plugin;
+    const chosen = await agentAndModel(bot, { defaults, route, directory });
+    if (chosen instanceof Error)
+        return chosen;
+    const title = `coordinator: ${channel.name}`;
+    const session = await oc(bot, 'session.create', (client) => client.session.create({
+        title,
+        location: { directory },
+        ...(chosen.model && { model: chosen.model }),
+        ...(chosen.agent && { agent: chosen.agent }),
+        permissions: [NO_QUESTION_TOOL, ...disabledSkillRules(bot.disabledSkills)],
+        metadata: { kimaki: { threadId: channel.id, channelId: channel.id, source: 'discord', ...(bot.warmupTimers && { warmup: bot.warmupTimers }), ...cliContext(bot) } },
+    }));
+    if (session instanceof Error)
+        return session;
+    bot.analytics.track('session_created', { has_worktree: false, source: 'discord' });
+    const instructions = await putInstructions(bot, { sessionId: session.id, conversation: channel, channel, directory, userId: author.id });
+    if (instructions instanceof Error)
+        return instructions;
+    const bound = await bindThread(bot, { threadId: channel.id, sessionId: session.id, channelId: channel.id, directory, isNew: true });
+    if (bound instanceof Error)
+        return bound;
     const sent = await runInSession(bot, {
         sessionId: session.id,
-        threadId: thread.id,
-        threadName,
+        threadId: channel.id,
+        threadName: channel.name,
         directory,
-        route: first,
+        route,
         author,
         messageId,
         files,
     });
     if (sent instanceof Error)
         return sent;
-    return { threadId: thread.id, sessionId: session.id };
+    return { threadId: channel.id, sessionId: session.id };
+}
+// /reset-coordinator: the channel forgets its coordinator. The next message starts a fresh
+// one; the old session stays in OpenCode for /resume.
+export async function endCoordinator(bot, channelId) {
+    const deleted = await bot.db
+        .delete(schema.thread_sessions)
+        .where(orm.eq(schema.thread_sessions.thread_id, channelId))
+        .catch((cause) => new DbError({ operation: 'delete coordinator binding', cause }));
+    if (deleted instanceof Error)
+        return deleted;
+    bot.eventLoop.unbind(channelId);
 }
 // --- Sessions that get a new thread: /resume, /fork, /fork-subagent, btw.
 // Binds an existing session to a new thread. Order matters:
@@ -415,7 +518,7 @@ async function adoptSession(bot, { channel, session, threadName, intro, note, au
             return marked;
         const instructions = await putInstructions(bot, {
             sessionId,
-            thread,
+            conversation: thread,
             channel,
             directory: session.location.directory,
             userId: author.id,
@@ -519,8 +622,8 @@ export async function resume(bot, { channelId, sessionId, author }) {
 }
 // Forks the thread's session (or one of its subagent sessions) into a new
 // thread. `before`: a user message ID; the fork ends right before it.
-export async function fork(bot, { sourceThread, sessionId, before, subagent, name, author, worktree, }) {
-    const root = rootSession(bot, sourceThread.id);
+export async function fork(bot, { source, sessionId, before, subagent, name, author, worktree, }) {
+    const root = rootSession(bot, source.id);
     if (root instanceof Error)
         return root;
     if (sessionId !== root) {
@@ -531,7 +634,7 @@ export async function fork(bot, { sourceThread, sessionId, before, subagent, nam
             return new ConfigError({ reason: "This session is not the thread's root or a direct subagent. Run /fork or /fork-subagent in the session's own thread." });
         }
     }
-    const project = await threadProject(bot, sourceThread);
+    const project = await conversationProject(bot, source);
     if (project instanceof Error)
         return project;
     const channel = await textChannel(bot, project.channelId);
@@ -579,13 +682,13 @@ export async function fork(bot, { sourceThread, sessionId, before, subagent, nam
     }
     const intro = subagent
         ? `**Forked subagent session created!**\nAgent: \`${subagent.agent}\`\nTask: ${subagent.description || 'No description'}\nFrom: \`${sessionId}\`\nNew session: \`${forked.id}\``
-        : `**Forked session created!**\nFrom: <#${sourceThread.id}> (\`${sessionId}\`)\nNew session: \`${forked.id}\``;
+        : `**Forked session created!**\nFrom: <#${source.id}> (\`${sessionId}\`)\nNew session: \`${forked.id}\``;
     return adoptSession(bot, {
         channel,
         session: relocated,
         discard,
         // OpenCode titles forks "<title> (fork #1)".
-        threadName: name ?? (forked.title || `Fork: ${subagent?.description || sourceThread.name}`),
+        threadName: name ?? (forked.title || `Fork: ${subagent?.description || source.name}`),
         intro,
         note: 'You can now continue the conversation from this point.',
         author,
@@ -594,18 +697,18 @@ export async function fork(bot, { sourceThread, sessionId, before, subagent, nam
 // Fork the whole session into a new "btw:" thread that answers one side
 // question (V1 /btw). The source session keeps running. The fork inherits
 // messages, agent, model and instructions, so its prompt cache is warm.
-export async function forkBtw(bot, { sourceThread, text, author, messageId, files = [], agent, }) {
-    const parentSessionId = rootSession(bot, sourceThread.id);
-    if (parentSessionId instanceof Error)
-        return parentSessionId;
-    const project = await threadProject(bot, sourceThread);
+export async function forkBtw(bot, { source, text, author, messageId, files = [], agent, parentSessionId, sender, }) {
+    const sourceSessionId = rootSession(bot, source.id);
+    if (sourceSessionId instanceof Error)
+        return sourceSessionId;
+    const project = await conversationProject(bot, source);
     if (project instanceof Error)
         return project;
     const channel = await textChannel(bot, project.channelId);
     if (channel instanceof Error)
         return channel;
     const [forked, thread] = await Promise.all([
-        oc(bot, 'session.fork', (client) => client.session.fork({ sessionID: parentSessionId })),
+        oc(bot, 'session.fork', (client) => client.session.fork({ sessionID: sourceSessionId })),
         channel.threads
             .create({ name: `btw: ${text.replace(/\s+/g, ' ')}`.slice(0, 100), autoArchiveDuration: 1440 })
             .catch((cause) => new DiscordError({ operation: 'create btw thread', cause })),
@@ -622,10 +725,18 @@ export async function forkBtw(bot, { sourceThread, text, author, messageId, file
             logger.warn(`discard btw fork ${forked.id}`, removed);
         return thread;
     }
-    const kimaki = { threadId: thread.id, channelId: project.channelId, source: 'discord', ...cliContext(bot) };
+    const kimaki = { threadId: thread.id, channelId: project.channelId, source: 'discord', ...cliContext(bot), ...(parentSessionId && { parentSessionId }) };
+    const fromCoordinator = !source.isThread();
     const marked = await oc(bot, 'session.update', (client) => client.session.update({ sessionID: forked.id, metadata: { kimaki } }));
     if (marked instanceof Error)
         return marked;
+    // A fork of a thread keeps its copied instructions (prompt cache); a fork of a coordinator gets thread
+    // ones. The plugin makes it a worker (plugin/coordinator.ts).
+    if (fromCoordinator) {
+        const instructions = await putInstructions(bot, { sessionId: forked.id, conversation: thread, channel, directory: project.directory, userId: author.id, parentSessionId: sourceSessionId });
+        if (instructions instanceof Error)
+            return instructions;
+    }
     const bound = await bindThread(bot, {
         threadId: thread.id,
         sessionId: forked.id,
@@ -637,7 +748,7 @@ export async function forkBtw(bot, { sourceThread, text, author, messageId, file
         return bound;
     await thread.members.add(author.id).catch((e) => logger.warn(`add btw member`, e));
     const intro = await thread
-        .send({ content: `Reusing context from <#${sourceThread.id}> to answer prompt...\n${text}`.slice(0, 2_000), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
+        .send({ content: `Reusing context from <#${source.id}> to answer prompt...\n${text}`.slice(0, 2_000), allowedMentions: { parse: [] }, flags: SILENT_MESSAGE_FLAGS })
         .catch((cause) => new DiscordError({ operation: 'send btw intro', cause }));
     if (intro instanceof Error)
         return intro;
@@ -650,11 +761,12 @@ export async function forkBtw(bot, { sourceThread, text, author, messageId, file
         sessionId: forked.id,
         threadId: thread.id,
         threadName: thread.name,
-        text: btwPrompt({ text, parentSessionId, sourceThreadId: sourceThread.id, sessionId: forked.id, threadId: thread.id }),
+        text: btwPrompt({ text, parentSessionId: sourceSessionId, sourceThreadId: source.id, sessionId: forked.id, threadId: thread.id }),
         author,
         messageId,
         delivery: 'steer',
         files,
+        sender,
     });
     if (sent instanceof Error)
         return sent;