kimaki 0.28.0 → 0.30.0

package/dist/cli-commands/session.js

@@ -54,45 +54,92 @@ async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
     }
     return new Error(`Session is not linked to a Kimaki thread in the local database: ${sessionId}`);
 }
+// Total token footprint of a session (input + output + reasoning + cache).
+function getSessionTokenTotal(tokens) {
+    return (tokens.input +
+        tokens.output +
+        tokens.reasoning +
+        tokens.cache.read +
+        tokens.cache.write);
+}
+// Compact token count: 1234 -> "1k", 200000 -> "200k", 1_500_000 -> "1.5M".
+function formatTokenCount(count) {
+    if (count >= 1_000_000) {
+        return `${(count / 1_000_000).toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        return `${Math.round(count / 1_000)}k`;
+    }
+    return String(count);
+}
 cli
     .command('session list', 'List all OpenCode sessions, marking which were started via Kimaki')
     .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
+    .option('--all', 'List sessions across every locally registered project')
     .option('--active', 'Only list active sessions; exits 1 when none remain')
     .option('--exclude <sessionId>', 'Exclude one session ID from the results')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     try {
-        const projectDirectory = path.resolve(options.project || '.');
         await initDatabase();
-        cliLogger.log('Connecting to OpenCode server...');
-        const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (getClient instanceof Error) {
-            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+        if (options.all && options.project) {
+            cliLogger.error('Use either --all or --project, not both');
             process.exit(EXIT_NO_RESTART);
         }
-        const sessionsResponse = await getClient().session.list();
-        const sessions = sessionsResponse.data || [];
-        const statuses = await (async () => {
-            if (!options.active)
-                return null;
-            const response = await getClient().session.status({
-                directory: projectDirectory,
-            });
-            if (response.error) {
-                cliLogger.error('Failed to list active sessions');
+        const projectDirectories = options.all
+            ? Array.from(new Set((await getAllTextChannelDirectories()).map((directory) => path.resolve(directory))))
+            : [path.resolve(options.project || '.')];
+        if (projectDirectories.length === 0) {
+            cliLogger.error('No registered project directories found. Add a project with `kimaki project add`.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const gathered = [];
+        for (const projectDirectory of projectDirectories) {
+            cliLogger.log(`Connecting to OpenCode server for ${projectDirectory}...`);
+            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+            if (getClient instanceof Error) {
+                if (options.all) {
+                    cliLogger.warn(`Skipping ${projectDirectory}: failed to connect to OpenCode: ${getClient.message}`);
+                    continue;
+                }
+                cliLogger.error('Failed to connect to OpenCode:', getClient.message);
                 process.exit(EXIT_NO_RESTART);
             }
-            return response.data || {};
-        })();
-        const selectedSessions = sessions.filter((session) => {
-            if (session.id === options.exclude)
+            const client = getClient();
+            const [sessionsResponse, statusResponse, questionsResponse] = await Promise.all([
+                client.session.list(),
+                client.session.status({ directory: projectDirectory }).catch(() => null),
+                client.question.list({ directory: projectDirectory }).catch(() => null),
+            ]);
+            const statuses = statusResponse?.data || {};
+            const sessionsWithPendingQuestion = new Set((questionsResponse?.data || []).map((request) => request.sessionID));
+            for (const session of sessionsResponse.data || []) {
+                const status = statuses[session.id];
+                const isBusy = Boolean(status && status.type !== 'idle');
+                // Only relabel to showing-question when the session is actually busy.
+                // An orphaned question left in the list after an abort (session idle)
+                // must not hide or relabel an otherwise-idle session.
+                gathered.push({
+                    session,
+                    projectDirectory,
+                    status: isBusy && sessionsWithPendingQuestion.has(session.id)
+                        ? 'showing-question'
+                        : isBusy
+                            ? 'busy'
+                            : 'idle',
+                });
+            }
+        }
+        const selected = gathered
+            .filter((entry) => {
+            if (entry.session.id === options.exclude)
                 return false;
-            if (!options.active)
-                return true;
-            const status = statuses?.[session.id];
-            return Boolean(status && status.type !== 'idle');
-        });
-        if (selectedSessions.length === 0) {
+            if (options.active && entry.status !== 'busy')
+                return false;
+            return true;
+        })
+            .sort((a, b) => b.session.time.updated - a.session.time.updated);
+        if (selected.length === 0) {
             if (options.json)
                 console.log('[]');
             else
@@ -107,15 +154,26 @@ cli
         const sessionToThread = new Map(threadSessions
             .filter((row) => row.session_id !== '')
             .map((row) => [row.session_id, row.thread_id]));
-        const sessionStartSources = await getSessionStartSourcesBySessionIds(selectedSessions.map((session) => session.id));
+        const sessionStartSources = await getSessionStartSourcesBySessionIds(selected.map((entry) => entry.session.id));
         const scheduleModeLabel = ({ scheduleKind, }) => {
             if (scheduleKind === 'at') {
                 return 'delay';
             }
             return 'cron';
         };
+        // Token footprint straight from the session object (no message fetch).
+        // Session.tokens is a per-session aggregate, so it is reported as a token
+        // count rather than a context-window percentage.
+        const contextInfo = (entry) => {
+            const tokens = entry.session.tokens;
+            if (!tokens)
+                return null;
+            const total = getSessionTokenTotal(tokens);
+            return total > 0 ? total : null;
+        };
         if (options.json) {
-            const output = selectedSessions.map((session) => {
+            const output = selected.map((entry) => {
+                const session = entry.session;
                 const startSource = sessionStartSources.get(session.id);
                 const startedBy = startSource
                     ? `scheduled-${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}`
@@ -127,15 +185,18 @@ cli
                     updated: new Date(session.time.updated).toISOString(),
                     source: sessionToThread.has(session.id) ? 'kimaki' : 'opencode',
                     threadId: sessionToThread.get(session.id) || null,
+                    status: entry.status,
+                    model: session.model?.id || null,
+                    tokens: contextInfo(entry),
                     startedBy,
                     scheduledTaskId: startSource?.scheduled_task_id || null,
-                    status: options.active ? statuses?.[session.id]?.type || 'busy' : undefined,
                 };
             });
             console.log(JSON.stringify(output, null, 2));
             process.exit(0);
         }
-        for (const session of selectedSessions) {
+        for (const entry of selected) {
+            const session = entry.session;
             const threadId = sessionToThread.get(session.id);
             const startSource = sessionStartSources.get(session.id);
             const source = threadId ? '(kimaki)' : '(opencode)';
@@ -144,10 +205,15 @@ cli
                 : '';
             const updatedAt = new Date(session.time.updated).toISOString();
             const threadInfo = threadId ? ` | thread: ${threadId}` : '';
-            const statusInfo = options.active
-                ? ` | status: ${statuses?.[session.id]?.type || 'busy'}`
-                : '';
-            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}${startedBy}${statusInfo}`);
+            const statusLabel = entry.status === 'busy'
+                ? 'working'
+                : entry.status === 'showing-question'
+                    ? 'showing-question'
+                    : 'idle';
+            const statusInfo = ` | status: ${statusLabel}`;
+            const tokens = contextInfo(entry);
+            const tokensText = tokens ? ` | tokens: ${formatTokenCount(tokens)}` : '';
+            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${statusInfo}${tokensText}${threadInfo}${startedBy}`);
         }
         process.exit(0);
     }
@@ -230,9 +296,18 @@ cli
     }
 });
 cli
-    .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
+    .command('session read <sessionId>', dedent `
+      Read a session conversation as markdown (pipe to file to grep).
+
+      Thinking is omitted by default. Tool inputs are truncated. Use
+      \`--thinking\` and \`--verbose\` for the full dump.
+    `)
     .option('--project <path>', 'Project directory (defaults to cwd)')
     .option('--verbose', 'Show full tool inputs and outputs instead of compact summaries')
+    .option('--thinking', 'Include reasoning / thinking parts')
+    .option('--tool-input-max-chars <n>', z.number().default(80).describe('Max characters for compact tool input'))
+    .example('kimaki session read ses_xxx > ./tmp/session.md')
+    .example('kimaki session read ses_xxx --thinking --verbose')
     .action(async (sessionId, options) => {
     try {
         const projectDirectory = path.resolve(options.project || '.');
@@ -246,7 +321,12 @@ cli
         // Try current project first (fast path)
         const compactTools = !options.verbose;
         const markdown = new ShareMarkdown(getClient());
-        const result = await markdown.generate({ sessionID: sessionId, compactTools });
+        const result = await markdown.generate({
+            sessionID: sessionId,
+            compactTools,
+            includeThinking: options.thinking,
+            toolInputMaxChars: options.toolInputMaxChars,
+        });
         if (!(result instanceof Error)) {
             process.stdout.write(result);
             process.exit(0);
@@ -280,6 +360,8 @@ cli
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
                 compactTools,
+                includeThinking: options.thinking,
+                toolInputMaxChars: options.toolInputMaxChars,
             });
             if (!(otherResult instanceof Error)) {
                 process.stdout.write(otherResult);
@@ -295,7 +377,7 @@ cli
     }
 });
 cli
-    .command('session wait <sessionId>', 'Wait for a session to finish, then print its conversation as markdown')
+    .command('session wait <sessionId>', 'Wait until a session finishes or pauses for a user question, then print its conversation as markdown')
     .action(async (sessionId) => {
     try {
         await initDatabase();

package/dist/cli-commands/thread.js

@@ -0,0 +1,63 @@
+import { goke } from 'goke';
+import { z } from 'zod';
+import { createLogger, LogPrefix } from '../logger.js';
+import { initDatabase } from '../discord-bot.js';
+import { createDiscordRest } from '../discord-urls.js';
+import { EXIT_NO_RESTART, resolveBotCredentials } from '../cli-runner.js';
+import { listDiscordChannelThreads } from '../list-channel-threads.js';
+const cliLogger = createLogger(LogPrefix.CLI);
+const cli = goke();
+cli
+    .command('thread list', 'List Discord threads in a channel. Use this to find a thread on another computer, then send with --thread.')
+    .option('-c, --channel <channelId>', 'Discord channel ID')
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', z.number().default(50).describe('Maximum threads to show'))
+    .example('kimaki thread list --channel 123456789012345678')
+    .example('kimaki thread list --channel 123456789012345678 --json')
+    .action(async (options, { console, process }) => {
+    try {
+        if (!options.channel) {
+            cliLogger.error('Channel ID is required. Use --channel <channelId>. Find remote channels with `kimaki project list --all --json`.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        await initDatabase();
+        const { token: botToken } = await resolveBotCredentials({});
+        const rest = createDiscordRest(botToken);
+        const listed = await listDiscordChannelThreads({
+            rest,
+            channelId: options.channel,
+        });
+        if (!listed.ok) {
+            cliLogger.error(listed.error.message);
+            process.exit(EXIT_NO_RESTART);
+            return;
+        }
+        const limited = listed.threads.slice(0, options.limit);
+        if (options.json) {
+            console.log(JSON.stringify(limited.map((thread) => ({
+                thread_id: thread.id,
+                name: thread.name,
+                channel_id: thread.parentId,
+                guild_id: thread.guildId,
+                archived: thread.archived,
+                archive_state: thread.archiveState,
+                last_message_id: thread.lastMessageId,
+            })), null, 2));
+            process.exit(0);
+        }
+        if (limited.length === 0) {
+            console.log(`No threads found in channel ${options.channel}`);
+            process.exit(0);
+        }
+        for (const thread of limited) {
+            const archivedTag = thread.archived ? ' [archived]' : '';
+            console.log(`${thread.id} | ${thread.name}${archivedTag}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+export default cli;

package/dist/cli-parsing.test.js

@@ -50,7 +50,7 @@ async function parseRootBotOptions(argv) {
     const script = [
         "import { goke } from 'goke'",
         'const cli = goke(\'kimaki\')',
-        "cli.command('', 'bot').option('--no-analytics', 'Disable analytics').option('--skip-footer-mentions', 'Do not mention the thread creator in final footers')",
+        "cli.command('', 'bot').option('--no-analytics', 'Disable analytics').option('--enable-footer-mentions', 'Mention the thread creator in final footers')",
         `const result = await cli.parse(${JSON.stringify(argv)}, { run: false })`,
         'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
     ].join(';');
@@ -213,13 +213,13 @@ describe('goke CLI ID parsing', () => {
             'node',
             'kimaki',
             '--no-analytics',
-            '--skip-footer-mentions',
+            '--enable-footer-mentions',
         ]);
         expect(result.options).toMatchInlineSnapshot(`
       {
         "--": [],
+        "enableFooterMentions": true,
         "noAnalytics": true,
-        "skipFooterMentions": true,
       }
     `);
     });

package/dist/cli-runner.js

@@ -2,7 +2,7 @@
 // Keeps cli.ts focused on command composition while preserving the bot onboarding flow.
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, generateDiscordInstallUrlForBot, KIMAKI_GATEWAY_APP_ID, KIMAKI_WEBSITE_URL, abbreviatePath, } from './utils.js';
-import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, assertCompatibleOpencodeVersion, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
+import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, registerBotLifecycleHandlers, initializeOpencodeForDirectory, assertCompatibleOpencodeVersion, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
 import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getDb, } from './database.js';
 import * as orm from 'drizzle-orm';
 import * as dbSchema from './schema.js';
@@ -1175,6 +1175,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
         cliLogger.error('Failed to start hrana server:', hranaResult.message);
         process.exit(EXIT_NO_RESTART);
     }
+    // We own the lock port from here on. Stop signals must release it in every
+    // startup phase (Discord login, channel reconcile), not only after ready.
+    registerBotLifecycleHandlers();
     // Initialize database (connects to hrana server via HTTP)
     await initDatabase();
     const { appId, token, credentialSource, isGatewayMode, installerDiscordUserId } = await resolveCredentials({
@@ -1316,6 +1319,10 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
         }
         process.exit(EXIT_NO_RESTART);
     }
+    // Stop signal during Discord login: shutdown owns the process now.
+    if (global.shuttingDown) {
+        return;
+    }
     await setBotToken(appId, token);
     // In gateway mode the bot only sees guilds the user has installed
     // it in. Zero guilds means the install URL callback never completed or the
@@ -1351,6 +1358,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
         // Start bot immediately — channel sync happens in the background.
         cliLogger.log('Starting Discord bot...');
         await startDiscordBot({ token, appId, discordClient, useWorktrees });
+        if (global.shuttingDown) {
+            return;
+        }
         cliLogger.log('Discord bot is running!');
         // Background channel sync + role reconciliation + default channel creation.
         // Never blocks ready state.

package/dist/cli-send-thread.e2e.test.js

@@ -319,9 +319,9 @@ describe('kimaki send --channel thread creation', () => {
         "--- from: user (cli-send-tester)
         thread empty content seed
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > caught-by-model
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000830>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)
         I can see you sent a message, but Discord did not include its text.

package/dist/cli.js

@@ -20,6 +20,7 @@ import projectCommands from './cli-commands/project.js';
 import sendCommands from './cli-commands/send.js';
 import sessionCommands from './cli-commands/session.js';
 import taskCommands from './cli-commands/task.js';
+import threadCommands from './cli-commands/thread.js';
 import userCommands from './cli-commands/user.js';
 import { EXIT_NO_RESTART, printDiscordInstallUrlAndExit, run, } from './cli-runner.js';
 const cliLogger = createLogger(LogPrefix.CLI);
@@ -38,7 +39,7 @@ cli
     .option('--verbosity <level>', 'Default verbosity for all channels (tools_and_text, text_and_essential_tools, or text_only)')
     .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
-    .option('--skip-footer-mentions', 'Do not mention the thread creator in final session footers')
+    .option('--enable-footer-mentions', 'Mention the thread creator in final session footers so they get a notification')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
     .option('--restrict-directories', 'Only allow the agent to access the session working directory and a few known-safe paths. Any other folder asks for permission. By default every directory is allowed and you protect folders with deny/ask rules in opencode.json')
@@ -175,7 +176,7 @@ cli
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
-            ...(options.skipFooterMentions && { footerMentionsEnabled: false }),
+            ...(options.enableFooterMentions && { footerMentionsEnabled: true }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
             ...(options.restrictDirectories && { restrictExternalDirectories: true }),
             ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
@@ -211,8 +212,8 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
-        if (options.skipFooterMentions) {
-            cliLogger.log('Footer mentions disabled: final session footers will not mention thread creators');
+        if (options.enableFooterMentions) {
+            cliLogger.log('Footer mentions enabled: final session footers will mention thread creators');
         }
         if (options.noAutoUpgrade) {
             cliLogger.log('Auto-upgrade disabled: kimaki will not check for updates on startup');
@@ -258,6 +259,7 @@ cli.use(miscCommands);
 cli.use(sendCommands);
 cli.use(taskCommands);
 cli.use(projectCommands);
+cli.use(threadCommands);
 cli.use(userCommands);
 cli.use(sessionCommands);
 cli.use(maintenanceCommands);

package/dist/commands/ask-question.js

@@ -8,6 +8,7 @@ import { getOpencodeClient } from '../opencode.js';
 import { DiscordOperationError } from '../errors.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { QUEUE_PREFIX } from '../message-formatting.js';
+import { getRuntime } from '../session-handler/thread-session-runtime.js';
 const logger = createLogger(LogPrefix.ASK_QUESTION);
 // Store pending question contexts by hash.
 // No TTL on purpose: a question can only be answered by the user, so expiring it
@@ -185,41 +186,89 @@ export async function handleAskQuestionSelectMenu(interaction) {
     });
     const username = interaction.user.globalName || interaction.user.username;
     await sendThreadMessage(context.thread, `${QUEUE_PREFIX}**${username}:** ${answeredText}`);
-    // Check if all questions are answered
-    if (areAllQuestionsAnswered(context)) {
-        // All questions answered - send result back to session
-        await submitQuestionAnswers(context);
+    // Check if all questions are answered. Claim the context synchronously
+    // (delete before awaiting submit) so two concurrent final selections for a
+    // multi-question tool cannot both submit and double-resume the session.
+    if (areAllQuestionsAnswered(context)
+        && pendingQuestionContexts.get(contextHash) === context) {
         deletePendingQuestionContextsForRequest({
             threadId: context.thread.id,
             requestId: context.requestId,
         });
+        await submitQuestionAnswers(context);
+    }
+}
+/**
+ * Format collected answers as a plain-text summary the model can read when
+ * the run is resumed after an abort (e.g. `"Which option?"="Alpha"`).
+ *
+ * Known limitation: if the user had queued items via /queue during the pending
+ * question AND aborted the run from another opencode client, the first queued
+ * item may have already been handed off to opencode and can lose its ordering
+ * on resume. That rare combination needs a queue-handoff redesign; the common
+ * (no-queue) abort case is handled correctly.
+ */
+function formatQuestionAnswersText(context) {
+    const parts = context.questions.map((q, i) => {
+        const answer = (context.answers[i] || []).join(', ') || 'Unanswered';
+        return `"${q.question}"="${answer}"`;
+    });
+    return `Answers to your previous questions: ${parts.join(', ')}`;
+}
+/** Resume the session by feeding the answers back as a new user prompt. */
+async function resumeSessionWithAnswers(context) {
+    const runtime = getRuntime(context.thread.id);
+    const resumed = await runtime?.resumeWithText({
+        text: formatQuestionAnswersText(context),
+    });
+    if (!resumed) {
+        await sendThreadMessage(context.thread, '✗ Failed to submit answers: session is no longer active');
     }
 }
 /**
  * Submit all collected answers back to the OpenCode session.
- * Uses the question.reply API to provide answers to the waiting tool.
+ *
+ * The decision is based on whether the session still has a live run:
+ *
+ * - Busy: a live run is parked on the question. Reply so it continues.
+ * - Idle: the run was aborted (from this or another opencode client). Replying
+ *   would resolve a dead run and the session would never continue, so resume it
+ *   with the answers as a fresh prompt instead.
+ *
+ * Note: `question.list` is not a reliable signal here. After an abort the
+ * question request can stay in the pending list but orphaned (no run awaiting
+ * it), so a reply would succeed yet the session would still not continue. The
+ * session busy state, derived from the event stream, is the accurate signal.
+ * The reply `.error` check is a safety net for the case where the request was
+ * actually removed while the session still looked busy.
  */
 async function submitQuestionAnswers(context) {
-    try {
-        const client = getOpencodeClient(context.directory);
-        if (!client) {
-            throw new Error('OpenCode server not found for directory');
-        }
-        // Build answers array: each element is an array of selected labels for that question
-        const answers = context.questions.map((_, i) => {
-            return context.answers[i] || [];
-        });
-        await client.question.reply({
-            requestID: context.requestId,
-            directory: context.directory,
-            answers,
-        });
-        logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
+    const client = getOpencodeClient(context.directory);
+    if (!client) {
+        logger.error('OpenCode server not found for directory');
+        return;
     }
-    catch (error) {
-        logger.error('Failed to submit answers:', error);
-        await sendThreadMessage(context.thread, `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    const runtime = getRuntime(context.thread.id);
+    if (runtime && !runtime.isBusy()) {
+        logger.log(`Session ${context.sessionId} idle; resuming with answers for question ${context.requestId}`);
+        await resumeSessionWithAnswers(context);
+        return;
+    }
+    const answers = context.questions.map((_, i) => {
+        return context.answers[i] || [];
+    });
+    // throwOnError is off on this client, so failures come back in `.error`.
+    const replyResult = await client.question
+        .reply({ requestID: context.requestId, directory: context.directory, answers })
+        .catch((error) => ({ error }));
+    if (!replyResult.error) {
+        logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
+        return;
     }
+    // Reply failed (the request was removed while the session still looked busy).
+    // Resume so the answer still reaches the model.
+    logger.log(`Reply failed for question ${context.requestId}; resuming session ${context.sessionId} with answers`);
+    await resumeSessionWithAnswers(context);
 }
 /**
  * Check if a tool part is an AskUserQuestion tool.