@otto-assistant/bridge 0.4.93 → 0.4.97

package/dist/anthropic-account-identity.js

@@ -0,0 +1,62 @@
+// Helpers for extracting and normalizing Anthropic OAuth account identity.
+const identityHintKeys = new Set(['user', 'profile', 'account', 'viewer']);
+const idKeys = ['user_id', 'userId', 'account_id', 'accountId', 'id', 'sub'];
+export function normalizeAnthropicAccountIdentity(identity) {
+    const email = typeof identity?.email === 'string' && identity.email.trim()
+        ? identity.email.trim().toLowerCase()
+        : undefined;
+    const accountId = typeof identity?.accountId === 'string' && identity.accountId.trim()
+        ? identity.accountId.trim()
+        : undefined;
+    if (!email && !accountId)
+        return undefined;
+    return {
+        ...(email ? { email } : {}),
+        ...(accountId ? { accountId } : {}),
+    };
+}
+function getCandidateFromRecord(record, path) {
+    const email = typeof record.email === 'string' ? record.email : undefined;
+    const accountId = idKeys
+        .map((key) => {
+        const value = record[key];
+        return typeof value === 'string' ? value : undefined;
+    })
+        .find((value) => {
+        return Boolean(value);
+    });
+    const normalized = normalizeAnthropicAccountIdentity({ email, accountId });
+    if (!normalized)
+        return undefined;
+    const hasIdentityHint = path.some((segment) => {
+        return identityHintKeys.has(segment);
+    });
+    return {
+        ...normalized,
+        score: (normalized.email ? 4 : 0) + (normalized.accountId ? 2 : 0) + (hasIdentityHint ? 2 : 0),
+    };
+}
+function collectIdentityCandidates(value, path = []) {
+    if (!value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => {
+            return collectIdentityCandidates(entry, path);
+        });
+    }
+    const record = value;
+    const nested = Object.entries(record).flatMap(([key, entry]) => {
+        return collectIdentityCandidates(entry, [...path, key]);
+    });
+    const current = getCandidateFromRecord(record, path);
+    return current ? [current, ...nested] : nested;
+}
+export function extractAnthropicAccountIdentity(value) {
+    const candidates = collectIdentityCandidates(value);
+    const best = candidates.sort((a, b) => {
+        return b.score - a.score;
+    })[0];
+    if (!best)
+        return undefined;
+    return normalizeAnthropicAccountIdentity(best);
+}

package/dist/anthropic-account-identity.test.js

@@ -0,0 +1,38 @@
+// Tests Anthropic OAuth account identity parsing and normalization.
+import { describe, expect, test } from 'vitest';
+import { extractAnthropicAccountIdentity, normalizeAnthropicAccountIdentity, } from './anthropic-account-identity.js';
+describe('normalizeAnthropicAccountIdentity', () => {
+    test('normalizes email casing and drops empty values', () => {
+        expect(normalizeAnthropicAccountIdentity({
+            email: '  User@Example.com ',
+            accountId: '  user_123  ',
+        })).toEqual({
+            email: 'user@example.com',
+            accountId: 'user_123',
+        });
+        expect(normalizeAnthropicAccountIdentity({ email: '   ' })).toBeUndefined();
+    });
+});
+describe('extractAnthropicAccountIdentity', () => {
+    test('prefers nested user profile identity from client_data responses', () => {
+        expect(extractAnthropicAccountIdentity({
+            organizations: [{ id: 'org_123', name: 'Workspace' }],
+            user: {
+                id: 'usr_123',
+                email: 'User@Example.com',
+            },
+        })).toEqual({
+            accountId: 'usr_123',
+            email: 'user@example.com',
+        });
+    });
+    test('falls back to profile-style payloads without email', () => {
+        expect(extractAnthropicAccountIdentity({
+            profile: {
+                user_id: 'usr_456',
+            },
+        })).toEqual({
+            accountId: 'usr_456',
+        });
+    });
+});

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 { 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.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
 function base64urlEncode(bytes) {
@@ -52,6 +53,8 @@ const CLIENT_ID = (() => {
 })();
 const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
 const CREATE_API_KEY_URL = 'https://api.anthropic.com/api/oauth/claude_cli/create_api_key';
+const CLIENT_DATA_URL = 'https://api.anthropic.com/api/oauth/claude_cli/client_data';
+const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
 const CALLBACK_PORT = 53692;
 const CALLBACK_PATH = '/callback';
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
@@ -64,6 +67,7 @@ const CLAUDE_CODE_BETA = 'claude-code-20250219';
 const OAUTH_BETA = 'oauth-2025-04-20';
 const FINE_GRAINED_TOOL_STREAMING_BETA = 'fine-grained-tool-streaming-2025-05-14';
 const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14';
+const TOAST_SESSION_HEADER = 'x-kimaki-session-id';
 const ANTHROPIC_HOSTS = new Set([
     'api.anthropic.com',
     'claude.ai',
@@ -227,6 +231,29 @@ async function createApiKey(accessToken) {
     const json = JSON.parse(responseText);
     return { type: 'success', key: json.raw_key };
 }
+async function fetchAnthropicAccountIdentity(accessToken) {
+    const urls = [CLIENT_DATA_URL, PROFILE_URL];
+    for (const url of urls) {
+        const responseText = await requestText(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                authorization: `Bearer ${accessToken}`,
+                'user-agent': process.env.OPENCODE_ANTHROPIC_USER_AGENT || `claude-cli/${CLAUDE_CODE_VERSION}`,
+                'x-app': 'cli',
+            },
+        }).catch(() => {
+            return undefined;
+        });
+        if (!responseText)
+            continue;
+        const parsed = JSON.parse(responseText);
+        const identity = extractAnthropicAccountIdentity(parsed);
+        if (identity)
+            return identity;
+    }
+    return undefined;
+}
 async function startCallbackServer(expectedState) {
     return new Promise((resolve, reject) => {
         let settle;
@@ -376,12 +403,13 @@ function buildAuthorizeHandler(mode) {
             if (mode === 'apikey') {
                 return createApiKey(creds.access);
             }
+            const identity = await fetchAnthropicAccountIdentity(creds.access);
             await rememberAnthropicOAuth({
                 type: 'oauth',
                 refresh: creds.refresh,
                 access: creds.access,
                 expires: creds.expires,
-            });
+            }, identity);
             return creds;
         };
         if (!isRemote) {
@@ -395,8 +423,7 @@ function buildAuthorizeHandler(mode) {
                             const result = await waitForCallback(auth.callbackServer);
                             return await finalize(result);
                         }
-                        catch (error) {
-                            console.error(`[anthropic-auth] ${error}`);
+                        catch {
                             return { type: 'failed' };
                         }
                     })();
@@ -414,8 +441,7 @@ function buildAuthorizeHandler(mode) {
                         const result = await waitForCallback(auth.callbackServer, input);
                         return await finalize(result);
                     }
-                    catch (error) {
-                        console.error(`[anthropic-auth] ${error}`);
+                    catch {
                         return { type: 'failed' };
                     }
                 })();
@@ -430,15 +456,25 @@ function buildAuthorizeHandler(mode) {
 function toClaudeCodeToolName(name) {
     return OPENCODE_TO_CLAUDE_CODE_TOOL_NAME[name.toLowerCase()] ?? name;
 }
-function sanitizeSystemText(text) {
-    return text.replaceAll(OPENCODE_IDENTITY, CLAUDE_CODE_IDENTITY);
+function sanitizeSystemText(text, onError) {
+    const startIdx = text.indexOf(OPENCODE_IDENTITY);
+    if (startIdx === -1)
+        return text;
+    const codeRefsMarker = '# Code References';
+    const endIdx = text.indexOf(codeRefsMarker, startIdx);
+    if (endIdx === -1) {
+        onError?.(`sanitizeSystemText: could not find '# Code References' after OpenCode identity`);
+        return text;
+    }
+    // Remove everything from the OpenCode identity up to (but not including) '# Code References'
+    return text.slice(0, startIdx) + text.slice(endIdx);
 }
-function prependClaudeCodeIdentity(system) {
+function prependClaudeCodeIdentity(system, onError) {
     const identityBlock = { type: 'text', text: CLAUDE_CODE_IDENTITY };
     if (typeof system === 'undefined')
         return [identityBlock];
     if (typeof system === 'string') {
-        const sanitized = sanitizeSystemText(system);
+        const sanitized = sanitizeSystemText(system, onError);
         if (sanitized === CLAUDE_CODE_IDENTITY)
             return [identityBlock];
         return [identityBlock, { type: 'text', text: sanitized }];
@@ -447,11 +483,11 @@ function prependClaudeCodeIdentity(system) {
         return [identityBlock, system];
     const sanitized = system.map((item) => {
         if (typeof item === 'string')
-            return { type: 'text', text: sanitizeSystemText(item) };
+            return { type: 'text', text: sanitizeSystemText(item, onError) };
         if (item && typeof item === 'object' && item.type === 'text') {
             const text = item.text;
             if (typeof text === 'string') {
-                return { ...item, text: sanitizeSystemText(text) };
+                return { ...item, text: sanitizeSystemText(text, onError) };
             }
         }
         return item;
@@ -465,7 +501,7 @@ function prependClaudeCodeIdentity(system) {
     }
     return [identityBlock, ...sanitized];
 }
-function rewriteRequestPayload(body) {
+function rewriteRequestPayload(body, onError) {
     if (!body)
         return { body, modelId: undefined, reverseToolNameMap: new Map() };
     try {
@@ -486,7 +522,7 @@ function rewriteRequestPayload(body) {
             });
         }
         // Rename system prompt
-        payload.system = prependClaudeCodeIdentity(payload.system);
+        payload.system = prependClaudeCodeIdentity(payload.system, onError);
         // Rename tool_choice
         if (payload.tool_choice &&
             typeof payload.tool_choice === 'object' &&
@@ -567,6 +603,12 @@ function wrapResponseStream(response, reverseToolNameMap) {
         headers: response.headers,
     });
 }
+function appendToastSessionMarker({ message, sessionId, }) {
+    if (!sessionId) {
+        return message;
+    }
+    return `${message} ${sessionId}`;
+}
 // --- Beta headers ---
 function getRequiredBetas(modelId) {
     const betas = [CLAUDE_CODE_BETA, OAUTH_BETA, FINE_GRAINED_TOOL_STREAMING_BETA];
@@ -614,7 +656,19 @@ async function getFreshOAuth(getAuth, client) {
         await setAnthropicAuth(refreshed, client);
         const store = await loadAccountStore();
         if (store.accounts.length > 0) {
-            upsertAccount(store, refreshed);
+            const identity = (() => {
+                const currentIndex = store.accounts.findIndex((account) => {
+                    return account.refresh === latest.refresh || account.access === latest.access;
+                });
+                const current = currentIndex >= 0 ? store.accounts[currentIndex] : undefined;
+                if (!current)
+                    return undefined;
+                return {
+                    ...(current.email ? { email: current.email } : {}),
+                    ...(current.accountId ? { accountId: current.accountId } : {}),
+                };
+            })();
+            upsertAccount(store, { ...refreshed, ...identity });
             await saveAccountStore(store);
         }
         return refreshed;
@@ -627,6 +681,12 @@ async function getFreshOAuth(getAuth, client) {
 // --- Plugin export ---
 const AnthropicAuthPlugin = async ({ client }) => {
     return {
+        'chat.headers': async (input, output) => {
+            if (input.model.providerID !== 'anthropic') {
+                return;
+            }
+            output.headers[TOAST_SESSION_HEADER] = input.sessionID;
+        },
         auth: {
             provider: 'anthropic',
             async loader(getAuth, provider) {
@@ -658,7 +718,6 @@ const AnthropicAuthPlugin = async ({ client }) => {
                                     .text()
                                     .catch(() => undefined)
                                 : undefined;
-                        const rewritten = rewriteRequestPayload(originalBody);
                         const headers = new Headers(init?.headers);
                         if (input instanceof Request) {
                             input.headers.forEach((v, k) => {
@@ -666,9 +725,19 @@ const AnthropicAuthPlugin = async ({ client }) => {
                                     headers.set(k, v);
                             });
                         }
+                        const sessionId = headers.get(TOAST_SESSION_HEADER) ?? undefined;
+                        const rewritten = rewriteRequestPayload(originalBody, (msg) => {
+                            client.tui.showToast({
+                                body: {
+                                    message: appendToastSessionMarker({ message: msg, sessionId }),
+                                    variant: 'error',
+                                },
+                            }).catch(() => { });
+                        });
                         const betas = getRequiredBetas(rewritten.modelId);
                         const runRequest = async (auth) => {
                             const requestHeaders = new Headers(headers);
+                            requestHeaders.delete(TOAST_SESSION_HEADER);
                             requestHeaders.set('accept', 'application/json');
                             requestHeaders.set('anthropic-beta', mergeBetas(requestHeaders.get('anthropic-beta'), betas));
                             requestHeaders.set('anthropic-dangerous-direct-browser-access', 'true');
@@ -697,7 +766,10 @@ const AnthropicAuthPlugin = async ({ client }) => {
                                     // Show toast notification so Discord thread shows the rotation
                                     client.tui.showToast({
                                         body: {
-                                            message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                                            message: appendToastSessionMarker({
+                                                message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                                                sessionId,
+                                            }),
                                             variant: 'info',
                                         },
                                     }).catch(() => { });

package/dist/anthropic-auth-state.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { normalizeAnthropicAccountIdentity, } from './anthropic-account-identity.js';
 const AUTH_LOCK_STALE_MS = 30_000;
 const AUTH_LOCK_RETRY_MS = 100;
 async function readJson(filePath, fallback) {
@@ -80,6 +81,8 @@ export function normalizeAccountStore(input) {
             typeof account.refresh === 'string' &&
             typeof account.access === 'string' &&
             typeof account.expires === 'number' &&
+            (typeof account.email === 'undefined' || typeof account.email === 'string') &&
+            (typeof account.accountId === 'undefined' || typeof account.accountId === 'string') &&
             typeof account.addedAt === 'number' &&
             typeof account.lastUsed === 'number')
         : [];
@@ -96,8 +99,13 @@ export async function saveAccountStore(store) {
 }
 /** Short label for an account: first 8 + last 4 chars of refresh token. */
 export function accountLabel(account, index) {
+    const accountWithIdentity = account;
+    const identity = accountWithIdentity.email || accountWithIdentity.accountId;
     const r = account.refresh;
     const short = r.length > 12 ? `${r.slice(0, 8)}...${r.slice(-4)}` : r;
+    if (identity) {
+        return index !== undefined ? `#${index + 1} (${identity})` : identity;
+    }
     return index !== undefined ? `#${index + 1} (${short})` : short;
 }
 function findCurrentAccountIndex(store, auth) {
@@ -116,14 +124,29 @@ function findCurrentAccountIndex(store, auth) {
     return store.activeIndex;
 }
 export function upsertAccount(store, auth, now = Date.now()) {
+    const authWithIdentity = auth;
+    const identity = normalizeAnthropicAccountIdentity({
+        email: authWithIdentity.email,
+        accountId: authWithIdentity.accountId,
+    });
     const index = store.accounts.findIndex((account) => {
-        return account.refresh === auth.refresh || account.access === auth.access;
+        if (account.refresh === auth.refresh || account.access === auth.access) {
+            return true;
+        }
+        if (identity?.accountId && account.accountId === identity.accountId) {
+            return true;
+        }
+        if (identity?.email && account.email === identity.email) {
+            return true;
+        }
+        return false;
     });
     const nextAccount = {
         type: 'oauth',
         refresh: auth.refresh,
         access: auth.access,
         expires: auth.expires,
+        ...identity,
         addedAt: now,
         lastUsed: now,
     };
@@ -139,14 +162,16 @@ export function upsertAccount(store, auth, now = Date.now()) {
         ...existing,
         ...nextAccount,
         addedAt: existing.addedAt,
+        email: nextAccount.email || existing.email,
+        accountId: nextAccount.accountId || existing.accountId,
     };
     store.activeIndex = index;
     return index;
 }
-export async function rememberAnthropicOAuth(auth) {
+export async function rememberAnthropicOAuth(auth, identity) {
     await withAuthStateLock(async () => {
         const store = await loadAccountStore();
-        upsertAccount(store, auth);
+        upsertAccount(store, { ...auth, ...normalizeAnthropicAccountIdentity(identity) });
         await saveAccountStore(store);
     });
 }

package/dist/{anthropic-auth-plugin.test.js → anthropic-auth-state.test.js}

@@ -1,9 +1,9 @@
-// Tests for Anthropic OAuth multi-account persistence and rotation.
+// Tests Anthropic OAuth account persistence, deduplication, and rotation.
 import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
+import { accountLabel, authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
 const firstAccount = {
     type: 'oauth',
     refresh: 'refresh-first',
@@ -45,6 +45,25 @@ describe('rememberAnthropicOAuth', () => {
             expires: 3,
         });
     });
+    test('deduplicates new tokens by email or account ID', async () => {
+        await rememberAnthropicOAuth(firstAccount, {
+            email: 'user@example.com',
+            accountId: 'usr_123',
+        });
+        await rememberAnthropicOAuth(secondAccount, {
+            email: 'User@example.com',
+            accountId: 'usr_123',
+        });
+        const store = await loadAccountStore();
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]).toMatchObject({
+            refresh: 'refresh-second',
+            access: 'access-second',
+            email: 'user@example.com',
+            accountId: 'usr_123',
+        });
+        expect(accountLabel(store.accounts[0])).toBe('user@example.com');
+    });
 });
 describe('rotateAnthropicAccount', () => {
     test('rotates to the next stored account and syncs auth state', async () => {

package/dist/cli-parsing.test.js

@@ -22,8 +22,8 @@ function createCliForIdParsing() {
         .command('add-project', 'Add a project')
         .option('-g, --guild <guildId>', 'Discord guild/server ID');
     cli.command('task delete <id>', 'Delete task');
-    cli.command('anthropic-accounts list', 'List stored Anthropic accounts').hidden();
-    cli.command('anthropic-accounts remove <index>', 'Remove stored Anthropic account').hidden();
+    cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
+    cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account');
     return cli;
 }
 describe('goke CLI ID parsing', () => {
@@ -113,13 +113,16 @@ describe('goke CLI ID parsing', () => {
         expect(result.args[0]).toBe(taskId);
         expect(typeof result.args[0]).toBe('string');
     });
-    test('hidden anthropic account commands still parse', () => {
+    test('anthropic account remove parses index and email as strings', () => {
         const cli = createCliForIdParsing();
-        const result = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', '2'], { run: false });
-        expect(result.args[0]).toBe('2');
-        expect(typeof result.args[0]).toBe('string');
+        const indexResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', '2'], { run: false });
+        const emailResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', 'user@example.com'], { run: false });
+        expect(indexResult.args[0]).toBe('2');
+        expect(typeof indexResult.args[0]).toBe('string');
+        expect(emailResult.args[0]).toBe('user@example.com');
+        expect(typeof emailResult.args[0]).toBe('string');
     });
-    test('hidden anthropic account commands are excluded from help output', () => {
+    test('anthropic account commands are included in help output', () => {
         const stdout = {
             text: '',
             write(data) {
@@ -128,10 +131,10 @@ describe('goke CLI ID parsing', () => {
         };
         const cli = goke('kimaki', { stdout: stdout });
         cli.command('send', 'Send a message');
-        cli.command('anthropic-accounts list', 'List stored Anthropic accounts').hidden();
+        cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
         cli.help();
         cli.parse(['node', 'kimaki', '--help'], { run: false });
         expect(stdout.text).toContain('send');
-        expect(stdout.text).not.toContain('anthropic-accounts');
+        expect(stdout.text).toContain('anthropic-accounts');
     });
 });

package/dist/cli.js

@@ -662,7 +662,8 @@ async function resolveCredentials({ forceRestartOnboarding, forceGateway, gatewa
                 options: [
                     {
                         value: 'gateway',
-                        label: 'Gateway (pre-built Kimaki bot — no setup needed)',
+                        disabled: true,
+                        label: 'Gateway (pre-built Kimaki bot, currently disabled because of Discord verification process. will be re-enabled soon)',
                     },
                     {
                         value: 'self_hosted',
@@ -2224,7 +2225,6 @@ cli
 });
 cli
     .command('anthropic-accounts list', 'List stored Anthropic OAuth accounts used for automatic rotation')
-    .hidden()
     .action(async () => {
     const store = await loadAccountStore();
     console.log(`Store: ${accountsFilePath()}`);
@@ -2239,16 +2239,29 @@ cli
     process.exit(0);
 });
 cli
-    .command('anthropic-accounts remove <index>', 'Remove a stored Anthropic OAuth account from the rotation pool')
-    .hidden()
-    .action(async (index) => {
-    const value = Number(index);
-    if (!Number.isInteger(value) || value < 1) {
-        cliLogger.error('Usage: kimaki anthropic-accounts remove <index>');
+    .command('anthropic-accounts remove <indexOrEmail>', 'Remove a stored Anthropic OAuth account from the rotation pool by index or email')
+    .action(async (indexOrEmail) => {
+    const value = Number(indexOrEmail);
+    const store = await loadAccountStore();
+    const resolvedIndex = (() => {
+        if (Number.isInteger(value) && value >= 1) {
+            return value - 1;
+        }
+        const email = indexOrEmail.trim().toLowerCase();
+        if (!email) {
+            return -1;
+        }
+        return store.accounts.findIndex((account) => {
+            return account.email?.toLowerCase() === email;
+        });
+    })();
+    if (resolvedIndex < 0) {
+        cliLogger.error('Usage: kimaki anthropic-accounts remove <index-or-email>');
         process.exit(EXIT_NO_RESTART);
     }
-    await removeAccount(value - 1);
-    cliLogger.log(`Removed Anthropic account ${value}`);
+    const removed = store.accounts[resolvedIndex];
+    await removeAccount(resolvedIndex);
+    cliLogger.log(`Removed Anthropic account ${removed ? accountLabel(removed, resolvedIndex) : indexOrEmail}`);
     process.exit(0);
 });
 cli

package/dist/context-awareness-plugin.js

@@ -61,7 +61,7 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
         inject: true,
         text: `\n[working directory changed. Previous working directory: ${priorDirectory}. ` +
             `Current working directory: ${currentDir}. ` +
-            `You MUST read, write, and edit files only under ${currentDir}. ` +
+            `You should read, write, and edit files under ${currentDir}. ` +
             `Do NOT read, write, or edit files under ${priorDirectory}.]`,
     };
 }

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

@@ -36,7 +36,7 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You MUST read, write, and edit files only under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
+      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You should read, write, and edit files under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
       }
     `);
     });
@@ -50,7 +50,7 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You MUST read, write, and edit files only under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
+      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You should read, write, and edit files under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
       }
     `);
     });

package/dist/discord-command-registration.js

@@ -110,7 +110,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-worktree')
-            .setDescription(truncateCommandDescription('Create a git worktree branch from origin/HEAD (or main). Optionally pick a base branch.'))
+            .setDescription(truncateCommandDescription('Create a git worktree branch from HEAD by default. Optionally pick a base branch.'))
             .addStringOption((option) => {
             option
                 .setName('name')
@@ -121,7 +121,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .addStringOption((option) => {
             option
                 .setName('base-branch')
-                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: origin/HEAD or main)'))
+                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: HEAD)'))
                 .setRequired(false)
                 .setAutocomplete(true);
             return option;

package/dist/discord-utils.js

@@ -1,8 +1,11 @@
 // Discord-specific utility functions.
 // Handles markdown splitting for Discord's 2000-char limit, code block escaping,
 // thread message sending, and channel metadata extraction from topic tags.
-import { ChannelType, GuildMember, MessageFlags, PermissionsBitField, } from 'discord.js';
-import { REST, Routes } from 'discord.js';
+// Use namespace import for CJS interop — discord.js is CJS and its named
+// exports aren't detectable by all ESM loaders (e.g. tsx/esbuild) because
+// discord.js uses tslib's __exportStar which is opaque to static analysis.
+import * as discord from 'discord.js';
+const { ChannelType, GuildMember, MessageFlags, PermissionsBitField, REST, Routes } = discord;
 import { discordApiUrl } from './discord-urls.js';
 import { Lexer } from 'marked';
 import { splitTablesFromMarkdown } from './format-tables.js';

package/dist/kimaki-opencode-plugin.js

@@ -11,6 +11,7 @@
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
+export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';

package/dist/logger.js

@@ -80,12 +80,18 @@ export function setLogFilePath(dataDir) {
 export function getLogFilePath() {
     return logFilePath;
 }
+const MAX_LOG_ARG_LENGTH = 1000;
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, max) + `… [truncated ${str.length - max} chars]`;
+}
 function formatArg(arg) {
     if (typeof arg === 'string') {
-        return sanitizeSensitiveText(arg, { redactPaths: false });
+        return truncate(sanitizeSensitiveText(arg, { redactPaths: false }), MAX_LOG_ARG_LENGTH);
     }
     const safeArg = sanitizeUnknownValue(arg, { redactPaths: false });
-    return util.inspect(safeArg, { colors: true, depth: 4 });
+    return truncate(util.inspect(safeArg, { colors: true, depth: 4 }), MAX_LOG_ARG_LENGTH);
 }
 export function formatErrorWithStack(error) {
     if (error instanceof Error) {