kimaki 0.20.1 → 0.22.0

package/dist/agent-model.e2e.test.js

@@ -539,13 +539,14 @@ describe('agent model resolution', () => {
         const db = await getDb();
         await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
         await db.delete(schema.channel_models).where(orm.eq(schema.channel_models.channel_id, TEXT_CHANNEL_ID));
+        const existingThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id));
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: btw-source-msg',
         });
         const sourceThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: btw-source-msg';
+            predicate: (thread) => {
+                return !existingThreadIds.has(thread.id);
             },
         });
         await waitForFooterMessage({
@@ -567,13 +568,14 @@ describe('agent model resolution', () => {
             channelId: TEXT_CHANNEL_ID,
             modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
         });
+        const existingForkThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => thread.id));
         await discord.thread(sourceThread.id).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: btw-model-check. btw',
         });
         const forkedThread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'btw: Reply with exactly: btw-model-check';
+            predicate: (thread) => {
+                return !existingForkThreadIds.has(thread.id);
             },
         });
         await waitForFooterMessage({

package/dist/cli-commands/project.js

@@ -98,6 +98,8 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
     await initDatabase();
@@ -106,20 +108,19 @@ cli
         where: { channel_type: 'text' },
         orderBy: { created_at: 'desc' },
     });
-    if (channels.length === 0) {
-        cliLogger.log('No projects registered');
-        process.exit(0);
-    }
-    // Fetch Discord channel names via REST API
+    // Fetch Discord channel names and guild IDs via REST API
     const botRow = await getBotTokenWithMode();
     const rest = botRow ? createDiscordRest(botRow.token) : null;
+    const localChannelIds = new Set(channels.map((ch) => ch.channel_id));
     const enriched = await Promise.all(channels.map(async (ch) => {
         let channelName = '';
+        let guildId = '';
         let deleted = false;
         if (rest) {
             try {
                 const data = (await rest.get(Routes.channel(ch.channel_id)));
                 channelName = data.name || '';
+                guildId = data.guild_id || '';
             }
             catch (error) {
                 // Only mark as deleted for Unknown Channel (10003) or 404,
@@ -130,13 +131,100 @@ cli
                 deleted = isUnknownChannel;
             }
         }
-        return { ...ch, channelName, deleted };
+        return { ...ch, channelName, guildId, deleted, isLocal: true };
+    }));
+    // Fetch guild names for unique guild IDs (deduplicated to save API calls)
+    const guildNameMap = new Map();
+    // Collect guild IDs from local channels + explicit --guild flag
+    const guildIdsFromChannels = enriched.map((ch) => ch.guildId).filter(Boolean);
+    if (options.guild) {
+        guildIdsFromChannels.push(options.guild);
+    }
+    const uniqueGuildIds = [...new Set(guildIdsFromChannels)];
+    if (rest) {
+        await Promise.all(uniqueGuildIds.map(async (guildId) => {
+            try {
+                const data = (await rest.get(Routes.guild(guildId)));
+                guildNameMap.set(guildId, data.name || '');
+            }
+            catch (error) {
+                cliLogger.debug(`Failed to fetch guild ${guildId}:`, error instanceof Error ? error.stack : String(error));
+            }
+        }));
+    }
+    // When --all is passed, scan each guild's channels to find Kimaki category
+    // text channels not in our local DB (projects from other machines).
+    // Fail explicitly when prerequisites are missing so the user doesn't
+    // confuse "scan never ran" with "no remote projects found".
+    let remoteEntries = [];
+    if (options.all) {
+        if (!rest) {
+            cliLogger.error('Discord credentials are required to scan remote projects. Run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (uniqueGuildIds.length === 0) {
+            cliLogger.error('Cannot determine which Discord server to scan. Pass `--guild <guildId>` or register a local project first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        let guildScanFailures = 0;
+        for (const guildId of uniqueGuildIds) {
+            try {
+                const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
+                // Find Kimaki category channels (type 4 = GuildCategory)
+                const kimakiCategoryIds = new Set(guildChannels
+                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .map((ch) => ch.id));
+                // Find text channels (type 0) in Kimaki categories that are not in our local DB
+                for (const ch of guildChannels) {
+                    if (ch.type === 0 &&
+                        ch.parent_id &&
+                        kimakiCategoryIds.has(ch.parent_id) &&
+                        !localChannelIds.has(ch.id)) {
+                        remoteEntries.push({
+                            channel_id: ch.id,
+                            directory: '',
+                            channel_type: 'text',
+                            created_at: null,
+                            channelName: ch.name,
+                            guildId,
+                            deleted: false,
+                            isLocal: false,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                guildScanFailures++;
+                cliLogger.warn(`Failed to scan guild ${guildNameMap.get(guildId) || guildId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (guildScanFailures === uniqueGuildIds.length) {
+            cliLogger.error('Failed to scan all guilds. Check bot permissions or try again.');
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
+    // Build final enriched entries with guild names resolved
+    const allEntries = [...enriched, ...remoteEntries];
+    const enrichedWithGuild = allEntries.map((ch) => ({
+        ...ch,
+        guildName: ch.guildId ? (guildNameMap.get(ch.guildId) || '') : '',
     }));
+    // Warn on stderr if the same directory appears in multiple channels (multi-guild duplicates)
+    const directoryCounts = new Map();
+    for (const ch of enrichedWithGuild) {
+        if (!ch.deleted && ch.directory) {
+            directoryCounts.set(ch.directory, (directoryCounts.get(ch.directory) || 0) + 1);
+        }
+    }
+    for (const [dir, count] of directoryCounts) {
+        if (count > 1) {
+            cliLogger.warn(`Directory "${dir}" is registered in ${count} channels. Use channel_id to disambiguate.`);
+        }
+    }
     // Prune stale entries if requested
+    let finalEntries = enrichedWithGuild;
     if (options.prune) {
-        const stale = enriched.filter((ch) => {
-            return ch.deleted;
-        });
+        const stale = finalEntries.filter((ch) => ch.deleted && ch.isLocal);
         if (stale.length === 0) {
             cliLogger.log('No stale channels to prune');
         }
@@ -147,37 +235,73 @@ cli
             }
             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) {
+        finalEntries = finalEntries.filter((ch) => !ch.deleted);
+        if (finalEntries.length === 0) {
             cliLogger.log('No projects registered');
             process.exit(0);
         }
-        enriched.length = 0;
-        enriched.push(...live);
+    }
+    if (finalEntries.length === 0) {
+        cliLogger.log('No projects registered');
+        process.exit(0);
     }
     if (options.json) {
-        const output = enriched.map((ch) => ({
+        const output = finalEntries.map((ch) => ({
             channel_id: ch.channel_id,
             channel_name: ch.channelName,
-            directory: ch.directory,
-            folder_name: path.basename(ch.directory),
+            guild_id: ch.guildId,
+            guild_name: ch.guildName,
+            directory: ch.directory || null,
+            folder_name: ch.directory ? path.basename(ch.directory) : null,
             deleted: ch.deleted,
+            is_local: ch.isLocal,
         }));
         console.log(JSON.stringify(output, null, 2));
         process.exit(0);
     }
-    for (const ch of enriched) {
-        const folderName = path.basename(ch.directory);
+    for (const ch of finalEntries) {
         const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
+        const remoteTag = !ch.isLocal ? ' [remote]' : '';
         const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
-        console.log(`\n${channelLabel}${deletedTag}`);
-        console.log(`   Folder: ${folderName}`);
-        console.log(`   Directory: ${ch.directory}`);
+        const guildLabel = ch.guildName || ch.guildId || '';
+        const guildSuffix = guildLabel ? ` (${guildLabel})` : '';
+        console.log(`\n${channelLabel}${guildSuffix}${deletedTag}${remoteTag}`);
+        if (ch.isLocal && ch.directory) {
+            const folderName = path.basename(ch.directory);
+            console.log(`   Folder: ${folderName}`);
+            console.log(`   Directory: ${ch.directory}`);
+        }
+        else if (!ch.isLocal) {
+            console.log(`   (Not registered on this machine)`);
+        }
         console.log(`   Channel ID: ${ch.channel_id}`);
+        if (ch.guildId) {
+            console.log(`   Guild ID: ${ch.guildId}`);
+        }
+    }
+    process.exit(0);
+});
+cli
+    .command('project remove <channelId>', 'Remove a project channel mapping from the local database (does not delete the Discord channel)')
+    .action(async (channelId) => {
+    await initDatabase();
+    const db = await getDb();
+    const row = await db.query.channel_directories.findFirst({
+        where: { channel_id: channelId },
+    });
+    if (!row) {
+        cliLogger.error(`No channel mapping found for channel ID: ${channelId}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const removed = await deleteChannelDirectoryById(channelId);
+    if (!removed) {
+        cliLogger.error(`Channel mapping disappeared before it could be removed: ${channelId}`);
+        process.exit(EXIT_NO_RESTART);
     }
+    cliLogger.log(`Removed channel mapping:`);
+    cliLogger.log(`  Channel ID: ${channelId}`);
+    cliLogger.log(`  Directory: ${row.directory}`);
+    cliLogger.log(`  Type: ${row.channel_type}`);
     process.exit(0);
 });
 cli

package/dist/cli-commands/send.js

@@ -15,7 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getChannelWorktreesEnabled } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -24,7 +24,7 @@ import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-e
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
-import { execAsync, resolveSessionWorkingDirectory } from '../worktrees.js';
+import { execAsync, resolveSessionWorkingDirectory, isGitRepositoryRoot } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
@@ -48,9 +48,12 @@ cli
     'Actions: allow, deny, ask. Examples: --permission "bash:deny" --permission "edit:deny"'))
     .option('--injection-guard <pattern>', z.array(z.string()).describe('Injection guard scan pattern (repeatable). Enables prompt injection detection for this session. ' +
     'Format: "tool:argsGlob". Examples: --injection-guard "bash:*" --injection-guard "webfetch:*"'))
+    .option('-f, --file <path>', z.array(z.string()).describe('Local file to attach (repeatable). Images, text files, PDFs, etc. ' +
+    'Examples: --file screenshot.png --file report.pdf'))
     .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
     .option('--thread <threadId>', 'Post prompt to an existing thread')
     .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
+    .option('--parent-session <sessionId>', 'Parent OpenCode session ID for newly created child sessions')
     .option('--wait', 'Wait for session to complete, then print session text to stdout')
     .action(async (options) => {
     try {
@@ -79,16 +82,45 @@ cli
             cliLogger.error('Prompt is required. Use --prompt <prompt>');
             process.exit(EXIT_NO_RESTART);
         }
+        const filePaths = options.file?.length
+            ? options.file.map((f) => path.resolve(f))
+            : undefined;
         if (sendAt) {
             if (options.wait) {
                 cliLogger.error('Cannot use --wait with --send-at');
                 process.exit(EXIT_NO_RESTART);
             }
+            if (filePaths?.length) {
+                cliLogger.error('Cannot use --file with --send-at');
+                process.exit(EXIT_NO_RESTART);
+            }
             if (prompt.length > 1900) {
                 cliLogger.error('--send-at currently supports prompts up to 1900 characters');
                 process.exit(EXIT_NO_RESTART);
             }
         }
+        // Validate all --file paths exist and are regular files
+        if (filePaths?.length) {
+            // Discord allows max 10 attachments per message. Long prompts also
+            // consume one slot (prompt.md), so reserve space for that.
+            const maxUserFiles = prompt.length > 2000 ? 9 : 10;
+            if (filePaths.length > maxUserFiles) {
+                cliLogger.error(`Too many files: ${filePaths.length} provided, Discord allows at most ${maxUserFiles} attachments per message` +
+                    (maxUserFiles === 9 ? ' (1 slot reserved for long prompt)' : ''));
+                process.exit(EXIT_NO_RESTART);
+            }
+            for (const file of filePaths) {
+                if (!fs.existsSync(file)) {
+                    cliLogger.error(`File not found: ${file}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+                const stat = fs.statSync(file);
+                if (!stat.isFile()) {
+                    cliLogger.error(`Not a regular file: ${file}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+            }
+        }
         const parsedSchedule = (() => {
             if (!sendAt) {
                 return null;
@@ -299,6 +331,7 @@ cli
                     userId: null,
                     permissions: options.permission?.length ? options.permission : null,
                     injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+                    parentSessionId: options.parentSession || null,
                 };
                 const taskId = await createScheduledTask({
                     scheduleKind: parsedSchedule.scheduleKind,
@@ -325,6 +358,7 @@ cli
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
                 ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
+                ...(options.parentSession && { parentSessionId: options.parentSession }),
             };
             const promptEmbed = [
                 {
@@ -342,6 +376,7 @@ cli
                 botToken,
                 embeds: promptEmbed,
                 rest,
+                files: filePaths,
             });
             const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
             const existingSessionId = sessionId || await getThreadSession(targetThreadId);
@@ -415,12 +450,19 @@ cli
                 : cleanPrompt);
         // Explicit string => use as-is via formatWorktreeName (no vowel strip).
         // Boolean true => derived from thread/prompt, compress via formatAutoWorktreeName.
+        // When no --worktree flag but channel has worktrees enabled via toggle,
+        // the bot-side ThreadCreate handler auto-creates the worktree. We add
+        // the prefix here for cosmetic consistency (thread name shows 🌳).
+        const channelWorktreesEnabled = !options.worktree && !options.cwd && !notifyOnly && projectDirectory
+            ? (await getChannelWorktreesEnabled(channelId)) &&
+                (await isGitRepositoryRoot(projectDirectory))
+            : false;
         const worktreeName = options.worktree
             ? typeof options.worktree === 'string'
                 ? formatWorktreeName(options.worktree)
                 : formatAutoWorktreeName(baseThreadName)
             : undefined;
-        const threadName = worktreeName
+        const threadName = worktreeName || channelWorktreesEnabled
             ? `${WORKTREE_PREFIX}${baseThreadName}`
             : baseThreadName;
         if (parsedSchedule) {
@@ -438,6 +480,7 @@ cli
                 userId: resolvedUser?.id || null,
                 permissions: options.permission?.length ? options.permission : null,
                 injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+                parentSessionId: options.parentSession || null,
             };
             const taskId = await createScheduledTask({
                 scheduleKind: parsedSchedule.scheduleKind,
@@ -471,6 +514,7 @@ cli
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length && { permissions: options.permission }),
                 ...(options.injectionGuard?.length && { injectionGuardPatterns: options.injectionGuard }),
+                ...(options.parentSession && { parentSessionId: options.parentSession }),
             };
         const autoStartEmbed = embedMarker
             ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } }]
@@ -482,6 +526,7 @@ cli
             embeds: autoStartEmbed,
             rest,
             splitInsteadOfAttach: notifyOnly,
+            files: filePaths,
         });
         // For notify-only on non-project channels, just post the message without
         // creating a thread. There's no session to start, so a thread is unnecessary.

package/dist/cli-runner.js

@@ -12,6 +12,7 @@ import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInt
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
+import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -134,8 +135,64 @@ export function isThreadChannelType(type) {
         ChannelType.AnnouncementThread,
     ].includes(type);
 }
-export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, }) {
+export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, files, }) {
     const discordMaxLength = 2000;
+    // When files are provided, always use multipart FormData upload
+    if (files?.length) {
+        const { DISCORD_DEFAULT_MAX_FILE_SIZE } = await import('./discord-utils.js');
+        const { default: mime } = await import('mime');
+        for (const file of files) {
+            const stat = fs.statSync(file);
+            if (stat.size > DISCORD_DEFAULT_MAX_FILE_SIZE) {
+                const fileMB = (stat.size / 1024 / 1024).toFixed(1);
+                const limitMB = (DISCORD_DEFAULT_MAX_FILE_SIZE / 1024 / 1024).toFixed(0);
+                throw new Error(`File "${path.basename(file)}" is ${fileMB} MB, which exceeds Discord's ${limitMB} MB upload limit`);
+            }
+        }
+        // When prompt exceeds Discord's limit, attach it as prompt.md alongside
+        // user files so nothing is silently lost.
+        const isLongPrompt = prompt.length > discordMaxLength;
+        const content = isLongPrompt
+            ? `Prompt attached as file (${prompt.length} chars)\n\n> ${prompt.slice(0, 100).replace(/\n/g, ' ')}...`
+            : prompt;
+        // Build attachment metadata: user files + optional prompt.md
+        const allFiles = files.map((file) => ({
+            filePath: file,
+            filename: path.basename(file),
+            mimeType: mime.getType(file) || 'application/octet-stream',
+        }));
+        if (isLongPrompt) {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
+            const tmpFile = path.join(tmpDir, 'prompt.md');
+            fs.writeFileSync(tmpFile, prompt);
+            allFiles.push({ filePath: tmpFile, filename: 'prompt.md', mimeType: 'text/markdown' });
+        }
+        const attachments = allFiles.map((f, index) => ({
+            id: index,
+            filename: f.filename,
+        }));
+        const formData = new FormData();
+        formData.append('payload_json', JSON.stringify({
+            content,
+            attachments,
+            embeds,
+            allowed_mentions: { parse: store.getState().allowedMentions },
+        }));
+        for (const [index, f] of allFiles.entries()) {
+            const buffer = fs.readFileSync(f.filePath);
+            formData.append(`files[${index}]`, new Blob([buffer], { type: f.mimeType }), f.filename);
+        }
+        const response = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
+            method: 'POST',
+            headers: { Authorization: `Bot ${botToken}` },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Discord API error: ${response.status} - ${error}`);
+        }
+        return (await response.json());
+    }
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
             body: {
@@ -174,11 +231,8 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
     const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
-    const tmpDir = path.join(process.cwd(), 'tmp');
-    if (!fs.existsSync(tmpDir)) {
-        fs.mkdirSync(tmpDir, { recursive: true });
-    }
-    const tmpFile = path.join(tmpDir, `prompt-${Date.now()}.md`);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
+    const tmpFile = path.join(tmpDir, 'prompt.md');
     // Wrap long lines so the file is readable in Discord's preview
     // (Discord doesn't wrap text in file attachments)
     const wrappedPrompt = prompt
@@ -235,6 +289,7 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     }
     finally {
         fs.unlinkSync(tmpFile);
+        fs.rmdirSync(tmpDir);
     }
 }
 export function formatRelativeTime(target) {
@@ -308,7 +363,7 @@ function readErrorField(error, key) {
     }
     return undefined;
 }
-/** Transient network errors that may resolve on retry (DNS down, gateway unreachable). */
+/** Transient network errors that may resolve on retry (DNS down, gateway unreachable, TLS blips). */
 const TRANSIENT_ERROR_CODES = new Set([
     'ENOTFOUND',
     'ECONNREFUSED',
@@ -318,13 +373,37 @@ const TRANSIENT_ERROR_CODES = new Set([
     'EPIPE',
     'EHOSTUNREACH',
     'ENETUNREACH',
+    // TLS/cert errors can be transient (intermediate CA blip, MITM proxy, cert rotation).
+    // Without these, Discord login failure exits EXIT_NO_RESTART and the bin wrapper
+    // never restarts — the bot dies permanently on "unable to verify the first certificate".
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'UNABLE_TO_GET_ISSUER_CERT',
+    'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+    'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY',
+    'CERT_SIGNATURE_FAILURE',
+    'CERT_NOT_YET_VALID',
+    'CERT_HAS_EXPIRED',
+    'CRL_HAS_EXPIRED',
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'ERR_TLS_CERT_ALTNAME_INVALID',
 ]);
+const TRANSIENT_ERROR_MESSAGE_PATTERNS = [
+    /unable to verify the first certificate/i,
+    /certificate has expired/i,
+    /self[- ]signed certificate/i,
+    /unable to get local issuer certificate/i,
+];
 export function isTransientNetworkError(error) {
     if (!(error instanceof Error))
         return false;
     const code = error.code;
     if (code && TRANSIENT_ERROR_CODES.has(code))
         return true;
+    // Fallback when code is stripped by wrappers (discord.js sometimes rethrows by message only).
+    if (TRANSIENT_ERROR_MESSAGE_PATTERNS.some((pattern) => pattern.test(error.message))) {
+        return true;
+    }
     // discord.js wraps errors in cause chains
     if (error.cause instanceof Error)
         return isTransientNetworkError(error.cause);

package/dist/cli-runner.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { getOpenUrlCommand } from './cli-runner.js';
+import { getOpenUrlCommand, isTransientNetworkError } from './cli-runner.js';
 describe('getOpenUrlCommand', () => {
     const installUrl = 'https://kimaki.dev/discord-install?clientId=abc&clientSecret=def';
     test('uses a shell-free opener on Windows', () => {
@@ -21,3 +21,30 @@ describe('getOpenUrlCommand', () => {
         });
     });
 });
+describe('isTransientNetworkError', () => {
+    test('treats TLS leaf verification failures as transient', () => {
+        const error = Object.assign(new Error('unable to verify the first certificate'), {
+            code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+        });
+        expect(isTransientNetworkError(error)).toBe(true);
+    });
+    test('matches TLS cert failures by message when code is missing', () => {
+        expect(isTransientNetworkError(new Error('unable to verify the first certificate'))).toBe(true);
+    });
+    test('walks cause chains for nested TLS errors', () => {
+        const cause = Object.assign(new Error('unable to verify the first certificate'), {
+            code: 'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+        });
+        expect(isTransientNetworkError(new Error('Discord login failed', { cause }))).toBe(true);
+    });
+    test('keeps fatal auth-style errors non-transient', () => {
+        expect(isTransientNetworkError(new Error('An invalid token was provided.'))).toBe(false);
+        expect(isTransientNetworkError(new Error('Used disallowed intents'))).toBe(false);
+    });
+    test('still treats classic socket codes as transient', () => {
+        const error = Object.assign(new Error('getaddrinfo ENOTFOUND'), {
+            code: 'ENOTFOUND',
+        });
+        expect(isTransientNetworkError(error)).toBe(true);
+    });
+});

package/dist/commands/btw.js

@@ -10,7 +10,7 @@ import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.FORK);
-export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
+export async function forkSessionToBtwThread({ sourceThread, projectDirectory, sdkDirectory, prompt, userId, username, appId, }) {
     // Parallelize: session lookup + opencode init + parent channel resolve are independent
     const [sessionId, getClientResult, textChannel] = await Promise.all([
         getThreadSession(sourceThread.id),
@@ -57,6 +57,9 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`),
     ]);
     logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId})`);
+    // Parent context stays in the user prompt only. Do NOT pass parentSessionId
+    // into enqueueIncoming: that would inject a parent block into the system
+    // message and bust prompt cache shared with the parent session.
     const wrappedPrompt = [
         `The user asked a side question while you were working on another task.`,
         `This is a forked session whose ONLY goal is to answer this question.`,
@@ -71,7 +74,7 @@ export async function forkSessionToBtwThread({ sourceThread, projectDirectory, p
         threadId: thread.id,
         thread,
         projectDirectory,
-        sdkDirectory: projectDirectory,
+        sdkDirectory,
         channelId,
         appId,
     });
@@ -117,12 +120,13 @@ export async function handleBtwCommand({ command, appId, }) {
         });
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     await command.deferReply({ flags: MessageFlags.Ephemeral });
     try {
         const result = await forkSessionToBtwThread({
             sourceThread: threadChannel,
             projectDirectory,
+            sdkDirectory: workingDirectory,
             prompt,
             userId: command.user.id,
             username: command.user.displayName,

package/dist/commands/new-worktree.js

@@ -8,7 +8,7 @@ import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChanne
 import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
+import { execAsync, listBranchesByLastCommit, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
@@ -22,10 +22,22 @@ async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch
         // unpublished commits in the main checkout.
         return DEFAULT_WORKTREE_BASE_REF;
     }
-    return validateBranchRef({
+    const validated = await validateBranchRef({
         directory: projectDirectory,
         ref: rawBaseBranch,
     });
+    if (validated instanceof Error)
+        return validated;
+    // Fetch and prefer the remote tracking ref if it's strictly ahead of local.
+    // Handles the common case where user says "main" but upstream/main has new commits.
+    const bestRef = await resolveBestBaseRef({
+        directory: projectDirectory,
+        branch: validated,
+    });
+    if (bestRef !== validated) {
+        logger.log(`Base branch resolved: ${validated} → ${bestRef} (remote is ahead)`);
+    }
+    return bestRef;
 }
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName) {