kimaki 0.28.0 → 0.30.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 { asSystemLine, 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: asSystemLine('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: asSystemLine(`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;
@@ -95,14 +145,13 @@ 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: [
                 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}`,
@@ -156,13 +205,13 @@ 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}`);
         return;
     }
-    const cleared = runtime?.clearQueue() ?? [];
+    const cleared = await runtime?.clearQueue() ?? [];
     const lines = cleared.map((item, i) => {
         const label = item.command
             ? `/${item.command.name}`
@@ -174,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}`);
@@ -250,14 +299,13 @@ 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: [
                 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

@@ -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();
@@ -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,24 +869,131 @@ 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));
 }
-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;
@@ -906,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;
 }

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