kimaki 0.4.87 → 0.4.88

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

@@ -302,8 +302,7 @@ describe('agent model resolution', () => {
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
-        ⬥ ok"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -346,7 +345,8 @@ describe('agent model resolution', () => {
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
         ⬥ system-context-ok
-        *project ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        ⬥ ok"
       `);
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
@@ -513,6 +513,7 @@ describe('agent model resolution', () => {
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
@@ -595,6 +596,7 @@ describe('agent model resolution', () => {
         Reply with exactly: default-second-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
@@ -662,6 +664,7 @@ describe('agent model resolution', () => {
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]

package/dist/cli-send-thread.e2e.test.js

@@ -0,0 +1,280 @@
+// E2e test for `kimaki send --channel` flow.
+// Reproduces the race condition where the bot's MessageCreate GuildText handler
+// tries to call startThread() on the same message that the CLI already created
+// a thread for via REST, causing DiscordAPIError[160004].
+//
+// The test simulates the exact flow: bot posts a starter message with a
+// `start: true` embed marker, then creates a thread on that message via REST.
+// The ThreadCreate handler should pick it up and start a session. The
+// MessageCreate handler must NOT try to startThread() on the same message.
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval.
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { describe, beforeAll, afterAll, test, expect } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials, Routes, } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { store } from './store.js';
+import { startDiscordBot } from './discord-bot.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import yaml from 'js-yaml';
+const TEST_USER_ID = '200000000000000830';
+const TEXT_CHANNEL_ID = '200000000000000831';
+const BOT_USER_ID = '200000000000000832';
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'cli-send-thread-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+function createDeterministicMatchers() {
+    const userReplyMatcher = {
+        id: 'user-reply',
+        priority: 10,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'Reply with exactly:',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'default-reply' },
+                { type: 'text-delta', id: 'default-reply', delta: 'ok' },
+                { type: 'text-end', id: 'default-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 100, 0, 0, 0],
+        },
+    };
+    return [userReplyMatcher];
+}
+describe('kimaki send --channel thread creation', () => {
+    let directories;
+    let discord;
+    let botClient;
+    let previousDefaultVerbosity = null;
+    let testStartTime = Date.now();
+    beforeAll(async () => {
+        testStartTime = Date.now();
+        directories = createRunDirectories();
+        const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
+        process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+        setDataDir(directories.dataDir);
+        previousDefaultVerbosity = store.getState().defaultVerbosity;
+        store.setState({ defaultVerbosity: 'tools_and_text' });
+        const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+        discord = new DigitalDiscord({
+            botUser: { id: BOT_USER_ID },
+            guild: {
+                name: 'CLI Send E2E Guild',
+                // Use bot as guild owner so bot-authored messages pass
+                // hasKimakiBotPermission (owner check). This matches production where
+                // the bot typically has admin or is the app owner. Without this, the
+                // MessageCreate handler drops bot messages before reaching the GuildText
+                // path, hiding the race condition we're testing.
+                ownerId: BOT_USER_ID,
+            },
+            channels: [
+                {
+                    id: TEXT_CHANNEL_ID,
+                    name: 'cli-send-e2e',
+                    type: ChannelType.GuildText,
+                },
+            ],
+            users: [
+                {
+                    id: TEST_USER_ID,
+                    username: 'cli-send-tester',
+                },
+            ],
+            dbUrl: `file:${digitalDiscordDbPath}`,
+        });
+        await discord.start();
+        const providerNpm = url
+            .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+            .toString();
+        const opencodeConfig = buildDeterministicOpencodeConfig({
+            providerName: 'deterministic-provider',
+            providerNpm,
+            model: 'deterministic-v2',
+            smallModel: 'deterministic-v2',
+            settings: {
+                strict: false,
+                matchers: createDeterministicMatchers(),
+            },
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: TEXT_CHANNEL_ID,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools_and_text');
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        // Pre-warm the opencode server
+        const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
+        if (warmup instanceof Error) {
+            throw warmup;
+        }
+    }, 60_000);
+    afterAll(async () => {
+        if (directories) {
+            await cleanupTestSessions({
+                projectDirectory: directories.projectDirectory,
+                testStartTime,
+            });
+        }
+        if (botClient) {
+            botClient.destroy();
+        }
+        await stopOpencodeServer();
+        await Promise.all([
+            closeDatabase().catch(() => {
+                return;
+            }),
+            stopHranaServer().catch(() => {
+                return;
+            }),
+            discord?.stop().catch(() => {
+                return;
+            }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        if (previousDefaultVerbosity) {
+            store.setState({ defaultVerbosity: previousDefaultVerbosity });
+        }
+        if (directories) {
+            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+        }
+    }, 10_000);
+    test('bot-posted starter message with start marker creates thread without DiscordAPIError[160004]', async () => {
+        // Simulate what `kimaki send --channel` does:
+        // 1. Bot posts a starter message with `start: true` embed marker
+        // 2. Bot creates a thread on that message via REST
+        // The ThreadCreate handler should pick it up. The MessageCreate GuildText
+        // handler must NOT try to startThread() on the same message (race).
+        const prompt = 'Reply with exactly: cli-send-test';
+        const embedMarker = {
+            start: true,
+            username: 'cli-send-tester',
+            userId: TEST_USER_ID,
+        };
+        // Step 1: Bot posts the starter message (same as CLI's sendDiscordMessageWithOptionalAttachment)
+        const starterMessage = (await botClient.rest.post(Routes.channelMessages(TEXT_CHANNEL_ID), {
+            body: {
+                content: prompt,
+                embeds: [
+                    { color: 0x2b2d31, footer: { text: yaml.dump(embedMarker) } },
+                ],
+            },
+        }));
+        // Give the bot's MessageCreate handler time to process the starter
+        // message. Without the fix, the handler enters the GuildText path and
+        // tries to startThread() on this message, which races the CLI's thread
+        // creation below. The digital twin enforces Discord's 160004 uniqueness
+        // constraint, so the second startThread call fails.
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+        // Verify the MessageCreate handler did NOT create a thread on this
+        // message. If the handler ignored the start marker (correct behavior),
+        // no thread exists yet and the REST call below succeeds.
+        const threadsBeforeCliCreate = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .getThreads();
+        const preExistingThread = threadsBeforeCliCreate.find((t) => {
+            return t.name?.includes('cli-send-test');
+        });
+        // This is the core regression assertion: without the fix in discord-bot.ts
+        // (skipping start markers in the GuildText handler), the MessageCreate
+        // handler would create a thread here, and the CLI's REST call below would
+        // fail with 160004.
+        expect(preExistingThread).toBeUndefined();
+        // Step 2: Bot creates a thread on the starter message (same as CLI's Routes.threads call)
+        const threadData = (await botClient.rest.post(Routes.threads(TEXT_CHANNEL_ID, starterMessage.id), {
+            body: {
+                name: 'cli-send-test',
+                auto_archive_duration: 1440,
+            },
+        }));
+        // Add test user to thread
+        await botClient.rest.put(Routes.threadMembers(threadData.id, TEST_USER_ID));
+        // Wait for the bot to reply with the ⬥ prefix (proves ThreadCreate
+        // handler picked up the starter message and started a session)
+        await waitForBotMessageContaining({
+            discord,
+            threadId: threadData.id,
+            userId: discord.botUserId,
+            text: '⬥',
+            timeout: 4_000,
+        });
+        // Wait for footer message (proves session completed successfully)
+        await waitForFooterMessage({
+            discord,
+            threadId: threadData.id,
+            timeout: 4_000,
+            afterMessageIncludes: '⬥',
+            afterAuthorId: discord.botUserId,
+        });
+        // Verify no DiscordAPIError[160004] or other errors in the thread.
+        // Before the fix, the MessageCreate GuildText handler would race the
+        // CLI's thread creation and produce an error message here.
+        const messages = await discord.thread(threadData.id).getMessages();
+        const errorMessages = messages.filter((m) => {
+            return m.content.includes('Error:') || m.content.includes('160004');
+        });
+        expect(errorMessages).toHaveLength(0);
+        // Verify at least one ⬥ reply exists (session produced output)
+        const botReplies = messages.filter((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('⬥'));
+        });
+        expect(botReplies.length).toBeGreaterThanOrEqual(1);
+    }, 15_000);
+});

package/dist/discord-bot.js

@@ -512,6 +512,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 }
             }
             if (channel.type === ChannelType.GuildText) {
+                // `kimaki send` posts a starter message with a `start` embed marker,
+                // then creates the thread via REST. The ThreadCreate handler picks up
+                // that thread and starts the session. If we don't skip here, this
+                // handler races the CLI to call startThread() on the same message,
+                // causing DiscordAPIError[160004] "A thread has already been created
+                // for this message".
+                if (promptMarker?.start) {
+                    return;
+                }
                 const textChannel = channel;
                 voiceLogger.log(`[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`);
                 const channelConfig = await getChannelDirectory(textChannel.id);

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

@@ -353,8 +353,9 @@ describeIf('gateway-proxy e2e', () => {
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok"
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
@@ -384,8 +385,9 @@ describeIf('gateway-proxy e2e', () => {
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (proxy-tester)
         !echo proxy-shell-test
         --- from: assistant (TestBot)

package/dist/kimaki-opencode-plugin.js

@@ -13,3 +13,4 @@ export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';
+export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard';

package/dist/message-finish-field.e2e.test.js

@@ -0,0 +1,164 @@
+// E2e test verifying that the opencode server populates the `finish` field
+// on assistant messages. This field is critical for kimaki's footer logic:
+// isAssistantMessageNaturalCompletion checks `message.finish !== 'tool-calls'`
+// to suppress footers on intermediate tool-call steps.
+// When `finish` is missing/null, every completed assistant message gets a
+// spurious footer, breaking multi-step tool chains (16 test failures).
+//
+// Direct SDK test — no Discord layer needed since this is a server-level bug.
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { test, expect, beforeAll, afterAll } from 'vitest';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
+import { cleanupTestSessions } from './test-utils.js';
+const ROOT = path.resolve(process.cwd(), 'tmp', 'finish-field-e2e');
+function createRunDirectories() {
+    fs.mkdirSync(ROOT, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'));
+    const projectDirectory = path.join(ROOT, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { dataDir, projectDirectory };
+}
+function createMatchers() {
+    // Tool-call step: finish="tool-calls"
+    const toolCallMatcher = {
+        id: 'finish-tool-call',
+        priority: 20,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'ft' },
+                { type: 'text-delta', id: 'ft', delta: 'calling tool' },
+                { type: 'text-end', id: 'ft' },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'finish-bash',
+                    toolName: 'bash',
+                    input: JSON.stringify({ command: 'echo ok', description: 'test' }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    // Follow-up after tool result: finish="stop"
+    const followupMatcher = {
+        id: 'finish-followup',
+        priority: 21,
+        when: {
+            lastMessageRole: 'tool',
+            latestUserTextIncludes: 'FINISH_FIELD_TOOLCALL',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'ff' },
+                { type: 'text-delta', id: 'ff', delta: 'tool done' },
+                { type: 'text-end', id: 'ff' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    return [toolCallMatcher, followupMatcher];
+}
+let client;
+let directories;
+let testStartTime;
+beforeAll(async () => {
+    testStartTime = Date.now();
+    directories = createRunDirectories();
+    setDataDir(directories.dataDir);
+    const providerNpm = url
+        .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+        .toString();
+    const opencodeConfig = buildDeterministicOpencodeConfig({
+        providerName: 'deterministic-provider',
+        providerNpm,
+        model: 'deterministic-v2',
+        smallModel: 'deterministic-v2',
+        settings: { strict: false, matchers: createMatchers() },
+    });
+    fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+    const getClient = await initializeOpencodeForDirectory(directories.projectDirectory);
+    if (getClient instanceof Error) {
+        throw getClient;
+    }
+    client = getClient();
+}, 60_000);
+afterAll(async () => {
+    await cleanupTestSessions({
+        projectDirectory: directories.projectDirectory,
+        testStartTime,
+    });
+    await stopOpencodeServer();
+}, 10_000);
+test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
+    const session = await client.session.create({
+        directory: directories.projectDirectory,
+        title: 'finish-field-test',
+    });
+    const sessionID = session.data.id;
+    await client.session.promptAsync({
+        sessionID,
+        directory: directories.projectDirectory,
+        parts: [{ type: 'text', text: 'FINISH_FIELD_TOOLCALL' }],
+    });
+    // Poll until we have 2 completed assistant messages (tool-call + follow-up)
+    const maxWait = 8_000;
+    const pollStart = Date.now();
+    let completedAssistants = [];
+    while (Date.now() - pollStart < maxWait) {
+        const msgs = await client.session.messages({ sessionID });
+        completedAssistants = (msgs.data || [])
+            .filter((m) => {
+            return m.info.role === 'assistant' && m.info.time.completed;
+        })
+            .map((m) => {
+            return {
+                finish: m.info.finish ?? null,
+                partTypes: m.parts.map((p) => { return p.type; }),
+            };
+        });
+        if (completedAssistants.length >= 2) {
+            break;
+        }
+        await new Promise((resolve) => { setTimeout(resolve, 100); });
+    }
+    // Snapshot completed assistant messages — finish should NOT be null
+    expect(completedAssistants).toMatchInlineSnapshot(`
+    [
+      {
+        "finish": null,
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+      {
+        "finish": null,
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+    ]
+  `);
+    const finishes = completedAssistants.map((m) => { return m.finish; });
+    expect(finishes).toEqual(['tool-calls', 'stop']);
+}, 15_000);

package/dist/opencode.js

@@ -378,6 +378,59 @@ async function startSingleServer() {
             XDG_STATE_HOME: path.join(root, '.local', 'state'),
         };
     })();
+    // Write config to a file instead of passing via OPENCODE_CONFIG_CONTENT env var.
+    // OPENCODE_CONFIG (file path) is loaded before project config in opencode's
+    // priority chain, so project-level opencode.json can override kimaki defaults.
+    // OPENCODE_CONFIG_CONTENT was loaded last and overrode user project configs,
+    // causing issue #90 (project permissions not being respected).
+    const opencodeConfig = {
+        $schema: 'https://opencode.ai/config.json',
+        lsp: false,
+        formatter: false,
+        plugin: [new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href],
+        permission: {
+            edit: 'allow',
+            bash: 'allow',
+            external_directory: externalDirectoryPermissions,
+            webfetch: 'allow',
+        },
+        agent: {
+            explore: {
+                permission: {
+                    '*': 'deny',
+                    grep: 'allow',
+                    glob: 'allow',
+                    list: 'allow',
+                    read: {
+                        '*': 'allow',
+                        '*.env': 'deny',
+                        '*.env.*': 'deny',
+                        '*.env.example': 'allow',
+                    },
+                    webfetch: 'allow',
+                    websearch: 'allow',
+                    codesearch: 'allow',
+                    external_directory: externalDirectoryPermissions,
+                },
+            },
+        },
+        skills: {
+            paths: [path.resolve(__dirname, '..', 'skills')],
+        },
+    };
+    const opencodeConfigPath = path.join(getDataDir(), 'opencode-config.json');
+    const opencodeConfigJson = JSON.stringify(opencodeConfig, null, 2);
+    const existingContent = (() => {
+        try {
+            return fs.readFileSync(opencodeConfigPath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+    })();
+    if (existingContent !== opencodeConfigJson) {
+        fs.writeFileSync(opencodeConfigPath, opencodeConfigJson);
+    }
     const serverProcess = spawn(spawnCommand, spawnArgs, {
         stdio: 'pipe',
         detached: false,
@@ -387,41 +440,7 @@ async function startSingleServer() {
         cwd: os.homedir(),
         env: {
             ...process.env,
-            OPENCODE_CONFIG_CONTENT: JSON.stringify({
-                $schema: 'https://opencode.ai/config.json',
-                lsp: false,
-                formatter: false,
-                plugin: [new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href],
-                permission: {
-                    edit: 'allow',
-                    bash: 'allow',
-                    external_directory: externalDirectoryPermissions,
-                    webfetch: 'allow',
-                },
-                agent: {
-                    explore: {
-                        permission: {
-                            '*': 'deny',
-                            grep: 'allow',
-                            glob: 'allow',
-                            list: 'allow',
-                            read: {
-                                '*': 'allow',
-                                '*.env': 'deny',
-                                '*.env.*': 'deny',
-                                '*.env.example': 'allow',
-                            },
-                            webfetch: 'allow',
-                            websearch: 'allow',
-                            codesearch: 'allow',
-                            external_directory: externalDirectoryPermissions,
-                        },
-                    },
-                },
-                skills: {
-                    paths: [path.resolve(__dirname, '..', 'skills')],
-                },
-            }),
+            OPENCODE_CONFIG: opencodeConfigPath,
             OPENCODE_PORT: port.toString(),
             KIMAKI: '1',
             KIMAKI_DATA_DIR: getDataDir(),

package/dist/queue-advanced-abort.e2e.test.js

@@ -84,6 +84,7 @@ e2eTest('queue advanced: abort and retry', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
@@ -91,7 +92,6 @@ e2eTest('queue advanced: abort and retry', () => {
         --- from: user (queue-advanced-tester)
         Reply with exactly: papa
         --- from: assistant (TestBot)
-        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1);