@otto-assistant/bridge 0.4.102 → 0.4.103

package/dist/commands/worktrees.js

@@ -1,15 +1,20 @@
-// /worktrees command — list worktree sessions for the current channel's project.
+// /worktrees command — list all git worktrees for the current channel's project.
+// Uses `git worktree list --porcelain` as source of truth, enriched with
+// DB metadata (thread link, created_at) when available. Shows kimaki-created,
+// opencode-created, and manually created worktrees in a single table.
 // Renders a markdown table that the CV2 pipeline auto-formats for Discord,
 // including HTML-backed action buttons for deletable worktrees.
 import { ButtonInteraction, ChatInputCommandInteraction, ChannelType, ComponentType, MessageFlags, } from 'discord.js';
-import { deleteThreadWorktree, getThreadWorktree, } from '../database.js';
+import { deleteThreadWorktree, } from '../database.js';
 import { getPrisma } from '../db.js';
 import { splitTablesFromMarkdown } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import * as errore from 'errore';
+import crypto from 'node:crypto';
 import { GitCommandError } from '../errors.js';
 import { resolveWorkingDirectory } from '../discord-utils.js';
-import { deleteWorktree, git, getDefaultBranch } from '../worktrees.js';
+import { deleteWorktree, git, getDefaultBranch, listGitWorktrees, } from '../worktrees.js';
+import path from 'node:path';
 // Extracts the git stderr from a deleteWorktree error via errore.findCause.
 // Chain: Error { cause: GitCommandError { cause: CommandError { stderr } } }.
 export function extractGitStderr(error) {
@@ -42,33 +47,36 @@ export function formatTimeAgo(date) {
     const remainingHours = hours % 24;
     return remainingHours > 0 ? `${days}d ${remainingHours}h ago` : `${days}d ago`;
 }
-function statusLabel(wt) {
-    if (wt.status === 'ready') {
-        return 'ready';
-    }
-    if (wt.status === 'error') {
-        return 'error';
-    }
-    return 'pending';
+// Stable button ID derived from directory path via sha1 hash.
+// Avoids collisions that truncated path suffixes can cause.
+function worktreeButtonKey(directory) {
+    return crypto.createHash('sha1').update(directory).digest('hex').slice(0, 12);
 }
 // 5s timeout per git call — prevents hangs from deleted dirs, git locks, slow disks.
 // Returns null on timeout/error so the table shows "unknown" for that worktree.
 const GIT_CMD_TIMEOUT = 5_000;
 const GLOBAL_TIMEOUT = 10_000;
-// Checks dirty state and commits ahead of default branch in parallel.
-// Returns null for worktrees that aren't ready or when the directory is
-// missing / git commands fail / timeout (e.g. deleted worktree folder).
-async function getWorktreeGitStatus({ wt, defaultBranch, }) {
-    if (wt.status !== 'ready' || !wt.worktree_directory) {
-        return null;
+// Detect worktree source from branch name and directory path.
+// opencode/kimaki-* branches → kimaki, opencode worktree paths → opencode, else manual.
+function detectWorktreeSource({ branch, directory, }) {
+    if (branch?.startsWith('opencode/kimaki-')) {
+        return 'kimaki';
+    }
+    // opencode stores worktrees under ~/.local/share/opencode/worktree/
+    if (directory.includes('/opencode/worktree/')) {
+        return 'opencode';
     }
+    return 'manual';
+}
+// Checks dirty state and commits ahead of default branch in parallel.
+// Returns null when the directory is missing / git commands fail / timeout.
+async function getWorktreeGitStatus({ directory, defaultBranch, }) {
     try {
-        const dir = wt.worktree_directory;
         // Use raw git calls so errors/timeouts are visible — isDirty() swallows
         // errors and returns false, which would render "merged" instead of "unknown".
         const [statusResult, aheadResult] = await Promise.all([
-            git(dir, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
-            git(dir, `rev-list --count "${defaultBranch}..HEAD"`, {
+            git(directory, 'status --porcelain', { timeout: GIT_CMD_TIMEOUT }),
+            git(directory, `rev-list --count "${defaultBranch}..HEAD"`, {
                 timeout: GIT_CMD_TIMEOUT,
             }),
         ]);
@@ -85,16 +93,28 @@ async function getWorktreeGitStatus({ wt, defaultBranch, }) {
         return null;
     }
 }
-function buildWorktreeTable({ worktrees, gitStatuses, guildId, }) {
-    const header = '| Thread | Name | Status | Created | Folder | Action |';
+function buildWorktreeTable({ rows, gitStatuses, guildId, }) {
+    const header = '| Source | Name | Status | Created | Folder | Action |';
     const separator = '|---|---|---|---|---|---|';
-    const rows = worktrees.map((wt, i) => {
-        const threadLink = `[thread](https://discord.com/channels/${guildId}/${wt.thread_id})`;
-        const name = wt.worktree_name;
+    const tableRows = rows.map((row, i) => {
+        const sourceCell = (() => {
+            if (row.threadId && row.guildId) {
+                const threadLink = `[${row.source}](https://discord.com/channels/${row.guildId}/${row.threadId})`;
+                return threadLink;
+            }
+            return row.source;
+        })();
+        const name = row.name;
         const gs = gitStatuses[i] ?? null;
         const status = (() => {
-            if (wt.status !== 'ready') {
-                return statusLabel(wt);
+            if (row.dbStatus !== 'ready') {
+                return row.dbStatus;
+            }
+            if (row.locked) {
+                return 'locked';
+            }
+            if (row.prunable) {
+                return 'prunable';
             }
             if (!gs) {
                 return 'unknown';
@@ -111,26 +131,29 @@ function buildWorktreeTable({ worktrees, gitStatuses, guildId, }) {
             }
             return parts.join(', ');
         })();
-        const created = wt.created_at ? formatTimeAgo(wt.created_at) : 'unknown';
-        const folder = wt.worktree_directory ?? wt.project_directory;
-        const action = buildActionCell({ wt, gitStatus: gs });
-        return `| ${threadLink} | ${name} | ${status} | ${created} | ${folder} | ${action} |`;
+        const created = row.createdAt ? formatTimeAgo(row.createdAt) : '-';
+        const folder = row.directory;
+        const action = buildActionCell({ row, gitStatus: gs });
+        return `| ${sourceCell} | ${name} | ${status} | ${created} | ${folder} | ${action} |`;
     });
-    return [header, separator, ...rows].join('\n');
+    return [header, separator, ...tableRows].join('\n');
 }
-function buildActionCell({ wt, gitStatus, }) {
-    if (!canDeleteWorktree({ wt, gitStatus })) {
+function buildActionCell({ row, gitStatus, }) {
+    if (!canDeleteWorktree({ row, gitStatus })) {
         return '-';
     }
     return buildDeleteButtonHtml({
-        buttonId: `delete-worktree-${wt.thread_id}`,
+        buttonId: `del-wt-${worktreeButtonKey(row.directory)}`,
     });
 }
 function buildDeleteButtonHtml({ buttonId, }) {
     return `<button id="${buttonId}" variant="secondary">Delete</button>`;
 }
-function canDeleteWorktree({ wt, gitStatus, }) {
-    if (wt.status !== 'ready' || !wt.worktree_directory) {
+function canDeleteWorktree({ row, gitStatus, }) {
+    if (row.dbStatus !== 'ready') {
+        return false;
+    }
+    if (row.locked) {
         return false;
     }
     if (!gitStatus) {
@@ -142,11 +165,8 @@ function canDeleteWorktree({ wt, gitStatus, }) {
     return gitStatus.aheadCount === 0;
 }
 // Resolves git statuses for all worktrees within a single global deadline.
-// Caches getDefaultBranch per project_directory to avoid redundant spawns.
-// Returns null for any worktree whose git calls fail, timeout, or exceed
-// the global deadline — the table renders those as "unknown".
-async function resolveGitStatuses({ worktrees, timeout, }) {
-    const nullFallback = worktrees.map(() => null);
+async function resolveGitStatuses({ rows, projectDirectory, timeout, }) {
+    const nullFallback = rows.map(() => null);
     let timer;
     const deadline = new Promise((resolve) => {
         timer = setTimeout(() => {
@@ -154,19 +174,14 @@ async function resolveGitStatuses({ worktrees, timeout, }) {
         }, timeout);
     });
     const work = (async () => {
-        // Resolve default branch once per unique project directory (avoids
-        // redundant git subprocess spawns when multiple worktrees share a project).
-        const uniqueProjectDirs = [
-            ...new Set(worktrees.map((wt) => wt.project_directory)),
-        ];
-        const defaultBranchEntries = await Promise.all(uniqueProjectDirs.map(async (dir) => {
-            const branch = await getDefaultBranch(dir, { timeout: GIT_CMD_TIMEOUT });
-            return [dir, branch];
-        }));
-        const defaultBranchByProject = new Map(defaultBranchEntries);
-        return Promise.all(worktrees.map((wt) => {
-            const defaultBranch = defaultBranchByProject.get(wt.project_directory) ?? 'main';
-            return getWorktreeGitStatus({ wt, defaultBranch });
+        const defaultBranch = await getDefaultBranch(projectDirectory, {
+            timeout: GIT_CMD_TIMEOUT,
+        });
+        return Promise.all(rows.map((row) => {
+            if (row.dbStatus !== 'ready' || row.locked || row.prunable) {
+                return null;
+            }
+            return getWorktreeGitStatus({ directory: row.directory, defaultBranch });
         }));
     })();
     try {
@@ -176,15 +191,91 @@ async function resolveGitStatuses({ worktrees, timeout, }) {
         clearTimeout(timer);
     }
 }
-async function getRecentWorktrees({ projectDirectory, }) {
+// Merge git worktrees with DB metadata into unified WorktreeRows.
+// Git is the source of truth for what exists on disk. DB rows that aren't
+// in the git list (pending/error) are appended at the end.
+async function buildWorktreeRows({ projectDirectory, gitWorktrees, }) {
     const prisma = await getPrisma();
-    return await prisma.thread_worktrees.findMany({
-        where: {
-            project_directory: projectDirectory,
-        },
-        orderBy: { created_at: 'desc' },
-        take: 10,
+    const dbWorktrees = await prisma.thread_worktrees.findMany({
+        where: { project_directory: projectDirectory },
+    });
+    // Index DB worktrees by directory for fast lookup
+    const dbByDirectory = new Map();
+    for (const dbWt of dbWorktrees) {
+        if (dbWt.worktree_directory) {
+            dbByDirectory.set(dbWt.worktree_directory, dbWt);
+        }
+    }
+    // Track which DB rows got matched so we can append unmatched ones
+    const matchedDbThreadIds = new Set();
+    // Build rows from git worktrees (the source of truth for on-disk state).
+    // Use real DB status when available — a git-visible worktree whose DB row
+    // is still 'pending' means setup hasn't finished (race window).
+    const gitRows = gitWorktrees.map((gw) => {
+        const dbMatch = dbByDirectory.get(gw.directory);
+        if (dbMatch) {
+            matchedDbThreadIds.add(dbMatch.thread_id);
+        }
+        const source = detectWorktreeSource({
+            branch: gw.branch,
+            directory: gw.directory,
+        });
+        const name = gw.branch ?? path.basename(gw.directory);
+        const dbStatus = (() => {
+            if (!dbMatch) {
+                return 'ready';
+            }
+            if (dbMatch.status === 'error') {
+                return 'error';
+            }
+            if (dbMatch.status === 'pending') {
+                return 'pending';
+            }
+            return 'ready';
+        })();
+        return {
+            directory: gw.directory,
+            branch: gw.branch,
+            name,
+            threadId: dbMatch?.thread_id ?? null,
+            guildId: null, // filled in by caller
+            createdAt: dbMatch?.created_at ?? null,
+            source,
+            dbStatus,
+            locked: gw.locked,
+            prunable: gw.prunable,
+        };
+    });
+    // Append DB-only worktrees (pending/error/stale — not visible to git).
+    // Preserve actual DB status so stale 'ready' rows show as 'ready' (missing).
+    const dbOnlyRows = dbWorktrees
+        .filter((dbWt) => {
+        return !matchedDbThreadIds.has(dbWt.thread_id);
+    })
+        .map((dbWt) => {
+        const dbStatus = (() => {
+            if (dbWt.status === 'error') {
+                return 'error';
+            }
+            if (dbWt.status === 'pending') {
+                return 'pending';
+            }
+            return 'ready';
+        })();
+        return {
+            directory: dbWt.worktree_directory ?? dbWt.project_directory,
+            branch: null,
+            name: dbWt.worktree_name,
+            threadId: dbWt.thread_id,
+            guildId: null,
+            createdAt: dbWt.created_at,
+            source: 'kimaki',
+            dbStatus,
+            locked: false,
+            prunable: false,
+        };
     });
+    return [...gitRows, ...dbOnlyRows];
 }
 function getWorktreesActionOwnerKey({ userId, channelId, }) {
     return `worktrees:${userId}:${channelId}`;
@@ -203,9 +294,21 @@ function isProjectChannel(channel) {
 async function renderWorktreesReply({ guildId, userId, channelId, projectDirectory, notice, editReply, }) {
     const ownerKey = getWorktreesActionOwnerKey({ userId, channelId });
     cancelHtmlActionsForOwner(ownerKey);
-    const worktrees = await getRecentWorktrees({ projectDirectory });
-    if (worktrees.length === 0) {
-        const message = notice ? `${notice}\n\nNo worktrees found.` : 'No worktrees found.';
+    const gitWorktrees = await listGitWorktrees({
+        projectDirectory,
+        timeout: GIT_CMD_TIMEOUT,
+    });
+    // On git failure, fall back to empty list (DB-only rows still shown)
+    const gitList = gitWorktrees instanceof Error ? [] : gitWorktrees;
+    const rows = await buildWorktreeRows({ projectDirectory, gitWorktrees: gitList });
+    // Inject guildId into all rows for thread link rendering
+    for (const row of rows) {
+        row.guildId = guildId;
+    }
+    if (rows.length === 0) {
+        const message = notice
+            ? `${notice}\n\nNo worktrees found.`
+            : 'No worktrees found.';
         const textDisplay = {
             type: ComponentType.TextDisplay,
             content: message,
@@ -217,36 +320,40 @@ async function renderWorktreesReply({ guildId, userId, channelId, projectDirecto
         return;
     }
     const gitStatuses = await resolveGitStatuses({
-        worktrees,
+        rows,
+        projectDirectory,
         timeout: GLOBAL_TIMEOUT,
     });
-    const deletableWorktreesByButtonId = new Map();
-    worktrees.forEach((wt, index) => {
+    // Map deletable worktrees by button ID for the HTML action resolver.
+    // Uses the same worktreeButtonKey() as buildActionCell.
+    const deletableRowsByButtonId = new Map();
+    rows.forEach((row, index) => {
         const gitStatus = gitStatuses[index] ?? null;
-        if (!canDeleteWorktree({ wt, gitStatus })) {
+        if (!canDeleteWorktree({ row, gitStatus })) {
             return;
         }
-        deletableWorktreesByButtonId.set(`delete-worktree-${wt.thread_id}`, wt);
+        deletableRowsByButtonId.set(`del-wt-${worktreeButtonKey(row.directory)}`, row);
     });
     const tableMarkdown = buildWorktreeTable({
-        worktrees,
+        rows,
         gitStatuses,
         guildId,
     });
     const markdown = notice ? `${notice}\n\n${tableMarkdown}` : tableMarkdown;
     const segments = splitTablesFromMarkdown(markdown, {
         resolveButtonCustomId: ({ button }) => {
-            const worktree = deletableWorktreesByButtonId.get(button.id);
-            if (!worktree) {
+            const row = deletableRowsByButtonId.get(button.id);
+            if (!row) {
                 return new Error(`No worktree registered for button ${button.id}`);
             }
             const actionId = registerHtmlAction({
                 ownerKey,
-                threadId: worktree.thread_id,
+                threadId: row.threadId ?? row.directory,
                 run: async ({ interaction }) => {
                     await handleDeleteWorktreeAction({
                         interaction,
-                        threadId: worktree.thread_id,
+                        row,
+                        projectDirectory,
                     });
                 },
             });
@@ -268,7 +375,7 @@ async function renderWorktreesReply({ guildId, userId, channelId, projectDirecto
         flags: MessageFlags.IsComponentsV2,
     });
 }
-async function handleDeleteWorktreeAction({ interaction, threadId, }) {
+async function handleDeleteWorktreeAction({ interaction, row, projectDirectory, }) {
     const guildId = interaction.guildId;
     if (!guildId) {
         await interaction.editReply({
@@ -282,75 +389,22 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
         });
         return;
     }
-    const worktree = await getThreadWorktree(threadId);
-    if (!worktree) {
-        if (!isProjectChannel(interaction.channel)) {
-            await interaction.editReply({
-                components: [
-                    {
-                        type: ComponentType.TextDisplay,
-                        content: 'This action can only be used in a project channel or thread.',
-                    },
-                ],
-                flags: MessageFlags.IsComponentsV2,
-            });
-            return;
-        }
-        const resolved = await resolveWorkingDirectory({
-            channel: interaction.channel,
-        });
-        if (!resolved) {
-            await interaction.editReply({
-                components: [
-                    {
-                        type: ComponentType.TextDisplay,
-                        content: 'Could not determine the project folder for this channel.',
-                    },
-                ],
-                flags: MessageFlags.IsComponentsV2,
-            });
-            return;
-        }
-        await renderWorktreesReply({
-            guildId,
-            userId: interaction.user.id,
-            channelId: interaction.channelId,
-            projectDirectory: resolved.projectDirectory,
-            notice: 'Worktree was already removed.',
-            editReply: (options) => {
-                return interaction.editReply(options);
-            },
-        });
-        return;
-    }
-    if (worktree.status !== 'ready' || !worktree.worktree_directory) {
-        await renderWorktreesReply({
-            guildId,
-            userId: interaction.user.id,
-            channelId: interaction.channelId,
-            projectDirectory: worktree.project_directory,
-            notice: `Cannot delete \`${worktree.worktree_name}\` because it is ${worktree.status}.`,
-            editReply: (options) => {
-                return interaction.editReply(options);
-            },
-        });
-        return;
-    }
+    // Pass branch name for branch cleanup. Empty string for detached HEAD
+    // worktrees so deleteWorktree skips the `git branch -d` step.
+    const displayName = row.branch ?? row.name;
     const deleteResult = await deleteWorktree({
-        projectDirectory: worktree.project_directory,
-        worktreeDirectory: worktree.worktree_directory,
-        worktreeName: worktree.worktree_name,
+        projectDirectory,
+        worktreeDirectory: row.directory,
+        worktreeName: row.branch ?? '',
     });
     if (deleteResult instanceof Error) {
-        // Send error as a separate ephemeral follow-up so the table stays intact.
-        // Dig into cause chain to surface the actual git stderr when available.
         const gitStderr = extractGitStderr(deleteResult);
         const detail = gitStderr
             ? `\`\`\`\n${gitStderr}\n\`\`\``
             : deleteResult.message;
         await interaction
             .followUp({
-            content: `Failed to delete \`${worktree.worktree_name}\`\n${detail}`,
+            content: `Failed to delete \`${displayName}\`\n${detail}`,
             flags: MessageFlags.Ephemeral,
         })
             .catch(() => {
@@ -358,13 +412,16 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
         });
         return;
     }
-    await deleteThreadWorktree(threadId);
+    // Clean up DB row if this was a kimaki-tracked worktree
+    if (row.threadId) {
+        await deleteThreadWorktree(row.threadId);
+    }
     await renderWorktreesReply({
         guildId,
         userId: interaction.user.id,
         channelId: interaction.channelId,
-        projectDirectory: worktree.project_directory,
-        notice: `Deleted \`${worktree.worktree_name}\`.`,
+        projectDirectory,
+        notice: `Deleted \`${displayName}\`.`,
         editReply: (options) => {
             return interaction.editReply(options);
         },

package/dist/context-awareness-plugin.js

@@ -32,8 +32,10 @@ export function shouldInjectBranch({ previousGitState, currentGitState, }) {
     if (previousGitState && previousGitState.key === currentGitState.key) {
         return { inject: false };
     }
-    const text = currentGitState.warning || `\n[current git branch is ${currentGitState.label}]`;
-    return { inject: true, text };
+    // Trailing newline so this synthetic part does not fuse with the next text
+    // part when the model concatenates message parts.
+    const base = currentGitState.warning || `\n[current git branch is ${currentGitState.label}]`;
+    return { inject: true, text: `${base}\n` };
 }
 export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
     if (announcedDir === currentDir) {
@@ -45,10 +47,16 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
     }
     return {
         inject: true,
-        text: `\n[working directory changed. Previous working directory: ${priorDirectory}. ` +
-            `Current working directory: ${currentDir}. ` +
-            `You should read, write, and edit files under ${currentDir}. ` +
-            `Do NOT read, write, or edit files under ${priorDirectory}.]`,
+        // Trailing newline so this synthetic part does not fuse with the next text
+        // part when the model concatenates message parts.
+        text: `\n[working directory changed (cwd / pwd has changed). ` +
+            `The user expects you to edit files in the new cwd. ` +
+            `Previous folder (DO NOT TOUCH): ${priorDirectory}. ` +
+            `New folder (new cwd / pwd, edit files here): ${currentDir}. ` +
+            `You MUST read, write, and edit files only under the new folder ${currentDir}. ` +
+            `You MUST NOT read, write, or edit any files under the previous folder ${priorDirectory} — ` +
+            `that folder is a separate checkout and the user or another agent may be actively working there, ` +
+            `so writing to it would override their unrelated changes.]\n`,
     };
 }
 const MEMORY_REMINDER_OUTPUT_TOKENS = 12_000;
@@ -198,7 +206,7 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                             sessionID,
                             messageID: firstTextPart.messageID,
                             type: 'text',
-                            text: `<system-reminder>\n${ONBOARDING_TUTORIAL_INSTRUCTIONS}\n</system-reminder>`,
+                            text: `<system-reminder>\n${ONBOARDING_TUTORIAL_INSTRUCTIONS}\n</system-reminder>\n`,
                             synthetic: true,
                         });
                     }
@@ -273,7 +281,7 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                             sessionID,
                             messageID,
                             type: 'text',
-                            text: '<system-reminder>The previous assistant message was large. If the conversation had non-obvious learnings that prevent future mistakes and are not already in code comments or AGENTS.md, add them to MEMORY.md with concise titles and brief content (2-3 sentences max).</system-reminder>',
+                            text: '<system-reminder>The previous assistant message was large. If the conversation had non-obvious learnings that prevent future mistakes and are not already in code comments or AGENTS.md, add them to MEMORY.md with concise titles and brief content (2-3 sentences max).</system-reminder>\n',
                             synthetic: true,
                         });
                         state.lastMemoryReminderAssistantMessageId =

package/dist/context-awareness-plugin.test.js

@@ -36,7 +36,8 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You should read, write, and edit files under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/main. New folder (new cwd / pwd, edit files here): /repo/worktree. You MUST read, write, and edit files only under the new folder /repo/worktree. You MUST NOT read, write, or edit any files under the previous folder /repo/main — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
       }
     `);
     });
@@ -50,7 +51,8 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You should read, write, and edit files under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
+      [working directory changed (cwd / pwd has changed). The user expects you to edit files in the new cwd. Previous folder (DO NOT TOUCH): /repo/worktree-a. New folder (new cwd / pwd, edit files here): /repo/worktree-b. You MUST read, write, and edit files only under the new folder /repo/worktree-b. You MUST NOT read, write, or edit any files under the previous folder /repo/worktree-a — that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes.]
+      ",
       }
     `);
     });

package/dist/discord-bot.js

@@ -3,14 +3,16 @@
 // and orchestrates the main event loop for the Kimaki bot.
 import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorktree, setWorktreeReady, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
-import { formatWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
+import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { validateWorktreeDirectory, git } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
+import { extractBtwPrefix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
+import { forkSessionToBtwThread } from './commands/btw.js';
 import { preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
@@ -430,6 +432,35 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         return;
                     }
                 }
+                // Raw `btw ` mirrors /btw for fast side-question forks from Discord.
+                // Keep this at ingress instead of preprocess because it must create a
+                // new thread/runtime, not just transform the current prompt.
+                // Voice-transcribed `btw` still goes through normal preprocessing.
+                const btwShortcut = projectDirectory && worktreeInfo?.status !== 'pending'
+                    ? extractBtwPrefix(message.content || '')
+                    : null;
+                if (btwShortcut && projectDirectory) {
+                    const result = await forkSessionToBtwThread({
+                        sourceThread: thread,
+                        projectDirectory,
+                        prompt: btwShortcut.prompt,
+                        userId: message.author.id,
+                        username: message.member?.displayName || message.author.displayName,
+                        appId: currentAppId,
+                    });
+                    if (result instanceof Error) {
+                        await message.reply({
+                            content: result.message,
+                            flags: SILENT_MESSAGE_FLAGS,
+                        });
+                        return;
+                    }
+                    await message.reply({
+                        content: `Session forked! Continue in ${result.thread.toString()}`,
+                        flags: SILENT_MESSAGE_FLAGS,
+                    });
+                    return;
+                }
                 const hasVoiceAttachment = message.attachments.some((attachment) => {
                     return isVoiceAttachment(attachment);
                 });
@@ -592,7 +623,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 // and the first message's preprocess callback awaits it before resolving.
                 let worktreePromise;
                 if (shouldUseWorktrees) {
-                    const worktreeName = formatWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
+                    // Auto-derived from thread name -- compress long slugs so the
+                    // folder path stays short and the agent doesn't reuse old worktrees.
+                    const worktreeName = formatAutoWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
                     discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
                     const worktreeStatusMessage = await thread
                         .send({

package/dist/discord-command-registration.js

@@ -110,7 +110,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-worktree')
-            .setDescription(truncateCommandDescription('Create a git worktree branch from HEAD by default. Optionally pick a base branch.'))
+            .setDescription(truncateCommandDescription('Create a git worktree from the current HEAD by default. Optionally pick a base branch.'))
             .addStringOption((option) => {
             option
                 .setName('name')
@@ -121,7 +121,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .addStringOption((option) => {
             option
                 .setName('base-branch')
-                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: HEAD)'))
+                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: current HEAD)'))
                 .setRequired(false)
                 .setAutocomplete(true);
             return option;
@@ -276,6 +276,13 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         new SlashCommandBuilder()
             .setName('clear-queue')
             .setDescription(truncateCommandDescription('Clear all queued messages in this thread'))
+            .addIntegerOption((option) => {
+            option
+                .setName('position')
+                .setDescription(truncateCommandDescription('1-based queued message position to clear (default: all)'))
+                .setMinValue(1);
+            return option;
+        })
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()