kimaki 0.4.23 → 0.4.25

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kimaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+
+// CLI entrypoint with automatic restart capability.
+// Spawns the main CLI and restarts it on non-zero exit codes with throttling.
+// Exit codes 0, 130 (SIGINT), 143 (SIGTERM), or 64 (EXIT_NO_RESTART) terminate cleanly.
+
 import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
@@ -62,4 +67,4 @@ async function run() {
 run().catch(err => {
   console.error('Fatal error:', err)
   process.exit(1)
-})
+})

package/dist/ai-tool-to-genai.js

@@ -1,3 +1,6 @@
+// AI SDK to Google GenAI tool converter.
+// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
 import { Type } from '@google/genai';
 import { z, toJSONSchema } from 'zod';
 /**

package/dist/channel-management.js

@@ -1,3 +1,6 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
 import { ChannelType, } from 'discord.js';
 import path from 'node:path';
 import { getDatabase } from './database.js';

package/dist/cli.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// Main CLI entrypoint for the Kimaki Discord bot.
+// Handles interactive setup, Discord OAuth, slash command registration,
+// project channel creation, and launching the bot with opencode integration.
 import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
@@ -13,31 +16,84 @@ const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
 const LOCK_PORT = 29988;
+async function killProcessOnPort(port) {
+    const isWindows = process.platform === 'win32';
+    const myPid = process.pid;
+    try {
+        if (isWindows) {
+            // Windows: find PID using netstat, then kill
+            const result = spawnSync('cmd', ['/c', `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`], {
+                shell: false,
+                encoding: 'utf-8',
+            });
+            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            // Filter out our own PID and take the first (oldest)
+            const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
+            if (targetPid) {
+                cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`);
+                spawnSync('taskkill', ['/F', '/PID', targetPid], { shell: false });
+                return true;
+            }
+        }
+        else {
+            // Unix: use lsof with -sTCP:LISTEN to only find the listening process
+            const result = spawnSync('lsof', ['-i', `:${port}`, '-sTCP:LISTEN', '-t'], {
+                shell: false,
+                encoding: 'utf-8',
+            });
+            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            // Filter out our own PID and take the first (oldest)
+            const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
+            if (targetPid) {
+                cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`);
+                process.kill(parseInt(targetPid, 10), 'SIGKILL');
+                return true;
+            }
+        }
+    }
+    catch {
+        // Failed to kill, continue anyway
+    }
+    return false;
+}
 async function checkSingleInstance() {
     try {
         const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
             signal: AbortSignal.timeout(1000),
         });
         if (response.ok) {
-            cliLogger.error('Another kimaki instance is already running');
-            process.exit(1);
+            cliLogger.log('Another kimaki instance detected');
+            await killProcessOnPort(LOCK_PORT);
+            // Wait a moment for port to be released
+            await new Promise((resolve) => { setTimeout(resolve, 500); });
         }
     }
     catch {
         // Connection refused means no instance running, continue
     }
 }
-function startLockServer() {
-    const server = http.createServer((req, res) => {
-        res.writeHead(200);
-        res.end('kimaki');
-    });
-    server.listen(LOCK_PORT, '127.0.0.1');
-    server.on('error', (err) => {
-        if (err.code === 'EADDRINUSE') {
-            cliLogger.error('Another kimaki instance is already running');
-            process.exit(1);
-        }
+async function startLockServer() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            res.writeHead(200);
+            res.end('kimaki');
+        });
+        server.listen(LOCK_PORT, '127.0.0.1');
+        server.once('listening', () => {
+            resolve();
+        });
+        server.on('error', async (err) => {
+            if (err.code === 'EADDRINUSE') {
+                cliLogger.log('Port still in use, retrying...');
+                await killProcessOnPort(LOCK_PORT);
+                await new Promise((r) => { setTimeout(r, 500); });
+                // Retry once
+                server.listen(LOCK_PORT, '127.0.0.1');
+            }
+            else {
+                reject(err);
+            }
+        });
     });
 }
 const EXIT_NO_RESTART = 64;
@@ -125,6 +181,29 @@ async function registerCommands(token, appId) {
             .setName('model')
             .setDescription('Set the preferred model for this channel or session')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('queue')
+            .setDescription('Queue a message to be sent after the current response finishes')
+            .addStringOption((option) => {
+            option
+                .setName('message')
+                .setDescription('The message to queue')
+                .setRequired(true);
+            return option;
+        })
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('clear-queue')
+            .setDescription('Clear all queued messages in this thread')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('undo')
+            .setDescription('Undo the last assistant message (revert file changes)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('redo')
+            .setDescription('Redo previously undone changes')
+            .toJSON(),
     ];
     const rest = new REST().setToken(token);
     try {
@@ -469,7 +548,7 @@ cli
     .action(async (options) => {
     try {
         await checkSingleInstance();
-        startLockServer();
+        await startLockServer();
         await run({
             restart: options.restart,
             addChannels: options.addChannels,

package/dist/commands/abort.js

@@ -0,0 +1,78 @@
+// /abort command - Abort the current OpenCode request in this thread.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { abortControllers } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ABORT');
+export async function handleAbortCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        const existingController = abortControllers.get(sessionId);
+        if (existingController) {
+            existingController.abort(new Error('User requested abort'));
+            abortControllers.delete(sessionId);
+        }
+        const getClient = await initializeOpencodeForDirectory(directory);
+        await getClient().session.abort({
+            path: { id: sessionId },
+        });
+        await command.reply({
+            content: `🛑 Request **aborted**`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} aborted by user`);
+    }
+    catch (error) {
+        logger.error('[ABORT] Error:', error);
+        await command.reply({
+            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/add-project.js

@@ -0,0 +1,97 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { createProjectChannels } from '../channel-management.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('ADD-PROJECT');
+export async function handleAddProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectId = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await command.editReply('Failed to fetch projects');
+            return;
+        }
+        const project = projectsResponse.data.find((p) => p.id === projectId);
+        if (!project) {
+            await command.editReply('Project not found');
+            return;
+        }
+        const directory = project.worktree;
+        if (!fs.existsSync(directory)) {
+            await command.editReply(`Directory does not exist: ${directory}`);
+            return;
+        }
+        const db = getDatabase();
+        const existingChannel = db
+            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+            .get(directory, 'text');
+        if (existingChannel) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+            return;
+        }
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory: directory,
+            appId,
+        });
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+        logger.log(`Created channels for project ${channelName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[ADD-PROJECT] Error:', error);
+        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleAddProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    try {
+        const currentDir = process.cwd();
+        const getClient = await initializeOpencodeForDirectory(currentDir);
+        const projectsResponse = await getClient().project.list({});
+        if (!projectsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const db = getDatabase();
+        const existingDirs = db
+            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+            .all('text');
+        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+        const projects = availableProjects
+            .filter((project) => {
+            const baseName = path.basename(project.worktree);
+            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .sort((a, b) => {
+            const aTime = a.time.initialized || a.time.created;
+            const bTime = b.time.initialized || b.time.created;
+            return bTime - aTime;
+        })
+            .slice(0, 25)
+            .map((project) => {
+            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                value: project.id,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/create-new-project.js

@@ -0,0 +1,78 @@
+// /create-new-project command - Create a new project folder, initialize git, and start a session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createProjectChannels } from '../channel-management.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('CREATE-NEW-PROJECT');
+export async function handleCreateNewProjectCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const projectName = command.options.getString('name', true);
+    const guild = command.guild;
+    const channel = command.channel;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in a text channel');
+        return;
+    }
+    const sanitizedName = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        await command.editReply('Invalid project name');
+        return;
+    }
+    const kimakiDir = path.join(os.homedir(), 'kimaki');
+    const projectDirectory = path.join(kimakiDir, sanitizedName);
+    try {
+        if (!fs.existsSync(kimakiDir)) {
+            fs.mkdirSync(kimakiDir, { recursive: true });
+            logger.log(`Created kimaki directory: ${kimakiDir}`);
+        }
+        if (fs.existsSync(projectDirectory)) {
+            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+            return;
+        }
+        fs.mkdirSync(projectDirectory, { recursive: true });
+        logger.log(`Created project directory: ${projectDirectory}`);
+        const { execSync } = await import('node:child_process');
+        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+        logger.log(`Initialized git in: ${projectDirectory}`);
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+            guild,
+            projectDirectory,
+            appId,
+        });
+        const textChannel = (await guild.channels.fetch(textChannelId));
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+        const starterMessage = await textChannel.send({
+            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: `Init: ${sanitizedName}`,
+            autoArchiveDuration: 1440,
+            reason: 'New project session',
+        });
+        await handleOpencodeSession({
+            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+            thread,
+            projectDirectory,
+            channelId: textChannel.id,
+        });
+        logger.log(`Created new project ${channelName} at ${projectDirectory}`);
+    }
+    catch (error) {
+        logger.error('[CREATE-NEW-PROJECT] Error:', error);
+        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/fork.js

@@ -0,0 +1,186 @@
+// /fork command - Fork the session from a past user message.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger } from '../logger.js';
+const sessionLogger = createLogger('SESSION');
+const forkLogger = createLogger('FORK');
+export async function handleForkCommand(interaction) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await interaction.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await interaction.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await interaction.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Defer reply before API calls to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    const sessionId = row.session_id;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch session messages',
+            });
+            return;
+        }
+        const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user');
+        if (userMessages.length === 0) {
+            await interaction.editReply({
+                content: 'No user messages found in this session',
+            });
+            return;
+        }
+        const recentMessages = userMessages.slice(-25);
+        const options = recentMessages.map((m, index) => {
+            const textPart = m.parts.find((p) => p.type === 'text');
+            const preview = textPart?.text?.slice(0, 80) || '(no text)';
+            const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`;
+            return {
+                label: label.slice(0, 100),
+                value: m.info.id,
+                description: new Date(m.info.time.created).toLocaleString().slice(0, 50),
+            };
+        });
+        const encodedDir = Buffer.from(directory).toString('base64');
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`fork_select:${sessionId}:${encodedDir}`)
+            .setPlaceholder('Select a message to fork from')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder()
+            .addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Fork Session**\nSelect the user message to fork from. The forked session will continue as if you had not sent that message:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        forkLogger.error('Error loading messages:', error);
+        await interaction.editReply({
+            content: `Failed to load messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleForkSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('fork_select:')) {
+        return;
+    }
+    const [, sessionId, encodedDir] = customId.split(':');
+    if (!sessionId || !encodedDir) {
+        await interaction.reply({
+            content: 'Invalid selection data',
+            ephemeral: true,
+        });
+        return;
+    }
+    const directory = Buffer.from(encodedDir, 'base64').toString('utf-8');
+    const selectedMessageId = interaction.values[0];
+    if (!selectedMessageId) {
+        await interaction.reply({
+            content: 'No message selected',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.deferReply({ ephemeral: false });
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const forkResponse = await getClient().session.fork({
+            path: { id: sessionId },
+            body: { messageID: selectedMessageId },
+        });
+        if (!forkResponse.data) {
+            await interaction.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const parentChannel = interaction.channel;
+        if (!parentChannel || ![
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(parentChannel.type)) {
+            await interaction.editReply('Could not access parent channel');
+            return;
+        }
+        const textChannel = await resolveTextChannel(parentChannel);
+        if (!textChannel) {
+            await interaction.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const thread = await textChannel.threads.create({
+            name: `Fork: ${forkedSession.title}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `Forked from session ${sessionId}`,
+        });
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+            .run(thread.id, forkedSession.id);
+        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id}`);
+        await sendThreadMessage(thread, `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``);
+        // Fetch and display the last assistant messages from the forked session
+        const messagesResponse = await getClient().session.messages({
+            path: { id: forkedSession.id },
+        });
+        if (messagesResponse.data) {
+            const { partIds, content } = collectLastAssistantParts({
+                messages: messagesResponse.data,
+            });
+            if (content.trim()) {
+                const discordMessage = await sendThreadMessage(thread, content);
+                // Store part-message mappings for future reference
+                const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                const transaction = getDatabase().transaction((ids) => {
+                    for (const partId of ids) {
+                        stmt.run(partId, discordMessage.id, thread.id);
+                    }
+                });
+                transaction(partIds);
+            }
+        }
+        await sendThreadMessage(thread, `You can now continue the conversation from this point.`);
+        await interaction.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        forkLogger.error('Error forking session:', error);
+        await interaction.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}