kimaki 0.26.0 → 0.28.0

package/dist/commands/login.js

@@ -12,6 +12,7 @@ import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectM
 import crypto from 'node:crypto';
 import { initializeOpencodeForDirectory, getOpencodeServerPort, getOpencodeServerAuthHeaders, } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { clearModelListCache } from '../session-handler/model-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const loginLogger = createLogger(LogPrefix.LOGIN);
@@ -31,7 +32,9 @@ function createContextHash(context) {
 // ── Provider popularity order ───────────────────────────────────
 // Discord select menus cap at 25 options, so we show popular ones first.
 // IDs sourced from opencode's provider.list() API (scripts/list-providers.ts).
+// `subrouter` leads: it pools every subscription and cycles across them.
 const PROVIDER_POPULARITY_ORDER = [
+    'subrouter',
     'anthropic',
     'openai',
     'google',
@@ -691,6 +694,7 @@ export async function handleOAuthCodeModalSubmit(interaction) {
             return;
         }
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         pendingLoginContexts.delete(hash);
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,
@@ -736,6 +740,7 @@ export async function handleApiKeyModalSubmit(interaction) {
         });
         // Dispose to refresh provider state so new credentials are recognized
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,
         });
@@ -870,6 +875,7 @@ async function startOAuthFlow(interaction, ctx, hash) {
             return;
         }
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         pendingLoginContexts.delete(hash);
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,

package/dist/commands/merge-worktree.js

@@ -1,23 +1,30 @@
-// /merge-worktree command - Merge worktree commits into default branch.
-// Pipeline: rebase worktree commits onto target -> local fast-forward push.
-// Preserves all commits (no squash). On rebase conflicts, asks the AI model
-// in the thread to resolve them.
+// /merge-worktree command - Rebase or squash worktree commits into a target branch.
+// On rebase conflicts, asks the AI model in the thread to resolve them.
 import {} from 'discord.js';
 import { getThreadWorktreeOrWorkspace, getThreadSession, getChannelDirectory, } from '../database.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
+import { mergeWorktree, listBranchesByLastCommit, validateBranchRef, formatMergeWorktreeError, } from '../worktrees.js';
 import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, NothingToMergeError, } from '../errors.js';
+import { WORKTREE_PREFIX } from '../message-formatting.js';
 const logger = createLogger(LogPrefix.WORKTREE);
-/** Worktree thread title prefix - indicates unmerged worktree */
-export const WORKTREE_PREFIX = '⬦ ';
+function quoteShellArg(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export { WORKTREE_PREFIX };
+function worktreePrefixLength(name) {
+    if (name.startsWith(WORKTREE_PREFIX))
+        return WORKTREE_PREFIX.length;
+    return 0;
+}
 async function removeWorktreePrefixFromTitle(thread) {
-    if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+    const prefixLength = worktreePrefixLength(thread.name);
+    if (!prefixLength) {
         return;
     }
-    const newName = thread.name.slice(WORKTREE_PREFIX.length);
+    const newName = thread.name.slice(prefixLength);
     const timeoutMs = 5000;
     await Promise.race([
         thread.setName(newName).catch((e) => {
@@ -73,6 +80,14 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         await command.editReply(`Worktree is not ready (status: ${info.status})${info.error_message ? `: ${info.error_message}` : ''}`);
         return;
     }
+    const strategyOption = command.options.getString('strategy') || 'rebase';
+    if (strategyOption !== 'rebase' && strategyOption !== 'squash') {
+        await command.editReply(`Invalid merge strategy: \`${strategyOption}\``);
+        return;
+    }
+    const strategyName = strategyOption === 'squash'
+        ? 'Squash into one commit'
+        : 'Keep commits (rebase)';
     const rawTargetBranch = command.options.getString('target-branch') || undefined;
     let targetBranch = rawTargetBranch;
     if (targetBranch) {
@@ -91,6 +106,7 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         mainRepoDir: info.project_directory,
         worktreeName: info.workspace_name,
         targetBranch,
+        strategy: strategyOption,
         onProgress: (msg) => {
             logger.log(`[merge] ${msg}`);
         },
@@ -106,11 +122,22 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         }
         if (result instanceof NothingToMergeError) {
             void removeWorktreePrefixFromTitle(thread);
-            await command.editReply(`Merge failed: ${result.message}`);
+            await command.editReply(formatMergeWorktreeError(result));
             return;
         }
         if (result instanceof RebaseConflictError) {
-            await command.editReply('Rebase conflict detected. Asking the model to resolve...');
+            const prefixLength = worktreePrefixLength(thread.name);
+            const mergedThreadName = prefixLength
+                ? thread.name.slice(prefixLength)
+                : thread.name;
+            const mergeCommand = [
+                'kimaki merge-worktree',
+                `--strategy ${strategyOption}`,
+                `--target-branch ${quoteShellArg(String(result.target))}`,
+                `--thread ${quoteShellArg(thread.id)}`,
+                `--thread-name ${quoteShellArg(mergedThreadName)}`,
+            ].join(' ');
+            await command.editReply(`Rebase conflict detected. Asking the model to resolve it and retry the merge with **${strategyName}**.`);
             await sendPromptToModel({
                 prompt: [
                     `A rebase conflict occurred while merging this worktree into \`${result.target}\`.`,
@@ -124,7 +151,8 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
                     '6. Stage resolved files with `git add`',
                     '7. Continue the rebase with `git rebase --continue`',
                     '8. If git reports more conflicts, repeat steps 1-7 until the rebase finishes (no more rebase in progress, `git status` is clean)',
-                    '9. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
+                    `9. Once the rebase is fully complete, run \`${mergeCommand}\` yourself`,
+                    '10. If that command fails because the target changed or is not ready, stop and report the failure. The user can run it again later.',
                 ].join('\n'),
                 thread,
                 projectDirectory: info.project_directory,
@@ -133,11 +161,16 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             });
             return;
         }
-        await command.editReply(`Merge failed: ${result.message}`);
+        const formatted = formatMergeWorktreeError(result);
+        logger.error(formatted);
+        await command.editReply(formatted);
         return;
     }
     void removeWorktreePrefixFromTitle(thread);
-    await command.editReply(`Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})\nWorktree now at detached HEAD.`);
+    const mergeSummary = strategyOption === 'squash'
+        ? `Squashed \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} source commit${result.commitCount === 1 ? '' : 's'} → 1)`
+        : `Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`;
+    await command.editReply(`${mergeSummary}\nWorktree now at detached HEAD.`);
 }
 /**
  * Autocomplete handler for /merge-worktree target-branch option.

package/dist/commands/model-variant.js

@@ -13,6 +13,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, applyToCurrentSession, } from './model.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
+import { resolveDisplayedModelId } from '../session-handler/model-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.MODEL);
 const pendingVariantContexts = new Map();
@@ -137,6 +138,12 @@ export async function showModelVariantPicker({ channel, appId, editReply, }) {
     const { providerID, modelID, model: fullModelId } = currentModelInfo;
     const sourceLabel = formatSourceLabel(currentModelInfo);
     const variantLabel = cascadeVariant ? ` (${cascadeVariant})` : '';
+    const displayedModelId = (await resolveDisplayedModelId({
+        providers: providersResponse.data.all,
+        providerID,
+        modelID,
+        sessionID: sessionId,
+    })) ?? fullModelId;
     const provider = providersResponse.data.all.find((p) => {
         return p.id === providerID;
     });
@@ -146,7 +153,7 @@ export async function showModelVariantPicker({ channel, appId, editReply, }) {
         providerId: providerID,
         modelId: modelID,
     });
-    const statusText = `**Current model:** \`${fullModelId}\`${variantLabel} — ${sourceLabel}`;
+    const statusText = `**Current model:** \`${displayedModelId}\`${variantLabel} — ${sourceLabel}`;
     if (variants.length === 0) {
         await editReply({
             content: `${statusText}\nThis model doesn't support thinking level variants.`,

package/dist/commands/model.js

@@ -4,7 +4,7 @@ import crypto from 'node:crypto';
 import { setChannelModel, setSessionModel, setSessionAgent, getChannelModel, getSessionModel, getSessionAgent, getChannelAgent, getThreadSession, getGlobalModel, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { getDefaultModel } from '../session-handler/model-utils.js';
+import { getDefaultModel, resolveDisplayedModelId, } from '../session-handler/model-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
@@ -321,22 +321,29 @@ export async function handleModelCommand({ interaction, appId, }) {
             });
             return;
         }
-        const currentModelText = (() => {
+        const currentModelText = await (async () => {
+            if (currentModelInfo.type === 'none') {
+                return '**Current:** none';
+            }
+            const displayed = (await resolveDisplayedModelId({
+                providers: allProviders,
+                providerID: currentModelInfo.providerID,
+                modelID: currentModelInfo.modelID,
+                sessionID: sessionId,
+            })) ?? currentModelInfo.model;
             switch (currentModelInfo.type) {
                 case 'session':
-                    return `**Current (this thread):** \`${currentModelInfo.model}\``;
+                    return `**Current (this thread):** \`${displayed}\``;
                 case 'agent':
-                    return `**Current (agent "${currentModelInfo.agentName}"):** \`${currentModelInfo.model}\``;
+                    return `**Current (agent "${currentModelInfo.agentName}"):** \`${displayed}\``;
                 case 'channel':
-                    return `**Current (channel override):** \`${currentModelInfo.model}\``;
+                    return `**Current (channel override):** \`${displayed}\``;
                 case 'global':
-                    return `**Current (global default):** \`${currentModelInfo.model}\``;
+                    return `**Current (global default):** \`${displayed}\``;
                 case 'opencode-config':
                 case 'opencode-recent':
                 case 'opencode-provider-default':
-                    return `**Current (opencode default):** \`${currentModelInfo.model}\``;
-                case 'none':
-                    return '**Current:** none';
+                    return `**Current (opencode default):** \`${displayed}\``;
             }
         })();
         const variantText = (() => {

package/dist/commands/multioauth.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * CLI commands for multi-provider OAuth account management.
  * Mounted via goke .use() in cli.ts under the `multioauth` namespace.

package/dist/commands/new-worktree.js

@@ -2,25 +2,26 @@
 // Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType, REST, } from 'discord.js';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { OpenCodeSdkError } from '../errors.js';
-import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, getThreadWorktreeOrWorkspace, setThreadSession, } from '../database.js';
+import { createPendingWorkspace, setWorkspaceReady, setWorkspaceError, getChannelDirectory, getThreadSession, setThreadSession, } from '../database.js';
 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, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
+import { execAsync, getManagedWorktreeDirectory, listBranchesByLastCommit, resolveBestBaseRef, validateBranchRef, } from '../worktrees.js';
+import { KIMAKI_WORKTREE_ADAPTER_TYPE, removeWorktreeFromOwnRepository, resolveGitCommit, validateWorktreeIdentity, } from '../git-worktree-core.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { buildSessionPermissions, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 import { copyCurrentSessionModel } from './model.js';
 const logger = createLogger(LogPrefix.WORKTREE);
-const DEFAULT_WORKTREE_BASE_REF = 'HEAD';
 async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch, }) {
     if (!rawBaseBranch) {
         // Default to the current local HEAD so worktrees can branch from
         // unpublished commits in the main checkout.
-        return DEFAULT_WORKTREE_BASE_REF;
+        return resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' });
     }
     const validated = await validateBranchRef({
         directory: projectDirectory,
@@ -37,7 +38,7 @@ async function resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch
     if (bestRef !== validated) {
         logger.log(`Base branch resolved: ${validated} → ${bestRef} (remote is ahead)`);
     }
-    return bestRef;
+    return resolveGitCommit({ directory: projectDirectory, ref: bestRef });
 }
 /** Status message shown while a worktree is being created. */
 export function worktreeCreatingMessage(worktreeName) {
@@ -153,28 +154,83 @@ async function getProjectDirectoryFromChannel(channel) {
 /**
  * Try creating a worktree via the OpenCode workspace SDK.
  * Returns the workspace directory on success, or an Error if the workspace
- * feature is not available or the creation fails. Callers fall back to the
- * direct git path on Error.
+ * feature is not available or the creation fails.
  */
-async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, baseBranch, }) {
+export async function tryWorkspaceCreate({ worktreeName, projectDirectory, baseCommit, }) {
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error)
         return getClient;
     const client = getClient();
+    const workspaceId = `wrk_${crypto.randomUUID()}`;
+    const managedDirectory = getManagedWorktreeDirectory({
+        directory: projectDirectory,
+        name: worktreeName,
+    });
+    const cleanupFailedWorkspace = async (worktreeDirectory) => {
+        const removeResponse = await client.experimental.workspace.remove({
+            id: workspaceId,
+            directory: projectDirectory,
+        }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.remove', cause: e }));
+        const sdkCleanupError = (() => {
+            if (removeResponse instanceof Error)
+                return removeResponse;
+            if (removeResponse.error) {
+                return new Error(`Workspace cleanup failed: ${JSON.stringify(removeResponse.error)}`);
+            }
+            return undefined;
+        })();
+        const gitCleanupError = fs.existsSync(worktreeDirectory)
+            ? await removeWorktreeFromOwnRepository({
+                worktreeDirectory,
+                branchName: worktreeName,
+            })
+            : undefined;
+        return sdkCleanupError ?? gitCleanupError;
+    };
     const response = await client.experimental.workspace.create({
+        id: workspaceId,
         directory: projectDirectory,
-        type: 'kimaki-worktree',
+        type: KIMAKI_WORKTREE_ADAPTER_TYPE,
         branch: worktreeName,
-        extra: baseBranch ? { baseBranch } : null,
+        extra: {
+            projectDirectory,
+            baseCommit,
+        },
     }).catch((e) => new OpenCodeSdkError({ operation: 'workspace.create', cause: e }));
-    if (response instanceof Error)
-        return response;
-    if (response.error) {
-        return new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
+    if (response instanceof Error || response.error) {
+        const creationError = response instanceof Error
+            ? response
+            : new Error(`Workspace creation failed: ${JSON.stringify(response.error)}`);
+        const cleanupError = await cleanupFailedWorkspace(managedDirectory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+                cause: creationError,
+            });
+        }
+        return creationError;
     }
     const workspace = response.data;
     if (!workspace?.directory || !workspace.id) {
-        return new Error('Workspace SDK returned no directory or ID');
+        const creationError = new Error('Workspace SDK returned no directory or ID');
+        const cleanupError = await cleanupFailedWorkspace(managedDirectory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${creationError.message}; cleanup failed: ${cleanupError.message}`, {
+                cause: creationError,
+            });
+        }
+        return creationError;
+    }
+    const identityResult = await validateWorktreeIdentity({
+        projectDirectory,
+        worktreeDirectory: workspace.directory,
+        baseCommit,
+    });
+    if (identityResult instanceof Error) {
+        const cleanupError = await cleanupFailedWorkspace(workspace.directory);
+        if (cleanupError instanceof Error) {
+            return new Error(`${identityResult.message}; cleanup failed: ${cleanupError.message}`, { cause: identityResult });
+        }
+        return identityResult;
     }
     return { directory: workspace.directory, workspaceId: workspace.id };
 }
@@ -188,13 +244,13 @@ async function tryWorkspaceCreate({ threadId, worktreeName, projectDirectory, ba
  * 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.
+ * beforeReady can bind a session before incoming messages may use the checkout.
  *
  * Returns the worktree directory on success, or an Error on failure.
  * Never throws — all internal errors are caught and returned as Error values.
  */
-export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseBranch, rest, }) {
+export async function createWorktreeInBackground({ thread, starterMessage, worktreeName, projectDirectory, baseCommit, rest, beforeReady, }) {
     return (async () => {
-        logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}${baseBranch ? ` from ${baseBranch}` : ''}`);
         // Serialize status message edits so onProgress can't overwrite the
         // final success/error edit even if Discord's API is slow.
         let editChain = Promise.resolve();
@@ -213,11 +269,23 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             workspaceName: worktreeName,
             projectDirectory,
         });
+        const resolvedBaseCommit = baseCommit
+            ? baseCommit
+            : await resolveGitCommit({ directory: projectDirectory, ref: 'HEAD' });
+        if (resolvedBaseCommit instanceof Error) {
+            await setWorkspaceError({
+                threadId: thread.id,
+                errorMessage: resolvedBaseCommit.message,
+            });
+            editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${resolvedBaseCommit.message}`);
+            await editChain;
+            return resolvedBaseCommit;
+        }
+        logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory} from ${resolvedBaseCommit}`);
         const workspaceResult = await tryWorkspaceCreate({
-            threadId: thread.id,
             worktreeName,
             projectDirectory,
-            baseBranch,
+            baseCommit: resolvedBaseCommit,
         });
         if (workspaceResult instanceof Error) {
             const errorMsg = workspaceResult.message;
@@ -227,6 +295,14 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
             await editChain;
             return workspaceResult;
         }
+        const preparationResult = beforeReady
+            ? await beforeReady(workspaceResult).catch((e) => new WorktreeError('Failed to prepare worktree session', { cause: e }))
+            : undefined;
+        if (preparationResult instanceof Error) {
+            logger.error('[WORKTREE] Session preparation failed:', preparationResult);
+            void notifyError(preparationResult, 'Worktree session preparation failed');
+            await sendThreadMessage(thread, `Worktree is ready, but failed to prepare its session: ${preparationResult.message}`);
+        }
         await setWorkspaceReady({
             threadId: thread.id,
             workspaceId: workspaceResult.workspaceId,
@@ -308,11 +384,11 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         return;
     }
     // Parallelize: base branch validation and existing worktree check are independent
-    const [baseBranch, existingWorktree] = await Promise.all([
+    const [baseCommit, existingWorktree] = await Promise.all([
         resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
         findExistingWorktreePath({ projectDirectory, worktreeName }),
     ]);
-    if (baseBranch instanceof Error) {
+    if (baseCommit instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
@@ -354,7 +430,7 @@ export async function handleNewWorktreeCommand({ command, appId, }) {
         starterMessage,
         worktreeName,
         projectDirectory,
-        baseBranch,
+        baseCommit,
         rest: command.client.rest,
     }).catch((e) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
@@ -391,12 +467,12 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
     // Parallelize: base branch validation, existing worktree check, and parent channel
     // resolve are all independent. resolveTextChannel fetches the parent from Discord
     // cache/API which can overlap with the git operations.
-    const [baseBranch, existingWorktreePath, textChannel] = await Promise.all([
+    const [baseCommit, existingWorktreePath, textChannel] = await Promise.all([
         resolveRequestedWorktreeBaseRef({ projectDirectory, rawBaseBranch }),
         findExistingWorktreePath({ projectDirectory, worktreeName }),
         resolveTextChannel(thread),
     ]);
-    if (baseBranch instanceof Error) {
+    if (baseCommit instanceof Error) {
         await command.editReply(`Invalid base branch: \`${rawBaseBranch}\``);
         return;
     }
@@ -440,86 +516,78 @@ async function handleWorktreeInThread({ command, thread, appId, }) {
         starterMessage: statusMessage,
         worktreeName,
         projectDirectory,
-        baseBranch,
+        baseCommit,
         rest: command.client.rest,
-    })
-        .then(async (result) => {
-        if (result instanceof Error)
-            return;
-        const sourceSessionId = await getThreadSession(thread.id);
-        if (!sourceSessionId) {
-            await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
-            return;
-        }
-        const workspace = await getThreadWorktreeOrWorkspace(worktreeThread.id);
-        if (!workspace?.workspace_id) {
-            await sendThreadMessage(worktreeThread, '✗ Worktree is ready, but OpenCode returned no workspace ID for context reuse.');
-            return;
-        }
-        const getClient = await initializeOpencodeForDirectory(result, {
-            originalRepoDirectory: projectDirectory,
-            channelId: parent.id,
-        });
-        if (getClient instanceof Error) {
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to initialize OpenCode for context reuse: ${getClient.message}`);
-            return;
-        }
-        const forkResponse = await getClient().session.fork({
-            sessionID: sourceSessionId,
-            directory: result,
-            workspace: workspace.workspace_id,
-        }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
-        if (forkResponse instanceof Error) {
-            logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);
-            void notifyError(forkResponse, 'Failed to fork session into worktree');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${forkResponse.message}`);
-            return;
-        }
-        const forkedSession = forkResponse.data;
-        if (!forkedSession) {
-            const error = new Error('OpenCode did not return a forked session');
-            logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', error);
-            void notifyError(error, 'Failed to fork session into worktree');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
-            return;
-        }
-        await copyCurrentSessionModel({
-            sourceSessionId,
-            targetSessionId: forkedSession.id,
-            channelId: parent.id,
-            appId,
-            getClient,
-            directory: projectDirectory,
-        });
-        const permissionResponse = await getClient().session.update({
-            sessionID: forkedSession.id,
-            directory: result,
-            permission: buildSessionPermissions({
-                directory: result,
+        beforeReady: async ({ directory, workspaceId }) => {
+            const sourceSessionId = await getThreadSession(thread.id);
+            if (!sourceSessionId) {
+                await sendThreadMessage(worktreeThread, 'Worktree is ready. Send a message here to start a fresh session in this checkout.');
+                return;
+            }
+            const getClient = await initializeOpencodeForDirectory(directory, {
                 originalRepoDirectory: projectDirectory,
-            }),
-        }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
-        if (permissionResponse instanceof Error || permissionResponse.error) {
-            const error = permissionResponse instanceof Error
-                ? permissionResponse
-                : new Error('OpenCode rejected forked session permission update');
-            logger.error('[NEW-WORKTREE] Failed to update forked session permissions:', error);
-            void notifyError(error, 'Failed to update forked session permissions');
-            await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to update forked session permissions: ${error.message}`);
-            return;
-        }
-        await setThreadSession(worktreeThread.id, forkedSession.id);
-        getOrCreateRuntime({
-            threadId: worktreeThread.id,
-            thread: worktreeThread,
-            projectDirectory,
-            sdkDirectory: result,
-            channelId: parent.id,
-            appId,
-        });
-        await sendThreadMessage(worktreeThread, `Reusing context from <#${thread.id}> in worktree session \`${forkedSession.id}\`.`);
-    })
-        .catch((e) => {
+                channelId: parent.id,
+            });
+            if (getClient instanceof Error) {
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to initialize OpenCode for context reuse: ${getClient.message}`);
+                return;
+            }
+            const forkResponse = await getClient().session.fork({
+                sessionID: sourceSessionId,
+                directory,
+                workspace: workspaceId,
+            }).catch((e) => new OpenCodeSdkError({ operation: 'session.fork', cause: e }));
+            if (forkResponse instanceof Error) {
+                logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', forkResponse);
+                void notifyError(forkResponse, 'Failed to fork session into worktree');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${forkResponse.message}`);
+                return;
+            }
+            const forkedSession = forkResponse.data;
+            if (!forkedSession) {
+                const error = new Error('OpenCode did not return a forked session');
+                logger.error('[NEW-WORKTREE] Failed to fork session into worktree:', error);
+                void notifyError(error, 'Failed to fork session into worktree');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to reuse session context there: ${error.message}`);
+                return;
+            }
+            await copyCurrentSessionModel({
+                sourceSessionId,
+                targetSessionId: forkedSession.id,
+                channelId: parent.id,
+                appId,
+                getClient,
+                directory: projectDirectory,
+            });
+            const permissionResponse = await getClient().session.update({
+                sessionID: forkedSession.id,
+                directory,
+                permission: buildSessionPermissions({
+                    directory,
+                    originalRepoDirectory: projectDirectory,
+                }),
+            }).catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
+            if (permissionResponse instanceof Error || permissionResponse.error) {
+                const error = permissionResponse instanceof Error
+                    ? permissionResponse
+                    : new Error('OpenCode rejected forked session permission update');
+                logger.error('[NEW-WORKTREE] Failed to update forked session permissions:', error);
+                void notifyError(error, 'Failed to update forked session permissions');
+                await sendThreadMessage(worktreeThread, `✗ Worktree is ready, but failed to update forked session permissions: ${error.message}`);
+                return;
+            }
+            await setThreadSession(worktreeThread.id, forkedSession.id);
+            getOrCreateRuntime({
+                threadId: worktreeThread.id,
+                thread: worktreeThread,
+                projectDirectory,
+                sdkDirectory: directory,
+                channelId: parent.id,
+                appId,
+            });
+            await sendThreadMessage(worktreeThread, `Reusing context from <#${thread.id}> in worktree session \`${forkedSession.id}\`.`);
+        },
+    }).catch((e) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
         void notifyError(e, 'Background worktree creation failed (in-thread)');
     });

package/dist/commands/queue.js

@@ -6,6 +6,7 @@ import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils
 import { getOrCreateRuntime, getRuntime, } from '../session-handler/thread-session-runtime.js';
 import { buildHtmlActionCustomId, registerHtmlAction, } from '../html-actions.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { store } from '../store.js';
 const logger = createLogger(LogPrefix.QUEUE);
 function buildQueueRemoveRow({ threadId, queueId, position, }) {
@@ -108,7 +109,7 @@ export async function handleQueueCommand({ command, appId, }) {
         });
         return;
     }
-    const responseText = `» **${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
+    const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${message.slice(0, 1000)}${message.length > 1000 ? '...' : ''}`;
     await command.reply({
         content: responseText,
         flags: SILENT_MESSAGE_FLAGS,
@@ -264,7 +265,7 @@ export async function handleQueueCommandCommand({ command, appId, }) {
         logger.log(`[QUEUE] User ${command.user.displayName} queued command /${commandName} in thread ${channel.id}`);
         return;
     }
-    const responseText = `» **${command.user.displayName}:** ${displayText}`;
+    const responseText = `${QUEUE_PREFIX}**${command.user.displayName}:** ${displayText}`;
     await command.reply({
         content: responseText,
         flags: SILENT_MESSAGE_FLAGS,