kimaki 0.30.1 → 0.31.0

package/dist/commands/context-usage.js

@@ -6,6 +6,45 @@ import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.j
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.SESSION);
+export function formatContextBreakdown({ messages, lastAssistantId, inputTokens, }) {
+    if (inputTokens <= 0)
+        return undefined;
+    const lastIndex = messages.findIndex((message) => message.info.id === lastAssistantId);
+    if (lastIndex < 0)
+        return undefined;
+    const history = messages.slice(0, lastIndex);
+    const compactIndex = history.findLastIndex((message) => message.parts.some((part) => part.type === 'compaction'));
+    const active = history.slice(compactIndex < 0 ? 0 : compactIndex + 1);
+    const system = [...active].reverse().find((message) => message.info.role === 'user' && message.info.system);
+    const systemChars = system?.info.role === 'user' ? system.info.system?.length ?? 0 : 0;
+    const toolChars = new Map();
+    for (const message of active) {
+        if (message.info.role !== 'assistant')
+            continue;
+        for (const part of message.parts) {
+            if (part.type !== 'tool')
+                continue;
+            const output = part.state.status === 'completed' && !part.state.time.compacted
+                ? part.state.output
+                : part.state.status === 'error' ? part.state.error : '';
+            const chars = JSON.stringify(part.state.input).length + output.length;
+            toolChars.set(part.tool, (toolChars.get(part.tool) ?? 0) + chars);
+        }
+    }
+    const estimates = [
+        { name: 'system', tokens: Math.ceil(systemChars / 4) },
+        ...[...toolChars].map(([name, chars]) => ({ name: `tool ${name}`, tokens: Math.ceil(chars / 4) })),
+    ].sort((a, b) => b.tokens - a.tokens);
+    const estimated = estimates.reduce((total, entry) => total + entry.tokens, 0);
+    const scale = estimated > inputTokens ? inputTokens / estimated : 1;
+    const visible = estimates.slice(0, 5).map((entry) => ({
+        name: entry.name,
+        tokens: Math.floor(entry.tokens * scale),
+    }));
+    const other = inputTokens - visible.reduce((total, entry) => total + entry.tokens, 0);
+    const format = ({ name, tokens }) => `${name} ${(tokens / inputTokens * 100).toFixed(1)}% (${tokens.toLocaleString('en-US')})`;
+    return `**Estimated input mix:** ${[...visible.filter((entry) => entry.tokens > 0), { name: 'other', tokens: other }].map(format).join(' · ')} tokens (other includes messages and unexposed prompts)`;
+}
 function getTokenTotal({ input, output, reasoning, cache, }) {
     return input + output + reasoning + cache.read + cache.write;
 }
@@ -96,6 +135,7 @@ export async function handleContextUsageCommand({ command, }) {
         }
         const { tokens, modelID, providerID } = lastAssistant.info;
         const totalTokens = getTokenTotal(tokens);
+        const inputTokens = tokens.input + tokens.cache.read + tokens.cache.write;
         // Sum cost across all assistant messages for accurate session total
         // (AssistantMessage.cost is per-message, not cumulative)
         const totalCost = assistantMessages.reduce((sum, m) => {
@@ -129,6 +169,13 @@ export async function handleContextUsageCommand({ command, }) {
         else {
             lines.push(`**Context usage:** ${formattedTokens} tokens (context limit unavailable)`);
         }
+        const breakdown = formatContextBreakdown({
+            messages,
+            lastAssistantId: lastAssistant.info.id,
+            inputTokens,
+        });
+        if (breakdown)
+            lines.push(breakdown);
         if (modelID) {
             lines.push(`**Model:** ${modelID}`);
         }

package/dist/commands/context-usage.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import { formatContextBreakdown } from './context-usage.js';
+const part = (messageID, value) => ({
+    id: `part-${messageID}`,
+    sessionID: 'session',
+    messageID,
+    ...value,
+});
+const user = (id, system) => ({
+    id, sessionID: 'session', role: 'user', time: { created: 1 },
+    agent: 'build', model: { providerID: 'test', modelID: 'test' }, system,
+});
+const assistant = (id, input) => ({
+    id, sessionID: 'session', role: 'assistant', time: { created: 2 },
+    parentID: 'user', modelID: 'test', providerID: 'test', mode: 'build',
+    agent: 'build', path: { cwd: '/', root: '/' }, cost: 0,
+    tokens: { input, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
+});
+describe('formatContextBreakdown', () => {
+    test('attributes tool call inputs and outputs by type, and excludes the response to the measured prompt', () => {
+        const messages = [
+            { info: user('user', 's'.repeat(40)), parts: [part('user', { type: 'text', text: 'u'.repeat(20) })] },
+            { info: assistant('first', 20), parts: [
+                    part('first', { type: 'tool', tool: 'read', callID: 'call', state: {
+                            status: 'completed', input: { filePath: 'a'.repeat(28) }, output: 'o'.repeat(40),
+                            title: 'read', metadata: {}, time: { start: 1, end: 2 },
+                        } }),
+                ] },
+            { info: assistant('last', 50), parts: [part('last', { type: 'text', text: 'x'.repeat(800) })] },
+        ];
+        expect(formatContextBreakdown({ messages, lastAssistantId: 'last', inputTokens: 50 }))
+            .toMatchInlineSnapshot(`"**Estimated input mix:** tool read 42.0% (21) · system 20.0% (10) · other 38.0% (19) tokens (other includes messages and unexposed prompts)"`);
+    });
+    test('ignores compacted history and old tool outputs', () => {
+        const messages = [
+            { info: user('old', 'x'.repeat(800)), parts: [part('old', { type: 'text', text: 'x'.repeat(800) })] },
+            { info: assistant('old-answer', 30), parts: [part('old-answer', { type: 'tool', tool: 'bash', callID: 'old', state: {
+                            status: 'completed', input: {}, output: 'x'.repeat(800), title: 'old', metadata: {},
+                            time: { start: 1, end: 2, compacted: 3 },
+                        } })] },
+            { info: user('compact'), parts: [part('compact', { type: 'compaction', auto: true })] },
+            { info: assistant('summary', 20), parts: [part('summary', { type: 'text', text: 'summary'.repeat(8) })] },
+            { info: user('new', 's'.repeat(20)), parts: [part('new', { type: 'text', text: 'u'.repeat(20) })] },
+            { info: assistant('last', 40), parts: [] },
+        ];
+        expect(formatContextBreakdown({ messages, lastAssistantId: 'last', inputTokens: 40 }))
+            .toMatchInlineSnapshot(`"**Estimated input mix:** system 12.5% (5) · other 87.5% (35) tokens (other includes messages and unexposed prompts)"`);
+    });
+});

package/dist/commands/fork.js

@@ -5,6 +5,8 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, sendSessionPartBatches, } from '../discord-utils.js';
 import { collectSessionChunks, batchChunksForDiscord, } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { copySessionPreferences } from './model.js';
+import { copySessionSystemPrompt } from '../system-message.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
 const forkLogger = createLogger(LogPrefix.FORK);
@@ -224,7 +226,36 @@ export async function handleForkSelectMenu(interaction) {
         });
         // Claim the forked session immediately so external polling does not race
         // and create a duplicate Sync thread before the rest of this setup runs.
-        await setThreadSession(thread.id, forkedSession.id);
+        // Same agent, model and pinned system prompt keep the source prompt cache.
+        const [, , copiedSystem] = await Promise.all([
+            setThreadSession(thread.id, forkedSession.id),
+            copySessionPreferences({
+                sourceSessionId: sessionId,
+                targetSessionId: forkedSession.id,
+                channelId: textChannel.id,
+                appId: interaction.applicationId,
+                getClient,
+                directory: projectDirectory,
+            }),
+            copySessionSystemPrompt({
+                sourceSessionId: sessionId,
+                targetSessionId: forkedSession.id,
+            }),
+        ]);
+        // `false` (source not pinned yet) is the only fallback; I/O errors fail setup.
+        if (copiedSystem instanceof Error) {
+            forkLogger.error(`Could not pin source system prompt on fork ${forkedSession.id}:`, copiedSystem);
+            await Promise.all([
+                thread.delete('fork setup failed').catch((error) => {
+                    forkLogger.warn(`Could not delete orphan fork thread ${thread.id}:`, error);
+                }),
+                getClient().session.delete({ sessionID: forkedSession.id }).catch((error) => {
+                    forkLogger.warn(`Could not delete orphan fork session ${forkedSession.id}:`, error);
+                }),
+            ]);
+            await interaction.editReply(`Failed to fork session: could not copy the source system prompt (${copiedSystem.message})`);
+            return;
+        }
         // Add user to thread so it appears in their sidebar
         await thread.members.add(interaction.user.id);
         const sourceThreadLink = `<#${threadChannel.id}>`;

package/dist/commands/model.js

@@ -6,9 +6,11 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getDefaultModel, resolveDisplayedModelId, } from '../session-handler/model-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { resolveAgentPreference } from '../session-handler/agent-utils.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { OpenCodeSdkError } from '../errors.js';
 import * as errore from 'errore';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
@@ -123,27 +125,80 @@ export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, a
     });
     modelLogger.log(`[MODEL] Snapshotted session model ${bootstrappedModel.model} for session ${sessionId}`);
 }
-export async function copyCurrentSessionModel({ sourceSessionId, targetSessionId, channelId, appId, getClient, directory, }) {
-    const modelInfo = await getCurrentModelInfo({
-        sessionId: sourceSessionId,
-        channelId,
-        appId,
-        getClient,
-        directory,
-    });
+const LAST_USER_AGENT_PAGE_SIZE = 50;
+const LAST_USER_AGENT_MAX_PAGES = 10;
+/**
+ * Agent of the newest user message in a session, paging back from the end.
+ * Long agentic turns hold many assistant messages after one user message.
+ */
+async function getLastUserMessageAgent({ getClient, sessionId, directory, before, page = 0, }) {
+    if (page >= LAST_USER_AGENT_MAX_PAGES)
+        return undefined;
+    const response = await (async () => {
+        return getClient().session.messages({
+            sessionID: sessionId,
+            directory,
+            limit: LAST_USER_AGENT_PAGE_SIZE,
+            before,
+        });
+    })().catch((cause) => new OpenCodeSdkError({ operation: 'session.messages', cause }));
+    if (response instanceof Error)
+        return response;
+    if (response.error || !response.data) {
+        return new OpenCodeSdkError({ operation: 'session.messages', cause: response.error });
+    }
+    const newestUser = response.data
+        .map((message) => message.info)
+        .filter((info) => info.role === 'user')
+        .sort((a, b) => b.time.created - a.time.created)[0];
+    if (newestUser?.role === 'user')
+        return newestUser.agent;
+    const cursor = response.response.headers.get('X-Next-Cursor');
+    if (!cursor)
+        return undefined;
+    return getLastUserMessageAgent({ getClient, sessionId, directory, before: cursor, page: page + 1 });
+}
+/**
+ * Copy the agent, model and variant onto a forked session. The fork must run
+ * the same agent and model as the source: a different agent changes tools and
+ * prompts, which busts the prompt cache. The agent comes from the fork's own
+ * history (the fork point, also right for /fork at an earlier message), with
+ * the source DB preference as fallback.
+ */
+export async function copySessionPreferences({ sourceSessionId, targetSessionId, channelId, appId, getClient, directory, }) {
+    const [historyAgent, preferredAgent, modelInfo, variant] = await Promise.all([
+        getClient instanceof Error
+            ? undefined
+            : getLastUserMessageAgent({ getClient, sessionId: targetSessionId, directory }),
+        resolveAgentPreference({ sessionId: sourceSessionId, channelId }),
+        getCurrentModelInfo({
+            sessionId: sourceSessionId,
+            channelId,
+            appId,
+            getClient,
+            directory,
+        }),
+        getVariantCascade({
+            sessionId: sourceSessionId,
+            channelId,
+            appId,
+        }),
+    ]);
+    if (historyAgent instanceof Error) {
+        modelLogger.warn(`[MODEL] Could not read fork history agent for ${targetSessionId}, using DB preference: ${historyAgent.message}`);
+    }
+    const agent = (historyAgent instanceof Error ? undefined : historyAgent) || preferredAgent;
+    if (agent) {
+        await setSessionAgent(targetSessionId, agent);
+    }
     if (modelInfo.type === 'none')
         return;
-    const variant = await getVariantCascade({
-        sessionId: sourceSessionId,
-        channelId,
-        appId,
-    });
     await setSessionModel({
         sessionId: targetSessionId,
         modelId: modelInfo.model,
         variant: variant ?? null,
     });
-    modelLogger.log(`[MODEL] Copied session model ${modelInfo.model} from ${sourceSessionId} to ${targetSessionId}`);
+    modelLogger.log(`[MODEL] Copied session agent ${agent ?? 'default'} and model ${modelInfo.model} from ${sourceSessionId} to ${targetSessionId}`);
 }
 /**
  * Get the current model info for a channel/session, including where it comes from.

package/dist/commands/new-worktree.js

@@ -15,7 +15,7 @@ import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
-import { copyCurrentSessionModel } from './model.js';
+import { copySessionPreferences } from './model.js';
 const logger = createLogger(LogPrefix.WORKTREE);
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
     if (!rawBaseBranch) {
@@ -551,7 +551,10 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
                 await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
                 return;
             }
-            await copyCurrentSessionModel({
+            // No system prompt copy: OpenCode's env block (cwd) precedes the kimaki
+            // system prompt, so a fork into another directory never shares the
+            // source cache prefix. The fork pins its own prompt on its first turn.
+            await copySessionPreferences({
                 sourceSessionId,
                 targetSessionId: forkedSession.id,
                 channelId: parent.id,

package/dist/commands/queue.js

@@ -6,6 +6,7 @@ import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils
 import { getOrCreateRuntime, getRuntime, } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { asSubtext, QUEUE_PREFIX } from '../message-formatting.js';
+import { extractBtwQueueSuffix } from '../btw-prefix-detection.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
 export const QUEUE_REMOVE_CUSTOM_ID_PREFIX = 'queue_remove:';
@@ -52,6 +53,19 @@ function buildQueueRemoveRow({ threadId, queueId, }) {
         .setLabel('Remove from queue')
         .setStyle(ButtonStyle.Secondary));
 }
+// Replies "Queued message" and returns the ack id, so the drain indicator can
+// reply to it. The runtime calls this inside the serialized enqueue.
+function replyQueuedAck({ command, threadId, }) {
+    return async ({ queueId, position }) => {
+        await command.reply({
+            content: asSubtext(`Queued message (position ${position})`),
+            components: [buildQueueRemoveRow({ threadId, queueId })],
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const ack = await command.fetchReply();
+        return ack.id;
+    };
+}
 export async function handleQueueRemoveButton(interaction) {
     const parsed = parseQueueRemoveCustomId(interaction.customId);
     if (!parsed) {
@@ -90,8 +104,18 @@ export async function handleQueueRemoveButton(interaction) {
     logger.log(`[QUEUE] User ${interaction.user.displayName} removed queued item ${parsed.queueId} in thread ${parsed.threadId}`);
 }
 export async function handleQueueCommand({ command, appId, }) {
-    const message = command.options.getString('message', true);
+    // /queue always queues; a typed suffix is redundant, so only strip it.
+    const rawMessage = command.options.getString('message', true);
+    const btw = extractBtwQueueSuffix(rawMessage);
+    const message = btw.prompt;
     const channel = command.channel;
+    if (!message.trim()) {
+        await command.reply({
+            content: 'Write a message to queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
     if (!channel) {
         await command.reply({
             content: 'This command can only be used in a channel',
@@ -139,23 +163,15 @@ export async function handleQueueCommand({ command, appId, }) {
     // /queue explicitly uses kimaki local queue mode.
     const enqueueResult = await runtime.enqueueIncoming({
         prompt: message,
+        queuedAction: btw.forceBtw ? 'btw' : undefined,
         userId: command.user.id,
         username: command.user.displayName,
         appId,
         mode: 'local-queue',
+        onLocalQueued: replyQueuedAck({ command, threadId: thread.id }),
     });
-    if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = asSubtext(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
-        await command.reply({
-            content: responseText,
-            components: [
-                buildQueueRemoveRow({
-                    threadId: thread.id,
-                    queueId: enqueueResult.queueId,
-                }),
-            ],
-            flags: SILENT_MESSAGE_FLAGS,
-        });
+    // onLocalQueued already posted the ack.
+    if (enqueueResult.queued) {
         return;
     }
     const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
@@ -297,19 +313,10 @@ export async function handleQueueCommandCommand({ command, appId, }) {
         appId,
         command: commandPayload,
         mode: 'local-queue',
+        onLocalQueued: replyQueuedAck({ command, threadId: thread.id }),
     });
-    if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = asSubtext(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
-        await command.reply({
-            content: responseText,
-            components: [
-                buildQueueRemoveRow({
-                    threadId: thread.id,
-                    queueId: enqueueResult.queueId,
-                }),
-            ],
-            flags: SILENT_MESSAGE_FLAGS,
-        });
+    // onLocalQueued already posted the ack.
+    if (enqueueResult.queued) {
         logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
         return;
     }

package/dist/commands/session.js

@@ -12,6 +12,7 @@ import { sendThreadMessage, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, resol
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { DiscordOperationError } from '../errors.js';
+import { extractQueueSuffix } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.SESSION);
 // Create only: callers confirm the destination before dispatching the full prompt.
 export async function createNewSessionThread({ textChannel, projectDirectory, sourceWorkspace, prompt, files = [], userId, }) {
@@ -54,10 +55,14 @@ export async function createNewSessionThread({ textChannel, projectDirectory, so
 }
 export async function handleSessionCommand({ command, appId, }) {
     await command.deferReply();
-    const prompt = command.options.getString('prompt', true);
+    const { prompt, forceQueue } = extractQueueSuffix(command.options.getString('prompt', true));
     const filesString = command.options.getString('files') || '';
     const agent = command.options.getString('agent') || undefined;
     const channel = command.channel;
+    if (!prompt.trim()) {
+        await command.editReply('Write a prompt for the new session');
+        return;
+    }
     const isThread = channel && [
         ChannelType.PublicThread,
         ChannelType.PrivateThread,
@@ -139,7 +144,7 @@ export async function handleSessionCommand({ command, appId, }) {
         username: command.user.displayName,
         agent,
         appId,
-        mode: 'opencode',
+        mode: forceQueue ? 'local-queue' : 'opencode',
     }).catch(async (error) => {
         logger.error('New session dispatch failed:', error);
         await sendThreadMessage(thread, 'Could not send the request to OpenCode. Send your request again in this thread.');

package/dist/db.test.js

@@ -7,11 +7,11 @@ import { afterAll, describe, expect, test } from 'vitest';
 import { closeDb, getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
-import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, cleanupDeletedThread, completeIpcRequest, createIpcRequest, createScheduledTask, createPendingWorkspace, deleteChannelDirectoryById, deleteThreadQueueItem, getChannelDirectory, getDueSessionSleeps, getIpcRequestById, getScheduledTask, getSessionEventSnapshot, getSessionAgent, getSessionModel, getSessionSleep, getThreadSession, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setChannelDirectory, setChannelVerbosity, setSessionAgent, setSessionModel, setThreadSession, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
 import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
-import { copyCurrentSessionModel } from './commands/model.js';
+import { copySessionPreferences } from './commands/model.js';
 afterAll(async () => {
     await closeDb();
 });
@@ -566,7 +566,9 @@ describe('getDb', () => {
         await db.delete(schema.thread_workspaces).where(orm.eq(schema.thread_workspaces.thread_id, threadId));
         await db.delete(schema.thread_sessions).where(orm.eq(schema.thread_sessions.thread_id, threadId));
     });
-    test('copyCurrentSessionModel snapshots source session model to forked session', async () => {
+    // Regression: btw forks lost the agent and ran `build` instead of the source
+    // agent, which changed tools and busted the whole prompt cache.
+    test('copySessionPreferences snapshots source session agent and model to forked session', async () => {
         const db = await getDb();
         const sourceSessionId = `test-source-session-${crypto.randomUUID()}`;
         const targetSessionId = `test-target-session-${crypto.randomUUID()}`;
@@ -578,18 +580,26 @@ describe('getDb', () => {
             modelId: 'anthropic/claude-opus-4-6',
             variant: 'thinking',
         });
-        await copyCurrentSessionModel({
+        await setSessionAgent(sourceSessionId, 'opus');
+        await copySessionPreferences({
             sourceSessionId,
             targetSessionId,
             getClient,
         });
-        await expect(getSessionModel(targetSessionId)).resolves.toMatchInlineSnapshot(`
+        expect({
+            agent: await getSessionAgent(targetSessionId),
+            model: await getSessionModel(targetSessionId),
+        }).toMatchInlineSnapshot(`
       {
-        "modelId": "anthropic/claude-opus-4-6",
-        "variant": "thinking",
+        "agent": "opus",
+        "model": {
+          "modelId": "anthropic/claude-opus-4-6",
+          "variant": "thinking",
+        },
       }
     `);
         await db.delete(schema.session_models).where(orm.inArray(schema.session_models.session_id, [sourceSessionId, targetSessionId]));
+        await db.delete(schema.session_agents).where(orm.inArray(schema.session_agents.session_id, [sourceSessionId, targetSessionId]));
     });
     test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
         const db = await getDb();