kimaki 0.28.0 → 0.30.0

package/dist/agent-model.e2e.test.js

@@ -399,9 +399,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -443,9 +443,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > system-context-ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
     }, 15_000);
     test('session.command path includes kimaki system prompt on first message', async () => {
@@ -549,9 +549,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: channel-model-check
         --- from: assistant (TestBot)
-        > *using deterministic-provider/channel-model-v2*
+        -# *using deterministic-provider/channel-model-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -593,9 +593,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: variant-check
         --- from: assistant (TestBot)
-        > *using deterministic-provider/channel-model-v2*
+        -# *using deterministic-provider/channel-model-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*"
       `);
         expect(footer?.content).toContain(CHANNEL_MODEL);
         expect(footer?.content).not.toContain(DEFAULT_MODEL);
@@ -662,7 +662,7 @@ describe('agent model resolution', () => {
         Reusing context from <#SOURCE_THREAD> to answer prompt...
         Reply with exactly: btw-model-check
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2* <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2*"
       `);
         expect(forkedSessionModel).toMatchInlineSnapshot(`
         {
@@ -725,14 +725,14 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: first-thread-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         --- from: user (agent-model-tester)
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
         const secondFooter = [...secondMessages]
@@ -779,9 +779,9 @@ describe('agent model resolution', () => {
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: assistant (TestBot)
         » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
-        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        -# *using deterministic-provider/plan-model-v2 ⋅ plan*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
     }, 20_000);
     test('/plan-agent with prompt persists a supported thinking variant', async () => {
@@ -815,9 +815,9 @@ describe('agent model resolution', () => {
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: assistant (TestBot)
         » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-variant-msg
-        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        -# *using deterministic-provider/plan-model-v2 ⋅ plan*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         expect(sessionId ? await getSessionModel(sessionId) : undefined).toMatchInlineSnapshot(`
         {
@@ -908,12 +908,12 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: inline-existing-first-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         » **agent-model-tester** (plan): Reply with exactly: inline-existing-plan-msg
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
     }, 20_000);
     test('/plan-agent inside a thread switches the model for that thread', async () => {
@@ -962,9 +962,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: switch-in-thread-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
@@ -972,7 +972,7 @@ describe('agent model resolution', () => {
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
             .reverse()
@@ -1021,9 +1021,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: race-switch-first-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         --- from: user (agent-model-tester)
         Reply with exactly: race-switch-follow-up
         --- from: assistant (TestBot)
@@ -1031,7 +1031,7 @@ describe('agent model resolution', () => {
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]
             .reverse()
@@ -1071,9 +1071,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: race-channel-follow-up
         --- from: assistant (TestBot)
-        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        -# *using deterministic-provider/plan-model-v2 ⋅ plan*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const footer = [...(await discord.thread(thread.id).getMessages())]
             .reverse()
@@ -1119,9 +1119,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: refresh-agent-model-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/plan-model-v2 ⋅ plan*
+        -# *using deterministic-provider/plan-model-v2 ⋅ plan*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ plan-model-v2 ⋅ **plan*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
         Using **plan** agent for this session
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1161,9 +1161,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: channel-vs-agent-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        -# *using deterministic-provider/agent-model-v2 ⋅ test-agent*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ agent-model-v2 ⋅ **test-agent*** <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
         Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message."
@@ -1203,9 +1203,9 @@ describe('agent model resolution', () => {
         "--- from: user (agent-model-tester)
         Reply with exactly: plain-agent-override-msg
         --- from: assistant (TestBot)
-        > *using deterministic-provider/channel-model-v2*
+        -# *using deterministic-provider/channel-model-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ channel-model-v2* <@200000000000000920>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
         Switched to **plain** agent for this session
         Model: *deterministic-provider/channel-model-v2* (channel override)
         This model comes from a channel override. Use /model and press Clear override if you want this agent's model.

package/dist/anthropic-account-identity.js

@@ -1,6 +1,6 @@
 // LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 // Helpers for Anthropic OAuth account and Claude Code client identity.
-const CLAUDE_CODE_USER_AGENT = 'claude-cli/2.1.257 (external, cli)';
+const CLAUDE_CODE_USER_AGENT = 'claude-cli/2.1.280 (external, cli)';
 export function applyClaudeCodeRequestIdentity({ headers, accessToken, }) {
     headers.set('authorization', `Bearer ${accessToken}`);
     headers.set('user-agent', process.env.OPENCODE_ANTHROPIC_USER_AGENT || CLAUDE_CODE_USER_AGENT);

package/dist/anthropic-auth-plugin.js

@@ -25,7 +25,7 @@
  */
 import { appendToastSessionMarker } from "./plugin-logger.js";
 import { createPluginClient } from "./plugin-opencode-client.js";
-import { isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
+import { isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, isOAuthStored, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
 import { applyClaudeCodeRequestIdentity, 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
@@ -717,9 +717,6 @@ function mergeBetas(existing, required) {
     ].join(",");
 }
 // --- Token refresh with dedup ---
-function isOAuthStored(auth) {
-    return auth.type === "oauth";
-}
 /**
  * Refresh Anthropic OAuth. On permanent refresh failure (invalid_grant),
  * remove that account from the pool and retry with the next one.
@@ -727,6 +724,9 @@ function isOAuthStored(auth) {
  */
 async function getFreshOAuth(getAuth, client, options) {
     const auth = await getAuth();
+    if (auth == null) {
+        throw new Error("Anthropic OAuth credentials are missing. Re-login with /login and pick Claude Pro/Max.");
+    }
     if (!isOAuthStored(auth))
         return undefined;
     if (auth.access && auth.expires > Date.now())
@@ -820,7 +820,7 @@ const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
             provider: "anthropic",
             async loader(getAuth, provider) {
                 const auth = await getAuth();
-                if (auth.type !== "oauth")
+                if (!auth || auth.type !== "oauth")
                     return {};
                 // Zero out costs for OAuth users (Claude Pro/Max subscription)
                 for (const model of Object.values(provider.models)) {

package/dist/anthropic-auth-plugin.test.js

@@ -1,7 +1,7 @@
 // Tests Anthropic system prompt rewriting so project instructions survive OpenCode prompt layout changes.
 import { describe, expect, test } from 'vitest';
 import { applyClaudeCodeRequestIdentity } from './anthropic-account-identity.js';
-import { replacer } from './anthropic-auth-plugin.js';
+import { anthropicAuthPlugin, replacer } from './anthropic-auth-plugin.js';
 async function transformSystem(systemText) {
     const plugin = await replacer({});
     const transform = plugin['experimental.chat.system.transform'];
@@ -13,6 +13,34 @@ async function transformSystem(systemText) {
     }, output);
     return output.system.join('\n');
 }
+describe('Anthropic OAuth loader', () => {
+    test('missing auth does not crash on auth.type', async () => {
+        const plugin = await anthropicAuthPlugin({
+            serverUrl: new URL('http://127.0.0.1:9'),
+            directory: '/tmp',
+        });
+        const loader = plugin.auth?.loader;
+        if (!loader)
+            throw new Error('missing loader');
+        let reads = 0;
+        const options = await loader((async () => {
+            reads += 1;
+            if (reads === 1) {
+                return {
+                    type: 'oauth',
+                    refresh: 'refresh-token',
+                    access: 'access-token',
+                    expires: Date.now() + 60_000,
+                };
+            }
+            return undefined;
+        }), { models: {} });
+        await expect(options.fetch?.('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            body: '{}',
+        })).rejects.toThrow('Anthropic OAuth credentials are missing');
+    });
+});
 describe('Anthropic OAuth request identity', () => {
     test('applies the current external Claude Code client headers', () => {
         const headers = applyClaudeCodeRequestIdentity({
@@ -23,7 +51,7 @@ describe('Anthropic OAuth request identity', () => {
       {
         "accept": "application/json",
         "authorization": "Bearer access-token",
-        "user-agent": "claude-cli/2.1.257 (external, cli)",
+        "user-agent": "claude-cli/2.1.280 (external, cli)",
         "x-app": "cli",
       }
     `);

package/dist/anthropic-auth-state.js

@@ -9,7 +9,7 @@ import { homedir } from 'node:os';
 import path from 'node:path';
 import { normalizeAnthropicAccountIdentity, } from './anthropic-account-identity.js';
 import { accountLabel, authFilePath, findCurrentAccountIndex, isOAuthStored, isPermanentOAuthRefreshFailure, normalizeAccountStore, readJson, upsertAccount as sharedUpsertAccount, withAuthStateLock, writeJson, shouldRotateAuth, } from './oauth-rotation-shared.js';
-export { accountLabel, authFilePath, withAuthStateLock, shouldRotateAuth, isPermanentOAuthRefreshFailure, };
+export { accountLabel, authFilePath, isOAuthStored, withAuthStateLock, shouldRotateAuth, isPermanentOAuthRefreshFailure, };
 // --- Store file path ---
 export function accountsFilePath() {
     if (process.env.XDG_DATA_HOME) {

package/dist/bash-tool-schema-plugin.js

@@ -3,7 +3,22 @@
 // Assign jsonSchema only. Leave parameters as the Effect Schema used to decode
 // args before execute. Extra fields stay in the model-facing schema and in
 // Discord input; they never reach the shell.
+//
+// Also injects KIMAKI_SESSION_ID into bash env. /btw and /fork clone parent
+// history, so the copied system prompt still says --session <parent>. Upload
+// then prefers this live env over that stale flag.
 import { z } from 'zod';
+export const KIMAKI_SESSION_ID_ENV = 'KIMAKI_SESSION_ID';
+export function injectKimakiSessionEnv({ sessionID, env, }) {
+    if (!sessionID)
+        return;
+    env[KIMAKI_SESSION_ID_ENV] = sessionID;
+}
+export function resolveUploadToDiscordSessionId({ flagSessionId, envSessionId = process.env[KIMAKI_SESSION_ID_ENV], } = {}) {
+    if (envSessionId)
+        return envSessionId;
+    return flagSessionId;
+}
 export const bashParameters = z.object({
     command: z.string().describe('The command to execute'),
     description: z
@@ -28,5 +43,8 @@ export const bashToolSchemaPlugin = async () => {
                 return;
             extendBashToolDefinition(output);
         },
+        'shell.env': async (input, output) => {
+            injectKimakiSessionEnv({ sessionID: input.sessionID, env: output.env });
+        },
     };
 };

package/dist/bash-tool-schema-plugin.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { extendBashToolDefinition, } from './bash-tool-schema-plugin.js';
+import { extendBashToolDefinition, injectKimakiSessionEnv, KIMAKI_SESSION_ID_ENV, resolveUploadToDiscordSessionId, } from './bash-tool-schema-plugin.js';
 describe('extendBashToolDefinition', () => {
     test('keeps parameters and assigns jsonSchema from bashParameters', () => {
         const parameters = { keep: true };
@@ -47,3 +47,22 @@ describe('extendBashToolDefinition', () => {
     `);
     });
 });
+describe('upload-to-discord session targeting', () => {
+    test('bash env uses the live OpenCode session, not a copied --session flag', () => {
+        const env = {};
+        injectKimakiSessionEnv({ sessionID: 'ses_child', env });
+        expect(env).toEqual({ [KIMAKI_SESSION_ID_ENV]: 'ses_child' });
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+            envSessionId: env[KIMAKI_SESSION_ID_ENV],
+        })).toBe('ses_child');
+    });
+    test('falls back to --session when bash is not inside an OpenCode session', () => {
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+        })).toBe('ses_parent');
+    });
+    test('returns undefined when neither live session nor flag is set', () => {
+        expect(resolveUploadToDiscordSessionId({})).toBeUndefined();
+    });
+});

package/dist/bin.js

@@ -91,8 +91,11 @@ else {
             `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
         ];
         const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)];
+        // The IPC channel is only a liveness link: when this wrapper dies (even by
+        // SIGKILL) the child sees 'disconnect' and shuts down instead of staying
+        // orphaned on the lock port. See registerBotLifecycleHandlers.
         const currentChild = spawn(process.argv[0], args, {
-            stdio: 'inherit',
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
             env: { ...process.env, __KIMAKI_CHILD: '1' },
         });
         child = currentChild;
@@ -130,8 +133,9 @@ else {
         });
     }
     // Forward signals to child so graceful shutdown and heap snapshots work.
-    // SIGTERM/SIGINT mark shutdownRequested so we don't restart after graceful exit.
-    for (const sig of ['SIGTERM', 'SIGINT']) {
+    // Termination signals mark shutdownRequested so we don't restart after
+    // graceful exit. SIGHUP comes from closing the terminal.
+    for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
         process.on(sig, () => {
             shutdownRequested = true;
             killChild(sig);

package/dist/bot-lifecycle.test.js

@@ -0,0 +1,206 @@
+// Real-process tests for bot shutdown and lock-port recovery.
+// Regression: Ctrl+C during startup left the bot alive on the hrana lock port
+// (29988), and every next start failed with "still in use after eviction".
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import dedent from 'string-dedent';
+import * as errore from 'errore';
+import { afterEach, describe, expect, test } from 'vitest';
+import { evictExistingInstance } from './hrana-server.js';
+const srcDir = path.dirname(fileURLToPath(import.meta.url));
+const hranaModule = pathToFileURL(path.join(srcDir, 'hrana-server.ts')).href;
+const botModule = pathToFileURL(path.join(srcDir, 'discord-bot.ts')).href;
+const children = [];
+afterEach(() => {
+    for (const child of children.splice(0)) {
+        if (child.exitCode === null && child.signalCode === null) {
+            child.kill('SIGKILL');
+        }
+    }
+});
+async function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.once('error', reject);
+        srv.listen(0, '127.0.0.1', () => {
+            const address = srv.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('No port assigned'));
+                return;
+            }
+            srv.close(() => resolve(address.port));
+        });
+    });
+}
+async function isPortFree(port) {
+    return new Promise((resolve) => {
+        const srv = net.createServer();
+        srv.once('error', () => resolve(false));
+        srv.listen(port, '127.0.0.1', () => {
+            srv.close(() => resolve(true));
+        });
+    });
+}
+// Runs an ESM script through tsx so it can import the real .ts sources.
+function startFixture({ script, port, ipc = false, env = {}, }) {
+    const child = spawn(process.execPath, ['--import', 'tsx', '--input-type=module', '-e', script], {
+        cwd: path.dirname(srcDir),
+        env: {
+            ...process.env,
+            KIMAKI_LOCK_PORT: String(port),
+            __KIMAKI_CHILD: ipc ? '1' : undefined,
+            ...env,
+        },
+        stdio: ipc ? ['ignore', 'pipe', 'pipe', 'ipc'] : ['ignore', 'pipe', 'pipe'],
+    });
+    children.push(child);
+    let output = '';
+    const ready = new Promise((resolve, reject) => {
+        child.stdout.on('data', (chunk) => {
+            output += chunk.toString();
+            if (output.includes('FIXTURE_READY'))
+                resolve();
+        });
+        child.stderr.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        child.once('exit', (code, signal) => {
+            reject(new Error(`fixture exited early (${code ?? signal}): ${output}`));
+        });
+    });
+    const exited = new Promise((resolve) => {
+        child.once('exit', (code, signal) => resolve({ code, signal }));
+    });
+    return { child, ready, exited, output: () => output };
+}
+function hranaScript({ extra = '', afterReady = '', }) {
+    return dedent `
+    import os from 'node:os'
+    import path from 'node:path'
+    import fs from 'node:fs'
+    import { startHranaServer } from '${hranaModule}'
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-lifecycle-'))
+    const result = await startHranaServer({ dbPath: path.join(dir, 'db.sqlite') })
+    if (result instanceof Error) throw result
+    ${extra}
+    // Same situation as the opencode.ts fallback: a listener that never exits.
+    process.on('SIGINT', () => {})
+    process.on('SIGTERM', () => {})
+    console.log('FIXTURE_READY')
+    ${afterReady}
+    setInterval(() => {}, 1000)
+  `;
+}
+// Minimal stand-in for bin.ts: IPC child, respawn on crash, no respawn after
+// SIGTERM. Enough to prove eviction targets the wrapper, not just the child.
+const WRAPPER_SCRIPT = dedent `
+  import { spawn } from 'node:child_process'
+  let stopping = false
+  let child
+  process.on('SIGTERM', () => {
+    stopping = true
+    child.kill('SIGTERM')
+  })
+  function start() {
+    child = spawn(
+      process.execPath,
+      ['--import', 'tsx', '--input-type=module', '-e', process.env.CHILD_SCRIPT],
+      { stdio: ['ignore', 'inherit', 'inherit', 'ipc'], env: { ...process.env, __KIMAKI_CHILD: '1' } },
+    )
+    console.log('CHILD_PID=' + child.pid)
+    child.on('exit', () => {
+      if (stopping) process.exit(0)
+      console.log('RESPAWNED')
+      start()
+    })
+  }
+  start()
+`;
+function isPidAlive(pid) {
+    const result = errore.try(() => {
+        process.kill(pid, 0);
+    });
+    return !(result instanceof Error);
+}
+describe('bot lifecycle', () => {
+    test('eviction SIGKILLs an old instance that ignores SIGTERM', async () => {
+        const port = await getFreePort();
+        const fixture = startFixture({ script: hranaScript({ extra: '' }), port });
+        await fixture.ready;
+        expect(await isPortFree(port)).toBe(false);
+        await evictExistingInstance({ port, gracePeriodMs: 500 });
+        expect(await fixture.exited).toEqual({ code: null, signal: 'SIGKILL' });
+        expect(await isPortFree(port)).toBe(true);
+    }, 20_000);
+    test('eviction stops the old wrapper so it cannot respawn the child', async () => {
+        const port = await getFreePort();
+        const wrapper = startFixture({
+            script: WRAPPER_SCRIPT,
+            port,
+            env: { CHILD_SCRIPT: hranaScript({}) },
+        });
+        await wrapper.ready;
+        const childPid = Number(/CHILD_PID=(\d+)/.exec(wrapper.output())?.[1]);
+        // The child ignores SIGTERM, so the wrapper's forwarded SIGTERM is not
+        // enough and eviction must SIGKILL both, wrapper first.
+        await evictExistingInstance({ port, gracePeriodMs: 500 });
+        expect(await wrapper.exited).toEqual({ code: null, signal: 'SIGKILL' });
+        expect(isPidAlive(childPid)).toBe(false);
+        expect(wrapper.output()).not.toContain('RESPAWNED');
+        expect(await isPortFree(port)).toBe(true);
+    }, 20_000);
+    test('SIGINT during startup releases the lock port', async () => {
+        const port = await getFreePort();
+        const fixture = startFixture({
+            script: hranaScript({
+                extra: dedent `
+          const { registerBotLifecycleHandlers } = await import('${botModule}')
+          registerBotLifecycleHandlers()
+        `,
+            }),
+            port,
+        });
+        await fixture.ready;
+        fixture.child.kill('SIGINT');
+        expect(await fixture.exited).toEqual({ code: 0, signal: null });
+        expect(await isPortFree(port)).toBe(true);
+    }, 30_000);
+    test('child shuts down when the wrapper IPC channel closes', async () => {
+        const port = await getFreePort();
+        const fixture = startFixture({
+            script: hranaScript({
+                extra: dedent `
+          const { registerBotLifecycleHandlers } = await import('${botModule}')
+          registerBotLifecycleHandlers()
+        `,
+            }),
+            port,
+            ipc: true,
+        });
+        await fixture.ready;
+        // Same as the wrapper dying: the OS closes the IPC pipe.
+        fixture.child.disconnect();
+        expect(await fixture.exited).toEqual({ code: 0, signal: null });
+        expect(await isPortFree(port)).toBe(true);
+    }, 30_000);
+    test('child shuts down if the wrapper died before handlers were registered', async () => {
+        const port = await getFreePort();
+        const fixture = startFixture({
+            script: hranaScript({
+                afterReady: dedent `
+          await new Promise((resolve) => process.once('disconnect', resolve))
+          const { registerBotLifecycleHandlers } = await import('${botModule}')
+          registerBotLifecycleHandlers()
+        `,
+            }),
+            port,
+            ipc: true,
+        });
+        await fixture.ready;
+        fixture.child.disconnect();
+        expect(await fixture.exited).toEqual({ code: 0, signal: null });
+        expect(await isPortFree(port)).toBe(true);
+    }, 30_000);
+});