kimaki 0.26.0 → 0.27.0

package/dist/gateway-proxy.e2e.test.js

@@ -325,7 +325,7 @@ describeIf('gateway-proxy e2e', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@900000000000000001>"
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
@@ -352,12 +352,12 @@ describeIf('gateway-proxy e2e', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
         ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@900000000000000001>"
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
@@ -384,12 +384,12 @@ describeIf('gateway-proxy e2e', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
         ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@900000000000000001>
         --- from: user (proxy-tester)
         !echo proxy-shell-test
         --- from: assistant (TestBot)

package/dist/git-worktree-core.js

@@ -1,4 +1,4 @@
-// Plugin-safe git worktree creation and removal primitives.
+// Plugin-safe Git worktree creation, identity validation, and removal primitives.
 // This module must NOT import config.ts, logger.ts, or any module that
 // transitively pulls them in. It is used by both:
 //   - worktrees.ts (bot process — wraps with kimaki logger + config)
@@ -7,6 +7,7 @@
 // All logging goes through an optional `log` callback so callers control output.
 import fs from 'node:fs';
 import path from 'node:path';
+import * as errore from 'errore';
 import { execAsync } from './exec-async.js';
 const SUBMODULE_INIT_TIMEOUT_MS = 20 * 60_000;
 const INSTALL_TIMEOUT_MS = 60_000;
@@ -17,6 +18,12 @@ const LOCKFILE_TO_INSTALL_COMMAND = [
     ['yarn.lock', 'yarn install'],
     ['package-lock.json', 'npm install'],
 ];
+export const KIMAKI_WORKTREE_ADAPTER_TYPE = 'kimaki-worktree';
+export class WorktreeIdentityError extends errore.createTaggedError({
+    name: 'WorktreeIdentityError',
+    message: 'Created worktree does not match the requested checkout: $reason',
+}) {
+}
 const silentLog = {
     info() { },
     warn() { },
@@ -114,7 +121,7 @@ async function hasSubmoduleGitMetadata(directory) {
  * Remove broken submodule stubs created by `git worktree add`.
  * git worktree creates .git files pointing to incomplete gitdirs (missing HEAD).
  */
-async function removeBrokenSubmoduleStubs(directory, log) {
+async function removeBrokenSubmoduleStubs({ directory, expectedCommonGitDirectory, log, }) {
     const submodulePaths = await getSubmodulePaths(directory, log);
     for (const subPath of submodulePaths) {
         const fullPath = path.join(directory, subPath);
@@ -130,7 +137,9 @@ async function removeBrokenSubmoduleStubs(directory, log) {
             const gitdir = path.resolve(fullPath, match[1].trim());
             const headFile = path.join(gitdir, 'HEAD');
             const headExists = await fs.promises.access(headFile).then(() => true).catch(() => false);
-            if (!headExists) {
+            const relativeGitdir = path.relative(expectedCommonGitDirectory, gitdir);
+            const pointsOutsideExpectedRepository = relativeGitdir === '..' || relativeGitdir.startsWith(`..${path.sep}`);
+            if (!headExists || pointsOutsideExpectedRepository) {
                 log.info(`Removing broken submodule stub: ${subPath}`);
                 await fs.promises.rm(fullPath, { recursive: true, force: true });
             }
@@ -186,17 +195,27 @@ async function initializeSubmodulesWithLocalReferences({ sourceDirectory, worktr
         }
     }
 }
-async function validateSubmodulePointers(directory, log) {
-    const submodulePaths = await getSubmodulePaths(directory, log);
+async function validateSubmodulePointers({ directory, expectedCommonGitDirectory, log, }) {
+    const submoduleConfigs = await readSubmoduleConfigs(directory);
+    if (submoduleConfigs instanceof Error) {
+        log.warn(submoduleConfigs.message);
+        return;
+    }
+    const submodulePaths = submoduleConfigs.map(({ path: submodulePath }) => {
+        return submodulePath;
+    });
     if (submodulePaths.length === 0)
         return;
     const issues = [];
+    const foreignGitdirs = [];
     await Promise.all(submodulePaths.map(async (subPath) => {
         const gitFile = path.join(directory, subPath, '.git');
         try {
             const stat = await fs.promises.stat(gitFile);
-            if (!stat.isFile())
+            if (!stat.isFile()) {
+                issues.push(`${subPath}: .git is not a file`);
                 return;
+            }
             const content = await fs.promises.readFile(gitFile, 'utf-8');
             const match = content.match(/^gitdir:\s*(.+)$/m);
             const gitdir = match?.[1]?.trim();
@@ -205,18 +224,26 @@ async function validateSubmodulePointers(directory, log) {
                 return;
             }
             const resolvedGitdir = path.resolve(path.join(directory, subPath), gitdir);
+            const relativeGitdir = path.relative(expectedCommonGitDirectory, resolvedGitdir);
+            if (relativeGitdir === '..' || relativeGitdir.startsWith(`..${path.sep}`)) {
+                foreignGitdirs.push(`${subPath}: ${resolvedGitdir}`);
+                return;
+            }
             const headExists = await fs.promises.access(path.join(resolvedGitdir, 'HEAD')).then(() => true).catch(() => false);
             if (!headExists) {
                 issues.push(`${subPath}: gitdir missing HEAD (${resolvedGitdir})`);
+                return;
             }
         }
-        catch {
-            // skip
+        catch (e) {
+            issues.push(`${subPath}: failed to validate .git (${e instanceof Error ? e.message : String(e)})`);
         }
     }));
-    if (issues.length > 0) {
-        log.warn(`Submodule validation issues: ${issues.join('; ')}`);
+    if (foreignGitdirs.length > 0) {
+        return new Error(`Submodule gitdir belongs to another repository: ${foreignGitdirs.join('; ')}`);
     }
+    if (issues.length > 0)
+        log.warn(`Submodule validation issues: ${issues.join('; ')}`);
 }
 function detectInstallCommand(directory) {
     for (const [lockfile, command] of LOCKFILE_TO_INSTALL_COMMAND) {
@@ -239,18 +266,107 @@ async function runDependencyInstall(directory, log) {
         return new Error(`Install failed: ${formatCommandError(e)}`, { cause: e });
     }
 }
+async function canonicalizePath(value) {
+    return await fs.promises.realpath(value).catch(() => path.resolve(value));
+}
+export async function resolveGitCommit({ directory, ref, }) {
+    const result = await execAsync(`git rev-parse --verify ${JSON.stringify(`${ref}^{commit}`)}`, {
+        cwd: directory,
+        timeout: 10_000,
+    }).catch((e) => new Error(`Failed to resolve Git commit ${ref}`, { cause: e }));
+    if (result instanceof Error)
+        return result;
+    const commit = result.stdout.trim();
+    if (!/^[0-9a-f]{40}$/i.test(commit)) {
+        return new Error(`Git returned an invalid commit for ${ref}: ${commit}`);
+    }
+    return commit;
+}
+export async function resolveGitCommonDirectory({ directory, }) {
+    const result = await execAsync('git rev-parse --git-common-dir', {
+        cwd: directory,
+        timeout: 10_000,
+    }).catch((e) => new Error(`Failed to resolve Git common directory for ${directory}`, { cause: e }));
+    if (result instanceof Error)
+        return result;
+    const commonDirectory = path.isAbsolute(result.stdout.trim())
+        ? result.stdout.trim()
+        : path.resolve(directory, result.stdout.trim());
+    return canonicalizePath(commonDirectory);
+}
+async function resolveGitDirectory({ directory, }) {
+    const result = await execAsync('git rev-parse --absolute-git-dir', {
+        cwd: directory,
+        timeout: 10_000,
+    }).catch((e) => new Error(`Failed to resolve Git directory for ${directory}`, { cause: e }));
+    if (result instanceof Error)
+        return result;
+    return canonicalizePath(result.stdout.trim());
+}
+export async function validateWorktreeIdentity({ projectDirectory, worktreeDirectory, baseCommit, }) {
+    const [sourceCommonGitDirectory, commonGitDirectory, gitDirectory, headCommit] = await Promise.all([
+        resolveGitCommonDirectory({ directory: projectDirectory }),
+        resolveGitCommonDirectory({ directory: worktreeDirectory }),
+        resolveGitDirectory({ directory: worktreeDirectory }),
+        resolveGitCommit({ directory: worktreeDirectory, ref: 'HEAD' }),
+    ]);
+    if (sourceCommonGitDirectory instanceof Error) {
+        return new WorktreeIdentityError({
+            reason: sourceCommonGitDirectory.message,
+            cause: sourceCommonGitDirectory,
+        });
+    }
+    if (commonGitDirectory instanceof Error) {
+        return new WorktreeIdentityError({
+            reason: commonGitDirectory.message,
+            cause: commonGitDirectory,
+        });
+    }
+    if (headCommit instanceof Error) {
+        return new WorktreeIdentityError({
+            reason: headCommit.message,
+            cause: headCommit,
+        });
+    }
+    if (gitDirectory instanceof Error) {
+        return new WorktreeIdentityError({
+            reason: gitDirectory.message,
+            cause: gitDirectory,
+        });
+    }
+    if (commonGitDirectory !== sourceCommonGitDirectory) {
+        return new WorktreeIdentityError({
+            reason: `expected common directory ${sourceCommonGitDirectory}, received ${commonGitDirectory}`,
+        });
+    }
+    if (gitDirectory === commonGitDirectory) {
+        return new WorktreeIdentityError({
+            reason: `${worktreeDirectory} is not a linked worktree`,
+        });
+    }
+    if (headCommit !== baseCommit) {
+        return new WorktreeIdentityError({
+            reason: `expected HEAD ${baseCommit}, received ${headCommit}`,
+        });
+    }
+    return { commonGitDirectory, headCommit };
+}
 /**
  * Create a git worktree with full submodule initialization and dependency install.
  * Plugin-safe: no config.ts or logger.ts imports. Logging is done via the `log`
  * callback (defaults to silent no-op for plugin use).
  */
-export async function createWorktreeCore({ projectDirectory, targetDirectory, branchName, baseBranch, onProgress, log = silentLog, }) {
+export async function createWorktreeCore({ projectDirectory, targetDirectory, branchName, baseCommit, onProgress, log = silentLog, }) {
     if (fs.existsSync(targetDirectory)) {
         return new Error(`Worktree directory already exists: ${targetDirectory}`);
     }
+    const commonGitDirectory = await resolveGitCommonDirectory({
+        directory: projectDirectory,
+    });
+    if (commonGitDirectory instanceof Error)
+        return commonGitDirectory;
     await fs.promises.mkdir(path.dirname(targetDirectory), { recursive: true });
-    const targetRef = baseBranch || 'HEAD';
-    const createCmd = `git worktree add ${JSON.stringify(targetDirectory)} -B ${JSON.stringify(branchName)} ${JSON.stringify(targetRef)}`;
+    const createCmd = `git worktree add ${JSON.stringify(targetDirectory)} -B ${JSON.stringify(branchName)} ${JSON.stringify(baseCommit)}`;
     const createResult = await execAsync(createCmd, {
         cwd: projectDirectory,
         timeout: SUBMODULE_INIT_TIMEOUT_MS,
@@ -258,7 +374,11 @@ export async function createWorktreeCore({ projectDirectory, targetDirectory, br
     if (createResult instanceof Error)
         return createResult;
     // Remove broken submodule stubs before init
-    await removeBrokenSubmoduleStubs(targetDirectory, log);
+    await removeBrokenSubmoduleStubs({
+        directory: targetDirectory,
+        expectedCommonGitDirectory: commonGitDirectory,
+        log,
+    });
     // Init submodules with local --reference directories
     log.info(`Initializing submodules in ${targetDirectory}`);
     const submoduleResult = await initializeSubmodulesWithLocalReferences({
@@ -272,8 +392,25 @@ export async function createWorktreeCore({ projectDirectory, targetDirectory, br
     else {
         log.info(`Submodules initialized in ${targetDirectory}`);
     }
-    // Validate submodule pointers (non-fatal)
-    await validateSubmodulePointers(targetDirectory, log);
+    // Invalid submodule pointers can route later Git commands into another clone.
+    const submoduleValidation = await validateSubmodulePointers({
+        directory: targetDirectory,
+        expectedCommonGitDirectory: commonGitDirectory,
+        log,
+    });
+    if (submoduleValidation instanceof Error) {
+        const cleanupResult = await removeWorktreeCore({
+            projectDirectory,
+            worktreeDirectory: targetDirectory,
+            branchName,
+        });
+        if (cleanupResult instanceof Error) {
+            return new Error(`${submoduleValidation.message}; cleanup failed: ${cleanupResult.message}`, {
+                cause: submoduleValidation,
+            });
+        }
+        return submoduleValidation;
+    }
     // Dependency install (non-fatal)
     onProgress?.('Installing dependencies...');
     const installResult = await runDependencyInstall(targetDirectory, log);
@@ -291,6 +428,34 @@ export async function removeWorktreeCore({ projectDirectory, worktreeDirectory,
     if (removeResult instanceof Error)
         return removeResult;
     if (branchName) {
-        await execAsync(`git branch -D ${JSON.stringify(branchName)}`, { cwd: projectDirectory, timeout: 10_000 }).catch(() => { });
+        const listResult = await execAsync(`git branch --list --format=${JSON.stringify('%(refname:short)')} ${JSON.stringify(branchName)}`, { cwd: projectDirectory, timeout: 10_000 }).catch((e) => new Error(`git branch list failed: ${formatCommandError(e)}`, { cause: e }));
+        if (listResult instanceof Error)
+            return listResult;
+        if (listResult.stdout.trim() === branchName) {
+            const deleteResult = await execAsync(`git branch -D ${JSON.stringify(branchName)}`, { cwd: projectDirectory, timeout: 10_000 }).catch((e) => new Error(`git branch delete failed: ${formatCommandError(e)}`, { cause: e }));
+            if (deleteResult instanceof Error)
+                return deleteResult;
+        }
     }
 }
+export async function removeWorktreeFromOwnRepository({ worktreeDirectory, branchName, }) {
+    if (!fs.existsSync(worktreeDirectory))
+        return;
+    const listResult = await execAsync('git worktree list --porcelain', {
+        cwd: worktreeDirectory,
+        timeout: 10_000,
+    }).catch((e) => new Error('Failed to locate the worktree repository', { cause: e }));
+    if (listResult instanceof Error)
+        return listResult;
+    const mainWorktreeLine = listResult.stdout
+        .split('\n')
+        .find((line) => line.startsWith('worktree '));
+    if (!mainWorktreeLine) {
+        return new Error('Git returned no main worktree during cleanup');
+    }
+    return removeWorktreeCore({
+        projectDirectory: mainWorktreeLine.slice('worktree '.length),
+        worktreeDirectory,
+        branchName,
+    });
+}

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,65 @@ const ipcToolsPlugin = async () => {
                     return 'Action button request timed out';
                 },
             }),
+            kimaki_sleep: tool({
+                description: dedent `
+          Sleep this session until a future time, then wake with a new message.
+          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. A new user message cancels the sleep.
+        `,
+                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 } = 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);
+                    const reasonText = reason?.trim()
+                        ? ` Reason: ${reason.trim()}.`
+                        : '';
+                    return {
+                        title: `until ${untilLabel}`,
+                        output: `Sleeping until ${untilLabel}.${reasonText} Stop now. You will be woken with a new message.`,
+                    };
+                },
+            }),
         },
     };
 };

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 config = JSON.parse(fs.readFileSync(path.join(subrouterHome, 'config.json'), 'utf8'));
+    expect(config.providers['opencode-go']?.accounts).toMatchObject([
+        { type: 'api', key: 'zen-key-1' },
+    ]);
+});

package/dist/kimaki-opencode-plugin.js

@@ -4,22 +4,26 @@
 // 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
 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';