kimaki 0.5.0 → 0.6.0

package/dist/anthropic-auth-plugin.js

@@ -22,6 +22,7 @@
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/anthropic.ts
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/anthropic.ts
  */
+import { appendToastSessionMarker } from "./plugin-logger.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.
@@ -485,13 +486,12 @@ function sanitizeAnthropicSystemText(text, onError) {
         return text;
     }
     // Re-inject the process working directory that was inside the stripped block.
-    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n`;
-    // Replace all case-insensitive whole-word occurrences of "opencode" with "openc0de"
+    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n\n`;
     const result = text.slice(0, startIdx) +
         envContext +
         text.slice(endIdx);
-    // Use a regex with global, case-insensitive, and word boundary flags
-    return result.replace(/\bopencode\b/gi, "openc0de");
+    return result;
+    // return result.replace(/\bopencode\b/gi, "openc0de");
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {
@@ -511,7 +511,10 @@ function mapSystemTextPart(part, onError) {
     return part;
 }
 function prependClaudeCodeIdentity(system, onError) {
-    const identityBlock = { type: "text", text: CLAUDE_CODE_IDENTITY };
+    const identityBlock = {
+        type: "text",
+        text: CLAUDE_CODE_IDENTITY,
+    };
     if (typeof system === "undefined")
         return [identityBlock];
     if (typeof system === "string") {
@@ -649,12 +652,6 @@ 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 = [

package/dist/commands/add-dir.test.js

@@ -84,4 +84,39 @@ describe('resolveDirectoryPermissionPattern', () => {
       ]
     `);
     });
+    test('pre-allows common toolchain caches under home with ~ patterns', () => {
+        expect(buildSessionPermissions({
+            directory: '/Users/me/project',
+        }).filter((rule) => {
+            return [
+                '~/.cache/zig',
+                '~/.cargo',
+                '~/.cache/go-build',
+                '~/go/pkg',
+            ].includes(rule.pattern);
+        })).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "~/.cache/zig",
+          "permission": "external_directory",
+        },
+        {
+          "action": "allow",
+          "pattern": "~/.cargo",
+          "permission": "external_directory",
+        },
+        {
+          "action": "allow",
+          "pattern": "~/.cache/go-build",
+          "permission": "external_directory",
+        },
+        {
+          "action": "allow",
+          "pattern": "~/go/pkg",
+          "permission": "external_directory",
+        },
+      ]
+    `);
+    });
 });

package/dist/kimaki-opencode-plugin.js

@@ -8,6 +8,7 @@
 // - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
 // - memory-overview-plugin: frozen MEMORY.md heading overview per session
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - subagent-rate-limit-plugin: aborts only task subagents after rate limits
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
@@ -16,5 +17,6 @@ export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plug
 export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
+export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
 export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';

package/dist/opencode-interrupt-plugin.js

@@ -68,8 +68,7 @@ function getInterruptStepTimeoutMsFromEnv() {
     return parsed;
 }
 // ── Encapsulated interrupt state ─────────────────────────────────
-// All 4 mutable variables (pendingByMessageId, latestAssistantMessageID,
-// recoveringSessions, waiters) are trapped inside this closure. The plugin
+// All mutable variables are trapped inside this closure. The plugin
 // hooks only see the returned API methods — they cannot break invariants
 // like forgetting to clear a timer or leaving a stale recovery lock.
 function createInterruptState() {
@@ -77,6 +76,11 @@ function createInterruptState() {
     const latestAssistantMessageIDBySession = new Map();
     const recoveringSessions = new Set();
     const waiters = new Set();
+    // Messages that were replayed after an abort. chat.message must skip
+    // scheduling a new interrupt timer for these to prevent an infinite
+    // abort→replay loop when the LLM takes >interruptStepTimeoutMs to
+    // return the first token (e.g. 239K token prompts).
+    const replayedMessageIds = new Set();
     function clearPending(messageID) {
         const pending = pendingByMessageId.get(messageID);
         if (!pending) {
@@ -176,6 +180,15 @@ function createInterruptState() {
         clearLatestAssistantMessage(sessionID) {
             latestAssistantMessageIDBySession.delete(sessionID);
         },
+        markReplayed(messageID) {
+            replayedMessageIds.add(messageID);
+        },
+        isReplayed(messageID) {
+            return replayedMessageIds.has(messageID);
+        },
+        clearReplayed(messageID) {
+            replayedMessageIds.delete(messageID);
+        },
         // Clean up all state for a deleted session — timers, recovery locks, etc.
         cleanupSession(sessionID) {
             latestAssistantMessageIDBySession.delete(sessionID);
@@ -183,6 +196,7 @@ function createInterruptState() {
                 if (pending.sessionID !== sessionID) {
                     return;
                 }
+                replayedMessageIds.delete(messageID);
                 clearPending(messageID);
             });
         },
@@ -257,6 +271,12 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             if (currentPending.model) {
                 replayBody.model = currentPending.model;
             }
+            // Mark as replayed BEFORE promptAsync so the chat.message hook
+            // (which fires synchronously when opencode processes the message)
+            // knows to skip scheduling a new interrupt timer. Without this,
+            // replayed messages re-enter the interrupt pipeline and create an
+            // infinite abort→replay loop when the LLM takes >timeout to respond.
+            state.markReplayed(messageID);
             await ctx.client.session.promptAsync({
                 path: { id: sessionID },
                 body: replayBody,
@@ -337,6 +357,13 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             if (!messageID) {
                 return;
             }
+            // Skip replayed messages — they were already interrupted and replayed
+            // by interruptPendingMessage. Scheduling a new timer would create an
+            // infinite abort→replay loop when the LLM is slow (large context).
+            if (state.isReplayed(messageID)) {
+                state.clearReplayed(messageID);
+                return;
+            }
             if (state.hasPending(messageID)) {
                 return;
             }

package/dist/opencode.js

@@ -710,39 +710,33 @@ export function buildSessionPermissions({ directory, originalRepoDirectory, }) {
         { permission: 'external_directory', pattern: normalizedDirectory, action: 'allow' },
         { permission: 'external_directory', pattern: `${normalizedDirectory}/*`, action: 'allow' },
     ];
+    const homeDirectoryRules = ({ relativePath }) => {
+        const normalizedRelativePath = relativePath.replaceAll('\\', '/');
+        const basePattern = path.resolve(os.homedir(), normalizedRelativePath);
+        return [
+            { permission: 'external_directory', pattern: basePattern, action: 'allow' },
+            { permission: 'external_directory', pattern: `${basePattern}/*`, action: 'allow' },
+        ];
+    };
     // Allow ~/.config/opencode so the agent doesn't get permission prompts when
     // it tries to read the global AGENTS.md or opencode config (the path is
     // visible in the system prompt, so models sometimes try to read it).
-    const opencodeConfigDir = path
-        .join(os.homedir(), '.config', 'opencode')
-        .replaceAll('\\', '/');
-    rules.push({ permission: 'external_directory', pattern: opencodeConfigDir, action: 'allow' }, { permission: 'external_directory', pattern: `${opencodeConfigDir}/*`, action: 'allow' });
+    rules.push(...homeDirectoryRules({ relativePath: '.config/opencode' }));
+    // Allow ~/.config/openc0de too because the Anthropic plugin rewrites the
+    // name in the system prompt and some models may try to inspect that path.
+    rules.push(...homeDirectoryRules({ relativePath: '.config/openc0de' }));
     // Allow ~/.opensrc so agents can inspect cached opensrc checkouts without
     // permission prompts.
-    const opensrcDir = path
-        .join(os.homedir(), '.opensrc')
-        .replaceAll('\\', '/');
-    rules.push({ permission: 'external_directory', pattern: opensrcDir, action: 'allow' }, { permission: 'external_directory', pattern: `${opensrcDir}/*`, action: 'allow' });
+    rules.push(...homeDirectoryRules({ relativePath: '.opensrc' }));
     // Allow ~/.kimaki so the agent can access kimaki data dir (logs, db, etc.)
     // without permission prompts.
-    const kimakiDataDir = path
-        .join(os.homedir(), '.kimaki')
-        .replaceAll('\\', '/');
-    rules.push({ permission: 'external_directory', pattern: kimakiDataDir, action: 'allow' }, { permission: 'external_directory', pattern: `${kimakiDataDir}/*`, action: 'allow' });
+    rules.push(...homeDirectoryRules({ relativePath: '.kimaki' }));
     // Allow opencode tool output artifacts under XDG data so agents can inspect
     // prior tool outputs without interactive permission prompts.
-    const opencodeToolOutputDir = path
-        .join(os.homedir(), '.local', 'share', 'opencode', 'tool-output')
-        .replaceAll('\\', '/');
-    rules.push({
-        permission: 'external_directory',
-        pattern: opencodeToolOutputDir,
-        action: 'allow',
-    }, {
-        permission: 'external_directory',
-        pattern: `${opencodeToolOutputDir}/*`,
-        action: 'allow',
-    });
+    rules.push(...homeDirectoryRules({ relativePath: '.local/share/opencode/tool-output' }));
+    // Allow common language caches under the user's home directory so toolchains
+    // can inspect downloaded modules and artifacts without external_directory prompts.
+    rules.push(...homeDirectoryRules({ relativePath: '.cache/zig' }), ...homeDirectoryRules({ relativePath: '.cargo' }), ...homeDirectoryRules({ relativePath: '.cache/go-build' }), ...homeDirectoryRules({ relativePath: 'go/pkg' }));
     // For worktree sessions: explicitly deny the original checkout so agents do
     // not keep editing the main repo after the thread has moved to a managed
     // worktree. Deny rules are appended last so they override earlier allow/

package/dist/plugin-logger.js

@@ -57,3 +57,12 @@ export function createPluginLogger(prefix) {
         },
     };
 }
+// Append a session ID marker at the end of a toast message so the bot-side
+// handleTuiToast can route the toast to the correct Discord thread.
+// Without this marker the toast is silently dropped.
+export function appendToastSessionMarker({ message, sessionId, }) {
+    if (!sessionId) {
+        return message;
+    }
+    return `${message} ${sessionId}`;
+}

package/dist/session-handler/thread-session-runtime.js

@@ -2106,6 +2106,10 @@ export class ThreadSessionRuntime {
         if (properties.variant === 'warning') {
             return;
         }
+        const toastSessionId = extractToastSessionId({ message: properties.message });
+        if (!toastSessionId) {
+            return;
+        }
         const toastMessage = stripToastSessionId({ message: properties.message }).trim();
         if (!toastMessage) {
             return;

package/dist/subagent-rate-limit-plugin.js

@@ -0,0 +1,175 @@
+// OpenCode plugin that aborts task-created subagent sessions after rate limits.
+import * as errore from 'errore';
+import { appendToastSessionMarker, createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('SUBMODEL');
+const RATE_LIMIT_TEXT_PATTERNS = [
+    'rate_limit',
+    'rate limit',
+    'resource exhausted',
+    'retry after',
+    'too many requests',
+    'quota exceeded',
+];
+function isRateLimitText(text) {
+    if (!text) {
+        return false;
+    }
+    const haystack = text.toLowerCase();
+    return RATE_LIMIT_TEXT_PATTERNS.some((pattern) => {
+        return haystack.includes(pattern);
+    });
+}
+function getTaskChildSession(event) {
+    if (event.type !== 'message.part.updated') {
+        return undefined;
+    }
+    const part = event.properties.part;
+    if (part.type !== 'tool' || part.tool !== 'task' || part.state.status === 'pending') {
+        return undefined;
+    }
+    const childSessionId = part.state.metadata?.sessionId;
+    if (typeof childSessionId !== 'string' || childSessionId.length === 0) {
+        return undefined;
+    }
+    const subagentType = part.state.input?.subagent_type;
+    return {
+        childSessionId,
+        subagentType: typeof subagentType === 'string' ? subagentType : undefined,
+    };
+}
+function getEventSessionId(event) {
+    if (event.type === 'session.status' || event.type === 'session.idle') {
+        return event.properties.sessionID;
+    }
+    if (event.type === 'session.error') {
+        return event.properties.sessionID;
+    }
+    if (event.type === 'message.updated') {
+        return event.properties.info.sessionID;
+    }
+    if (event.type === 'message.part.updated') {
+        return event.properties.part.sessionID;
+    }
+    if (event.type === 'session.created'
+        || event.type === 'session.updated'
+        || event.type === 'session.deleted') {
+        return event.properties.info.id;
+    }
+    return undefined;
+}
+function extractRateLimitReason(event) {
+    if (event.type === 'session.status' && event.properties.status.type === 'retry') {
+        return isRateLimitText(event.properties.status.message)
+            ? event.properties.status.message
+            : undefined;
+    }
+    if (event.type === 'message.part.updated' && event.properties.part.type === 'retry') {
+        const retryError = event.properties.part.error;
+        if (retryError.data.statusCode === 429) {
+            return retryError.data.message;
+        }
+        if (isRateLimitText(retryError.data.responseBody)) {
+            return retryError.data.responseBody;
+        }
+        return isRateLimitText(retryError.data.message)
+            ? retryError.data.message
+            : undefined;
+    }
+    const apiError = (() => {
+        if (event.type === 'session.error' && event.properties.error?.name === 'APIError') {
+            return event.properties.error.data;
+        }
+        if (event.type === 'message.updated'
+            && event.properties.info.role === 'assistant'
+            && event.properties.info.error?.name === 'APIError') {
+            return event.properties.info.error.data;
+        }
+        return undefined;
+    })();
+    if (!apiError) {
+        return undefined;
+    }
+    if (apiError.statusCode === 429) {
+        return apiError.message;
+    }
+    if (isRateLimitText(apiError.responseBody)) {
+        return apiError.responseBody;
+    }
+    return isRateLimitText(apiError.message) ? apiError.message : undefined;
+}
+export const subagentRateLimitPlugin = async ({ client, directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const subagentSessions = new Map();
+    return {
+        event: async ({ event }) => {
+            const taskChild = getTaskChildSession(event);
+            if (taskChild) {
+                const existing = subagentSessions.get(taskChild.childSessionId);
+                if (existing) {
+                    if (taskChild.subagentType) {
+                        existing.subagentType = taskChild.subagentType;
+                    }
+                }
+                else {
+                    subagentSessions.set(taskChild.childSessionId, {
+                        subagentType: taskChild.subagentType,
+                        aborting: false,
+                    });
+                }
+            }
+            const eventSessionId = getEventSessionId(event);
+            if (!eventSessionId) {
+                return;
+            }
+            if (event.type === 'session.deleted' || event.type === 'session.idle') {
+                subagentSessions.delete(eventSessionId);
+                return;
+            }
+            const rateLimitReason = extractRateLimitReason(event);
+            if (!rateLimitReason) {
+                return;
+            }
+            const subagent = subagentSessions.get(eventSessionId);
+            if (!subagent || subagent.aborting) {
+                return;
+            }
+            subagent.aborting = true;
+            const abortResult = await errore.tryAsync({
+                try: async () => {
+                    await client.session.abort({
+                        path: { id: eventSessionId },
+                        query: { directory },
+                    });
+                    await client.tui.showToast({
+                        body: {
+                            message: appendToastSessionMarker({
+                                message: `Aborting ${subagent.subagentType || 'subagent'} after rate limit so the parent task can recover: ${rateLimitReason}`,
+                                sessionId: eventSessionId,
+                            }),
+                            variant: 'info',
+                        },
+                    }).catch(() => {
+                        return;
+                    });
+                    logger.info(`Aborted subagent ${eventSessionId} after rate limit`);
+                },
+                catch: (error) => {
+                    return new Error('Subagent rate-limit abort failed', {
+                        cause: error,
+                    });
+                },
+            });
+            subagentSessions.delete(eventSessionId);
+            if (!(abortResult instanceof Error)) {
+                return;
+            }
+            logger.warn(`[subagent-rate-limit-plugin] ${formatPluginErrorWithStack(abortResult)}`);
+            void notifyError(abortResult, 'subagent rate-limit plugin abort failed');
+        },
+    };
+};

package/dist/subagent-rate-limit-plugin.test.js

@@ -0,0 +1,120 @@
+// Tests the fallback model ranking for subagent rate-limit recovery.
+import { describe, expect, test } from 'vitest';
+import { listCandidateModels } from './subagent-rate-limit-plugin.js';
+function createProviderData() {
+    return {
+        connected: ['anthropic', 'openai'],
+        default: {
+            anthropic: 'claude-sonnet-4-5',
+            openai: 'gpt-5',
+        },
+        all: [
+            {
+                id: 'anthropic',
+                api: 'https://api.anthropic.com',
+                name: 'Anthropic',
+                env: ['ANTHROPIC_API_KEY'],
+                models: {
+                    'claude-sonnet-4-5': {
+                        id: 'claude-sonnet-4-5',
+                        name: 'Claude Sonnet 4.5',
+                        release_date: '2026-01-01',
+                        attachment: true,
+                        reasoning: true,
+                        temperature: true,
+                        tool_call: true,
+                        limit: { context: 200_000, output: 16_000 },
+                        options: {},
+                        cost: { input: 3, output: 15 },
+                        modalities: { input: ['text'], output: ['text'] },
+                    },
+                    'claude-haiku-4-5': {
+                        id: 'claude-haiku-4-5',
+                        name: 'Claude Haiku 4.5',
+                        release_date: '2026-01-01',
+                        attachment: true,
+                        reasoning: false,
+                        temperature: true,
+                        tool_call: true,
+                        limit: { context: 200_000, output: 16_000 },
+                        options: {},
+                        cost: { input: 1, output: 5 },
+                        modalities: { input: ['text'], output: ['text'] },
+                    },
+                },
+            },
+            {
+                id: 'openai',
+                api: 'https://api.openai.com/v1',
+                name: 'OpenAI',
+                env: ['OPENAI_API_KEY'],
+                models: {
+                    'gpt-5': {
+                        id: 'gpt-5',
+                        name: 'GPT-5',
+                        release_date: '2026-01-01',
+                        attachment: true,
+                        reasoning: true,
+                        temperature: true,
+                        tool_call: true,
+                        limit: { context: 200_000, output: 16_000 },
+                        options: {},
+                        cost: { input: 1.25, output: 10 },
+                        modalities: { input: ['text'], output: ['text'] },
+                    },
+                    'gpt-4o-mini': {
+                        id: 'gpt-4o-mini',
+                        name: 'GPT-4o mini',
+                        release_date: '2026-01-01',
+                        attachment: true,
+                        reasoning: false,
+                        temperature: true,
+                        tool_call: true,
+                        limit: { context: 200_000, output: 16_000 },
+                        options: {},
+                        cost: { input: 0.15, output: 0.6 },
+                        modalities: { input: ['text'], output: ['text'] },
+                    },
+                },
+            },
+        ],
+    };
+}
+describe('listCandidateModels', () => {
+    test('prefers the cheapest model from other connected providers', () => {
+        const result = listCandidateModels({
+            providerData: createProviderData(),
+            currentModel: {
+                providerID: 'anthropic',
+                modelID: 'claude-sonnet-4-5',
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "modelID": "gpt-4o-mini",
+          "providerID": "openai",
+        },
+        {
+          "modelID": "gpt-5",
+          "providerID": "openai",
+        },
+      ]
+    `);
+    });
+    test('never falls back to models from the same provider', () => {
+        const providerData = createProviderData();
+        providerData.connected = ['anthropic'];
+        providerData.all = providerData.all.filter((provider) => {
+            return provider.id === 'anthropic';
+        });
+        const result = listCandidateModels({
+            providerData,
+            currentModel: {
+                providerID: 'anthropic',
+                modelID: 'claude-sonnet-4-5',
+            },
+        });
+        expect(result).toEqual([]);
+    });
+});

package/dist/system-prompt-drift-plugin.js

@@ -5,16 +5,12 @@
 // mutating the system prompt unexpectedly.
 import { diffLines } from 'diff';
 import * as errore from 'errore';
-import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
+import { appendToastSessionMarker, createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
 import { initSentry, notifyError } from './sentry.js';
 const logger = createPluginLogger('OPENCODE');
-const TOAST_SESSION_MARKER_SEPARATOR = ' ';
 function normalizeSystemPrompt({ system }) {
     return system.join('\n');
 }
-function appendToastSessionMarker({ message, sessionId, }) {
-    return `${message}${TOAST_SESSION_MARKER_SEPARATOR}${sessionId}`;
-}
 function buildTurnContext({ input, directory, }) {
     const model = input.model
         ? `${input.model.providerID}/${input.model.modelID}${input.variant ? `:${input.variant}` : ''}`