kimaki 0.4.87 → 0.4.89

package/dist/context-awareness-plugin.test.js

@@ -0,0 +1,57 @@
+// Tests for context-awareness directory switch reminders.
+import { describe, expect, test } from 'vitest';
+import { shouldInjectPwd } from './context-awareness-plugin.js';
+describe('shouldInjectPwd', () => {
+    test('does not inject when current directory matches announced directory', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: '/repo/main',
+            announcedDir: '/repo/worktree',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('does not inject without a previous directory to warn about', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: undefined,
+            announcedDir: undefined,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('names previous and current directories in the correct order', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree',
+            previousDir: '/repo/main',
+            announcedDir: undefined,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You MUST read, write, and edit files only under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
+      }
+    `);
+    });
+    test('prefers the last announced directory as the previous directory', () => {
+        const result = shouldInjectPwd({
+            currentDir: '/repo/worktree-b',
+            previousDir: '/repo/main',
+            announcedDir: '/repo/worktree-a',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": true,
+        "text": "
+      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You MUST read, write, and edit files only under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
+      }
+    `);
+    });
+});

package/dist/directory-permissions.js

@@ -0,0 +1,38 @@
+// Directory permission helpers for one-shot external directory preapproval.
+import os from 'node:os';
+import path from 'node:path';
+export function normalizeAllowedDirectoryPath({ input, workingDirectory, }) {
+    const trimmedInput = input.trim();
+    if (!trimmedInput) {
+        return new Error('Path cannot be empty');
+    }
+    const withoutTrailingGlob = trimmedInput.replace(/[\\/]\*+$/u, '');
+    if (!withoutTrailingGlob) {
+        return new Error('Path cannot be empty');
+    }
+    if (withoutTrailingGlob.includes('*') || withoutTrailingGlob.includes('?')) {
+        return new Error('Path must be a directory, not a glob pattern');
+    }
+    const expandedHomeDirectory = (() => {
+        if (withoutTrailingGlob === '~') {
+            return os.homedir();
+        }
+        if (withoutTrailingGlob.startsWith('~/')) {
+            return path.join(os.homedir(), withoutTrailingGlob.slice(2));
+        }
+        return withoutTrailingGlob;
+    })();
+    const absolutePath = path.isAbsolute(expandedHomeDirectory)
+        ? expandedHomeDirectory
+        : path.resolve(workingDirectory, expandedHomeDirectory);
+    const normalizedPath = path.normalize(absolutePath);
+    const root = path.parse(normalizedPath).root;
+    const withoutTrailingSlash = normalizedPath.length > root.length
+        ? normalizedPath.replace(/[\\/]+$/u, '')
+        : normalizedPath;
+    return withoutTrailingSlash.replaceAll('\\', '/');
+}
+export function buildAllowedDirectoryPatterns({ directory, }) {
+    const childPattern = directory.endsWith('/') ? `${directory}*` : `${directory}/*`;
+    return [directory, childPattern];
+}

package/dist/directory-permissions.test.js

@@ -0,0 +1,37 @@
+// Tests for one-shot directory permission path normalization helpers.
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, test } from 'vitest';
+import { buildAllowedDirectoryPatterns, normalizeAllowedDirectoryPath, } from './directory-permissions.js';
+describe('normalizeAllowedDirectoryPath', () => {
+    test('resolves relative paths from the working directory', () => {
+        const result = normalizeAllowedDirectoryPath({
+            input: '../shared/',
+            workingDirectory: '/repo/worktree/app',
+        });
+        expect(result).toBe('/repo/worktree/shared');
+    });
+    test('expands home directories and strips implicit trailing glob', () => {
+        const result = normalizeAllowedDirectoryPath({
+            input: '~/projects/*',
+            workingDirectory: '/repo/worktree/app',
+        });
+        expect(result).toBe(`${os.homedir().replaceAll('\\', '/')}/projects`);
+    });
+    test('rejects glob patterns in the middle of the path', () => {
+        const result = normalizeAllowedDirectoryPath({
+            input: 'src/*/nested',
+            workingDirectory: '/repo/worktree/app',
+        });
+        expect(result instanceof Error ? result.message : result).toBe('Path must be a directory, not a glob pattern');
+    });
+});
+describe('buildAllowedDirectoryPatterns', () => {
+    test('adds exact and child wildcard patterns for a directory', () => {
+        const directory = path.join('/repo', 'shared').replaceAll('\\', '/');
+        expect(buildAllowedDirectoryPatterns({ directory })).toEqual([
+            '/repo/shared',
+            '/repo/shared/*',
+        ]);
+    });
+});

package/dist/discord-bot.js

@@ -268,6 +268,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             const cliInjectedPermissions = isCliInjectedPrompt
                 ? promptMarker?.permissions
                 : undefined;
+            const cliInjectedInjectionGuardPatterns = isCliInjectedPrompt
+                ? promptMarker?.injectionGuardPatterns
+                : undefined;
             // Always ignore our own messages (unless CLI-injected prompt above).
             // Without this, assigning the Kimaki role to the bot itself would loop.
             if (isSelfBotMessage && !isCliInjectedPrompt) {
@@ -488,6 +491,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     agent: cliInjectedAgent,
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
+                    injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
                     sessionStartSource: sessionStartSource
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,
@@ -512,6 +516,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);
@@ -750,6 +763,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 agent: marker.agent,
                 model: marker.model,
                 permissions: marker.permissions,
+                injectionGuardPatterns: marker.injectionGuardPatterns,
                 mode: 'opencode',
                 sessionStartSource: botThreadStartSource
                     ? {

package/dist/generated/models/thread_allowed_directories.js

@@ -0,0 +1 @@
+export {};

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/markdown.test.js

@@ -184,22 +184,6 @@ test('generate markdown with system info', async () => {
 
 
     *Completed in Xs*
-
-    ### 🤖 Assistant (deterministic-v2)
-
-    **Started using deterministic-provider/deterministic-v2**
-
-    Hello! This is a deterministic markdown test response.
-
-
-    *Completed in Xs*
-
-    ### 🤖 Assistant (deterministic-v2)
-
-    **Started using deterministic-provider/deterministic-v2**
-
-    Hello! This is a deterministic markdown test response.
-
     "
   `);
 });
@@ -235,22 +219,6 @@ test('generate markdown without system info', async () => {
 
 
     *Completed in Xs*
-
-    ### 🤖 Assistant (deterministic-v2)
-
-    **Started using deterministic-provider/deterministic-v2**
-
-    Hello! This is a deterministic markdown test response.
-
-
-    *Completed in Xs*
-
-    ### 🤖 Assistant (deterministic-v2)
-
-    **Started using deterministic-provider/deterministic-v2**
-
-    Hello! This is a deterministic markdown test response.
-
     "
   `);
 });

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": "tool-calls",
+        "partTypes": [
+          "step-start",
+          "text",
+          "step-finish",
+        ],
+      },
+      {
+        "finish": "stop",
+        "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(),
@@ -728,6 +747,49 @@ export function parsePermissionRules(raw) {
         return [];
     });
 }
+// ── Injection guard per-session config ───────────────────────────
+// Per-session injection guard patterns are written as JSON files to a temp
+// directory keyed by session ID. The injection guard plugin (running inside
+// the opencode server process) checks for these files in tool.execute.after.
+// This avoids needing env vars (which are per-process, not per-session).
+const INJECTION_GUARD_DIR = path.join(os.tmpdir(), 'kimaki-injection-guard');
+/**
+ * Write per-session injection guard config so the plugin picks it up.
+ * Only call this if injectionGuardPatterns is non-empty.
+ */
+export function writeInjectionGuardConfig({ sessionId, scanPatterns, }) {
+    try {
+        fs.mkdirSync(INJECTION_GUARD_DIR, { recursive: true });
+        fs.writeFileSync(path.join(INJECTION_GUARD_DIR, `${sessionId}.json`), JSON.stringify({ scanPatterns }));
+    }
+    catch {
+        // Best effort -- don't crash the bot if temp dir write fails
+    }
+}
+/**
+ * Remove per-session injection guard config file.
+ */
+export function removeInjectionGuardConfig({ sessionId }) {
+    try {
+        fs.unlinkSync(path.join(INJECTION_GUARD_DIR, `${sessionId}.json`));
+    }
+    catch {
+        // File may already be gone
+    }
+}
+/**
+ * Read per-session injection guard config. Used by the kimaki plugin
+ * inside the opencode server process.
+ */
+export function readInjectionGuardConfig({ sessionId }) {
+    try {
+        const raw = fs.readFileSync(path.join(INJECTION_GUARD_DIR, `${sessionId}.json`), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 // ── Public helpers ───────────────────────────────────────────────
 // These helpers expose the single shared server and directory-scoped clients.
 export function getOpencodeServerPort(_directory) {

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

@@ -91,7 +91,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);

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

@@ -95,7 +95,6 @@ e2eTest('queue advanced: footer emission', () => {
         Reply with exactly: footer-multi-second
         --- from: assistant (TestBot)
         ⬥ ok
-        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         if (footerCount >= 2) {
@@ -191,14 +190,11 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-advanced-tester)
         Reply with exactly: interrupt-footer-followup
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(followupUserIdx).toBeGreaterThanOrEqual(0);
@@ -271,19 +267,15 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-advanced-tester)
         Reply with exactly: plugin-timeout-after
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(afterIndex).toBeGreaterThanOrEqual(0);
         const okReplyIndex = messagesWithFooter.findIndex((message, index) => {
@@ -363,10 +355,8 @@ e2eTest('queue advanced: footer emission', () => {
         TOOL_CALL_FOOTER_MARKER
         --- from: assistant (TestBot)
         ⬥ running tool
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         // Only ONE footer at the end — the tool-call step's footer is NOT
         // emitted mid-turn. The final text follow-up gets the footer.
@@ -416,19 +406,6 @@ e2eTest('queue advanced: footer emission', () => {
         MULTI_TOOL_FOOTER_MARKER
         --- from: assistant (TestBot)
         ⬥ investigating the issue
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ all done, fixed 3 files
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
@@ -482,24 +459,10 @@ e2eTest('queue advanced: footer emission', () => {
         MULTI_STEP_CHAIN_MARKER
         --- from: assistant (TestBot)
         ⬥ chain step 1: reading config
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain step 2: analyzing results
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain step 3: applying fix
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ chain complete: all 3 steps done"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         // The critical assertion: only 1 footer at the very end.
         // With the naive "allow tool-calls as natural completion" fix,

package/dist/queue-advanced-model-switch.e2e.test.js

@@ -252,20 +252,14 @@ describe('queue advanced: /model with interrupt recovery', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
         Model set for this session:
         **Deterministic Provider** / **deterministic-v3**
         \`deterministic-provider/deterministic-v3\`
         _Restarting current request with new model..._
         _Tip: create [agent .md files](https://github.com/remorses/kimaki/blob/main/docs/model-switching.md) in .opencode/agent/ for one-command model switching_
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        ⬥ ok
         --- from: user (queue-model-switch-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-model-switch-tester)