kimaki 0.26.0 → 0.28.0

package/dist/ipc-tools-plugin.js

@@ -1,9 +1,10 @@
-// OpenCode plugin that provides IPC-based tools for Discord interaction:
+// OpenCode plugin that provides Discord and session tools:
 // - kimaki_file_upload: prompts the Discord user to upload files via native picker
 // - kimaki_action_buttons: shows clickable action buttons in the Discord thread
+// - kimaki_sleep: persist a wake time so the session can sleep hours or days
 //
-// Tools communicate with the bot process via IPC rows in SQLite (the plugin
-// runs inside the OpenCode server process, not the bot process).
+// IPC tools talk to the bot process via SQLite rows. Sleep writes session_sleeps
+// directly. The plugin runs inside the OpenCode server process, not the bot.
 //
 // Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
 // plugin by OpenCode's plugin loader.
@@ -180,6 +181,70 @@ const ipcToolsPlugin = async () => {
                     return 'Action button request timed out';
                 },
             }),
+            kimaki_sleep: tool({
+                description: dedent `
+          Sleep this session until a future time. Kimaki later posts a wake
+          message in this thread and the same session continues.
+          Use this to wait hours or days for CI, a deploy, a date, or any later event.
+          The sleep is stored in SQLite and survives bot restarts.
+
+          Pass either duration (2h, 30m, 1d) or until (UTC ISO ending with Z).
+          Do not pass both. You MUST call kimaki_sleep LAST, after ALL text.
+          Do not call more tools after it.
+
+          The tool result is not a wake. After it succeeds, write one short
+          waiting line and stop. Do not continue the waited work until a later
+          Discord message that starts with "Woke after sleeping until".
+          A new user message cancels the sleep. If you still need that later
+          wake after answering, call kimaki_sleep again with until set to the
+          original UTC time.
+        `,
+                args: {
+                    duration: z
+                        .string()
+                        .optional()
+                        .describe('Relative wait. Examples: 30s, 2h, 1d. Do not pass with until.'),
+                    until: z
+                        .string()
+                        .optional()
+                        .describe('UTC ISO date ending with Z. Example: 2026-08-20T09:00:00Z.'),
+                    reason: z
+                        .string()
+                        .optional()
+                        .describe('Why the session is sleeping. Shown when it wakes.'),
+                },
+                async execute({ duration, until, reason }, context) {
+                    const { parseSleepWakeAt, formatSessionSleepWakeAt, formatSessionSleepToolOutput, } = await import('./task-schedule.js');
+                    const wakeAt = parseSleepWakeAt({
+                        duration,
+                        until,
+                        now: new Date(),
+                    });
+                    if (wakeAt instanceof Error) {
+                        return wakeAt.message;
+                    }
+                    const { getThreadIdBySessionId, upsertSessionSleep } = await loadDatabaseModule();
+                    // Only a check that a thread owns this session: subagents have none.
+                    // The wake resolves the thread again at delivery time, so nothing
+                    // here can go stale if /resume rebinds the session later.
+                    const threadId = await getThreadIdBySessionId(context.sessionID);
+                    if (!threadId) {
+                        return 'sleep is only available in the main session';
+                    }
+                    await upsertSessionSleep({
+                        sessionId: context.sessionID,
+                        wakeAt,
+                        reason,
+                    });
+                    // The title carries the resolved absolute time so Discord shows the
+                    // real wake instant instead of a relative input like "2h".
+                    const untilLabel = formatSessionSleepWakeAt(wakeAt);
+                    return {
+                        title: `until ${untilLabel}`,
+                        output: formatSessionSleepToolOutput({ wakeAt, reason }),
+                    };
+                },
+            }),
         },
     };
 };

package/dist/kimaki-opencode-plugin-loading.e2e.test.js

@@ -1,56 +1,64 @@
 // E2e test for OpenCode plugin loading.
-// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
-// waits for the health endpoint, then checks stderr for plugin errors.
-// No Discord infrastructure needed — just the OpenCode server process.
+// Spawns one `opencode serve` with the same plugin list kimaki writes (its own
+// plugin plus @subrouter/opencode), then checks stderr for load errors and
+// hits the real HTTP API. One server for both plugins, because that is how
+// they actually run, and because booting two costs seconds per file.
+// No Discord infrastructure and no real provider APIs.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { test, expect } from 'vitest';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { PROVIDER_IDS } from '@subrouter/cli';
 import { resolveOpencodeCommand } from './opencode.js';
 import { getSpawnCommandAndArgs } from './opencode-command.js';
 import { chooseLockPort } from './test-utils.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function waitForHealth({ port, maxAttempts = 30, }) {
-    for (let i = 0; i < maxAttempts; i++) {
-        try {
-            const response = await fetch(`http://127.0.0.1:${port}/api/health`);
-            if (response.status < 500) {
-                return true;
-            }
-        }
-        catch {
-            // connection refused, retry
-        }
+const require = createRequire(import.meta.url);
+const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' });
+const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e');
+const subrouterHome = path.join(projectDir, 'subrouter-home');
+const stderrLines = [];
+let serverProcess;
+async function api(routePath) {
+    const url = new URL(routePath, `http://127.0.0.1:${port}`);
+    url.searchParams.set('directory', projectDir);
+    const response = await fetch(url, { headers: { 'x-opencode-directory': projectDir } });
+    if (!response.ok)
+        throw new Error(`${routePath} returned ${response.status}`);
+    return (await response.json());
+}
+async function waitForHealth() {
+    for (let attempt = 0; attempt < 60; attempt++) {
+        const ok = await fetch(`http://127.0.0.1:${port}/api/health`)
+            .then((r) => r.status < 500)
+            .catch(() => false);
+        if (ok)
+            return true;
         await new Promise((resolve) => {
-            setTimeout(resolve, 1000);
+            setTimeout(resolve, 500);
         });
     }
     return false;
 }
-test('opencode server loads plugin without errors', async () => {
-    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e');
-    fs.mkdirSync(projectDir, { recursive: true });
-    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' });
-    const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href;
-    const stderrLines = [];
-    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home');
+beforeAll(async () => {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+    const opencodeRoot = path.join(projectDir, 'opencode-test-home');
     const xdgDirectories = {
-        OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-kimaki'),
-        XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
-        XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
-        XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
-        XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
+        OPENCODE_CONFIG_DIR: path.join(opencodeRoot, '.opencode-kimaki'),
+        XDG_CONFIG_HOME: path.join(opencodeRoot, '.config'),
+        XDG_DATA_HOME: path.join(opencodeRoot, '.local', 'share'),
+        XDG_CACHE_HOME: path.join(opencodeRoot, '.cache'),
+        XDG_STATE_HOME: path.join(opencodeRoot, '.local', 'state'),
     };
-    fs.mkdirSync(isolatedOpencodeRoot, { recursive: true });
-    Object.values(xdgDirectories).forEach((directory) => {
+    [...Object.values(xdgDirectories), subrouterHome].forEach((directory) => {
         fs.mkdirSync(directory, { recursive: true });
     });
-    const { command, args, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
+    const { command, args, windowsVerbatimArguments } = getSpawnCommandAndArgs({
         resolvedCommand: resolveOpencodeCommand(),
         baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
     });
-    const serverProcess = spawn(command, args, {
+    serverProcess = spawn(command, args, {
         stdio: 'pipe',
         cwd: projectDir,
         windowsVerbatimArguments,
@@ -60,35 +68,91 @@ test('opencode server loads plugin without errors', async () => {
                 $schema: 'https://opencode.ai/config.json',
                 lsp: false,
                 formatter: false,
-                plugin: [pluginPath],
+                plugin: [
+                    new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href,
+                    pathToFileURL(require.resolve('@subrouter/opencode')).href,
+                ],
             }),
-            OPENCODE_TEST_HOME: isolatedOpencodeRoot,
+            OPENCODE_TEST_HOME: opencodeRoot,
+            SUBROUTER_HOME: subrouterHome,
+            SUBROUTER_MANUAL_OAUTH: '1',
             ...xdgDirectories,
         },
     });
     serverProcess.stderr?.on('data', (data) => {
         stderrLines.push(...data.toString().split('\n').filter(Boolean));
     });
-    try {
-        const healthy = await waitForHealth({ port });
-        expect(healthy).toBe(true);
-        // Check no plugin-related errors in stderr
-        const pluginErrorPatterns = [
-            /plugin.*error/i,
-            /failed to load plugin/i,
-            /cannot find module/i,
-            /ERR_MODULE_NOT_FOUND/i,
-            /plugin.*failed/i,
-            /plugin.*crash/i,
-        ];
-        const errorLines = stderrLines.filter((line) => {
-            return pluginErrorPatterns.some((pattern) => {
-                return pattern.test(line);
-            });
+    expect(await waitForHealth()).toBe(true);
+}, 120_000);
+afterAll(() => {
+    serverProcess?.kill('SIGTERM');
+});
+test('server loads both plugins without errors', () => {
+    const pluginErrorPatterns = [
+        /plugin.*error/i,
+        /failed to load plugin/i,
+        /cannot find module/i,
+        /ERR_MODULE_NOT_FOUND/i,
+        /plugin.*failed/i,
+        /plugin.*crash/i,
+    ];
+    const errorLines = stderrLines.filter((line) => {
+        return pluginErrorPatterns.some((pattern) => {
+            return pattern.test(line);
         });
-        expect(errorLines).toEqual([]);
-    }
-    finally {
-        serverProcess.kill('SIGTERM');
-    }
-}, 60_000);
+    });
+    expect(errorLines).toEqual([]);
+});
+test('subrouter is a connected provider so /model accepts subrouter/default', async () => {
+    const providers = await api('/provider');
+    expect(providers.connected).toContain('subrouter');
+    const subrouter = providers.all.find((entry) => {
+        return entry.id === 'subrouter';
+    });
+    expect(subrouter?.name).toBe('subrouter.org');
+    expect(subrouter?.models.default).toMatchObject({
+        capabilities: {
+            attachment: false,
+            input: { image: false, pdf: false },
+        },
+    });
+});
+test('login offers subrouter and asks which subscription to add first', async () => {
+    const methods = await api('/provider/auth');
+    expect(methods.subrouter).toHaveLength(1);
+    expect(methods.subrouter?.[0]).toMatchObject({ type: 'oauth', label: 'Add a subscription' });
+    // Derived from subrouter, not hardcoded: it adds providers over time and a
+    // literal list here just breaks on the next one.
+    const prompt = methods.subrouter?.[0]?.prompts?.[0];
+    expect(prompt).toMatchObject({ type: 'select', key: 'provider' });
+    expect(prompt?.options?.map((option) => option.value)).toEqual([...PROVIDER_IDS]);
+});
+test('authorize and callback add an opencode-go subscription', async () => {
+    const url = new URL('/provider/subrouter/oauth/authorize', `http://127.0.0.1:${port}`);
+    url.searchParams.set('directory', projectDir);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-opencode-directory': projectDir },
+        body: JSON.stringify({ method: 0, inputs: { provider: 'opencode-go' } }),
+    });
+    expect(response.ok).toBe(true);
+    const authorization = (await response.json());
+    expect(authorization.method).toBe('code');
+    expect(authorization.url).toBe('https://opencode.ai/auth');
+    expect(authorization.instructions).toContain('API key');
+    const callbackUrl = new URL('/provider/subrouter/oauth/callback', `http://127.0.0.1:${port}`);
+    callbackUrl.searchParams.set('directory', projectDir);
+    const callbackResponse = await fetch(callbackUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-opencode-directory': projectDir,
+        },
+        body: JSON.stringify({ method: 0, code: 'zen-key-1' }),
+    });
+    expect(callbackResponse.ok).toBe(true);
+    const auth = JSON.parse(fs.readFileSync(path.join(subrouterHome, 'auth.json'), 'utf8'));
+    expect(auth.providers['opencode-go']?.accounts).toMatchObject([
+        { type: 'api', key: 'zen-key-1' },
+    ]);
+});

package/dist/kimaki-opencode-plugin.js

@@ -4,22 +4,28 @@
 // initializer functions. OpenCode calls every export as a plugin.
 //
 // Plugins are split into focused modules:
-// - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
+// - ipc-tools-plugin: file upload, action buttons, and session sleep
 // - 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
+// - file-edit-log: record edit/write/apply_patch files per session
+// - bash-tool-schema-plugin: add description and hasSideEffect to bash
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
+// LEGACY per-provider account rotation. Superseded by @subrouter/opencode
+// (registered separately in opencode.ts), which also fails over across
+// providers. These stay because they own `anthropic/*` auth, which opencode
+// itself does not provide. See anthropic-auth-plugin.ts for the full note.
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { openaiRotationPlugin } from './openai-auth-plugin.js';
 export { xaiRotationPlugin } from './xai-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
-export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';
 export { cacheDriftPlugin } from './cache-drift-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
 export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';
 export { kimakiWorkspaceAdaptorPlugin } from './kimaki-workspace-adaptor.js';
+export { fileEditTrackerPlugin } from './file-edit-log.js';
+export { bashToolSchemaPlugin } from './bash-tool-schema-plugin.js';

package/dist/kimaki-workspace-adaptor.js

@@ -7,7 +7,7 @@
 // Never use console.log/console.error — plugins must be silent.
 import crypto from 'node:crypto';
 import path from 'node:path';
-import { createWorktreeCore, removeWorktreeCore } from './git-worktree-core.js';
+import { createWorktreeCore, KIMAKI_WORKTREE_ADAPTER_TYPE, removeWorktreeFromOwnRepository, } from './git-worktree-core.js';
 /**
  * Compute the on-disk directory for a managed worktree.
  * Mirrors getManagedWorktreeDirectory from worktrees.ts but reads KIMAKI_DATA_DIR
@@ -29,14 +29,36 @@ function computeWorktreeDirectory({ projectDirectory, branchName, }) {
         .replaceAll('/', '-');
     return path.join(dataDir, 'worktrees', projectHash, withoutPrefix);
 }
-function createKimakiWorktreeAdaptor(projectDirectory) {
+function getWorktreeIdentity(info) {
+    if (!info.extra || typeof info.extra !== 'object') {
+        return new Error('Kimaki worktree identity is missing');
+    }
+    const identity = {};
+    Object.assign(identity, info.extra);
+    if (typeof identity.projectDirectory !== 'string' ||
+        !path.isAbsolute(identity.projectDirectory)) {
+        return new Error('Kimaki worktree project directory must be absolute');
+    }
+    if (typeof identity.baseCommit !== 'string' ||
+        !/^[0-9a-f]{40}$/i.test(identity.baseCommit)) {
+        return new Error('Kimaki worktree base commit must be a full commit SHA');
+    }
+    return {
+        projectDirectory: identity.projectDirectory,
+        baseCommit: identity.baseCommit,
+    };
+}
+function createKimakiWorktreeAdaptor() {
     return {
         name: 'Kimaki Worktree',
         description: 'Create a git worktree managed by Kimaki',
         configure(info) {
+            const identity = getWorktreeIdentity(info);
+            if (identity instanceof Error)
+                throw identity;
             const branchName = info.branch || info.name;
             const directory = computeWorktreeDirectory({
-                projectDirectory,
+                projectDirectory: identity.projectDirectory,
                 branchName,
             });
             if (directory instanceof Error) {
@@ -53,12 +75,14 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
             if (!info.directory) {
                 throw new Error('Workspace directory not set — configure() likely failed');
             }
-            const baseBranch = info.extra?.baseBranch || undefined;
+            const identity = getWorktreeIdentity(info);
+            if (identity instanceof Error)
+                throw identity;
             const result = await createWorktreeCore({
-                projectDirectory,
+                projectDirectory: identity.projectDirectory,
                 targetDirectory: info.directory,
                 branchName: info.branch || info.name,
-                baseBranch,
+                baseCommit: identity.baseCommit,
                 // Silent log — plugin must not write to stdout/stderr
             });
             if (result instanceof Error) {
@@ -68,8 +92,7 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
         async remove(info) {
             if (!info.directory)
                 return;
-            const result = await removeWorktreeCore({
-                projectDirectory,
+            const result = await removeWorktreeFromOwnRepository({
                 worktreeDirectory: info.directory,
                 branchName: info.branch || '',
             });
@@ -89,7 +112,7 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
  * Plugin entrypoint — registers the kimaki-worktree adaptor.
  * Called by OpenCode's plugin loader.
  */
-export const kimakiWorkspaceAdaptorPlugin = async ({ directory, experimental_workspace, }) => {
-    experimental_workspace.register('kimaki-worktree', createKimakiWorktreeAdaptor(directory));
+export const kimakiWorkspaceAdaptorPlugin = async ({ experimental_workspace, }) => {
+    experimental_workspace.register(KIMAKI_WORKTREE_ADAPTER_TYPE, createKimakiWorktreeAdaptor());
     return {};
 };

package/dist/logger.js

@@ -25,6 +25,7 @@ export const LogPrefix = {
     FORMATTING: 'FORMAT',
     GENAI: 'GENAI',
     HEAP: 'HEAP',
+    CPU: 'CPU',
     GENAI_WORKER: 'GENAI_W',
     INTERACTION: 'INTERACT',
     IPC: 'IPC',
@@ -95,7 +96,16 @@ function formatArg(arg) {
 }
 export function formatErrorWithStack(error) {
     if (error instanceof Error) {
-        return sanitizeSensitiveText(error.stack ?? `${error.name}: ${error.message}`, { redactPaths: false });
+        const seen = new Set();
+        const parts = [];
+        let current = error;
+        while (current instanceof Error && !seen.has(current)) {
+            seen.add(current);
+            const formatted = sanitizeSensitiveText(current.stack ?? `${current.name}: ${current.message}`, { redactPaths: false });
+            parts.push(parts.length === 0 ? formatted : `Caused by: ${formatted}`);
+            current = current.cause;
+        }
+        return parts.join('\n');
     }
     if (typeof error === 'string') {
         return sanitizeSensitiveText(error, { redactPaths: false });

package/dist/markdown.js

@@ -104,7 +104,9 @@ export class ShareMarkdown {
             }
         }
         else if (message.role === 'assistant') {
-            lines.push(`### 🤖 Assistant (${message.modelID || 'unknown model'})`);
+            const modelId = [message.providerID, message.modelID].filter(Boolean).join('/') ||
+                'unknown model';
+            lines.push(`### 🤖 Assistant (${modelId})`);
             lines.push('');
             // Filter and process parts
             const filteredParts = parts.filter((part) => {

package/dist/markdown.test.js

@@ -102,6 +102,10 @@ beforeAll(async () => {
     await client.session.promptAsync({
         sessionID,
         directory: directories.projectDirectory,
+        model: {
+            providerID: 'deterministic-provider',
+            modelID: 'deterministic-v2',
+        },
         parts: [{ type: 'text', text: 'hello markdown test' }],
     });
     // Wait for assistant text parts to be fully written (not just message existence).
@@ -139,6 +143,10 @@ beforeAll(async () => {
     await client.session.promptAsync({
         sessionID: toolSessionID,
         directory: directories.projectDirectory,
+        model: {
+            providerID: 'deterministic-provider',
+            modelID: 'deterministic-v2',
+        },
         parts: [{ type: 'text', text: 'use a tool please' }],
     });
     // Wait for tool execution to complete
@@ -200,7 +208,7 @@ test('generate markdown with system info', async () => {
     expect(markdown).toContain('## Conversation');
     expect(markdown).toContain('### 👤 User');
     expect(markdown).toContain('hello markdown test');
-    expect(markdown).toContain('### 🤖 Assistant');
+    expect(markdown).toContain('### 🤖 Assistant (deterministic-provider/deterministic-v2)');
     expect(markdown).toContain('Hello! This is a deterministic markdown test response.');
     expect(markdown).toContain('**Started using deterministic-provider/deterministic-v2**');
     const normalized = normalizeMarkdown(markdown);
@@ -220,7 +228,7 @@ test('generate markdown with system info', async () => {
     hello markdown test
 
 
-    ### 🤖 Assistant (deterministic-v2)
+    ### 🤖 Assistant (deterministic-provider/deterministic-v2)
 
     **Started using deterministic-provider/deterministic-v2**
 
@@ -253,7 +261,7 @@ test('generate markdown without system info', async () => {
     hello markdown test
 
 
-    ### 🤖 Assistant (deterministic-v2)
+    ### 🤖 Assistant (deterministic-provider/deterministic-v2)
 
     **Started using deterministic-provider/deterministic-v2**