kimaki 0.12.0 → 0.13.1

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/btw-prefix-detection.js

@@ -1,17 +1,15 @@
-// Detects the raw `btw ` Discord message shortcut used to fork a side-question
-// thread without invoking the /btw slash command UI.
-export function extractBtwPrefix(content) {
-    if (!content) {
-        return null;
+// Detects `. btw` suffix at the end of a Discord message, identical pattern
+// to the queue suffix. When present the suffix is stripped and the remaining
+// message is forked to a new btw thread via /btw.
+//
+// Supported forms:
+// - punctuation + btw: ". btw", "! btw", ". btw.", "!btw."
+// - btw as its own final line: "text\nbtw"
+// Non-matches: "btw fix this" (start only), "hello btw" (no punctuation)
+const BTW_SUFFIX_RE = /(?:[.!?,;:])\s*btw\.?\s*$|\n\s*btw\.?\s*$/i;
+export function extractBtwSuffix(content) {
+    if (!BTW_SUFFIX_RE.test(content)) {
+        return { prompt: content, forceBtw: false };
     }
-    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
-    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
-    if (!match) {
-        return null;
-    }
-    const prompt = match[1]?.trim();
-    if (!prompt) {
-        return null;
-    }
-    return { prompt };
+    return { prompt: content.replace(BTW_SUFFIX_RE, '').trimEnd(), forceBtw: true };
 }

package/dist/btw-prefix-detection.test.js

@@ -1,63 +1,93 @@
 import { describe, expect, test } from 'vitest';
-import { extractBtwPrefix } from './btw-prefix-detection.js';
-describe('extractBtwPrefix', () => {
-    test('matches lowercase prefix', () => {
-        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+import { extractBtwSuffix } from './btw-prefix-detection.js';
+describe('extractBtwSuffix', () => {
+    test('matches after period', () => {
+        expect(extractBtwSuffix('fix the bug. btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches uppercase prefix', () => {
-        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+    test('matches after exclamation', () => {
+        expect(extractBtwSuffix('done! btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "check this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('keeps multiline content', () => {
-        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+    test('matches after comma', () => {
+        expect(extractBtwSuffix('sure, btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "first line
-      second line",
+        "forceBtw": true,
+        "prompt": "sure",
       }
     `);
     });
-    test('matches dot separator', () => {
-        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+    test('matches after newline', () => {
+        expect(extractBtwSuffix('fix the bug\nbtw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches comma separator', () => {
-        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+    test('matches with trailing dot', () => {
+        expect(extractBtwSuffix('fix the bug. btw.')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches colon separator', () => {
-        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+    test('case insensitive', () => {
+        expect(extractBtwSuffix('done. BTW')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('matches punctuation without trailing space', () => {
-        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+    test('no space between punctuation and btw', () => {
+        expect(extractBtwSuffix('done.btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('does not match without separating whitespace', () => {
-        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    test('does not match at start of message', () => {
+        expect(extractBtwSuffix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "btw fix this",
+      }
+    `);
     });
-    test('does not match mid-message', () => {
-        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    test('does not match mid-message without punctuation', () => {
+        expect(extractBtwSuffix('hello btw')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "hello btw",
+      }
+    `);
     });
-    test('does not match empty payload', () => {
-        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    test('does not match empty content', () => {
+        expect(extractBtwSuffix('')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "",
+      }
+    `);
+    });
+    test('multiline message with btw at end', () => {
+        expect(extractBtwSuffix('first line\nsecond line. btw')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": true,
+        "prompt": "first line
+      second line",
+      }
+    `);
     });
 });

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-runner.js

@@ -111,7 +111,11 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     const discordMaxLength = 2000;
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
-            body: { content: prompt, embeds },
+            body: {
+                content: prompt,
+                embeds,
+                allowed_mentions: { parse: store.getState().allowedMentions },
+            },
         }));
     }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
@@ -158,6 +162,7 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             content: summaryContent,
             attachments: [{ id: 0, filename: 'prompt.md' }],
             embeds,
+            allowed_mentions: { parse: store.getState().allowedMentions },
         }));
         const buffer = fs.readFileSync(tmpFile);
         formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
@@ -509,6 +514,7 @@ export async function ensureCommandAvailable({ name, envPathKey, installUnix, in
 }
 // Run opencode upgrade in the background so the user always has the latest version.
 // Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Uses -s to also prevent sleep on lid close (AC power only, not battery).
 // Uses -w to watch the parent PID so caffeinate self-terminates if kimaki
 // exits for any reason (SIGTERM, crash, process.exit, supervisor stop).
 export function startCaffeinate() {
@@ -516,7 +522,7 @@ export function startCaffeinate() {
         return;
     }
     try {
-        const proc = spawn('caffeinate', ['-i', '-w', String(process.pid)], {
+        const proc = spawn('caffeinate', ['-s', '-w', String(process.pid)], {
             stdio: 'ignore',
             detached: false,
         });

package/dist/cli.js

@@ -44,6 +44,10 @@ cli
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
+    .option('--allow-mention <type>', z
+    .array(z.enum(['users', 'roles', 'everyone']))
+    .optional()
+    .describe('Which mention types the bot can trigger (users, roles, everyone). Repeatable. Default: users only.'))
     .option('--enable-skill <name>', z
     .array(z.string())
     .optional()
@@ -140,6 +144,7 @@ cli
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
+            ...(options.allowMention && { allowedMentions: options.allowMention }),
         });
         if (enabledSkills.length > 0) {
             cliLogger.log(`Skill whitelist enabled: only [${enabledSkills.join(', ')}] will be injected`);
@@ -202,4 +207,4 @@ cli.use(sessionCommands);
 cli.use(maintenanceCommands);
 cli.version(getCurrentVersion());
 cli.help();
-cli.parse();
+void cli.parse();

package/dist/commands/abort.js

@@ -27,7 +27,7 @@ export async function handleAbortCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const resolved = await resolveWorkingDirectory({
         channel: channel,
     });

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/model-variant.js

@@ -292,7 +292,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/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) {

package/dist/commands/model.js

@@ -728,7 +728,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/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) {

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)');
     });

package/dist/commands/restart-opencode-server.js

@@ -46,7 +46,7 @@ export async function handleRestartOpencodeServerCommand({ command, appId, }) {
     }
     const { projectDirectory } = resolved;
     // Defer reply since restart may take a moment
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     // Dispose all runtimes for this directory/channel scope.
     // disposeRuntimesForDirectory aborts active runs, kills listeners, and
     // removes runtimes from the registry. Scoped by channelId so runtimes

package/dist/commands/undo-redo.js

@@ -58,7 +58,7 @@ export async function handleUndoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to undo: ${getClient.message}`);
@@ -209,7 +209,7 @@ export async function handleRedoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to redo: ${getClient.message}`);