@otto-assistant/bridge 0.4.101 → 0.4.103

package/dist/agent-model.e2e.test.js

@@ -742,6 +742,7 @@ describe('agent model resolution', () => {
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2*
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg

package/dist/anthropic-auth-plugin.js

@@ -460,6 +460,20 @@ function buildAuthorizeHandler(mode) {
 function toClaudeCodeToolName(name) {
     return OPENCODE_TO_CLAUDE_CODE_TOOL_NAME[name.toLowerCase()] ?? name;
 }
+/**
+ * Strips the OpenCode identity block (from "You are OpenCode…" up to the
+ * Anthropic prompt marker "Skills provide specialized instructions") and
+ * re-injects essential environment context as a small XML tag.
+ *
+ * The original OpenCode prompt between those markers contains the current
+ * working directory and other runtime context. Stripping it wholesale loses
+ * that info, so we add back what the model needs (cwd) in a compact form.
+ *
+ * Original OpenCode Anthropic prompt structure (for reference):
+ *   "You are OpenCode, the best coding agent on the planet."
+ *   + environment block (cwd, OS, shell, date, etc.)
+ *   + "Skills provide specialized instructions …"
+ */
 function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
     if (startIdx === -1)
@@ -470,7 +484,14 @@ function sanitizeAnthropicSystemText(text, onError) {
         onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
         return text;
     }
-    return (text.slice(0, startIdx) + text.slice(endIdx)).replaceAll("opencode", "openc0de");
+    // Re-inject the process working directory that was inside the stripped block.
+    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n`;
+    // Replace all case-insensitive whole-word occurrences of "opencode" with "openc0de"
+    const result = text.slice(0, startIdx) +
+        envContext +
+        text.slice(endIdx);
+    // Use a regex with global, case-insensitive, and word boundary flags
+    return result.replace(/\bopencode\b/gi, "openc0de");
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {

package/dist/anthropic-auth-state.js

@@ -186,6 +186,37 @@ async function writeAnthropicAuthFile(auth) {
     }
     await writeJson(file, data);
 }
+function isOAuthStored(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    return (record.type === 'oauth' &&
+        typeof record.refresh === 'string' &&
+        typeof record.access === 'string' &&
+        typeof record.expires === 'number');
+}
+export async function getCurrentAnthropicAccount() {
+    const authJson = await readJson(authFilePath(), {});
+    const auth = authJson.anthropic;
+    if (!isOAuthStored(auth)) {
+        return null;
+    }
+    const store = await loadAccountStore();
+    const index = findCurrentAccountIndex(store, auth);
+    const account = store.accounts[index];
+    if (!account) {
+        return { auth };
+    }
+    if (account.refresh !== auth.refresh && account.access !== auth.access) {
+        return { auth };
+    }
+    return {
+        auth,
+        account,
+        index,
+    };
+}
 export async function setAnthropicAuth(auth, client) {
     await writeAnthropicAuthFile(auth);
     await client.auth.set({ path: { id: 'anthropic' }, body: auth });

package/dist/btw-prefix-detection.js

@@ -0,0 +1,17 @@
+// Detects the raw `btw ` Discord message shortcut used to fork a side-question
+// thread without invoking the /btw slash command UI.
+export function extractBtwPrefix(content) {
+    if (!content) {
+        return null;
+    }
+    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
+    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
+    if (!match) {
+        return null;
+    }
+    const prompt = match[1]?.trim();
+    if (!prompt) {
+        return null;
+    }
+    return { prompt };
+}

package/dist/btw-prefix-detection.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { extractBtwPrefix } from './btw-prefix-detection.js';
+describe('extractBtwPrefix', () => {
+    test('matches lowercase prefix', () => {
+        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches uppercase prefix', () => {
+        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "check this",
+      }
+    `);
+    });
+    test('keeps multiline content', () => {
+        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+      {
+        "prompt": "first line
+      second line",
+      }
+    `);
+    });
+    test('matches dot separator', () => {
+        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches comma separator', () => {
+        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches colon separator', () => {
+        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches punctuation without trailing space', () => {
+        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('does not match without separating whitespace', () => {
+        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match mid-message', () => {
+        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match empty payload', () => {
+        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    });
+});

package/dist/cli.js

@@ -10,7 +10,7 @@ import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChan
 import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, } from './database.js';
 import { ShareMarkdown } from './markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts, } from './session-search.js';
-import { formatWorktreeName } from './commands/new-worktree.js';
+import { formatWorktreeName, formatAutoWorktreeName } from './commands/new-worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { sendWelcomeMessage } from './onboarding-welcome.js';
 import { buildOpencodeEventLogLine } from './session-handler/opencode-session-event-log.js';
@@ -21,6 +21,7 @@ import { createDiscordRest, discordApiUrl, getDiscordRestApiUrl, getGatewayProxy
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import * as errore from 'errore';
 import { createLogger, formatErrorWithStack, initLogFile, LogPrefix } from './logger.js';
 import { initSentry, notifyError } from './sentry.js';
@@ -32,7 +33,7 @@ import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.
 import { startHranaServer } from './hrana-server.js';
 import { startIpcPolling, stopIpcPolling } from './ipc-polling.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, } from './task-schedule.js';
-import { accountLabel, accountsFilePath, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
+import { accountLabel, accountsFilePath, authFilePath, getCurrentAnthropicAccount, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 // Gateway bot mode constants.
 // KIMAKI_GATEWAY_APP_ID is the Discord Application ID of the gateway bot.
@@ -1287,6 +1288,14 @@ cli
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
+    .option('--enable-skill <name>', z
+    .array(z.string())
+    .optional()
+    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .option('--disable-skill <name>', z
+    .array(z.string())
+    .optional()
+    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
     .action(async (options) => {
     // Guard: only one kimaki bot process can run at a time (they share a lock
     // port). Running `kimaki` here would kill the already-running bot process
@@ -1321,13 +1330,54 @@ cli
                 process.exit(EXIT_NO_RESTART);
             }
         }
+        // --enable-skill and --disable-skill are mutually exclusive: the user
+        // either whitelists a small allowlist or blacklists a few unwanted
+        // skills, never both. Applied later in opencode.ts as permission.skill
+        // rules via computeSkillPermission().
+        const enabledSkills = options.enableSkill ?? [];
+        const disabledSkills = options.disableSkill ?? [];
+        if (enabledSkills.length > 0 && disabledSkills.length > 0) {
+            cliLogger.error('Cannot use --enable-skill and --disable-skill at the same time. Use one or the other.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Soft-validate skill names against the bundled skills/ folder. Users
+        // may rely on skills loaded from their own .opencode / .claude / .agents
+        // dirs, so unknown names only emit a warning rather than hard-failing.
+        if (enabledSkills.length > 0 || disabledSkills.length > 0) {
+            const bundledSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'skills');
+            const availableBundledSkills = (() => {
+                try {
+                    return fs
+                        .readdirSync(bundledSkillsDir, { withFileTypes: true })
+                        .filter((entry) => entry.isDirectory())
+                        .map((entry) => entry.name);
+                }
+                catch {
+                    return [];
+                }
+            })();
+            const availableSet = new Set(availableBundledSkills);
+            for (const name of [...enabledSkills, ...disabledSkills]) {
+                if (!availableSet.has(name)) {
+                    cliLogger.warn(`Skill "${name}" is not a bundled kimaki skill. Rule will still apply (user-provided skills from .opencode/.claude/.agents dirs may match). Available bundled skills: ${availableBundledSkills.join(', ')}`);
+                }
+            }
+        }
         store.setState({
             ...(options.verbosity && {
                 defaultVerbosity: options.verbosity,
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
+            ...(enabledSkills.length > 0 && { enabledSkills }),
+            ...(disabledSkills.length > 0 && { disabledSkills }),
         });
+        if (enabledSkills.length > 0) {
+            cliLogger.log(`Skill whitelist enabled: only [${enabledSkills.join(', ')}] will be injected`);
+        }
+        if (disabledSkills.length > 0) {
+            cliLogger.log(`Skill blacklist enabled: [${disabledSkills.join(', ')}] will be hidden`);
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }
@@ -1637,7 +1687,12 @@ cli
     .option('--wait', 'Wait for session to complete, then print session text to stdout')
     .action(async (options) => {
     try {
-        let { channel: channelId, prompt, name, appId: optionAppId, notifyOnly, thread: threadId, session: sessionId, } = options;
+        // `--name` / `--app-id` are optional-value flags: `undefined` when
+        // omitted, `''` when passed bare, a real string when given a value.
+        // `||` collapses `''` to `undefined` for downstream consumers.
+        const optionAppId = options.appId || undefined;
+        let { channel: channelId, prompt, notifyOnly, thread: threadId, session: sessionId, } = options;
+        let name = options.name || undefined;
         const { project: projectPath } = options;
         const sendAt = options.sendAt;
         const existingThreadMode = Boolean(threadId || sessionId);
@@ -1981,10 +2036,12 @@ cli
             (cleanPrompt.length > 80
                 ? cleanPrompt.slice(0, 77) + '...'
                 : cleanPrompt);
+        // Explicit string => use as-is via formatWorktreeName (no vowel strip).
+        // Boolean true => derived from thread/prompt, compress via formatAutoWorktreeName.
         const worktreeName = options.worktree
-            ? formatWorktreeName(typeof options.worktree === 'string'
-                ? options.worktree
-                : baseThreadName)
+            ? typeof options.worktree === 'string'
+                ? formatWorktreeName(options.worktree)
+                : formatAutoWorktreeName(baseThreadName)
             : undefined;
         const threadName = worktreeName
             ? `${WORKTREE_PREFIX}${baseThreadName}`
@@ -2238,6 +2295,33 @@ cli
     });
     process.exit(0);
 });
+cli
+    .command('anthropic-accounts current', 'Show the current Anthropic OAuth account being used, if any')
+    .action(async () => {
+    const current = await getCurrentAnthropicAccount();
+    console.log(`Store: ${accountsFilePath()}`);
+    console.log(`Auth: ${authFilePath()}`);
+    if (!current) {
+        console.log('No active Anthropic OAuth account configured.');
+        process.exit(0);
+    }
+    const lines = [];
+    lines.push(`Current: ${accountLabel(current.account || current.auth, current.index)}`);
+    if (current.account?.email) {
+        lines.push(`Email: ${current.account.email}`);
+    }
+    else {
+        lines.push('Email: unavailable');
+    }
+    if (current.account?.accountId) {
+        lines.push(`Account ID: ${current.account.accountId}`);
+    }
+    if (!current.account) {
+        lines.push('Rotation pool entry: not found');
+    }
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
 cli
     .command('anthropic-accounts remove <indexOrEmail>', 'Remove a stored Anthropic OAuth account from the rotation pool by index or email')
     .action(async (indexOrEmail) => {
@@ -2633,13 +2717,15 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const guildId = String(options.guild);
+        // Bare `--query` comes through as `''`; collapse it to undefined
+        const query = options.query || undefined;
         await initDatabase();
         const { token: botToken } = await resolveBotCredentials();
         const rest = createDiscordRest(botToken);
         const members = await (async () => {
-            if (options.query) {
+            if (query) {
                 return (await rest.get(Routes.guildMembersSearch(guildId), {
-                    query: new URLSearchParams({ query: options.query, limit: '20' }),
+                    query: new URLSearchParams({ query, limit: '20' }),
                 }));
             }
             return (await rest.get(Routes.guildMembers(guildId), {
@@ -2647,8 +2733,8 @@ cli
             }));
         })();
         if (members.length === 0) {
-            const msg = options.query
-                ? `No users found matching "${options.query}"`
+            const msg = query
+                ? `No users found matching "${query}"`
                 : 'No users found in guild';
             cliLogger.log(msg);
             process.exit(0);
@@ -2659,8 +2745,8 @@ cli
             return `- ${displayName} (ID: ${m.user.id}) - mention: <@${m.user.id}>`;
         })
             .join('\n');
-        const header = options.query
-            ? `Found ${members.length} users matching "${options.query}":`
+        const header = query
+            ? `Found ${members.length} users matching "${query}":`
             : `Found ${members.length} users:`;
         console.log(`${header}\n${userList}`);
         process.exit(0);
@@ -2693,10 +2779,10 @@ cli
     const { command } = parseCommandFromArgv(process.argv);
     await runTunnel({
         port,
-        tunnelId: options.tunnelId,
-        localHost: options.host,
+        tunnelId: options.tunnelId || undefined,
+        localHost: options.host || undefined,
         baseDomain: 'kimaki.dev',
-        serverUrl: options.server,
+        serverUrl: options.server || undefined,
         command: command.length > 0 ? command : undefined,
         kill: options.kill,
     });

package/dist/commands/agent.js

@@ -6,6 +6,7 @@ import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession,
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { getCurrentModelInfo } from './model.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
 const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000;
 const pendingAgentContexts = new Map();
@@ -315,14 +316,32 @@ export async function handleQuickAgentCommand({ command, appId, }) {
         const previousText = previousAgentName
             ? ` (was **${previousAgentName}**)`
             : '';
+        // Resolve the model that will now be used for the new agent so we can
+        // show it in the reply. setAgentForContext already cleared any session
+        // model preference, so getCurrentModelInfo falls through to the agent's
+        // configured model (or channel/global/default).
+        const modelInfo = await (async () => {
+            const getClient = await initializeOpencodeForDirectory(context.dir);
+            if (getClient instanceof Error) {
+                return { type: 'none' };
+            }
+            return getCurrentModelInfo({
+                sessionId: context.sessionId,
+                channelId: context.channelId,
+                appId,
+                agentPreference: resolvedAgentName,
+                getClient,
+            });
+        })();
+        const modelText = modelInfo.type === 'none' ? '' : `\nModel: *${modelInfo.model}*`;
         if (context.isThread && context.sessionId) {
             await command.editReply({
-                content: `Switched to **${resolvedAgentName}** agent for this session${previousText}\nThe agent will change on the next message.`,
+                content: `Switched to **${resolvedAgentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`,
             });
         }
         else {
             await command.editReply({
-                content: `Switched to **${resolvedAgentName}** agent for this channel${previousText}\nAll new sessions will use this agent.`,
+                content: `Switched to **${resolvedAgentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`,
             });
         }
     }

package/dist/commands/ask-question.js

@@ -11,6 +11,32 @@ const logger = createLogger(LogPrefix.ASK_QUESTION);
 // TTL prevents unbounded growth if user never answers a question.
 const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
 export const pendingQuestionContexts = new Map();
+export function findPendingQuestionContextForRequest({ threadId, requestId, }) {
+    for (const [contextHash, context] of pendingQuestionContexts) {
+        if (context.thread.id !== threadId) {
+            continue;
+        }
+        if (context.requestId !== requestId) {
+            continue;
+        }
+        return { contextHash, context };
+    }
+    return null;
+}
+export function deletePendingQuestionContextsForRequest({ threadId, requestId, }) {
+    const matchingContextHashes = [...pendingQuestionContexts.entries()]
+        .filter(([, context]) => {
+        return context.thread.id === threadId && context.requestId === requestId;
+    })
+        .map(([contextHash]) => {
+        return contextHash;
+    });
+    matchingContextHashes.map((contextHash) => {
+        pendingQuestionContexts.delete(contextHash);
+        return contextHash;
+    });
+    return matchingContextHashes.length;
+}
 export function hasPendingQuestionForThread(threadId) {
     return [...pendingQuestionContexts.values()].some((ctx) => {
         return ctx.thread.id === threadId;
@@ -21,6 +47,14 @@ export function hasPendingQuestionForThread(threadId) {
  * Sends one message per question with the dropdown directly under the question text.
  */
 export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, silent, }) {
+    const existingPending = findPendingQuestionContextForRequest({
+        threadId: thread.id,
+        requestId,
+    });
+    if (existingPending) {
+        logger.log(`Deduped question ${requestId} for thread ${thread.id} (existing context ${existingPending.contextHash})`);
+        return;
+    }
     const contextHash = crypto.randomBytes(8).toString('hex');
     const context = {
         sessionId,
@@ -46,7 +80,10 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         // Without this, a user clicking during the abort() await would still
         // be accepted by handleAskQuestionSelectMenu, then abort() would
         // kill that valid run.
-        pendingQuestionContexts.delete(contextHash);
+        deletePendingQuestionContextsForRequest({
+            threadId: ctx.thread.id,
+            requestId: ctx.requestId,
+        });
         // Abort the session so OpenCode isn't stuck waiting for a reply
         const client = getOpencodeClient(ctx.directory);
         if (client) {
@@ -150,7 +187,10 @@ export async function handleAskQuestionSelectMenu(interaction) {
     if (context.answeredCount >= context.totalQuestions) {
         // All questions answered - send result back to session
         await submitQuestionAnswers(context);
-        pendingQuestionContexts.delete(contextHash);
+        deletePendingQuestionContextsForRequest({
+            threadId: context.thread.id,
+            requestId: context.requestId,
+        });
     }
 }
 /**
@@ -245,7 +285,10 @@ export async function cancelPendingQuestion(threadId, userMessage) {
     // the question without providing an answer (e.g. voice/attachment-only
     // messages where content needs transcription before it can be an answer).
     if (userMessage === undefined) {
-        pendingQuestionContexts.delete(contextHash);
+        deletePendingQuestionContextsForRequest({
+            threadId: context.thread.id,
+            requestId: context.requestId,
+        });
         return 'no-pending';
     }
     try {
@@ -269,6 +312,9 @@ export async function cancelPendingQuestion(threadId, userMessage) {
         // Caller should not consume the user message since reply failed.
         return 'reply-failed';
     }
-    pendingQuestionContexts.delete(contextHash);
+    deletePendingQuestionContextsForRequest({
+        threadId: context.thread.id,
+        requestId: context.requestId,
+    });
     return 'replied';
 }

package/dist/commands/ask-question.test.js

@@ -0,0 +1,92 @@
+// Tests AskUserQuestion request deduplication and cleanup helpers.
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
+function createFakeThread() {
+    const send = vi.fn(async () => {
+        return { id: 'msg-1' };
+    });
+    return {
+        id: 'thread-1',
+        send,
+    };
+}
+afterEach(() => {
+    pendingQuestionContexts.clear();
+    vi.restoreAllMocks();
+});
+describe('ask-question', () => {
+    test('dedupes duplicate question requests for the same thread', async () => {
+        const thread = createFakeThread();
+        await showAskUserQuestionDropdowns({
+            thread,
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-1',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        await showAskUserQuestionDropdowns({
+            thread,
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-1',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        expect(thread.send).toHaveBeenCalledTimes(1);
+        expect(pendingQuestionContexts.size).toBe(1);
+    });
+    test('removes all duplicate contexts for one request', () => {
+        const thread = createFakeThread();
+        const baseContext = {
+            sessionId: 'ses-1',
+            directory: '/project',
+            thread,
+            requestId: 'req-1',
+            questions: [{
+                    question: 'Choose one',
+                    header: 'Pick',
+                    options: [
+                        { label: 'Alpha', description: 'A' },
+                        { label: 'Beta', description: 'B' },
+                    ],
+                }],
+            answers: {},
+            totalQuestions: 1,
+            answeredCount: 0,
+            contextHash: 'ctx-1',
+        };
+        pendingQuestionContexts.set('ctx-1', baseContext);
+        pendingQuestionContexts.set('ctx-2', {
+            ...baseContext,
+            contextHash: 'ctx-2',
+        });
+        pendingQuestionContexts.set('ctx-3', {
+            ...baseContext,
+            requestId: 'req-2',
+            contextHash: 'ctx-3',
+        });
+        const removed = deletePendingQuestionContextsForRequest({
+            threadId: thread.id,
+            requestId: 'req-1',
+        });
+        expect(removed).toBe(2);
+        expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3']);
+    });
+});