kimaki 0.13.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/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

@@ -207,4 +207,4 @@ cli.use(sessionCommands);
 cli.use(maintenanceCommands);
 cli.version(getCurrentVersion());
 cli.help();
-cli.parse();
+void cli.parse();

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/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) {

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/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) {

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/context-awareness-plugin.js

@@ -18,6 +18,7 @@ import crypto from 'node:crypto';
 import * as errore from 'errore';
 import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
 import { setDataDir } from './config.js';
+import { createPluginClient } from './plugin-opencode-client.js';
 import { initSentry, notifyError } from './sentry.js';
 import { execAsync } from './exec-async.js';
 import { ONBOARDING_TUTORIAL_INSTRUCTIONS, TUTORIAL_WELCOME_TEXT, } from './onboarding-tutorial.js';
@@ -145,7 +146,7 @@ async function resolveGitState({ directory, }) {
 async function resolveSessionDirectory({ client, sessionID, state, }) {
     const previousDirectory = state.resolvedDirectory;
     const result = await errore.tryAsync(() => {
-        return client.session.get({ path: { id: sessionID } });
+        return client.session.get({ sessionID });
     });
     if (result instanceof Error || !result.data?.directory) {
         return {
@@ -160,13 +161,16 @@ async function resolveSessionDirectory({ client, sessionID, state, }) {
     };
 }
 // ── Plugin ───────────────────────────────────────────────────────
-const contextAwarenessPlugin = async ({ directory, client }) => {
+const contextAwarenessPlugin = async ({ directory, serverUrl }) => {
     initSentry();
     const dataDir = process.env.KIMAKI_DATA_DIR;
     if (dataDir) {
         setDataDir(dataDir);
         setPluginLogFilePath(dataDir);
     }
+    // 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 });
     // Single Map for all per-session state. One entry per session, one
     // delete on cleanup — no parallel Maps that can drift out of sync.
     const sessions = new Map();
@@ -225,8 +229,9 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                     const messageID = first.messageID;
                     const latestAssistantMessageResult = await errore.tryAsync(() => {
                         return client.session.messages({
-                            path: { id: sessionID },
-                            query: { directory, limit: 20 },
+                            sessionID,
+                            directory,
+                            limit: 20,
                         });
                     });
                     const latestAssistantMessage = latestAssistantMessageResult instanceof Error

package/dist/discord-bot.js

@@ -687,11 +687,21 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         rest: discordClient.rest,
                     });
                 }
+                const sessionDirectory = await (async () => {
+                    if (!worktreePromise) {
+                        return projectDirectory;
+                    }
+                    const result = await worktreePromise;
+                    if (result instanceof Error) {
+                        return projectDirectory;
+                    }
+                    return result;
+                })();
                 const channelRuntime = getOrCreateRuntime({
                     threadId: thread.id,
                     thread,
                     projectDirectory,
-                    sdkDirectory: projectDirectory,
+                    sdkDirectory: sessionDirectory,
                     channelId: channel.id,
                     appId: currentAppId,
                 });
@@ -703,19 +713,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     sourceThreadId: thread.id,
                     appId: currentAppId,
                     preprocess: async () => {
-                        // Wait for worktree creation + install before preprocessing.
-                        // Follow-up messages queue behind this in the preprocess chain.
-                        let sessionDirectory = projectDirectory;
-                        if (worktreePromise) {
-                            const result = await worktreePromise;
-                            if (!(result instanceof Error)) {
-                                sessionDirectory = result;
-                                channelRuntime.handleDirectoryChanged({
-                                    oldDirectory: projectDirectory,
-                                    newDirectory: sessionDirectory,
-                                });
-                            }
-                        }
                         return preprocessNewThreadMessage({
                             message,
                             thread,
@@ -925,11 +922,24 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
             discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
             const botThreadStartSource = parseSessionStartSourceFromMarker(marker);
+            const sessionDirectory = await (async () => {
+                if (cwdDirectory) {
+                    return cwdDirectory;
+                }
+                if (!worktreePromise) {
+                    return projectDirectory;
+                }
+                const result = await worktreePromise;
+                if (result instanceof Error) {
+                    return projectDirectory;
+                }
+                return result;
+            })();
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
                 projectDirectory,
-                sdkDirectory: projectDirectory,
+                sdkDirectory: sessionDirectory,
                 channelId: parent.id,
                 appId: currentAppId,
             });
@@ -950,23 +960,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                     : undefined,
                 preprocess: async () => {
-                    // Wait for worktree creation + install before starting session.
-                    if (worktreePromise) {
-                        const result = await worktreePromise;
-                        if (!(result instanceof Error)) {
-                            runtime.handleDirectoryChanged({
-                                oldDirectory: projectDirectory,
-                                newDirectory: result,
-                            });
-                        }
-                    }
-                    // --cwd: switch sdkDirectory to the existing worktree path
-                    if (cwdDirectory) {
-                        runtime.handleDirectoryChanged({
-                            oldDirectory: projectDirectory,
-                            newDirectory: cwdDirectory,
-                        });
-                    }
                     const permissionRules = await getChannelReferencePermissionRules({
                         message: starterMessage,
                     });

package/dist/message-finish-field.e2e.test.js

@@ -150,6 +150,7 @@ test('tool-call step has finish="tool-calls", follow-up has finish="stop"', asyn
         "partTypes": [
           "step-start",
           "text",
+          "tool",
           "step-finish",
         ],
       },

package/dist/openai-auth-plugin.js

@@ -14,6 +14,7 @@
  * Account management is done via `kimaki multioauth openai` CLI commands.
  */
 import { createPluginLogger, appendToastSessionMarker } from './plugin-logger.js';
+import { createPluginClient } from './plugin-opencode-client.js';
 import { isRateLimitRetryMessage, isTokenRefreshError, isOAuthStored, readJson, authFilePath } from './oauth-rotation-shared.js';
 import { detectAndRememberNewOpenAIAccount, loadOpenAIAccountStore, rotateOpenAIAccount, } from './openai-auth-state.js';
 const log = createPluginLogger('openai-rotation');
@@ -30,7 +31,7 @@ function isRetryStatusEvent(event) {
 // the last message in the session to find the model.
 async function isOpenAISession(client, sessionID) {
     try {
-        const res = await client.session.messages({ path: { id: sessionID } });
+        const res = await client.session.messages({ sessionID });
         const lastMessage = res.data?.filter((m) => m.info).at(-1)?.info;
         if (!lastMessage)
             return false;
@@ -45,8 +46,11 @@ async function isOpenAISession(client, sessionID) {
 // Throttle login detection to avoid spamming auth.json reads
 let lastLoginCheckMs = 0;
 const LOGIN_CHECK_INTERVAL_MS = 30_000;
-const openaiRotationPlugin = async ({ client }) => {
+const openaiRotationPlugin = async ({ serverUrl, directory }) => {
     log.info('OpenAI rotation plugin loaded');
+    // 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 !== 'openai')
@@ -69,13 +73,11 @@ const openaiRotationPlugin = async ({ client }) => {
                         const count = store?.accounts.length ?? 1;
                         client.tui
                             .showToast({
-                            body: {
-                                message: appendToastSessionMarker({
-                                    message: `OpenAI account ${label} added to rotation pool (${count} account${count === 1 ? '' : 's'})`,
-                                    sessionId: event.properties.sessionID,
-                                }),
-                                variant: 'info',
-                            },
+                            message: appendToastSessionMarker({
+                                message: `OpenAI account ${label} added to rotation pool (${count} account${count === 1 ? '' : 's'})`,
+                                sessionId: event.properties.sessionID,
+                            }),
+                            variant: 'info',
                         })
                             .catch(() => { });
                     }
@@ -106,13 +108,11 @@ const openaiRotationPlugin = async ({ client }) => {
                 if (result) {
                     client.tui
                         .showToast({
-                        body: {
-                            message: appendToastSessionMarker({
-                                message: `Switching OpenAI from ${result.fromLabel} to ${result.toLabel}`,
-                                sessionId: sessionID,
-                            }),
-                            variant: 'info',
-                        },
+                        message: appendToastSessionMarker({
+                            message: `Switching OpenAI from ${result.fromLabel} to ${result.toLabel}`,
+                            sessionId: sessionID,
+                        }),
+                        variant: 'info',
                     })
                         .catch(() => { });
                 }

package/dist/openai-auth-state.js

@@ -92,7 +92,7 @@ async function writeOpenAIAuthFile(auth) {
 }
 export async function setOpenAIAuth(auth, client) {
     await writeOpenAIAuthFile(auth);
-    await client.auth.set({ path: { id: 'openai' }, body: auth });
+    await client.auth.set({ providerID: 'openai', auth });
 }
 // --- Remember new login ---
 export async function rememberOpenAIOAuth(auth, identity) {

package/dist/opencode-command.js

@@ -62,12 +62,36 @@ export function getSpawnCommandAndArgs({ resolvedCommand, baseArgs, platform, })
         windowsVerbatimArguments: true,
     };
 }
+// Remove flags from the parent process's execArgv that must not leak into the
+// relocatable kimaki shim. The shim runs from arbitrary working directories
+// (it is on PATH for opencode child processes), so a relative `--env-file=.env`
+// would make node abort with ".env: not found" whenever the cwd has no .env.
+// The shim does not need to re-load env files at all: the env vars the bot
+// cares about are already in the inherited process environment. We strip both
+// `--env-file`/`--env-file-if-exists` forms: `--env-file=value` (single arg)
+// and `--env-file value` (two args).
+export function sanitizeShimExecArgv(execArgv) {
+    const sanitized = [];
+    for (let index = 0; index < execArgv.length; index++) {
+        const arg = execArgv[index];
+        if (arg === '--env-file' || arg === '--env-file-if-exists') {
+            // Skip this flag and its separate value argument, if present.
+            index++;
+            continue;
+        }
+        if (arg.startsWith('--env-file=') || arg.startsWith('--env-file-if-exists=')) {
+            continue;
+        }
+        sanitized.push(arg);
+    }
+    return sanitized;
+}
 export function ensureKimakiCommandShim({ dataDir, execPath, execArgv, entryScript, platform, }) {
     const effectivePlatform = platform || process.platform;
     const shimDirectory = path.join(dataDir, 'bin');
     try {
         fs.mkdirSync(shimDirectory, { recursive: true });
-        const launcherArgs = [...execArgv, entryScript];
+        const launcherArgs = [...sanitizeShimExecArgv(execArgv), entryScript];
         if (effectivePlatform === 'win32') {
             const shimPath = path.join(shimDirectory, 'kimaki.cmd');
             const shimContent = [