kimaki 0.4.82 → 0.4.84

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/dist/anthropic-auth-plugin.js

@@ -1,6 +1,13 @@
 /**
  * Anthropic OAuth authentication plugin for OpenCode.
  *
+ * If you're copy-pasting this plugin into your OpenCode config folder,
+ * you need to install the runtime dependencies first:
+ *
+ *   cd ~/.config/opencode
+ *   bun init -y
+ *   bun add @openauthjs/openauth proper-lockfile
+ *
  * Handles two concerns:
  * 1. OAuth login + token refresh (PKCE flow against claude.ai)
  * 2. Request/response rewriting (tool names, system prompt, beta headers)

package/dist/cli.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 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, ensureKimakiCategory, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
-import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, } from './database.js';
+import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, } from './database.js';
 import { ShareMarkdown } from './markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts, } from './session-search.js';
 import { formatWorktreeName } from './commands/new-worktree.js';
@@ -26,7 +26,7 @@ import { createLogger, formatErrorWithStack, initLogFile, LogPrefix } from './lo
 import { initSentry, notifyError } from './sentry.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions, } from './discord-utils.js';
 import { spawn, execSync } from 'node:child_process';
-import { setDataDir, getDataDir, getProjectsDir, } from './config.js';
+import { setDataDir, setProjectsDir, getDataDir, getProjectsDir, } from './config.js';
 import { execAsync } from './worktrees.js';
 import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.js';
 import { startHranaServer } from './hrana-server.js';
@@ -1305,6 +1305,7 @@ cli
     .option('--restart-onboarding', 'Prompt for new credentials even if saved')
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
     .option('--install-url', 'Print the bot install URL and exit')
     .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
     .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
@@ -1332,6 +1333,10 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.projectsDir) {
+            setProjectsDir(options.projectsDir);
+            cliLogger.log(`Using projects directory: ${getProjectsDir()}`);
+        }
         // Initialize file logging to <dataDir>/kimaki.log
         initLogFile(getDataDir());
         // Batch all CLI flag store updates into a single setState call.
@@ -2353,6 +2358,7 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
+    .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
     await initDatabase();
     const prisma = await getPrisma();
@@ -2369,31 +2375,67 @@ cli
     const rest = botRow ? createDiscordRest(botRow.token) : null;
     const enriched = await Promise.all(channels.map(async (ch) => {
         let channelName = '';
+        let deleted = false;
         if (rest) {
             try {
                 const data = (await rest.get(Routes.channel(ch.channel_id)));
                 channelName = data.name || '';
             }
-            catch {
-                // Channel may have been deleted from Discord
+            catch (error) {
+                // Only mark as deleted for Unknown Channel (10003) or 404,
+                // not transient errors like rate limits or 5xx
+                const isUnknownChannel = error instanceof Error &&
+                    'code' in error &&
+                    'status' in error &&
+                    (error.code === 10003 ||
+                        error.status === 404);
+                deleted = isUnknownChannel;
             }
         }
-        return { ...ch, channelName };
+        return { ...ch, channelName, deleted };
     }));
+    // Prune stale entries if requested
+    if (options.prune) {
+        const stale = enriched.filter((ch) => {
+            return ch.deleted;
+        });
+        if (stale.length === 0) {
+            cliLogger.log('No stale channels to prune');
+        }
+        else {
+            for (const ch of stale) {
+                await deleteChannelDirectoryById(ch.channel_id);
+                cliLogger.log(`Pruned stale channel ${ch.channel_id} (${path.basename(ch.directory)})`);
+            }
+            cliLogger.log(`Pruned ${stale.length} stale channel(s)`);
+        }
+        // Re-filter to only show live entries after pruning
+        const live = enriched.filter((ch) => {
+            return !ch.deleted;
+        });
+        if (live.length === 0) {
+            cliLogger.log('No projects registered');
+            process.exit(0);
+        }
+        enriched.length = 0;
+        enriched.push(...live);
+    }
     if (options.json) {
         const output = enriched.map((ch) => ({
             channel_id: ch.channel_id,
             channel_name: ch.channelName,
             directory: ch.directory,
             folder_name: path.basename(ch.directory),
+            deleted: ch.deleted,
         }));
         console.log(JSON.stringify(output, null, 2));
         process.exit(0);
     }
     for (const ch of enriched) {
         const folderName = path.basename(ch.directory);
+        const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
         const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
-        console.log(`\n${channelLabel}`);
+        console.log(`\n${channelLabel}${deletedTag}`);
         console.log(`   Folder: ${folderName}`);
         console.log(`   Directory: ${ch.directory}`);
         console.log(`   Channel ID: ${ch.channel_id}`);
@@ -2586,6 +2628,7 @@ cli
     .option('-t, --tunnel-id [id]', 'Custom tunnel ID (only for services safe to expose publicly; prefer random default)')
     .option('-h, --host [host]', 'Local host (default: localhost)')
     .option('-s, --server [url]', 'Tunnel server URL')
+    .option('-k, --kill', 'Kill any existing process on the port before starting')
     .action(async (options) => {
     const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import('traforo/run-tunnel');
     if (!options.port) {
@@ -2607,10 +2650,11 @@ cli
         baseDomain: 'kimaki.xyz',
         serverUrl: options.server,
         command: command.length > 0 ? command : undefined,
+        kill: options.kill,
     });
 });
 cli
-    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 1 hour. Runs until Ctrl+C. Use tmux to run in background.')
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. Use tmux to run in background.')
     .action(async () => {
     const { startScreenshare } = await import('./commands/screenshare.js');
     try {

package/dist/commands/abort.js

@@ -27,23 +27,18 @@ export async function handleAbortCommand({ command, }) {
         });
         return;
     }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     const resolved = await resolveWorkingDirectory({
         channel: channel,
     });
     if (!resolved) {
-        await command.reply({
-            content: 'Could not determine project directory for this channel',
-            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
-        });
+        await command.editReply('Could not determine project directory for this channel');
         return;
     }
     const { projectDirectory } = resolved;
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
-        await command.reply({
-            content: 'No active session in this thread',
-            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
-        });
+        await command.editReply('No active session in this thread');
         return;
     }
     // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
@@ -55,10 +50,7 @@ export async function handleAbortCommand({ command, }) {
         // No runtime but session exists — fall back to direct API abort
         const getClient = await initializeOpencodeForDirectory(projectDirectory);
         if (getClient instanceof Error) {
-            await command.reply({
-                content: `Failed to abort: ${getClient.message}`,
-                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
-            });
+            await command.editReply(`Failed to abort: ${getClient.message}`);
             return;
         }
         try {
@@ -68,9 +60,6 @@ export async function handleAbortCommand({ command, }) {
             logger.error('[ABORT] API abort failed:', error);
         }
     }
-    await command.reply({
-        content: `Request **aborted**`,
-        flags: SILENT_MESSAGE_FLAGS,
-    });
+    await command.editReply('Request **aborted**');
     logger.log(`Session ${sessionId} aborted by user`);
 }

package/dist/commands/action-buttons.js

@@ -4,7 +4,7 @@
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { getThreadSession } from '../database.js';
-import { NOTIFY_MESSAGE_FLAGS, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
+import { NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
@@ -101,7 +101,7 @@ async function sendClickedActionToModel({ interaction, thread, prompt, }) {
         mode: 'opencode',
     });
 }
-export async function showActionButtons({ thread, sessionId, directory, buttons, }) {
+export async function showActionButtons({ thread, sessionId, directory, buttons, silent, }) {
     const safeButtons = buttons
         .slice(0, 3)
         .map((button) => {
@@ -145,7 +145,7 @@ export async function showActionButtons({ thread, sessionId, directory, buttons,
         const message = await thread.send({
             content: '**Action Required**',
             components: [row],
-            flags: NOTIFY_MESSAGE_FLAGS,
+            flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
         });
         context.messageId = message.id;
         logger.log(`Showed ${safeButtons.length} action button(s) for session ${sessionId}`);

package/dist/commands/add-project.js

@@ -9,7 +9,7 @@ import { abbreviatePath } from '../utils.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.ADD_PROJECT);
 export async function handleAddProjectCommand({ command, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const projectId = command.options.getString('project', true);
     const guild = command.guild;
     if (!guild) {

package/dist/commands/ask-question.js

@@ -3,7 +3,7 @@
 // for each question and collects user responses.
 import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { getOpencodeClient } from '../opencode.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.ASK_QUESTION);
@@ -15,7 +15,7 @@ export const pendingQuestionContexts = new Map();
  * Show dropdown menus for question tool input.
  * Sends one message per question with the dropdown directly under the question text.
  */
-export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, }) {
+export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, silent, }) {
     const contextHash = crypto.randomBytes(8).toString('hex');
     const context = {
         sessionId,
@@ -83,7 +83,7 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         await thread.send({
             content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
             components: [actionRow],
-            flags: NOTIFY_MESSAGE_FLAGS,
+            flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
         });
     }
     logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);

package/dist/commands/context-usage.js

@@ -75,7 +75,7 @@ export async function handleContextUsageCommand({ command, }) {
             if (m.info.role !== 'assistant') {
                 return false;
             }
-            if (!('tokens' in m.info) || !m.info.tokens) {
+            if (!m.info.tokens) {
                 return false;
             }
             return getTokenTotal(m.info.tokens) > 0;

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

@@ -58,7 +58,7 @@ export async function createNewProject({ guild, projectName, botName, }) {
     };
 }
 export async function handleCreateNewProjectCommand({ command, appId, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const projectName = command.options.getString('name', true);
     const guild = command.guild;
     const channel = command.channel;

package/dist/commands/fork.js

@@ -3,7 +3,7 @@ import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectM
 import { getThreadSession, setThreadSession, setPartMessagesBatch, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
-import { collectLastAssistantParts } from '../message-formatting.js';
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 const sessionLogger = createLogger(LogPrefix.SESSION);
@@ -135,7 +135,7 @@ export async function handleForkSelectMenu(interaction) {
         });
         return;
     }
-    await interaction.deferReply({ ephemeral: false });
+    await interaction.deferReply();
     const threadChannel = interaction.channel;
     if (!threadChannel) {
         await interaction.editReply('Could not access thread channel');
@@ -184,9 +184,11 @@ export async function handleForkSelectMenu(interaction) {
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `Forked from session ${sessionId}`,
         });
+        // Claim the forked session immediately so external polling does not race
+        // and create a duplicate Sync thread before the rest of this setup runs.
+        await setThreadSession(thread.id, forkedSession.id);
         // Add user to thread so it appears in their sidebar
         await thread.members.add(interaction.user.id);
-        await setThreadSession(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
@@ -194,13 +196,14 @@ export async function handleForkSelectMenu(interaction) {
             sessionID: forkedSession.id,
         });
         if (messagesResponse.data) {
-            const { partIds, content } = collectLastAssistantParts({
+            const { chunks } = collectSessionChunks({
                 messages: messagesResponse.data,
+                limit: 30,
             });
-            if (content.trim()) {
-                const discordMessage = await sendThreadMessage(thread, content);
-                // Store part-message mappings atomically
-                await setPartMessagesBatch(partIds.map((partId) => ({
+            const batched = batchChunksForDiscord(chunks);
+            for (const batch of batched) {
+                const discordMessage = await sendThreadMessage(thread, batch.content);
+                await setPartMessagesBatch(batch.partIds.map((partId) => ({
                     partId,
                     messageId: discordMessage.id,
                     threadId: thread.id,

package/dist/commands/merge-worktree.js

@@ -55,7 +55,7 @@ async function sendPromptToModel({ prompt, thread, projectDirectory, command, ap
     });
 }
 export async function handleMergeWorktreeCommand({ command, appId, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const channel = command.channel;
     if (!channel || !channel.isThread()) {
         await command.editReply('This command can only be used in a thread');

package/dist/commands/new-worktree.js

@@ -11,6 +11,10 @@ import { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, vali
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.WORKTREE);
+/** Status message shown while a worktree is being created. */
+export function worktreeCreatingMessage(worktreeName) {
+    return `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`;
+}
 class WorktreeError extends Error {
     constructor(message, options) {
         super(message, options);
@@ -65,37 +69,64 @@ async function getProjectDirectoryFromChannel(channel) {
     return channelConfig.directory;
 }
 /**
- * Create worktree in background and update starter message when done.
+ * Create worktree and update the status message when done.
+ * Handles the full lifecycle: pending DB entry, git creation, DB ready/error,
+ * tree emoji reaction, and editing the status message.
+ *
+ * starterMessage is optional — if omitted, status edits are skipped (creation
+ * still proceeds). This keeps worktree creation independent of Discord message
+ * delivery, so a transient send failure never silently skips the worktree.
+ *
+ * Returns the worktree directory on success, or an Error on failure.
+ * Never throws — all internal errors are caught and returned as Error values.
  */
-async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
-    logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
-    const worktreeResult = await createWorktreeWithSubmodules({
-        directory: projectDirectory,
-        name: worktreeName,
-        baseBranch,
-    });
-    if (worktreeResult instanceof Error) {
-        const errorMsg = worktreeResult.message;
-        logger.error('[NEW-WORKTREE] Error:', worktreeResult);
-        await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
-        await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
-        return;
-    }
-    // Success - update database and edit starter message
-    await setWorktreeReady({
-        threadId: thread.id,
-        worktreeDirectory: worktreeResult.directory,
-    });
-    // React with tree emoji to mark as worktree thread
-    await reactToThread({
-        rest,
-        threadId: thread.id,
-        channelId: thread.parentId || undefined,
-        emoji: '🌳',
+export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
+    return errore.tryAsync({
+        try: async () => {
+            logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
+            await createPendingWorktree({
+                threadId: thread.id,
+                worktreeName,
+                projectDirectory,
+            });
+            const worktreeResult = await createWorktreeWithSubmodules({
+                directory: projectDirectory,
+                name: worktreeName,
+                baseBranch,
+            });
+            if (worktreeResult instanceof Error) {
+                const errorMsg = worktreeResult.message;
+                logger.error('[WORKTREE] Creation failed:', worktreeResult);
+                await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
+                await starterMessage
+                    ?.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
+                    .catch(() => { });
+                return worktreeResult;
+            }
+            // Success - update database and edit starter message
+            await setWorktreeReady({
+                threadId: thread.id,
+                worktreeDirectory: worktreeResult.directory,
+            });
+            // React with tree emoji to mark as worktree thread
+            await reactToThread({
+                rest,
+                threadId: thread.id,
+                channelId: thread.parentId || undefined,
+                emoji: '🌳',
+            });
+            await starterMessage
+                ?.edit(`🌳 **Worktree: ${worktreeName}**\n` +
+                `📁 \`${worktreeResult.directory}\`\n` +
+                `🌿 Branch: \`${worktreeResult.branch}\``)
+                .catch(() => { });
+            return worktreeResult.directory;
+        },
+        catch: (e) => {
+            logger.error('[WORKTREE] Unexpected error in createWorktreeInBackground:', e);
+            return new Error(`Worktree creation failed: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+        },
     });
-    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n` +
-        `📁 \`${worktreeResult.directory}\`\n` +
-        `🌿 Branch: \`${worktreeResult.branch}\``);
 }
 async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
     const listResult = await errore.tryAsync({
@@ -121,7 +152,7 @@ async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
     return undefined;
 }
 export async function handleNewWorktreeCommand({ command, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const channel = command.channel;
     if (!channel) {
         await command.editReply('Cannot determine channel');
@@ -187,7 +218,7 @@ export async function handleNewWorktreeCommand({ command, }) {
     const result = await errore.tryAsync({
         try: async () => {
             const starterMessage = await textChannel.send({
-                content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+                content: worktreeCreatingMessage(worktreeName),
                 flags: SILENT_MESSAGE_FLAGS,
             });
             const thread = await starterMessage.startThread({
@@ -207,12 +238,6 @@ export async function handleNewWorktreeCommand({ command, }) {
         return;
     }
     const { thread, starterMessage } = result;
-    // Store pending worktree in database
-    await createPendingWorktree({
-        threadId: thread.id,
-        worktreeName,
-        projectDirectory,
-    });
     await command.editReply(`Creating worktree in ${thread.toString()}`);
     // Create worktree in background (don't await)
     createWorktreeInBackground({
@@ -282,15 +307,9 @@ async function handleWorktreeInThread({ command, thread, }) {
         await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
         return;
     }
-    // Store pending worktree in database for this existing thread
-    await createPendingWorktree({
-        threadId: thread.id,
-        worktreeName,
-        projectDirectory,
-    });
     // Send status message in thread
     const statusMessage = await thread.send({
-        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        content: worktreeCreatingMessage(worktreeName),
         flags: SILENT_MESSAGE_FLAGS,
     });
     await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);

package/dist/commands/remove-project.js

@@ -6,7 +6,7 @@ import { createLogger, LogPrefix } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
 const logger = createLogger(LogPrefix.REMOVE_PROJECT);
 export async function handleRemoveProjectCommand({ command, appId, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const directory = command.options.getString('project', true);
     const guild = command.guild;
     if (!guild) {

package/dist/commands/resume.js

@@ -4,12 +4,12 @@ import fs from 'node:fs';
 import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
-import { collectLastAssistantParts } from '../message-formatting.js';
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.RESUME);
 export async function handleResumeCommand({ command, }) {
-    await command.deferReply({ ephemeral: false });
+    await command.deferReply();
     const sessionId = command.options.getString('session', true);
     const channel = command.channel;
     const isThread = channel &&
@@ -56,9 +56,11 @@ export async function handleResumeCommand({ command, }) {
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `Resuming session ${sessionId}`,
         });
+        // Claim the resumed session immediately so external polling does not race
+        // and create a duplicate Sync thread before the rest of this setup runs.
+        await setThreadSession(thread.id, sessionId);
         // Add user to thread so it appears in their sidebar
         await thread.members.add(command.user.id);
-        await setThreadSession(thread.id, sessionId);
         logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
         const messagesResponse = await getClient().session.messages({
             sessionID: sessionId,
@@ -70,16 +72,17 @@ export async function handleResumeCommand({ command, }) {
         await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
         await sendThreadMessage(thread, `**Resumed session:** ${sessionTitle}\n**Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
         try {
-            const { partIds, content, skippedCount } = collectLastAssistantParts({
+            const { chunks, skippedCount } = collectSessionChunks({
                 messages,
+                limit: 30,
             });
             if (skippedCount > 0) {
                 await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
             }
-            if (content.trim()) {
-                const discordMessage = await sendThreadMessage(thread, content);
-                // Store part-message mappings atomically
-                await setPartMessagesBatch(partIds.map((partId) => ({
+            const batched = batchChunksForDiscord(chunks);
+            for (const batch of batched) {
+                const discordMessage = await sendThreadMessage(thread, batch.content);
+                await setPartMessagesBatch(batch.partIds.map((partId) => ({
                     partId,
                     messageId: discordMessage.id,
                     threadId: thread.id,

package/dist/commands/screenshare.js

@@ -15,11 +15,14 @@ import { startWebsockify } from '../websockify.js';
 import { createLogger } from '../logger.js';
 import { execAsync } from '../worktrees.js';
 const logger = createLogger('SCREEN');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
 /** One active screenshare per guild (Discord) or per machine (CLI) */
 const activeSessions = new Map();
 const VNC_PORT = 5900;
-const MAX_SESSION_MS = 60 * 60 * 1000; // 1 hour
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
 const TUNNEL_BASE_DOMAIN = 'kimaki.xyz';
+const SCREENSHARE_TUNNEL_ID_BYTES = 16;
 // Public noVNC client — we point it at our tunnel URL
 export function buildNoVncUrl({ tunnelHost }) {
     const params = new URLSearchParams({
@@ -32,6 +35,9 @@ export function buildNoVncUrl({ tunnelHost }) {
     });
     return `https://novnc.com/noVNC/vnc.html?${params.toString()}`;
 }
+export function createScreenshareTunnelId() {
+    return crypto.randomBytes(SCREENSHARE_TUNNEL_ID_BYTES).toString('hex');
+}
 // macOS has two separate services:
 // - "Screen Sharing" = view-only VNC (com.apple.screensharing)
 // - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
@@ -170,7 +176,7 @@ export async function startScreenshare({ sessionKey, startedBy, }) {
         throw err;
     }
     // Step 3: create tunnel
-    const tunnelId = crypto.randomBytes(8).toString('hex');
+    const tunnelId = createScreenshareTunnelId();
     const tunnelClient = new TunnelClient({
         localPort: wsInstance.port,
         tunnelId,
@@ -197,9 +203,9 @@ export async function startScreenshare({ sessionKey, startedBy, }) {
     const tunnelHost = `${tunnelId}-tunnel.${TUNNEL_BASE_DOMAIN}`;
     const tunnelUrl = `https://${tunnelHost}`;
     const noVncUrl = buildNoVncUrl({ tunnelHost });
-    // Auto-kill after 1 hour
+    // Auto-kill after a short session so a leaked URL does not stay usable all day.
     const timeoutTimer = setTimeout(() => {
-        logger.log(`Screen share auto-stopped after 1 hour (key: ${sessionKey})`);
+        logger.log(`Screen share auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
         stopScreenshare({ sessionKey });
     }, MAX_SESSION_MS);
     // Don't keep the process alive just for this timer
@@ -240,14 +246,16 @@ export async function handleScreenshareCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
     try {
         const session = await startScreenshare({
             sessionKey: guildId,
             startedBy: command.user.tag,
         });
         await command.editReply({
-            content: `Screen sharing started\n${session.noVncUrl}`,
+            content: `Screen sharing started. This reply is private and the URL uses a high-entropy tunnel id. ` +
+                `It will auto-stop after ${MAX_SESSION_MINUTES} minutes. Use /screenshare-stop to stop sooner.\n` +
+                `${session.noVncUrl}`,
         });
     }
     catch (err) {