kimaki 0.26.0 → 0.28.0

package/dist/voice.js

@@ -181,16 +181,22 @@ function createWavHeader({ dataLength, sampleRate, numChannels, bitsPerSample, }
 }
 // Build the transcription tool schema dynamically so the agent field can
 // use an enum constrained to the actual available agent names.
-function buildTranscriptionTool({ agentNames, }) {
+export function buildTranscriptionTool({ agentNames, canForkSession = false, }) {
     const properties = {
         transcription: {
             type: 'string',
-            description: 'The final transcription of the audio. MUST be non-empty. If audio is unclear, transcribe your best interpretation. If silent, too short to understand, or completely incomprehensible, use "[inaudible audio]".',
+            description: 'The final transcription of the audio. If only a session routing instruction was spoken with no request, return an empty string. If audio is unclear, transcribe your best interpretation. If silent, too short to understand, or completely incomprehensible, use "[inaudible audio]".',
         },
         queueMessage: {
             type: 'boolean',
             description: 'Set to true ONLY if the user explicitly says "queue this message", "queue this", or similar phrasing indicating they want this message queued instead of sent immediately. If not mentioned, omit or set to false.',
         },
+        sessionAction: {
+            type: 'string',
+            enum: canForkSession ? ['btw', 'new-session'] : ['new-session'],
+            description: 'Use "new-session" only when explicitly asked to create a new chat, session, or thread with no conversation history. Remove routing instructions from transcription. Omit for normal messages. Never combine with queueMessage.' +
+                (canForkSession ? ' Use "btw" only when explicitly asked to create a side chat or fork with current context.' : ''),
+        },
     };
     if (agentNames && agentNames.length > 0) {
         properties['agent'] = {
@@ -213,7 +219,7 @@ function buildTranscriptionTool({ agentNames, }) {
 /**
  * Extract transcription result from doGenerate content array.
  * Looks for a tool-call named 'transcriptionResult', falls back to text content.
- * Returns structured result with transcription text and queueMessage flag.
+ * Returns transcription text, queue/session routing, and optional agent selection.
  */
 export function extractTranscription(content) {
     const toolCall = content.find((c) => c.type === 'tool-call' && c.toolName === 'transcriptionResult');
@@ -226,13 +232,16 @@ export function extractTranscription(content) {
             return {};
         })();
         const transcription = (typeof args.transcription === 'string' ? args.transcription : '').trim();
-        const queueMessage = args.queueMessage === true;
+        const sessionAction = args.sessionAction === 'btw' || args.sessionAction === 'new-session'
+            ? args.sessionAction
+            : undefined;
+        const queueMessage = !sessionAction && args.queueMessage === true;
         const agent = typeof args.agent === 'string' ? args.agent : undefined;
         voiceLogger.log(`Transcription result received: "${transcription.slice(0, 100)}..."${queueMessage ? ' [QUEUE]' : ''}${agent ? ` [AGENT:${agent}]` : ''}`);
         if (!transcription) {
             return new EmptyTranscriptionError();
         }
-        return { transcription, queueMessage, agent };
+        return { transcription, queueMessage, agent, sessionAction };
     }
     // Fall back to text content if no tool call
     const textPart = content.find((c) => c.type === 'text');
@@ -247,8 +256,8 @@ export function extractTranscription(content) {
         reason: 'Model did not produce a transcription',
     });
 }
-async function runTranscriptionOnce({ model, prompt, audioBase64, mediaType, temperature, agentNames, provider, }) {
-    const tool = buildTranscriptionTool({ agentNames });
+async function runTranscriptionOnce({ model, prompt, audioBase64, mediaType, temperature, agentNames, canForkSession, provider, }) {
+    const tool = buildTranscriptionTool({ agentNames, canForkSession });
     const options = {
         prompt: [
             {
@@ -311,7 +320,7 @@ export function createTranscriptionModel({ apiKey, provider, }) {
     const google = createGoogleGenerativeAI({ apiKey });
     return google('gemini-2.5-flash');
 }
-export async function transcribeAudio({ audio, prompt, language, temperature, apiKey: apiKeyParam, model, provider, mediaType: mediaTypeParam, currentSessionContext, lastSessionContext, agents, }) {
+export async function transcribeAudio({ audio, prompt, language, temperature, apiKey: apiKeyParam, model, provider, mediaType: mediaTypeParam, currentSessionContext, lastSessionContext, agents, canForkSession = false, }) {
     const apiKey = apiKeyParam || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY;
     if (!model && !apiKey) {
         return Promise.resolve(new ApiKeyMissingError({ service: 'OpenAI or Gemini' }));
@@ -412,6 +421,16 @@ This is a software development environment. The speaker is giving instructions t
  - Example: "Queue this message. Fix the login bug in auth.ts" → transcription: "Fix the login bug in auth.ts", queueMessage: true
  - If removing the queue phrase would leave empty content (user only said "queue this" with nothing else), keep the full spoken text as the transcription — never return an empty transcription.
  - If no queue intent is detected, omit queueMessage or set it to false.
+
+ SESSION ROUTING:
+  - Only route when the user explicitly asks to create a new chat, session, or thread for the request. Set sessionAction to "new-session": a separate thread with NO conversation history.
+  ${canForkSession ? '- If the user explicitly asks to create a side chat or fork with current context, set sessionAction to "btw" instead.' : '- Context-preserving side chats and forks are unavailable here. Preserve requests for them as spoken text without setting sessionAction.'}
+ - Remove these routing words from the transcription. Include only the actual request, not instructions about where to send it.
+ - Example: "Fix the login bug. Create this as a new chat session" -> transcription: "Fix the login bug", sessionAction: "new-session".
+  - Do not infer routing from conversational phrases, task content, or session context.
+  - If both routing and queueing are requested, sessionAction takes priority; set queueMessage to false. An explicit fresh-session request takes priority over a contextual fork.
+  - If there is no actual request after removing routing words, return an empty transcription and omit sessionAction. Never invent placeholder content.
+ - Otherwise omit sessionAction. Agent selection can be combined with either route.
 ${agents && agents.length > 0 ? `
  AGENT SELECTION:
  - Only set the agent field when the user explicitly says phrases like "use the X agent", "switch to X agent", "with the X agent", or similar phrasing that clearly names a specific agent to switch to.
@@ -449,6 +468,7 @@ Note: "critique" is a CLI tool for showing diffs in the browser.`;
         mediaType,
         temperature: temperature ?? 0.3,
         agentNames: agentNames && agentNames.length > 0 ? agentNames : undefined,
+        canForkSession,
         provider: resolvedProvider,
     });
 }

package/dist/voice.test.js

@@ -3,7 +3,7 @@
 import { describe, test, expect } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
-import { transcribeAudio, convertOggToWav, extractTranscription, normalizeAudioMediaType, getOpenAIAudioConversionStrategy, } from './voice.js';
+import { transcribeAudio, convertOggToWav, extractTranscription, normalizeAudioMediaType, getOpenAIAudioConversionStrategy, buildTranscriptionTool, } from './voice.js';
 import { getVoiceAttachmentMatchReason, isVoiceAttachment, } from './voice-attachment.js';
 describe('audio media type routing', () => {
     test('normalizes m4a aliases to audio/mp4', () => {
@@ -50,8 +50,86 @@ describe('voice attachment detection', () => {
       ]
     `);
     });
+    test('does not treat iOS and Discord videos as voice', () => {
+        expect([
+            getVoiceAttachmentMatchReason({
+                name: 'ScreenRecording_08-26-2026_11-10-29_1.mov',
+                contentType: 'video/quicktime',
+                duration: 12.4,
+                width: 1170,
+                height: 2532,
+            }),
+            getVoiceAttachmentMatchReason({
+                name: 'IMG_1234.MOV',
+                contentType: null,
+                duration: 8,
+                width: 1920,
+                height: 1080,
+            }),
+            getVoiceAttachmentMatchReason({
+                name: 'clip.mp4',
+                contentType: 'video/mp4',
+                duration: 4,
+            }),
+            getVoiceAttachmentMatchReason({
+                name: 'clip.mp4',
+                contentType: null,
+            }),
+            isVoiceAttachment({
+                name: 'memo.m4a',
+                contentType: null,
+                duration: 3.2,
+            }),
+        ]).toMatchInlineSnapshot(`
+        [
+          null,
+          null,
+          null,
+          null,
+          true,
+        ]
+      `);
+    });
 });
 describe('extractTranscription', () => {
+    test('only offers contextual routing when a source session exists', () => {
+        expect(buildTranscriptionTool({}).inputSchema).toMatchObject({
+            properties: { sessionAction: { enum: ['new-session'] } },
+        });
+        expect(buildTranscriptionTool({ canForkSession: true }).inputSchema).toMatchObject({
+            properties: { sessionAction: { enum: ['btw', 'new-session'] } },
+        });
+        expect(JSON.stringify(buildTranscriptionTool({ canForkSession: true })))
+            .not.toContain('by the way');
+    });
+    test.each(['btw', 'new-session'])('extracts %s routing without queueing', (sessionAction) => {
+        const result = extractTranscription([{
+                type: 'tool-call',
+                toolCallId: 'routing',
+                toolName: 'transcriptionResult',
+                input: JSON.stringify({
+                    transcription: 'Explain the authentication flow',
+                    sessionAction,
+                    queueMessage: true,
+                    agent: 'plan',
+                }),
+            }]);
+        expect(result).toEqual({
+            transcription: 'Explain the authentication flow',
+            sessionAction,
+            queueMessage: false,
+            agent: 'plan',
+        });
+    });
+    test('ignores unknown session routing', () => {
+        const result = extractTranscription([{
+                type: 'tool-call',
+                toolCallId: 'routing',
+                toolName: 'transcriptionResult',
+                input: JSON.stringify({ transcription: 'Keep working', sessionAction: 'invalid' }),
+            }]);
+        expect(result).toEqual({ transcription: 'Keep working', queueMessage: false, agent: undefined });
+    });
     test('extracts transcription from tool call', () => {
         const result = extractTranscription([
             {
@@ -65,6 +143,7 @@ describe('extractTranscription', () => {
       {
         "agent": undefined,
         "queueMessage": false,
+        "sessionAction": undefined,
         "transcription": "hello world",
       }
     `);
@@ -85,6 +164,7 @@ describe('extractTranscription', () => {
       {
         "agent": undefined,
         "queueMessage": true,
+        "sessionAction": undefined,
         "transcription": "Fix the login bug in auth.ts",
       }
     `);
@@ -143,18 +223,17 @@ describe('extractTranscription', () => {
         expect(result.message).toMatchInlineSnapshot(`"Transcription failed: Model did not produce a transcription"`);
     });
 });
-describe('transcribeAudio with real API', () => {
+const liveVoiceTest = describe.skipIf(process.env['KIMAKI_LIVE_VOICE_TESTS'] !== '1');
+liveVoiceTest('transcribeAudio with real API', () => {
     const audioPath = path.join(import.meta.dirname, '..', 'scripts', 'example-audio.mp3');
-    test('transcribes with Gemini', { timeout: 30_000 }, async () => {
+    const oggPath = path.join(import.meta.dirname, '..', 'scripts', 'example-audio.ogg');
+    const geminiLiveTest = test.skipIf(!process.env.GEMINI_API_KEY || !fs.existsSync(audioPath));
+    const openAiLiveTest = test.skipIf(!process.env.OPENAI_API_KEY || !fs.existsSync(audioPath));
+    const openAiOggLiveTest = test.skipIf(!process.env.OPENAI_API_KEY || !fs.existsSync(oggPath));
+    geminiLiveTest('transcribes with Gemini', { timeout: 30_000 }, async () => {
         const apiKey = process.env.GEMINI_API_KEY;
-        if (!apiKey) {
-            console.log('Skipping: GEMINI_API_KEY not set');
-            return;
-        }
-        if (!fs.existsSync(audioPath)) {
-            console.log('Skipping: example-audio.mp3 not found');
-            return;
-        }
+        if (!apiKey)
+            throw new Error('GEMINI_API_KEY is required');
         const audio = fs.readFileSync(audioPath);
         const result = await transcribeAudio({
             audio,
@@ -167,16 +246,10 @@ describe('transcribeAudio with real API', () => {
         expect(transcription.length).toBeGreaterThan(0);
         console.log('Gemini transcription:', result);
     });
-    test('transcribes with OpenAI', { timeout: 30_000 }, async () => {
+    openAiLiveTest('transcribes with OpenAI', { timeout: 30_000 }, async () => {
         const apiKey = process.env.OPENAI_API_KEY;
-        if (!apiKey) {
-            console.log('Skipping: OPENAI_API_KEY not set');
-            return;
-        }
-        if (!fs.existsSync(audioPath)) {
-            console.log('Skipping: example-audio.mp3 not found');
-            return;
-        }
+        if (!apiKey)
+            throw new Error('OPENAI_API_KEY is required');
         const audio = fs.readFileSync(audioPath);
         const result = await transcribeAudio({
             audio,
@@ -189,17 +262,10 @@ describe('transcribeAudio with real API', () => {
         expect(transcription.length).toBeGreaterThan(0);
         console.log('OpenAI transcription:', result);
     });
-    test('transcribes OGG with OpenAI (converts to WAV)', { timeout: 30_000 }, async () => {
+    openAiOggLiveTest('transcribes OGG with OpenAI (converts to WAV)', { timeout: 30_000 }, async () => {
         const apiKey = process.env.OPENAI_API_KEY;
-        const oggPath = path.join(import.meta.dirname, '..', 'scripts', 'example-audio.ogg');
-        if (!apiKey) {
-            console.log('Skipping: OPENAI_API_KEY not set');
-            return;
-        }
-        if (!fs.existsSync(oggPath)) {
-            console.log('Skipping: example-audio.ogg not found');
-            return;
-        }
+        if (!apiKey)
+            throw new Error('OPENAI_API_KEY is required');
         const audio = fs.readFileSync(oggPath);
         const result = await transcribeAudio({
             audio,

package/dist/worktree-clone-isolation.e2e.test.js

@@ -0,0 +1,188 @@
+// Verifies OpenCode workspace creation stays bound to the requested local clone.
+import fs from 'node:fs';
+import path from 'node:path';
+import { afterAll, beforeAll, expect, test } from 'vitest';
+import { setDataDir } from './config.js';
+import { tryWorkspaceCreate } from './commands/new-worktree.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
+import { chooseLockPort } from './test-utils.js';
+import { execAsync, getManagedWorktreeDirectory } from './worktrees.js';
+import { KIMAKI_WORKTREE_ADAPTER_TYPE } from './git-worktree-core.js';
+const WORKTREE_BRANCH = 'opencode/kimaki-clone-isolation';
+const REJECTED_WORKTREE_BRANCH = 'opencode/kimaki-rejected-clone-isolation';
+async function git({ cwd, args }) {
+    const result = await execAsync(`git ${args.map((arg) => JSON.stringify(arg)).join(' ')}`, {
+        cwd,
+        timeout: 60_000,
+    });
+    return result.stdout.trim();
+}
+let sandbox = '';
+let requestedClone = '';
+let otherClone = '';
+beforeAll(async () => {
+    const root = path.resolve(process.cwd(), 'tmp');
+    fs.mkdirSync(root, { recursive: true });
+    sandbox = fs.mkdtempSync(path.join(root, 'worktree-clone-isolation-'));
+    const remote = path.join(sandbox, 'remote.git');
+    requestedClone = path.join(sandbox, 'holocron');
+    otherClone = path.join(sandbox, 'fumabase');
+    process.env['KIMAKI_LOCK_PORT'] = String(chooseLockPort({ key: 'worktree-clone-isolation' }));
+    setDataDir(path.join(sandbox, 'data'));
+    await git({ cwd: sandbox, args: ['init', '--bare', '-b', 'main', remote] });
+    await git({ cwd: sandbox, args: ['clone', remote, otherClone] });
+    await git({
+        cwd: otherClone,
+        args: ['config', 'user.email', 'kimaki-tests@example.com'],
+    });
+    await git({ cwd: otherClone, args: ['config', 'user.name', 'Kimaki Tests'] });
+    fs.writeFileSync(path.join(otherClone, 'preview.txt'), 'old preview\n');
+    await git({ cwd: otherClone, args: ['add', 'preview.txt'] });
+    await git({ cwd: otherClone, args: ['commit', '-m', 'old preview'] });
+    await git({ cwd: otherClone, args: ['push', 'origin', 'HEAD:main'] });
+    await git({ cwd: otherClone, args: ['switch', '-c', 'preview'] });
+    await git({ cwd: sandbox, args: ['clone', remote, requestedClone] });
+    await git({
+        cwd: requestedClone,
+        args: ['config', 'user.email', 'kimaki-tests@example.com'],
+    });
+    await git({ cwd: requestedClone, args: ['config', 'user.name', 'Kimaki Tests'] });
+    fs.mkdirSync(path.join(requestedClone, 'vite'));
+    fs.writeFileSync(path.join(requestedClone, 'vite', 'README.md'), 'new layout\n');
+    await git({ cwd: requestedClone, args: ['add', 'vite/README.md'] });
+    await git({ cwd: requestedClone, args: ['commit', '-m', 'add vite layout'] });
+}, 20_000);
+afterAll(async () => {
+    await stopOpencodeServer();
+    delete process.env['KIMAKI_LOCK_PORT'];
+    if (sandbox)
+        fs.rmSync(sandbox, { recursive: true, force: true });
+});
+test('creates a workspace from the exact requested clone and commit', async () => {
+    const requestedCommit = await git({
+        cwd: requestedClone,
+        args: ['rev-parse', 'HEAD^{commit}'],
+    });
+    const requestedCommonDirectory = path.resolve(requestedClone, await git({
+        cwd: requestedClone,
+        args: ['rev-parse', '--git-common-dir'],
+    }));
+    const requestedClientResult = await initializeOpencodeForDirectory(requestedClone);
+    if (requestedClientResult instanceof Error)
+        throw requestedClientResult;
+    const otherClientResult = await initializeOpencodeForDirectory(otherClone);
+    if (otherClientResult instanceof Error)
+        throw otherClientResult;
+    const requestedClient = requestedClientResult();
+    const otherClient = otherClientResult();
+    // Load the requested clone first, then overwrite the colliding OpenCode
+    // project adapter with the other clone before creating the workspace.
+    await requestedClient.config.get({ directory: requestedClone });
+    await otherClient.config.get({ directory: otherClone });
+    const response = await requestedClient.experimental.workspace.create({
+        directory: requestedClone,
+        type: KIMAKI_WORKTREE_ADAPTER_TYPE,
+        branch: WORKTREE_BRANCH,
+        extra: {
+            projectDirectory: requestedClone,
+            baseCommit: requestedCommit,
+        },
+    });
+    if (response.error)
+        throw new Error(JSON.stringify(response.error));
+    const workspace = response.data;
+    if (!workspace)
+        throw new Error('OpenCode returned no workspace');
+    try {
+        const actualCommit = await git({
+            cwd: workspace.directory,
+            args: ['rev-parse', 'HEAD^{commit}'],
+        });
+        const actualCommonDirectory = path.resolve(workspace.directory, await git({
+            cwd: workspace.directory,
+            args: ['rev-parse', '--git-common-dir'],
+        }));
+        expect({
+            usesRequestedClone: path.resolve(actualCommonDirectory) === path.resolve(requestedCommonDirectory),
+            usesRequestedCommit: actualCommit === requestedCommit,
+            hasRequestedLayout: fs.existsSync(path.join(workspace.directory, 'vite', 'README.md')),
+            absentFromOtherClone: !(await git({
+                cwd: otherClone,
+                args: ['worktree', 'list', '--porcelain'],
+            })).includes(workspace.directory),
+        }).toMatchInlineSnapshot(`
+        {
+          "absentFromOtherClone": true,
+          "hasRequestedLayout": true,
+          "usesRequestedClone": true,
+          "usesRequestedCommit": true,
+        }
+      `);
+    }
+    finally {
+        await requestedClient.experimental.workspace.remove({
+            id: workspace.id,
+            directory: requestedClone,
+        });
+    }
+}, 30_000);
+test('removes workspace state when identity validation rejects creation', async () => {
+    const requestedCommit = await git({
+        cwd: requestedClone,
+        args: ['rev-parse', 'HEAD^{commit}'],
+    });
+    const result = await tryWorkspaceCreate({
+        worktreeName: REJECTED_WORKTREE_BRANCH,
+        projectDirectory: requestedClone,
+        baseCommit: requestedCommit.toUpperCase(),
+    });
+    expect(result).toBeInstanceOf(Error);
+    const clientResult = await initializeOpencodeForDirectory(requestedClone);
+    if (clientResult instanceof Error)
+        throw clientResult;
+    const client = clientResult();
+    const listResponse = await client.experimental.workspace.list({
+        directory: requestedClone,
+    });
+    if (listResponse.error)
+        throw new Error(JSON.stringify(listResponse.error));
+    const rejectedWorkspaces = (listResponse.data ?? []).filter((workspace) => {
+        return workspace.branch === REJECTED_WORKTREE_BRANCH;
+    });
+    try {
+        const managedDirectory = getManagedWorktreeDirectory({
+            directory: requestedClone,
+            name: REJECTED_WORKTREE_BRANCH,
+        });
+        const [requestedWorktrees, otherWorktrees] = await Promise.all([
+            git({ cwd: requestedClone, args: ['worktree', 'list', '--porcelain'] }),
+            git({ cwd: otherClone, args: ['worktree', 'list', '--porcelain'] }),
+        ]);
+        const branchExists = await execAsync(`git show-ref --verify --quiet ${JSON.stringify(`refs/heads/${REJECTED_WORKTREE_BRANCH}`)}`, { cwd: requestedClone })
+            .then(() => true)
+            .catch(() => false);
+        expect({
+            workspaceRows: rejectedWorkspaces.length,
+            directoryExists: fs.existsSync(managedDirectory),
+            requestedCloneRegistration: requestedWorktrees.includes(managedDirectory),
+            otherCloneRegistration: otherWorktrees.includes(managedDirectory),
+            branchExists,
+        }).toMatchInlineSnapshot(`
+      {
+        "branchExists": false,
+        "directoryExists": false,
+        "otherCloneRegistration": false,
+        "requestedCloneRegistration": false,
+        "workspaceRows": 0,
+      }
+    `);
+    }
+    finally {
+        await Promise.all(rejectedWorkspaces.map((workspace) => {
+            return client.experimental.workspace.remove({
+                id: workspace.id,
+                directory: requestedClone,
+            });
+        }));
+    }
+}, 30_000);