kimaki 0.13.0 → 0.14.0

package/dist/anthropic-auth-plugin.js

@@ -23,6 +23,7 @@
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/anthropic.ts
  */
 import { appendToastSessionMarker } from "./plugin-logger.js";
+import { createPluginClient } from "./plugin-opencode-client.js";
 import { loadAccountStore, rememberAnthropicOAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
 import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
@@ -766,7 +767,10 @@ async function getFreshOAuth(getAuth, client) {
         pendingRefresh.delete(auth.refresh);
     });
 }
-const AnthropicAuthPlugin = async ({ client }) => {
+const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
+    // Build our own v2 client. The plugin-provided ctx.client (v1) does not
+    // reliably make REST calls from inside the plugin process.
+    const client = createPluginClient({ serverUrl, directory });
     return {
         "chat.headers": async (input, output) => {
             if (input.model.providerID !== "anthropic") {
@@ -816,13 +820,11 @@ const AnthropicAuthPlugin = async ({ client }) => {
                         const rewritten = rewriteRequestPayload(originalBody, (msg) => {
                             client.tui
                                 .showToast({
-                                body: {
-                                    message: appendToastSessionMarker({
-                                        message: msg,
-                                        sessionId,
-                                    }),
-                                    variant: "error",
-                                },
+                                message: appendToastSessionMarker({
+                                    message: msg,
+                                    sessionId,
+                                }),
+                                variant: "error",
                             })
                                 .catch(() => { });
                         });
@@ -859,13 +861,11 @@ const AnthropicAuthPlugin = async ({ client }) => {
                                     // Show toast notification so Discord thread shows the rotation
                                     client.tui
                                         .showToast({
-                                        body: {
-                                            message: appendToastSessionMarker({
-                                                message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
-                                                sessionId,
-                                            }),
-                                            variant: "info",
-                                        },
+                                        message: appendToastSessionMarker({
+                                            message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                                            sessionId,
+                                        }),
+                                        variant: "info",
                                     })
                                         .catch(() => { });
                                     const retryAuth = await getFreshOAuth(getAuth, client);

package/dist/anthropic-auth-state.js

@@ -55,7 +55,7 @@ async function writeAnthropicAuthFile(auth) {
 }
 export async function setAnthropicAuth(auth, client) {
     await writeAnthropicAuthFile(auth);
-    await client.auth.set({ path: { id: 'anthropic' }, body: auth });
+    await client.auth.set({ providerID: 'anthropic', auth });
 }
 // --- Current account ---
 export async function getCurrentAnthropicAccount() {

package/dist/anthropic-auth-state.test.js

@@ -97,8 +97,8 @@ describe('rotateAnthropicAccount', () => {
         expect(authJson.anthropic?.refresh).toBe('refresh-second');
         expect(authSetCalls).toEqual([
             {
-                path: { id: 'anthropic' },
-                body: {
+                providerID: 'anthropic',
+                auth: {
                     type: 'oauth',
                     refresh: 'refresh-second',
                     access: 'access-second',

package/dist/channel-reference-permissions.e2e.test.js

@@ -71,12 +71,14 @@ describe('channel reference permissions', () => {
       --- from: assistant (TestBot)
       *using deterministic-provider/deterministic-v2*
       ⬥ reading referenced channel directory
+      ┣ read *allowed.txt*
       ⬥ channel-reference-read-done
       *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
       --- from: user (channel-reference-tester)
       Use <#200000000000001022> CHANNEL_REFERENCE_PERMISSION_MARKER followup
       --- from: assistant (TestBot)
       ⬥ reading referenced channel directory
+      ┣ read *allowed.txt*
       ⬥ channel-reference-read-done
       *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
     `);

package/dist/cli-parsing.test.js

@@ -15,7 +15,7 @@ async function parseWithGoke(argv) {
         "cli.command('multioauth anthropic remove <indexOrEmail>', 'Remove stored Anthropic account')",
         "cli.command('multioauth openai list', 'List stored OpenAI accounts')",
         "cli.command('multioauth openai remove <indexOrEmail>', 'Remove stored OpenAI account')",
-        `const result = cli.parse(${JSON.stringify(argv)}, { run: false })`,
+        `const result = await cli.parse(${JSON.stringify(argv)}, { run: false })`,
         'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
     ].join(';');
     const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {

package/dist/cli.js

@@ -40,6 +40,7 @@ cli
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
+    .option('--permission-timeout-minutes <minutes>', 'Permission prompt timeout in minutes before auto-rejecting (default: 10)')
     .option('--disable-sync', 'Disable background sync of external OpenCode sessions into Discord')
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
@@ -134,6 +135,19 @@ cli
                 }
             }
         }
+        // --permission-timeout-minutes validation
+        // Node setTimeout max is 2_147_483_647ms; larger values fire immediately.
+        const MAX_TIMEOUT_MINUTES = Math.floor(2_147_483_647 / 60_000);
+        const permissionTimeoutMs = (() => {
+            if (!options.permissionTimeoutMinutes)
+                return undefined;
+            const parsed = Number(options.permissionTimeoutMinutes);
+            if (!Number.isInteger(parsed) || parsed <= 0 || parsed > MAX_TIMEOUT_MINUTES) {
+                cliLogger.error(`Invalid permission timeout: ${options.permissionTimeoutMinutes}. Must be a positive whole number of minutes (max ${MAX_TIMEOUT_MINUTES}).`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            return parsed * 60_000;
+        })();
         store.setState({
             ...(defaultVerbosity && {
                 defaultVerbosity,
@@ -141,6 +155,7 @@ cli
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
+            ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
@@ -155,6 +170,9 @@ cli
         if (options.allowAllUsers) {
             cliLogger.log('Allow all users: any Discord member can start sessions (no-kimaki role still blocks)');
         }
+        if (permissionTimeoutMs !== undefined) {
+            cliLogger.log(`Permission timeout set to ${options.permissionTimeoutMinutes} minutes`);
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }
@@ -207,4 +225,4 @@ cli.use(sessionCommands);
 cli.use(maintenanceCommands);
 cli.version(getCurrentVersion());
 cli.help();
-cli.parse();
+void cli.parse();

package/dist/commands/action-buttons.js

@@ -212,7 +212,9 @@ export async function handleActionButton(interaction) {
         content: `**Action Required**\n_Selected: ${button.label}_`,
         components: [],
     });
+    const username = interaction.user.globalName || interaction.user.username;
     const prompt = `User clicked: ${button.label}`;
+    await sendThreadMessage(thread, `» **${username}:** ${button.label}`);
     try {
         await sendClickedActionToModel({
             interaction,

package/dist/commands/ask-question.js

@@ -183,6 +183,8 @@ export async function handleAskQuestionSelectMenu(interaction) {
         content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
         components: [], // Remove the dropdown
     });
+    const username = interaction.user.globalName || interaction.user.username;
+    await sendThreadMessage(context.thread, `» **${username}:** ${answeredText}`);
     // Check if all questions are answered
     if (context.answeredCount >= context.totalQuestions) {
         // All questions answered - send result back to session

package/dist/commands/compact.js

@@ -1,7 +1,7 @@
 // /compact command - Trigger context compaction (summarization) for the current session.
 import { ChannelType, MessageFlags, } from 'discord.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory, getOpencodeClient, } from '../opencode.js';
+import { initializeOpencodeForDirectory, getOpencodeClient, extractSdkErrorMessage, } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.COMPACT);
@@ -97,10 +97,7 @@ export async function handleCompactCommand({ command, }) {
         });
         if (result.error) {
             logger.error('[COMPACT] Error:', result.error);
-            const errorData = result.error.data;
-            const errorMessage = errorData && typeof errorData === 'object' && 'message' in errorData
-                ? String(errorData.message || 'Unknown error')
-                : 'Unknown error';
+            const errorMessage = extractSdkErrorMessage(result.error);
             await command.editReply({
                 content: `Failed to compact: ${errorMessage}`,
             });

package/dist/commands/file-upload.js

@@ -11,7 +11,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { NOTIFY_MESSAGE_FLAGS, sendThreadMessage } from '../discord-utils.js';
 const logger = createLogger(LogPrefix.FILE_UPLOAD);
 // 5 minute TTL for pending contexts - if user doesn't click within this time,
 // clean up the context and resolve with empty array to unblock the plugin tool
@@ -219,6 +219,10 @@ export async function handleFileUploadModalSubmit(interaction) {
             return `Upload failed: ${errors.join('; ')}`;
         })();
         await interaction.editReply({ content: summary });
+        if (downloadedPaths.length > 0) {
+            const username = interaction.user.globalName || interaction.user.username;
+            await sendThreadMessage(context.thread, `» **${username}:** Uploaded ${fileNames.join(', ')}`);
+        }
         resolveContext(context, downloadedPaths);
         logger.log(`File upload completed for session ${context.sessionId}: ${downloadedPaths.length} files`);
     }

package/dist/commands/model-variant.js

@@ -7,11 +7,10 @@
 // Map. Whichever menu fires second sees the first selection stored and applies.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { setChannelModel, setSessionModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
+import { setChannelModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, } from './model.js';
-import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, applyToCurrentSession, } from './model.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.MODEL);
@@ -292,7 +291,7 @@ export async function handleVariantScopeSelectMenu(interaction) {
 async function applyVariant({ interaction, context, variant, scope, contextHash, }) {
     const modelId = context.modelId;
     const variantSuffix = variant ? ` (${variant})` : '';
-    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_';
+    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/getting-started/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (scope === 'session') {
             if (!context.sessionId) {
@@ -303,22 +302,14 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 });
                 return;
             }
-            await setSessionModel({
+            const retried = await applyToCurrentSession({
                 sessionId: context.sessionId,
+                thread: context.thread,
                 modelId,
                 variant,
             });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set variant ${variant ?? 'none'} for session ${context.sessionId} (model ${modelId})`);
-            let retried = false;
-            if (context.thread) {
-                const runtime = getRuntime(context.thread.id);
-                if (runtime) {
-                    retried = await runtime.retryLastUserPrompt();
-                }
-            }
-            const retryNote = retried
-                ? '\n_Restarting current request with new variant..._'
-                : '';
             await interaction.editReply({
                 content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
@@ -332,9 +323,16 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 modelId,
                 variant,
             });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set global variant ${variant ?? 'none'} for app ${context.appId} and channel ${context.channelId} (model ${modelId})`);
             await interaction.editReply({
-                content: `Variant set for this channel and as global default:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this variant (unless they have their own override).${agentTip}`,
+                content: `Variant set for this channel and as global default:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this variant (unless they have their own override).${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });
@@ -346,9 +344,16 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 modelId,
                 variant,
             });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set channel variant ${variant ?? 'none'} for channel ${context.channelId} (model ${modelId})`);
             await interaction.editReply({
-                content: `Variant set for this channel:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this variant.${agentTip}`,
+                content: `Variant set for this channel:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this variant.${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });

package/dist/commands/model.js

@@ -693,6 +693,24 @@ async function showScopeMenu({ interaction, contextHash, context, }) {
         components: [actionRow],
     });
 }
+/**
+ * If a session is active, also update its model preference and retry.
+ * Returns true if the current request was restarted.
+ */
+export async function applyToCurrentSession({ sessionId, thread, modelId, variant, }) {
+    if (!sessionId) {
+        return false;
+    }
+    await setSessionModel({ sessionId, modelId, variant });
+    if (!thread) {
+        return false;
+    }
+    const runtime = getRuntime(thread.id);
+    if (!runtime) {
+        return false;
+    }
+    return runtime.retryLastUserPrompt();
+}
 /**
  * Handle the scope select menu interaction.
  * Applies the model to either the channel or globally.
@@ -728,7 +746,7 @@ export async function handleModelScopeSelectMenu(interaction) {
     const modelDisplay = modelId.split('/')[1] || modelId;
     const variant = context.selectedVariant ?? null;
     const variantSuffix = variant ? ` (${variant})` : '';
-    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_';
+    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/getting-started/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (selectedScope === 'session') {
             if (!context.sessionId) {
@@ -739,18 +757,14 @@ export async function handleModelScopeSelectMenu(interaction) {
                 });
                 return;
             }
-            await setSessionModel({ sessionId: context.sessionId, modelId, variant });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new model..._' : '';
             modelLogger.log(`Set model ${modelId}${variantSuffix} for session ${context.sessionId}`);
-            let retried = false;
-            if (context.thread) {
-                const runtime = getRuntime(context.thread.id);
-                if (runtime) {
-                    retried = await runtime.retryLastUserPrompt();
-                }
-            }
-            const retryNote = retried
-                ? '\n_Restarting current request with new model..._'
-                : '';
             await interaction.editReply({
                 content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
@@ -768,9 +782,16 @@ export async function handleModelScopeSelectMenu(interaction) {
             }
             await setGlobalModel({ appId: context.appId, modelId, variant });
             await setChannelModel({ channelId: context.channelId, modelId, variant });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new model..._' : '';
             modelLogger.log(`Set global model ${modelId}${variantSuffix} for app ${context.appId} and channel ${context.channelId}`);
             await interaction.editReply({
-                content: `Model set for this channel and as global default:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this model (unless they have their own override).${agentTip}`,
+                content: `Model set for this channel and as global default:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this model (unless they have their own override).${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });
@@ -778,9 +799,16 @@ export async function handleModelScopeSelectMenu(interaction) {
         else {
             // channel scope
             await setChannelModel({ channelId: context.channelId, modelId, variant });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new model..._' : '';
             modelLogger.log(`Set model ${modelId}${variantSuffix} for channel ${context.channelId}`);
             await interaction.editReply({
-                content: `Model preference set for this channel:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this model.${agentTip}`,
+                content: `Model preference set for this channel:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this model.${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });

package/dist/commands/new-worktree.js

@@ -3,12 +3,13 @@
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
-import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, getThreadSession, } from '../database.js';
-import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, 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 { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
-import { buildExternalDirectoryPermissionRules, getOpencodeClient, initializeOpencodeForDirectory, } from '../opencode.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';
 const logger = createLogger(LogPrefix.WORKTREE);
@@ -187,10 +188,6 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
                 threadId: thread.id,
                 worktreeDirectory: worktreeResult.directory,
             });
-            await denyPreviousCheckoutForExistingSession({
-                threadId: thread.id,
-                projectDirectory,
-            });
             // React with tree emoji to mark as worktree thread
             await reactToThread({
                 rest,
@@ -210,41 +207,6 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
         },
     });
 }
-async function denyPreviousCheckoutForExistingSession({ threadId, projectDirectory, }) {
-    const sessionId = await getThreadSession(threadId);
-    if (!sessionId) {
-        return;
-    }
-    const initializeResult = await initializeOpencodeForDirectory(projectDirectory);
-    if (initializeResult instanceof Error) {
-        logger.warn(`[WORKTREE] Failed to initialize OpenCode before denying previous checkout for thread ${threadId}: ${initializeResult.message}`);
-        return;
-    }
-    const client = getOpencodeClient(projectDirectory);
-    if (!client) {
-        logger.warn(`[WORKTREE] Missing OpenCode client for previous checkout deny update in thread ${threadId}`);
-        return;
-    }
-    const updateResult = await errore.tryAsync({
-        try: async () => {
-            await client.session.update({
-                sessionID: sessionId,
-                permission: buildExternalDirectoryPermissionRules({
-                    resolvedPattern: projectDirectory.replaceAll('\\', '/'),
-                    action: 'deny',
-                }),
-            });
-        },
-        catch: (e) => new Error('Failed to deny previous checkout for existing session', {
-            cause: e,
-        }),
-    });
-    if (updateResult instanceof Error) {
-        logger.warn(`[WORKTREE] Failed to deny previous checkout for existing session in thread ${threadId}: ${updateResult.message}`);
-        return;
-    }
-    logger.log(`[WORKTREE] Denied previous checkout for existing session ${sessionId} in thread ${threadId}`);
-}
 async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
     const listResult = await errore.tryAsync({
         try: () => execAsync('git worktree list --porcelain', { cwd: projectDirectory }),
@@ -268,7 +230,7 @@ async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
     }
     return undefined;
 }
-export async function handleNewWorktreeCommand({ command, }) {
+export async function handleNewWorktreeCommand({ command, appId, }) {
     await command.deferReply();
     const channel = command.channel;
     if (!channel) {
@@ -281,6 +243,7 @@ export async function handleNewWorktreeCommand({ command, }) {
         await handleWorktreeInThread({
             command,
             thread: channel,
+            appId,
         });
         return;
     }
@@ -351,7 +314,7 @@ export async function handleNewWorktreeCommand({ command, }) {
     const { thread, starterMessage } = result;
     await command.editReply(`Creating worktree in ${thread.toString()}`);
     // Create worktree in background (don't await)
-    createWorktreeInBackground({
+    void createWorktreeInBackground({
         thread,
         starterMessage,
         worktreeName,
@@ -365,14 +328,10 @@ export async function handleNewWorktreeCommand({ command, }) {
 }
 /**
  * Handle /new-worktree when called inside an existing thread.
- * Attaches a worktree to the current thread, using thread name if no name provided.
+ * Creates a separate worktree thread, using the source thread name if no name
+ * is provided. The source thread stays bound to its original directory.
  */
-async function handleWorktreeInThread({ command, thread, }) {
-    // Error if thread already has a worktree
-    if (await getThreadWorktree(thread.id)) {
-        await command.editReply('This thread already has a worktree attached.');
-        return;
-    }
+async function handleWorktreeInThread({ command, thread, appId, }) {
     // Get worktree name from parameter or derive from thread name
     const rawName = command.options.getString('name');
     const rawBaseBranch = command.options.getString('base-branch') || undefined;
@@ -414,20 +373,109 @@ async function handleWorktreeInThread({ command, thread, }) {
         await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``);
         return;
     }
-    // Send status message in thread
-    const statusMessage = await thread.send({
-        content: worktreeCreatingMessage(worktreeName),
-        flags: SILENT_MESSAGE_FLAGS,
+    const textChannel = await resolveTextChannel(thread);
+    if (!textChannel) {
+        await command.editReply('Could not resolve parent text channel');
+        return;
+    }
+    const threadResult = await errore.tryAsync({
+        try: async () => {
+            const worktreeThread = await textChannel.threads.create({
+                name: `${WORKTREE_PREFIX}worktree: ${worktreeName}`.slice(0, 100),
+                autoArchiveDuration: 1440,
+                reason: `Worktree fork from thread ${thread.id}`,
+            });
+            await worktreeThread.members.add(command.user.id);
+            const statusMessage = await worktreeThread.send({
+                content: worktreeCreatingMessage(worktreeName),
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            return { worktreeThread, statusMessage };
+        },
+        catch: (e) => new WorktreeError('Failed to create worktree thread', { cause: e }),
     });
-    await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`);
-    createWorktreeInBackground({
-        thread,
+    if (threadResult instanceof Error) {
+        await command.editReply(threadResult.message);
+        return;
+    }
+    const { worktreeThread, statusMessage } = threadResult;
+    await command.editReply(`Creating worktree in ${worktreeThread.toString()}`);
+    void createWorktreeInBackground({
+        thread: worktreeThread,
         starterMessage: statusMessage,
         worktreeName,
         projectDirectory,
         baseBranch,
         rest: command.client.rest,
-    }).catch((e) => {
+    })
+        .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 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 errore.tryAsync(() => {
+            return getClient().session.fork({
+                sessionID: sourceSessionId,
+                directory: result,
+            });
+        });
+        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;
+        }
+        const permissionResponse = await errore.tryAsync(() => {
+            return getClient().session.update({
+                sessionID: forkedSession.id,
+                directory: result,
+                permission: buildSessionPermissions({
+                    directory: result,
+                    originalRepoDirectory: projectDirectory,
+                }),
+            });
+        });
+        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) => {
         logger.error('[NEW-WORKTREE] Background error:', e);
         void notifyError(e, 'Background worktree creation failed (in-thread)');
     });