kimaki 0.29.0 → 0.30.0

package/dist/cache-rewrite.test.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, expect, test } from 'vitest';
+import { countSystemPromptDiffLines, formatSystemPromptPatch, writeSystemPromptPatch, } from './cache-rewrite.js';
+const tempDirs = [];
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+test('counts added and removed system prompt lines', () => {
+    expect(countSystemPromptDiffLines({
+        beforeText: 'keep\nold line\n',
+        afterText: 'keep\nnew line\nextra\n',
+    })).toEqual({ additions: 2, deletions: 1 });
+});
+test('writes a unified patch only for the caller', async () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-cache-rewrite-'));
+    tempDirs.push(dataDir);
+    const filePath = await writeSystemPromptPatch({
+        dataDir,
+        sessionId: 'ses_test',
+        beforeText: 'alpha\n',
+        afterText: 'beta\n',
+        model: 'openai/gpt-5',
+        agent: 'build',
+        now: 1_700_000_000_000,
+    });
+    expect(path.basename(filePath)).toBe('1700000000000-ses_test.patch');
+    const text = fs.readFileSync(filePath, 'utf8');
+    expect(text).toContain('session: ses_test');
+    expect(text).toContain('system +1 -1');
+    expect(text).toContain('-alpha');
+    expect(text).toContain('+beta');
+    expect(formatSystemPromptPatch({
+        beforeText: 'alpha\n',
+        afterText: 'beta\n',
+        sessionId: 'ses_test',
+    })).toContain('--- system-before.txt');
+});

package/dist/cli-commands/session.js

@@ -106,17 +106,27 @@ cli
                 process.exit(EXIT_NO_RESTART);
             }
             const client = getClient();
-            const [sessionsResponse, statusResponse] = await Promise.all([
+            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: status && status.type !== 'idle' ? 'busy' : 'idle',
+                    status: isBusy && sessionsWithPendingQuestion.has(session.id)
+                        ? 'showing-question'
+                        : isBusy
+                            ? 'busy'
+                            : 'idle',
                 });
             }
         }
@@ -195,7 +205,12 @@ cli
                 : '';
             const updatedAt = new Date(session.time.updated).toISOString();
             const threadInfo = threadId ? ` | thread: ${threadId}` : '';
-            const statusInfo = ` | status: ${entry.status === 'busy' ? 'working' : 'idle'}`;
+            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}`);
@@ -281,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 || '.');
@@ -297,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);
@@ -331,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);
@@ -346,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-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

@@ -39,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')
@@ -176,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 }),
@@ -212,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');

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.

package/dist/commands/queue.js

@@ -5,7 +5,7 @@ import { deleteThreadQueueItem, getThreadSession } from '../database.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getOrCreateRuntime, getRuntime, } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { QUEUE_PREFIX } from '../message-formatting.js';
+import { asSystemLine, QUEUE_PREFIX } from '../message-formatting.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
 export const QUEUE_REMOVE_CUSTOM_ID_PREFIX = 'queue_remove:';
@@ -75,7 +75,7 @@ export async function handleQueueRemoveButton(interaction) {
         : await deleteThreadQueueItemWithoutRuntime(parsed.queueId);
     if (!removed) {
         await interaction.editReply({
-            content: 'Queued message is no longer in the queue',
+            content: asSystemLine('Queued message is no longer in the queue'),
             components: [],
         });
         return;
@@ -84,7 +84,7 @@ export async function handleQueueRemoveButton(interaction) {
         ? `/${removed.command.name}`
         : removed.prompt.slice(0, 120);
     await interaction.editReply({
-        content: `Removed queued message: ${label}`,
+        content: asSystemLine(`Removed queued message: ${label}`),
         components: [],
     });
     logger.log(`[QUEUE] User ${interaction.user.displayName} removed queued item ${parsed.queueId} in thread ${parsed.threadId}`);
@@ -145,7 +145,7 @@ export async function handleQueueCommand({ command, appId, }) {
         mode: 'local-queue',
     });
     if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`;
+        const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
         await command.reply({
             content: responseText,
             components: [
@@ -205,7 +205,7 @@ export async function handleClearQueueCommand({ command, }) {
             return;
         }
         await command.reply({
-            content: `Cleared queued message at position ${position}`,
+            content: asSystemLine(`Cleared queued message at position ${position}`),
             flags: SILENT_MESSAGE_FLAGS,
         });
         logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
@@ -223,7 +223,7 @@ export async function handleClearQueueCommand({ command, }) {
         list = list.slice(0, 597) + '...';
     }
     await command.reply({
-        content: `Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`,
+        content: asSystemLine(`Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`),
         flags: SILENT_MESSAGE_FLAGS,
     });
     logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
@@ -299,7 +299,7 @@ export async function handleQueueCommandCommand({ command, appId, }) {
         mode: 'local-queue',
     });
     if (enqueueResult.queued && enqueueResult.queueId) {
-        const responseText = `Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`;
+        const responseText = asSystemLine(`Queued message${enqueueResult.position ? ` (position ${enqueueResult.position})` : ''}`);
         await command.reply({
             content: responseText,
             components: [

package/dist/database.js

@@ -174,13 +174,13 @@ export async function recoverStaleRunningScheduledTasks({ staleBefore }) {
 export async function deleteScheduledTask(taskId) {
     const db = await getDb();
     await db.delete(schema.scheduled_tasks)
-        .where(orm.eq(schema.scheduled_tasks.id, taskId));
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
 }
 export async function markScheduledTaskCronRescheduled({ taskId, completedAt, nextRunAt }) {
     const db = await getDb();
     await db.update(schema.scheduled_tasks)
         .set({ status: 'planned', last_run_at: completedAt, running_started_at: null, last_error: null, next_run_at: nextRunAt })
-        .where(orm.eq(schema.scheduled_tasks.id, taskId));
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
 }
 export async function markScheduledTaskFailed({ taskId, failedAt, errorMessage }) {
     const db = await getDb();
@@ -192,7 +192,7 @@ export async function markScheduledTaskFailed({ taskId, failedAt, errorMessage }
         last_error: errorMessage,
         attempts: orm.sql `${schema.scheduled_tasks.attempts} + 1`,
     })
-        .where(orm.eq(schema.scheduled_tasks.id, taskId));
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
 }
 export async function markScheduledTaskCronRetry({ taskId, failedAt, errorMessage, nextRunAt }) {
     const db = await getDb();
@@ -205,7 +205,7 @@ export async function markScheduledTaskCronRetry({ taskId, failedAt, errorMessag
         last_error: errorMessage,
         attempts: orm.sql `${schema.scheduled_tasks.attempts} + 1`,
     })
-        .where(orm.eq(schema.scheduled_tasks.id, taskId));
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
 }
 export async function setSessionStartSource({ sessionId, scheduleKind, scheduledTaskId }) {
     const db = await getDb();
@@ -913,20 +913,87 @@ export async function deleteChannelDirectoriesByDirectory(directory) {
     const db = await getDb();
     await db.delete(schema.channel_directories).where(orm.eq(schema.channel_directories.directory, directory));
 }
-export async function deleteChannelDirectoryById(channelId) {
+export async function deleteChannelDirectoryById(channelId, { preserveMapping = false } = {}) {
     const db = await getDb();
     await db.batch([
+        db.update(schema.scheduled_tasks)
+            .set({
+            status: 'cancelled',
+            running_started_at: null,
+            last_error: 'Discord channel was deleted',
+        })
+            .where(orm.and(orm.eq(schema.scheduled_tasks.channel_id, channelId), orm.inArray(schema.scheduled_tasks.status, ['planned', 'running']))),
         db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, channelId)),
         db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, channelId)),
         db.delete(schema.channel_worktrees).where(orm.eq(schema.channel_worktrees.channel_id, channelId)),
         db.delete(schema.channel_verbosity).where(orm.eq(schema.channel_verbosity.channel_id, channelId)),
         db.delete(schema.channel_mention_mode).where(orm.eq(schema.channel_mention_mode.channel_id, channelId)),
     ]);
+    if (preserveMapping) {
+        return Boolean(await db.query.channel_directories.findFirst({
+            where: { channel_id: channelId },
+            columns: { channel_id: true },
+        }));
+    }
     const rows = await db.delete(schema.channel_directories)
         .where(orm.eq(schema.channel_directories.channel_id, channelId))
         .returning({ channel_id: schema.channel_directories.channel_id });
     return rows.length > 0;
 }
+export async function cleanupDeletedThread(threadId) {
+    const db = await getDb();
+    const binding = await db.query.thread_sessions.findFirst({
+        where: { thread_id: threadId },
+        columns: { session_id: true },
+    });
+    const currentThreadId = binding
+        ? await getThreadIdBySessionId(binding.session_id)
+        : undefined;
+    const currentSessionId = currentThreadId === threadId
+        ? binding?.session_id
+        : undefined;
+    await db.batch([
+        db.delete(schema.thread_queue_items)
+            .where(orm.eq(schema.thread_queue_items.thread_id, threadId)),
+        db.update(schema.session_sleeps)
+            .set({ status: 'cancelled' })
+            .where(orm.and(orm.eq(schema.session_sleeps.status, 'planned'), orm.eq(schema.session_sleeps.session_id, currentSessionId ?? ''))),
+        db.update(schema.scheduled_tasks)
+            .set({
+            status: 'cancelled',
+            running_started_at: null,
+            last_error: 'Discord thread was deleted',
+        })
+            .where(orm.and(orm.eq(schema.scheduled_tasks.thread_id, threadId), orm.inArray(schema.scheduled_tasks.status, ['planned', 'running']))),
+        db.update(schema.ipc_requests)
+            .set({
+            status: 'cancelled',
+            response: JSON.stringify({ error: 'Discord thread was deleted' }),
+        })
+            .where(orm.and(orm.eq(schema.ipc_requests.thread_id, threadId), orm.inArray(schema.ipc_requests.status, ['pending', 'processing']))),
+    ]);
+}
+export async function isCurrentThreadSessionBinding(threadId) {
+    const db = await getDb();
+    const binding = await db.query.thread_sessions.findFirst({
+        where: { thread_id: threadId },
+        columns: { session_id: true },
+    });
+    if (!binding)
+        return false;
+    return await getThreadIdBySessionId(binding.session_id) === threadId;
+}
+export async function clearGuildCategoryByChannelId(channelId) {
+    const db = await getDb();
+    await db.batch([
+        db.update(schema.guild_categories)
+            .set({ category_id: null })
+            .where(orm.eq(schema.guild_categories.category_id, channelId)),
+        db.update(schema.guild_categories)
+            .set({ audio_category_id: null })
+            .where(orm.eq(schema.guild_categories.audio_category_id, channelId)),
+    ]);
+}
 export async function getVoiceChannelDirectory(channelId) {
     const db = await getDb();
     return (await db.query.channel_directories.findFirst({ where: { channel_id: channelId, channel_type: 'voice' } }))?.directory;
@@ -982,7 +1049,7 @@ export async function completeIpcRequest({ id, response }) {
     const db = await getDb();
     const [row] = await db.update(schema.ipc_requests)
         .set({ response, status: 'completed' })
-        .where(orm.eq(schema.ipc_requests.id, id))
+        .where(orm.and(orm.eq(schema.ipc_requests.id, id), orm.inArray(schema.ipc_requests.status, ['pending', 'processing'])))
         .returning();
     return row;
 }