kimaki 0.28.0 → 0.29.0

package/dist/commands/queue.js

@@ -1,44 +1,94 @@
 // Queue commands - /queue, /queue-command
 // Clear/remove actions live as buttons on each queue confirmation message.
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, MessageFlags, } from 'discord.js';
-import { getThreadSession } from '../database.js';
+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 { buildHtmlActionCustomId, registerHtmlAction, } from '../html-actions.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { QUEUE_PREFIX } from '../message-formatting.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
-function buildQueueRemoveRow({ threadId, queueId, position, }) {
-    const actionId = registerHtmlAction({
-        ownerKey: `queue-remove:${threadId}:${queueId}`,
-        threadId,
-        run: async ({ interaction }) => {
-            const removed = getRuntime(threadId)?.removeQueueItemById(queueId);
-            if (!removed) {
-                await interaction.editReply({
-                    content: position
-                        ? `Queued message at position ${position} is no longer in the queue`
-                        : 'Queued message is no longer in the queue',
-                    components: [],
-                });
-                return;
-            }
-            const label = removed.command
-                ? `/${removed.command.name}`
-                : removed.prompt.slice(0, 120);
-            await interaction.editReply({
-                content: `Removed queued message${position ? ` (was position ${position})` : ''}: ${label}`,
-                components: [],
-            });
-            logger.log(`[QUEUE] User ${interaction.user.displayName} removed queued item ${queueId} in thread ${threadId}`);
-        },
+export const QUEUE_REMOVE_CUSTOM_ID_PREFIX = 'queue_remove:';
+async function deleteThreadQueueItemWithoutRuntime(queueId) {
+    const row = await deleteThreadQueueItem(queueId).catch((error) => {
+        logger.error(`[QUEUE] Failed to delete persisted queue item ${queueId}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
     });
+    if (!row) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(row.payload_json);
+        return {
+            prompt: typeof parsed.prompt === 'string' ? parsed.prompt : '',
+            username: typeof parsed.username === 'string' ? parsed.username : '',
+            command: parsed.command,
+        };
+    }
+    catch {
+        return { prompt: '', username: '' };
+    }
+}
+export function buildQueueRemoveCustomId({ threadId, queueId, }) {
+    return `${QUEUE_REMOVE_CUSTOM_ID_PREFIX}${threadId}:${queueId}`;
+}
+export function parseQueueRemoveCustomId(customId) {
+    if (!customId.startsWith(QUEUE_REMOVE_CUSTOM_ID_PREFIX)) {
+        return undefined;
+    }
+    const rest = customId.slice(QUEUE_REMOVE_CUSTOM_ID_PREFIX.length);
+    const separator = rest.indexOf(':');
+    if (separator <= 0 || separator >= rest.length - 1) {
+        return undefined;
+    }
+    return {
+        threadId: rest.slice(0, separator),
+        queueId: rest.slice(separator + 1),
+    };
+}
+function buildQueueRemoveRow({ threadId, queueId, }) {
     return new ActionRowBuilder().addComponents(new ButtonBuilder()
-        .setCustomId(buildHtmlActionCustomId(actionId))
+        .setCustomId(buildQueueRemoveCustomId({ threadId, queueId }))
         .setLabel('Remove from queue')
         .setStyle(ButtonStyle.Secondary));
 }
+export async function handleQueueRemoveButton(interaction) {
+    const parsed = parseQueueRemoveCustomId(interaction.customId);
+    if (!parsed) {
+        await interaction.reply({
+            content: 'Invalid queue remove button',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (interaction.channelId && interaction.channelId !== parsed.threadId) {
+        await interaction.reply({
+            content: 'This queue button does not belong to this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const runtime = getRuntime(parsed.threadId);
+    const removed = runtime
+        ? await runtime.removeQueueItemById(parsed.queueId)
+        : await deleteThreadQueueItemWithoutRuntime(parsed.queueId);
+    if (!removed) {
+        await interaction.editReply({
+            content: 'Queued message is no longer in the queue',
+            components: [],
+        });
+        return;
+    }
+    const label = removed.command
+        ? `/${removed.command.name}`
+        : removed.prompt.slice(0, 120);
+    await interaction.editReply({
+        content: `Removed queued message: ${label}`,
+        components: [],
+    });
+    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);
     const channel = command.channel;
@@ -102,7 +152,6 @@ export async function handleQueueCommand({ command, appId, }) {
                 buildQueueRemoveRow({
                     threadId: thread.id,
                     queueId: enqueueResult.queueId,
-                    position: enqueueResult.position,
                 }),
             ],
             flags: SILENT_MESSAGE_FLAGS,
@@ -147,7 +196,7 @@ export async function handleClearQueueCommand({ command, }) {
         return;
     }
     if (position !== undefined) {
-        const removed = runtime?.removeQueuePosition(position);
+        const removed = await runtime?.removeQueuePosition(position);
         if (!removed) {
             await command.reply({
                 content: `No queued message at position ${position}`,
@@ -162,7 +211,7 @@ export async function handleClearQueueCommand({ command, }) {
         logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
         return;
     }
-    const cleared = runtime?.clearQueue() ?? [];
+    const cleared = await runtime?.clearQueue() ?? [];
     const lines = cleared.map((item, i) => {
         const label = item.command
             ? `/${item.command.name}`
@@ -257,7 +306,6 @@ export async function handleQueueCommandCommand({ command, appId, }) {
                 buildQueueRemoveRow({
                     threadId: thread.id,
                     queueId: enqueueResult.queueId,
-                    position: enqueueResult.position,
                 }),
             ],
             flags: SILENT_MESSAGE_FLAGS,

package/dist/commands/queue.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, test } from 'vitest';
+import { buildQueueRemoveCustomId, parseQueueRemoveCustomId, } from './queue.js';
+describe('queue remove custom id', () => {
+    test('round-trips thread and queue ids under Discord custom_id limit', () => {
+        const customId = buildQueueRemoveCustomId({
+            threadId: '1550106184055398531',
+            queueId: 'a1b2c3d4e5f60789',
+        });
+        expect(customId.length).toBeLessThanOrEqual(100);
+        expect(parseQueueRemoveCustomId(customId)).toEqual({
+            threadId: '1550106184055398531',
+            queueId: 'a1b2c3d4e5f60789',
+        });
+    });
+});

package/dist/commands/restart-opencode-server.js

@@ -9,7 +9,7 @@ import { ChannelType, MessageFlags, } from 'discord.js';
 import { initializeOpencodeForDirectory, restartOpencodeServer } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { disposeRuntimesForDirectory } from '../session-handler/thread-session-runtime.js';
+import { disposeRuntimesForDirectory, restorePersistedLocalQueues, } from '../session-handler/thread-session-runtime.js';
 import { registerCommands } from '../discord-command-registration.js';
 const logger = createLogger(LogPrefix.OPENCODE);
 export async function handleRestartOpencodeServerCommand({ command, appId, }) {
@@ -74,6 +74,12 @@ export async function handleRestartOpencodeServerCommand({ command, appId, }) {
         content: `Opencode server **restarted** successfully${abortMsg}. Re-registering slash commands...`,
     });
     logger.log('[RESTART] Shared opencode server restarted');
+    await restorePersistedLocalQueues({
+        discordClient: command.client,
+        appId,
+    }).catch((error) => {
+        logger.warn(`[RESTART] Failed to restore persisted queues: ${error instanceof Error ? error.message : String(error)}`);
+    });
     // Re-register Discord slash commands after restart so new/changed
     // commands, agents, and plugins are picked up immediately.
     const token = command.client.token;

package/dist/commands/session-id.js

@@ -1,4 +1,4 @@
-// /session-id command - Show current session ID and an opencode attach command.
+// /session-id command - Show current session ID, Discord thread ID, and an opencode attach command.
 import { ChannelType, MessageFlags, } from 'discord.js';
 import { getThreadSession } from '../database.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
@@ -46,7 +46,7 @@ export async function handleSessionIdCommand({ command, }) {
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
         await command.reply({
-            content: 'No active session in this thread',
+            content: `No active session in this thread\n**Thread ID:** \`${channel.id}\``,
             flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
         });
         return;
@@ -57,7 +57,7 @@ export async function handleSessionIdCommand({ command, }) {
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
         if (getClient instanceof Error) {
             await command.editReply({
-                content: `Session ID: \`${sessionId}\`\nFailed to resolve OpenCode server port: ${getClient.message}`,
+                content: `**Session ID:** \`${sessionId}\`\n**Thread ID:** \`${channel.id}\`\nFailed to resolve OpenCode server port: ${getClient.message}`,
             });
             return;
         }
@@ -65,14 +65,14 @@ export async function handleSessionIdCommand({ command, }) {
     }
     if (!port) {
         await command.editReply({
-            content: `Session ID: \`${sessionId}\`\nCould not determine OpenCode server port`,
+            content: `**Session ID:** \`${sessionId}\`\n**Thread ID:** \`${channel.id}\`\nCould not determine OpenCode server port`,
         });
         return;
     }
     const attachUrl = `http://127.0.0.1:${port}`;
     const attachCommand = `opencode attach ${attachUrl} --session ${sessionId} --dir ${shellQuote(workingDirectory)}`;
     await command.editReply({
-        content: `**Session ID:** \`${sessionId}\`\n**Attach command:**\n\`\`\`bash\n${attachCommand}\n\`\`\``,
+        content: `**Session ID:** \`${sessionId}\`\n**Thread ID:** \`${channel.id}\`\n**Attach command:**\n\`\`\`bash\n${attachCommand}\n\`\`\``,
     });
     logger.log(`Session ID shown for thread ${channel.id}: ${sessionId}`);
 }

package/dist/database.js

@@ -542,6 +542,42 @@ export async function getThreadSession(threadId) {
     const db = await getDb();
     return (await db.query.thread_sessions.findFirst({ where: { thread_id: threadId } }))?.session_id;
 }
+export async function insertThreadQueueItem({ queueId, threadId, payloadJson, }) {
+    const db = await getDb();
+    await db.insert(schema.thread_queue_items).values({
+        queue_id: queueId,
+        thread_id: threadId,
+        payload_json: payloadJson,
+    });
+}
+export async function listThreadQueueItems(threadId) {
+    const db = await getDb();
+    return db.query.thread_queue_items.findMany({
+        where: { thread_id: threadId },
+        orderBy: { id: 'asc' },
+    });
+}
+export async function listAllThreadQueueItems() {
+    const db = await getDb();
+    return db.query.thread_queue_items.findMany({
+        orderBy: { id: 'asc' },
+    });
+}
+export async function deleteThreadQueueItem(queueId) {
+    const db = await getDb();
+    const rows = await db.delete(schema.thread_queue_items).where(orm.eq(schema.thread_queue_items.queue_id, queueId)).returning();
+    return rows[0];
+}
+export async function deleteThreadQueueItems(threadId) {
+    const db = await getDb();
+    await db.delete(schema.thread_queue_items).where(orm.eq(schema.thread_queue_items.thread_id, threadId));
+}
+export async function updateThreadQueueItemPayload({ queueId, payloadJson, }) {
+    const db = await getDb();
+    await db.update(schema.thread_queue_items)
+        .set({ payload_json: payloadJson })
+        .where(orm.eq(schema.thread_queue_items.queue_id, queueId));
+}
 export async function setThreadSession(threadId, sessionId) {
     await upsertThreadSession({ threadId, sessionId, source: 'kimaki' });
 }
@@ -833,6 +869,46 @@ export async function listTrackedTextChannels() {
         columns: { channel_id: true, directory: true, created_at: true },
     });
 }
+export async function getGuildCategories(guildId) {
+    const db = await getDb();
+    const row = await db.query.guild_categories.findFirst({ where: { guild_id: guildId } });
+    if (!row)
+        return null;
+    return {
+        guild_id: row.guild_id,
+        category_id: row.category_id,
+        audio_category_id: row.audio_category_id,
+    };
+}
+export async function listGuildCategoryIds() {
+    const db = await getDb();
+    const rows = await db.query.guild_categories.findMany({
+        columns: { category_id: true, audio_category_id: true },
+    });
+    const ids = new Set();
+    for (const row of rows) {
+        if (row.category_id)
+            ids.add(row.category_id);
+        if (row.audio_category_id)
+            ids.add(row.audio_category_id);
+    }
+    return [...ids];
+}
+export async function setGuildCategoryId({ guildId, kind, categoryId, }) {
+    const db = await getDb();
+    const values = kind === 'audio'
+        ? { guild_id: guildId, audio_category_id: categoryId }
+        : { guild_id: guildId, category_id: categoryId };
+    const set = kind === 'audio'
+        ? { audio_category_id: categoryId }
+        : { category_id: categoryId };
+    await db.insert(schema.guild_categories)
+        .values(values)
+        .onConflictDoUpdate({
+        target: schema.guild_categories.guild_id,
+        set,
+    });
+}
 export async function deleteChannelDirectoriesByDirectory(directory) {
     const db = await getDb();
     await db.delete(schema.channel_directories).where(orm.eq(schema.channel_directories.directory, directory));

package/dist/db.js

@@ -89,6 +89,37 @@ async function initializeDb() {
     dbInstance = db;
     return db;
 }
+async function rebuildLegacyThreadQueueItems(client) {
+    const info = await client.execute('PRAGMA table_info(thread_queue_items)').catch(() => undefined);
+    if (!info) {
+        return;
+    }
+    const columns = new Set(info.rows.map((row) => String(row.name)));
+    if (columns.has('id')) {
+        return;
+    }
+    if (!columns.has('queue_id')) {
+        return;
+    }
+    await client.execute('ALTER TABLE thread_queue_items RENAME TO thread_queue_items_legacy');
+    await client.execute(`
+    CREATE TABLE IF NOT EXISTS thread_queue_items (
+      id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+      queue_id text NOT NULL UNIQUE,
+      thread_id text NOT NULL,
+      payload_json text NOT NULL,
+      created_at datetime DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    await client.execute(`
+    INSERT INTO thread_queue_items (queue_id, thread_id, payload_json, created_at)
+    SELECT queue_id, thread_id, payload_json, created_at
+    FROM thread_queue_items_legacy
+    ORDER BY created_at, queue_id
+  `);
+    await client.execute('DROP TABLE thread_queue_items_legacy');
+    await client.execute('CREATE INDEX IF NOT EXISTS thread_queue_items_thread_id_id_idx ON thread_queue_items (thread_id, id)');
+}
 // CREATE TABLE IF NOT EXISTS cannot drop columns. The first two session_sleeps
 // shapes kept thread_id NOT NULL and posted_at. Inserts now omit thread_id, so
 // existing DBs fail with SQLITE_CONSTRAINT_NOTNULL until those columns go away.
@@ -104,6 +135,9 @@ async function dropLegacySessionSleepsColumns(client) {
     await client.execute("UPDATE session_sleeps SET status = 'planned' WHERE status = 'posted'");
 }
 async function migrateSchema({ db, client, }) {
+    // schema.sql CREATE TABLE IF NOT EXISTS cannot change the primary key.
+    // Rebuild first so CREATE INDEX (... id) does not hit the old queue_id table.
+    await rebuildLegacyThreadQueueItems(client);
     const schemaPath = path.join(__dirname, '../src/schema.sql');
     const sql = fs.readFileSync(schemaPath, 'utf-8');
     const statements = sql

package/dist/db.test.js

@@ -7,7 +7,7 @@ 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, createPendingWorkspace, getDueSessionSleeps, getSessionEventSnapshot, getSessionModel, getSessionSleep, setSessionModel, upsertSessionSleep, } from './database.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorkspace, deleteThreadQueueItem, getDueSessionSleeps, getSessionEventSnapshot, getSessionModel, getSessionSleep, insertThreadQueueItem, listAllThreadQueueItems, listThreadQueueItems, setSessionModel, updateThreadQueueItemPayload, upsertSessionSleep, } from './database.js';
 import { createClient } from '@libsql/client';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { chooseLockPort } from './test-utils.js';
@@ -27,6 +27,101 @@ describe('getDb', () => {
         ].map((match) => match[1]);
         expect(new Set(tablesFromSql)).toEqual(new Set(tablesFromTs));
         expect(tablesFromSql).toContain('session_sleeps');
+        expect(tablesFromSql).toContain('thread_queue_items');
+    });
+    test('persists local queue items in FIFO order', async () => {
+        const db = await getDb();
+        const threadId = `test-queue-thread-${crypto.randomUUID()}`;
+        const firstId = `queue-${crypto.randomUUID()}`;
+        const secondId = `queue-${crypto.randomUUID()}`;
+        await insertThreadQueueItem({
+            queueId: firstId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'first', userId: '1', username: 'tommy' }),
+        });
+        await insertThreadQueueItem({
+            queueId: secondId,
+            threadId,
+            payloadJson: JSON.stringify({ prompt: 'second', userId: '1', username: 'tommy' }),
+        });
+        const rows = await listThreadQueueItems(threadId);
+        expect(rows.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+            'first',
+            'second',
+        ]);
+        await updateThreadQueueItemPayload({
+            queueId: firstId,
+            payloadJson: JSON.stringify({ prompt: 'first-edited', userId: '1', username: 'tommy' }),
+        });
+        await deleteThreadQueueItem(secondId);
+        const after = await listAllThreadQueueItems();
+        const remaining = after.filter((row) => row.thread_id === threadId);
+        expect(remaining).toHaveLength(1);
+        expect(JSON.parse(remaining[0].payload_json).prompt).toBe('first-edited');
+        await db.delete(schema.thread_queue_items).where(orm.eq(schema.thread_queue_items.thread_id, threadId));
+    });
+    test('rebuilds thread_queue_items that still use queue_id as the primary key', async () => {
+        await closeDb();
+        const previousDbUrl = process.env['KIMAKI_DB_URL'];
+        const dbPath = path.join(process.cwd(), `tmp/test-db-legacy-queue-${crypto.randomUUID().slice(0, 8)}.db`);
+        try {
+            const client = createClient({ url: `file:${dbPath}` });
+            await client.execute(`
+        CREATE TABLE thread_queue_items (
+          queue_id text PRIMARY KEY,
+          thread_id text NOT NULL,
+          payload_json text NOT NULL,
+          created_at datetime DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            await client.execute(`
+        CREATE INDEX thread_queue_items_thread_id_created_at_queue_id_idx
+        ON thread_queue_items (thread_id, created_at, queue_id)
+      `);
+            await client.execute(`
+        INSERT INTO thread_queue_items (queue_id, thread_id, payload_json, created_at)
+        VALUES
+          ('queue-second', 'thr-legacy-queue', '{"prompt":"second"}', '2026-09-17 10:00:02'),
+          ('queue-first', 'thr-legacy-queue', '{"prompt":"first"}', '2026-09-17 10:00:01')
+      `);
+            client.close();
+            process.env['KIMAKI_DB_URL'] = `file:${dbPath}`;
+            await getDb();
+            const rows = await listThreadQueueItems('thr-legacy-queue');
+            expect(rows.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+                'first',
+                'second',
+            ]);
+            expect(rows.map((row) => row.id)).toEqual([1, 2]);
+            await insertThreadQueueItem({
+                queueId: 'queue-third',
+                threadId: 'thr-legacy-queue',
+                payloadJson: JSON.stringify({ prompt: 'third' }),
+            });
+            const after = await listThreadQueueItems('thr-legacy-queue');
+            expect(after.map((row) => JSON.parse(row.payload_json).prompt)).toEqual([
+                'first',
+                'second',
+                'third',
+            ]);
+        }
+        finally {
+            await closeDb();
+            if (previousDbUrl === undefined) {
+                delete process.env['KIMAKI_DB_URL'];
+            }
+            else {
+                process.env['KIMAKI_DB_URL'] = previousDbUrl;
+            }
+            for (const file of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+                try {
+                    fs.unlinkSync(file);
+                }
+                catch {
+                    // Test cleanup best effort.
+                }
+            }
+        }
     });
     test('removes part_messages rows whose thread_sessions parent is gone', async () => {
         await closeDb();

package/dist/default-channel-provisioning.test.js

@@ -97,11 +97,12 @@ for (const setup of ['legacy mapping', 'explicit onboarding']) {
         const guild = client.guilds.cache.get(trustedGuildId);
         if (setup === 'legacy mapping') {
             await setChannelDirectory({ channelId: projectChannelId, directory, channelType: 'text' });
+            expect((await findChannelsByDirectory({}))[0]?.guild_id).toBeNull();
         }
         else {
             await createProjectChannels({ guild, projectDirectory: path.join(directory, 'project'), analyticsSource: 'onboarding' });
+            expect((await findChannelsByDirectory({}))[0]?.guild_id).toBe(trustedGuildId);
         }
-        expect((await findChannelsByDirectory({}))[0]?.guild_id).toBeNull();
         // Fetching actual guild channels must work even when startup cache is empty.
         guild.channels.cache.clear();
         const created = await ensureDefaultChannelsWithWelcome({

package/dist/discord-bot.js

@@ -30,7 +30,7 @@ import { cancelHtmlActionsForThread } from './html-actions.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, registerVoiceStateHandler, } from './voice-handler.js';
 import {} from './session-handler/model-utils.js';
-import { getRuntime, getOrCreateRuntime, disposeRuntime, reserveThreadIngress, runInThreadIngressSlot, } from './session-handler/thread-session-runtime.js';
+import { getRuntime, getOrCreateRuntime, disposeRuntime, restorePersistedLocalQueues, reserveThreadIngress, runInThreadIngressSlot, } from './session-handler/thread-session-runtime.js';
 import { runShellCommand } from './commands/run-command.js';
 import { registerInteractionHandler } from './interaction-handler.js';
 import { getDiscordRestApiUrl } from './discord-urls.js';
@@ -214,6 +214,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         registerInteractionHandler({ discordClient: c, appId: currentAppId });
         registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
         startExternalOpencodeSessionSync({ discordClient: c });
+        await restorePersistedLocalQueues({
+            discordClient: c,
+            appId: currentAppId,
+        }).catch((error) => {
+            discordLogger.warn(`Failed to restore persisted local queues: ${error instanceof Error ? error.stack : String(error)}`);
+        });
         // Channel logging is informational only; do it in background so startup stays responsive.
         void (async () => {
             for (const guild of c.guilds.cache.values()) {
@@ -896,7 +902,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const { prompt, forceQueue } = extractQueueSuffix(resolveMentions(message));
             // If the edit removed the queue suffix, remove the item from the queue.
             // If the suffix is still present, update the prompt.
-            const result = runtime.updateQueuedMessage(message.id, forceQueue ? prompt : '');
+            const result = await runtime.updateQueuedMessage(message.id, forceQueue ? prompt : '');
             if (result.found && channel.isThread()) {
                 const displayName = message.member?.displayName ?? message.author.displayName;
                 if (result.removed) {
@@ -924,7 +930,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const runtime = getRuntime(channel.id);
             if (!runtime)
                 return;
-            const removed = runtime.removeQueuedMessage(message.id);
+            const removed = await runtime.removeQueuedMessage(message.id);
             if (!removed)
                 return;
             discordLogger.log(`[MESSAGE_DELETE] Removed queued message ${message.id} in thread ${channel.id}`);

package/dist/discord-command-registration.js

@@ -335,7 +335,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('session-id')
-            .setDescription(truncateCommandDescription('Show current session ID and opencode attach command for this thread'))
+            .setDescription(truncateCommandDescription('Show current session ID, Discord thread ID, and opencode attach command for this thread'))
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()