kimaki 0.4.102 → 0.4.104

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

@@ -742,6 +742,7 @@ describe('agent model resolution', () => {
         ⬥ ok
         *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*
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg

package/dist/anthropic-auth-plugin.js

@@ -460,6 +460,20 @@ function buildAuthorizeHandler(mode) {
 function toClaudeCodeToolName(name) {
     return OPENCODE_TO_CLAUDE_CODE_TOOL_NAME[name.toLowerCase()] ?? name;
 }
+/**
+ * Strips the OpenCode identity block (from "You are OpenCode…" up to the
+ * Anthropic prompt marker "Skills provide specialized instructions") and
+ * re-injects essential environment context as a small XML tag.
+ *
+ * The original OpenCode prompt between those markers contains the current
+ * working directory and other runtime context. Stripping it wholesale loses
+ * that info, so we add back what the model needs (cwd) in a compact form.
+ *
+ * Original OpenCode Anthropic prompt structure (for reference):
+ *   "You are OpenCode, the best coding agent on the planet."
+ *   + environment block (cwd, OS, shell, date, etc.)
+ *   + "Skills provide specialized instructions …"
+ */
 function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
     if (startIdx === -1)
@@ -470,7 +484,14 @@ function sanitizeAnthropicSystemText(text, onError) {
         onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
         return text;
     }
-    return (text.slice(0, startIdx) + text.slice(endIdx)).replaceAll("opencode", "openc0de");
+    // Re-inject the process working directory that was inside the stripped block.
+    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n`;
+    // Replace all case-insensitive whole-word occurrences of "opencode" with "openc0de"
+    const result = text.slice(0, startIdx) +
+        envContext +
+        text.slice(endIdx);
+    // Use a regex with global, case-insensitive, and word boundary flags
+    return result.replace(/\bopencode\b/gi, "openc0de");
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {

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

@@ -1,131 +1,109 @@
-// Tests for Anthropic OAuth multi-account persistence and rotation.
-import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
-const firstAccount = {
-    type: 'oauth',
-    refresh: 'refresh-first',
-    access: 'access-first',
-    expires: 1,
-};
-const secondAccount = {
-    type: 'oauth',
-    refresh: 'refresh-second',
-    access: 'access-second',
-    expires: 2,
-};
-let originalXdgDataHome;
-let tempDir = '';
-beforeEach(async () => {
-    originalXdgDataHome = process.env.XDG_DATA_HOME;
-    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
-    process.env.XDG_DATA_HOME = tempDir;
-});
-afterEach(async () => {
-    if (originalXdgDataHome === undefined) {
-        delete process.env.XDG_DATA_HOME;
-    }
-    else {
-        process.env.XDG_DATA_HOME = originalXdgDataHome;
+// Tests Anthropic request-time prompt rewriting and transform fallback behavior.
+import { describe, expect, test } from 'vitest';
+import { replacer, rewriteAnthropicRequestPayload, } from './anthropic-auth-plugin.js';
+function parseRewrittenBody(body) {
+    if (!body) {
+        throw new Error('Expected rewritten body');
     }
-    await rm(tempDir, { force: true, recursive: true });
-});
-describe('rememberAnthropicOAuth', () => {
-    test('stores accounts and updates existing entries by refresh token', async () => {
-        await rememberAnthropicOAuth(firstAccount);
-        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
-        const store = await loadAccountStore();
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]).toMatchObject({
-            refresh: 'refresh-first',
-            access: 'access-first-new',
-            expires: 3,
-        });
+    return JSON.parse(body);
+}
+describe('rewriteAnthropicRequestPayload', () => {
+    test('sanitizes raw opencode system text at request time', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nCWD: /repo\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            tool_choice: { type: 'tool', name: 'read' },
+            tools: [{ name: 'read' }],
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload).toMatchInlineSnapshot(`
+      {
+        "model": "claude-sonnet-4-5",
+        "system": [
+          {
+            "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+            "type": "text",
+          },
+          {
+            "text": "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+            "type": "text",
+          },
+        ],
+        "tool_choice": {
+          "name": "Read",
+          "type": "tool",
+        },
+        "tools": [
+          {
+            "name": "Read",
+          },
+        ],
+      }
+    `);
     });
-});
-describe('rotateAnthropicAccount', () => {
-    test('rotates to the next stored account and syncs auth state', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
-            ],
-        });
-        const authSetCalls = [];
-        const client = {
-            auth: {
-                set: async (input) => {
-                    authSetCalls.push(input);
+    test('does not duplicate claude code identity when request was already sanitized', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: [
+                {
+                    type: 'text',
+                    text: "You are Claude Code, Anthropic's official CLI for Claude.",
                 },
-            },
-        };
-        const rotated = await rotateAnthropicAccount(firstAccount, client);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(rotated).toMatchObject({
-            auth: { refresh: 'refresh-second' },
-            fromLabel: '#1 (refresh-...irst)',
-            toLabel: '#2 (refresh-...cond)',
-            fromIndex: 0,
-            toIndex: 1,
-        });
-        expect(store.activeIndex).toBe(1);
-        expect(authJson.anthropic?.refresh).toBe('refresh-second');
-        expect(authSetCalls).toEqual([
-            {
-                path: { id: 'anthropic' },
-                body: {
-                    type: 'oauth',
-                    refresh: 'refresh-second',
-                    access: 'access-second',
-                    expires: 2,
+                {
+                    type: 'text',
+                    text: '<environment>\n<cwd>/repo</cwd>\n</environment>\nSkills provide specialized instructions',
                 },
-            },
-        ]);
-    });
-});
-describe('removeAccount', () => {
-    test('removing the active account promotes the next stored account', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 1,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
             ],
-        });
-        await removeAccount(1);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]?.refresh).toBe('refresh-first');
-        expect(authJson.anthropic?.refresh).toBe('refresh-first');
-    });
-    test('removing the last account clears active Anthropic auth', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
-        });
-        await mkdir(path.dirname(authFilePath()), { recursive: true });
-        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
-        await removeAccount(0);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.accounts).toHaveLength(0);
-        expect(authJson.anthropic).toBeUndefined();
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload.system).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+          "type": "text",
+        },
+        {
+          "text": "<environment>
+      <cwd>/repo</cwd>
+      </environment>
+      Skills provide specialized instructions",
+          "type": "text",
+        },
+      ]
+    `);
     });
 });
-describe('shouldRotateAuth', () => {
-    test('only rotates on rate limit or auth failures', () => {
-        expect(shouldRotateAuth(429, '')).toBe(true);
-        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
-        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+describe('replacer', () => {
+    test('sanitizes system text only for anthropic provider metadata', async () => {
+        const plugin = await replacer({});
+        const transform = plugin['experimental.chat.system.transform'];
+        if (!transform) {
+            throw new Error('Expected experimental.chat.system.transform hook');
+        }
+        const output = {
+            system: [
+                "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            ],
+        };
+        await transform({
+            model: {
+                providerID: 'anthropic',
+            },
+        }, output);
+        expect(output.system).toMatchInlineSnapshot(`
+      [
+        "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+      ]
+    `);
     });
 });

package/dist/anthropic-auth-state.js

@@ -186,6 +186,37 @@ async function writeAnthropicAuthFile(auth) {
     }
     await writeJson(file, data);
 }
+function isOAuthStored(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    return (record.type === 'oauth' &&
+        typeof record.refresh === 'string' &&
+        typeof record.access === 'string' &&
+        typeof record.expires === 'number');
+}
+export async function getCurrentAnthropicAccount() {
+    const authJson = await readJson(authFilePath(), {});
+    const auth = authJson.anthropic;
+    if (!isOAuthStored(auth)) {
+        return null;
+    }
+    const store = await loadAccountStore();
+    const index = findCurrentAccountIndex(store, auth);
+    const account = store.accounts[index];
+    if (!account) {
+        return { auth };
+    }
+    if (account.refresh !== auth.refresh && account.access !== auth.access) {
+        return { auth };
+    }
+    return {
+        auth,
+        account,
+        index,
+    };
+}
 export async function setAnthropicAuth(auth, client) {
     await writeAnthropicAuthFile(auth);
     await client.auth.set({ path: { id: 'anthropic' }, body: auth });

package/dist/bash-tool.js

@@ -0,0 +1,194 @@
+// Bash tool for the GenAI worker.
+// Executes shell commands in the project directory and can preload remote
+// SKILL.md files into a local cache so their metadata can be exposed to the model.
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { tool } from './ai-tool.js';
+import { getDataDir } from './config.js';
+import { execAsync } from './exec-async.js';
+import { parseFrontmatter } from './forum-sync/markdown.js';
+import { createLogger, LogPrefix } from './logger.js';
+const bashToolLogger = createLogger(LogPrefix.TOOLS);
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_SHELL = process.env['SHELL'] || '/bin/zsh';
+const bashToolGlobalState = (() => {
+    const key = '__kimakiBashToolState';
+    const state = globalThis;
+    if (!state[key]) {
+        state[key] = {
+            skills: new Map(),
+        };
+    }
+    return state[key];
+})();
+function getExecErrorFields({ error, }) {
+    if (!(error instanceof Error)) {
+        return {
+            exitCode: 1,
+            stderr: String(error),
+            stdout: '',
+        };
+    }
+    const execError = error;
+    return {
+        exitCode: typeof execError.code === 'number' ? execError.code : 1,
+        stderr: typeof execError.stderr === 'string' ? execError.stderr : error.message,
+        stdout: typeof execError.stdout === 'string' ? execError.stdout : '',
+    };
+}
+function sanitizeSkillName({ name }) {
+    return (name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'skill');
+}
+export function normalizeSkillMarkdownUrl({ url }) {
+    const parsed = new URL(url);
+    if (parsed.hostname !== 'github.com') {
+        return parsed.toString();
+    }
+    const parts = parsed.pathname.replace(/^\/+|\/+$/g, '').split('/');
+    if (parts.length < 5) {
+        return parsed.toString();
+    }
+    const [owner, repo, kind, ref, ...rest] = parts;
+    if (kind !== 'blob' || rest.length === 0) {
+        return parsed.toString();
+    }
+    return new URL(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${rest.join('/')}`).toString();
+}
+async function fetchSkillMarkdown({ url }) {
+    const normalizedUrl = normalizeSkillMarkdownUrl({ url });
+    const candidates = normalizedUrl === url ? [url] : [normalizedUrl, url];
+    let lastStatus = null;
+    for (const candidate of candidates) {
+        const response = await fetch(candidate);
+        if (!response.ok) {
+            lastStatus = response.status;
+            continue;
+        }
+        return response.text();
+    }
+    throw new Error(`Failed to fetch skill markdown from ${url}${lastStatus ? ` (last status ${lastStatus})` : ''}`);
+}
+async function cacheSkillMarkdown({ url, }) {
+    const markdown = await fetchSkillMarkdown({ url });
+    const parsed = parseFrontmatter({ markdown });
+    const name = parsed.frontmatter['name'];
+    const description = parsed.frontmatter['description'];
+    if (typeof name !== 'string' || name.trim().length === 0) {
+        throw new Error(`Skill at ${url} is missing a valid frontmatter name`);
+    }
+    if (typeof description !== 'string' || description.trim().length === 0) {
+        throw new Error(`Skill at ${url} is missing a valid frontmatter description`);
+    }
+    const root = path.join(getDataDir(), 'remote-skills', sanitizeSkillName({ name }));
+    await fs.promises.mkdir(root, { recursive: true });
+    const location = path.join(root, 'SKILL.md');
+    await fs.promises.writeFile(location, markdown, 'utf-8');
+    return {
+        content: parsed.body,
+        description,
+        location,
+        name,
+    };
+}
+export async function loadRemoteSkills({ skillUrls, }) {
+    const uniqueUrls = Array.from(new Set(skillUrls));
+    const loaded = await Promise.all(uniqueUrls.map(async (url) => {
+        const cached = bashToolGlobalState.skills.get(url);
+        if (cached) {
+            return cached;
+        }
+        const promise = cacheSkillMarkdown({ url }).catch((error) => {
+            bashToolGlobalState.skills.delete(url);
+            throw error;
+        });
+        bashToolGlobalState.skills.set(url, promise);
+        return promise;
+    }));
+    return loaded.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function formatAvailableSkillsXml({ skills, }) {
+    if (skills.length === 0) {
+        return 'No skills are currently available.';
+    }
+    return [
+        '<available_skills>',
+        ...skills.flatMap((skill) => {
+            return [
+                '  <skill>',
+                `    <name>${skill.name}</name>`,
+                `    <description>${skill.description}</description>`,
+                `    <location>${pathToFileURL(skill.location).href}</location>`,
+                '  </skill>',
+            ];
+        }),
+        '</available_skills>',
+    ].join('\n');
+}
+function buildDescription({ directory, skills, }) {
+    const lines = [
+        `Execute a shell command in ${directory}.`,
+        'Use `workdir` instead of `cd` commands when you need a different directory.',
+        'Return fields include `stdout`, `stderr`, and `exitCode`.',
+    ];
+    if (skills.length === 0) {
+        return lines.join('\n');
+    }
+    return [
+        ...lines,
+        '',
+        'Skills provide specialized instructions and workflows for specific tasks.',
+        'If a task matches a skill, read that SKILL.md file with bash before continuing.',
+        formatAvailableSkillsXml({ skills }),
+    ].join('\n');
+}
+export async function createBashTool({ directory, skillUrls = [], }) {
+    const skills = await loadRemoteSkills({ skillUrls });
+    const description = buildDescription({ directory, skills });
+    if (skills.length > 0) {
+        bashToolLogger.info('Loaded cached remote skills for bash tool', skills.map((skill) => {
+            return skill.name;
+        }));
+    }
+    return tool({
+        description,
+        inputSchema: z.object({
+            command: z.string().describe('The shell command to execute'),
+            timeout: z.number().optional().describe('Optional timeout in milliseconds'),
+            workdir: z
+                .string()
+                .optional()
+                .describe('Optional working directory. Use this instead of cd commands.'),
+            description: z.string().describe('Short explanation of what the command does'),
+            hasSideEffect: z
+                .boolean()
+                .optional()
+                .describe('Whether this command writes files or changes external state'),
+        }),
+        execute: async ({ command, timeout, workdir }) => {
+            const cwd = workdir || directory;
+            const result = await execAsync(command, {
+                cwd,
+                shell: DEFAULT_SHELL,
+                timeout: timeout ?? DEFAULT_TIMEOUT_MS,
+                maxBuffer: 1024 * 1024 * 10,
+            })
+                .then(({ stdout, stderr }) => {
+                return {
+                    exitCode: 0,
+                    stderr,
+                    stdout,
+                };
+            })
+                .catch((error) => {
+                return getExecErrorFields({ error });
+            });
+            return result;
+        },
+    });
+}

package/dist/bash-tool.test.js

@@ -0,0 +1,82 @@
+// Tests for the GenAI bash tool helper and remote skill loading cache.
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { setDataDir } from './config.js';
+import { formatAvailableSkillsXml, loadRemoteSkills, normalizeSkillMarkdownUrl, } from './bash-tool.js';
+const tempRoot = path.join(process.cwd(), 'tmp', 'bash-tool-tests');
+let server;
+let serverUrl = '';
+let requestCount = 0;
+beforeAll(async () => {
+    await fs.promises.mkdir(tempRoot, { recursive: true });
+    setDataDir(tempRoot);
+    server = http.createServer((request, response) => {
+        if (request.url !== '/skill.md') {
+            response.statusCode = 404;
+            response.end('missing');
+            return;
+        }
+        requestCount += 1;
+        response.setHeader('content-type', 'text/markdown; charset=utf-8');
+        response.end(`---
+name: remote-skill
+description: Remote cached skill for bash tool tests
+---
+
+# Remote skill
+
+Use this skill in tests.
+`);
+    });
+    await new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (typeof address === 'object' && address) {
+                serverUrl = `http://127.0.0.1:${address.port}/skill.md`;
+            }
+            resolve();
+        });
+    });
+});
+afterAll(async () => {
+    await new Promise((resolve, reject) => {
+        if (!server) {
+            resolve();
+            return;
+        }
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+});
+describe('normalizeSkillMarkdownUrl', () => {
+    test('converts GitHub blob URLs to raw content URLs', () => {
+        expect(normalizeSkillMarkdownUrl({
+            url: 'https://github.com/remorses/kimaki/blob/main/cli/skills/errore/SKILL.md',
+        })).toBe('https://raw.githubusercontent.com/remorses/kimaki/main/cli/skills/errore/SKILL.md');
+    });
+});
+describe('loadRemoteSkills', () => {
+    test('fetches once, caches, writes SKILL.md, and formats skill XML', async () => {
+        const first = await loadRemoteSkills({ skillUrls: [serverUrl] });
+        const second = await loadRemoteSkills({ skillUrls: [serverUrl] });
+        expect(requestCount).toBe(1);
+        expect(second[0]?.location).toBe(first[0]?.location);
+        expect(await fs.promises.readFile(first[0].location, 'utf-8')).toContain('name: remote-skill');
+        expect(formatAvailableSkillsXml({ skills: first })).toMatchInlineSnapshot(`
+      "<available_skills>
+        <skill>
+          <name>remote-skill</name>
+          <description>Remote cached skill for bash tool tests</description>
+          <location>file:///Users/morse/Documents/GitHub/kimakivoice/cli/tmp/bash-tool-tests/remote-skills/remote-skill/SKILL.md</location>
+        </skill>
+      </available_skills>"
+    `);
+    });
+});

package/dist/btw-prefix-detection.js

@@ -0,0 +1,17 @@
+// Detects the raw `btw ` Discord message shortcut used to fork a side-question
+// thread without invoking the /btw slash command UI.
+export function extractBtwPrefix(content) {
+    if (!content) {
+        return null;
+    }
+    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
+    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
+    if (!match) {
+        return null;
+    }
+    const prompt = match[1]?.trim();
+    if (!prompt) {
+        return null;
+    }
+    return { prompt };
+}

package/dist/btw-prefix-detection.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { extractBtwPrefix } from './btw-prefix-detection.js';
+describe('extractBtwPrefix', () => {
+    test('matches lowercase prefix', () => {
+        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches uppercase prefix', () => {
+        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "check this",
+      }
+    `);
+    });
+    test('keeps multiline content', () => {
+        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+      {
+        "prompt": "first line
+      second line",
+      }
+    `);
+    });
+    test('matches dot separator', () => {
+        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches comma separator', () => {
+        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches colon separator', () => {
+        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches punctuation without trailing space', () => {
+        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('does not match without separating whitespace', () => {
+        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match mid-message', () => {
+        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match empty payload', () => {
+        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    });
+});