kimaki 0.26.0 → 0.28.0

package/dist/message-preprocessing.js

@@ -1,24 +1,109 @@
 // Message pre-processing pipeline for incoming Discord messages.
 // Extracts prompt text, voice transcription, file/text attachments, and
 // session context from a Discord Message before handing off to the runtime.
+// Voice side/fresh-chat requests dispatch to separate threads instead.
 //
 // This module exists so discord-bot.ts stays a thin event router and the
 // expensive async work (voice transcription, context fetch, attachment
 // download) runs inside the runtime's serialized preprocessChain —
 // preserving arrival order without a separate threadIngressQueue.
 import { DiscordOperationError, OpenCodeSdkError } from './errors.js';
+import { getOrCreateRuntime } from './session-handler/thread-session-runtime.js';
 import { resolveMentions, getFileAttachments, getTextAttachments, } from './message-formatting.js';
 import { processVoiceAttachment } from './voice-handler.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
 import { getCompactSessionContext, getLastSessionId } from './markdown.js';
-import { getThreadSession } from './database.js';
+import { getThreadSession, getThreadWorktreeOrWorkspace } from './database.js';
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage } from './discord-utils.js';
+import { forkSessionToBtwThread } from './commands/btw.js';
+import { createNewSessionThread } from './commands/session.js';
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 const logger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 export const VOICE_MESSAGE_TRANSCRIPTION_PREFIX = 'Voice message transcription from Discord user:\n';
+// Dispatch before returning a prompt so the source runtime never receives the side request.
+async function routeVoiceSession({ voiceResult, message, thread, appId, }) {
+    if (!voiceResult?.sessionAction)
+        return false;
+    const resolved = await resolveWorkingDirectory({ channel: thread });
+    if (!resolved) {
+        await sendThreadMessage(thread, 'Could not determine project directory. Use /add-project to configure it, then retry.');
+        return true;
+    }
+    const images = await getFileAttachments(message);
+    const textAttachments = await getTextAttachments(message);
+    const caption = resolveMentions(message).trim();
+    const prompt = [caption, voiceResult.transcription, textAttachments]
+        .filter((part) => part?.trim())
+        .join('\n\n');
+    const modelPrompt = [caption, `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`, textAttachments]
+        .filter((part) => part?.trim())
+        .join('\n\n');
+    if (voiceResult.sessionAction === 'btw') {
+        const result = await forkSessionToBtwThread({
+            sourceThread: thread,
+            projectDirectory: resolved.projectDirectory,
+            sdkDirectory: resolved.workingDirectory,
+            prompt,
+            modelPrompt,
+            images,
+            agent: voiceResult.agent,
+            userId: message.author.id,
+            username: message.member?.displayName || message.author.displayName,
+            appId,
+        })
+            .catch((cause) => new DiscordOperationError({ operation: 'forkVoiceSession', cause }));
+        if (result instanceof Error) {
+            logger.error('Voice side chat failed:', result);
+            await sendThreadMessage(thread, `${result.message}. Start a session first, then retry with /btw.`);
+            return true;
+        }
+        await sendThreadMessage(thread, `Session forked! Continue in ${result.thread.toString()}`);
+        return true;
+    }
+    const textChannel = await resolveTextChannel(thread);
+    if (!textChannel) {
+        await sendThreadMessage(thread, 'Could not resolve parent text channel. Retry /new-session in the project channel.');
+        return true;
+    }
+    const result = await createNewSessionThread({
+        textChannel,
+        projectDirectory: resolved.projectDirectory,
+        prompt,
+        userId: message.author.id,
+        sourceWorkspace: await getThreadWorktreeOrWorkspace(thread.id),
+    }).catch((cause) => new DiscordOperationError({ operation: 'createVoiceSessionThread', cause }));
+    if (result instanceof Error) {
+        logger.error('Voice new session failed:', result);
+        await sendThreadMessage(thread, `${result.message}. Retry with /new-session.`);
+        return true;
+    }
+    await sendThreadMessage(thread, `Created new session in ${result.toString()}`);
+    const runtime = getOrCreateRuntime({
+        threadId: result.id,
+        thread: result,
+        projectDirectory: resolved.projectDirectory,
+        sdkDirectory: resolved.workingDirectory,
+        channelId: textChannel.id,
+        appId,
+    });
+    await runtime.enqueueIncoming({
+        prompt: modelPrompt,
+        images,
+        agent: voiceResult.agent,
+        userId: message.author.id,
+        username: message.member?.displayName || message.author.displayName,
+        appId,
+        mode: 'opencode',
+    }).catch(async (error) => {
+        logger.error('Voice session dispatch failed:', error);
+        await sendThreadMessage(result, 'Could not send the request to OpenCode. Send your request again in this thread.');
+    });
+    return true;
+}
 /** Fetch available agents from OpenCode for voice transcription agent selection. */
 async function fetchAvailableAgents(getClient, directory) {
     if (getClient instanceof Error) {
@@ -170,7 +255,15 @@ export async function preprocessExistingThreadMessage({ message, thread, project
         currentSessionContext,
         lastSessionContext,
         agents,
+        canForkSession: true,
     });
+    if (voiceResult instanceof Error) {
+        voiceLogger.warn('Voice request not dispatched:', voiceResult);
+        return { prompt: '', mode: 'opencode', skip: true };
+    }
+    if (await routeVoiceSession({ voiceResult, message, thread, appId })) {
+        return { prompt: '', mode: 'opencode', skip: true };
+    }
     if (voiceResult) {
         messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
@@ -231,6 +324,13 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
         appId,
         agents,
     });
+    if (voiceResult instanceof Error) {
+        voiceLogger.warn('Voice request not dispatched:', voiceResult);
+        return { prompt: '', mode: 'opencode', skip: true };
+    }
+    if (await routeVoiceSession({ voiceResult, message, thread, appId })) {
+        return { prompt: '', mode: 'opencode', skip: true };
+    }
     if (voiceResult) {
         prompt = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }
@@ -304,6 +404,10 @@ export async function preprocessNewThreadMessage({ message, thread, projectDirec
         appId,
         agents,
     });
+    if (voiceResult instanceof Error) {
+        voiceLogger.warn('Voice request not dispatched:', voiceResult);
+        return { prompt: '', mode: 'opencode', skip: true };
+    }
     if (voiceResult) {
         messageContent = `${VOICE_MESSAGE_TRANSCRIPTION_PREFIX}${voiceResult.transcription}`;
     }

package/dist/oauth-rotation-shared.js

@@ -1,3 +1,13 @@
+/**
+ * LEGACY. Superseded by @subrouter/opencode, registered alongside the kimaki
+ * plugin in opencode.ts. This whole rotation path only cycles accounts inside
+ * one provider; subrouter also fails over to a different provider when every
+ * account of one is exhausted.
+ *
+ * Kept because opencode ships no Claude Pro/Max auth of its own, so deleting
+ * it would strand anyone still picking `anthropic/*` directly. To move to
+ * subrouter, log in again through /login and pick Subrouter.
+ */
 /**
  * Shared utilities for multi-provider OAuth account rotation.
  * Used by both anthropic-auth-state.ts and openai-auth-state.ts to avoid

package/dist/openai-auth-plugin.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth rotation plugin for OpenCode.
  *

package/dist/openai-auth-state.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth account store and rotation.
  * Mirrors anthropic-auth-state.ts but for OpenAI/Codex OAuth accounts.

package/dist/opencode-command.js

@@ -4,7 +4,35 @@
 // and creates a stable `kimaki` shim for OpenCode child processes.
 import fs from 'node:fs';
 import path from 'node:path';
+import { OpencodeIncompatibleVersionError } from './errors.js';
 const WINDOWS_CMD_SHIM_REGEX = /\.(cmd|bat)$/i;
+const OPENCODE_SEMVER_REGEX = /(\d+)\.(\d+)\.(\d+)/;
+// Kimaki still talks to OpenCode 1.x. Flip this to 1 after the v2 port ships.
+export const INCOMPATIBLE_OPENCODE_MAJOR_VERSION = 2;
+export function parseOpencodeVersion(output) {
+    const match = output.match(OPENCODE_SEMVER_REGEX);
+    if (!match)
+        return null;
+    const raw = match[0];
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch)) {
+        return null;
+    }
+    return { major, minor, patch, raw };
+}
+export function isIncompatibleOpencodeMajor({ major, }) {
+    return major === INCOMPATIBLE_OPENCODE_MAJOR_VERSION;
+}
+export function getIncompatibleOpencodeVersionError(output) {
+    const parsed = parseOpencodeVersion(output);
+    if (!parsed)
+        return null;
+    if (!isIncompatibleOpencodeMajor(parsed))
+        return null;
+    return new OpencodeIncompatibleVersionError({ version: parsed.raw });
+}
 function quotePosixShellSegment(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
 }

package/dist/opencode-command.test.js

@@ -1,9 +1,58 @@
 // Regression tests for Windows OpenCode command resolution and spawn args.
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { ensureKimakiCommandShim, getSpawnCommandAndArgs, sanitizeShimExecArgv, selectResolvedCommand, splitCommandLookupOutput, } from './opencode-command.js';
+import { ensureKimakiCommandShim, getIncompatibleOpencodeVersionError, getSpawnCommandAndArgs, INCOMPATIBLE_OPENCODE_MAJOR_VERSION, isIncompatibleOpencodeMajor, parseOpencodeVersion, sanitizeShimExecArgv, selectResolvedCommand, splitCommandLookupOutput, } from './opencode-command.js';
+import { OpencodeIncompatibleVersionError } from './errors.js';
+describe('parseOpencodeVersion', () => {
+    test('extracts major.minor.patch from opencode --version output', () => {
+        expect(parseOpencodeVersion('1.2.3')).toEqual({
+            major: 1,
+            minor: 2,
+            patch: 3,
+            raw: '1.2.3',
+        });
+        expect(parseOpencodeVersion('opencode 2.0.0\n')).toEqual({
+            major: 2,
+            minor: 0,
+            patch: 0,
+            raw: '2.0.0',
+        });
+        expect(parseOpencodeVersion('v2.1.0-beta.1')).toEqual({
+            major: 2,
+            minor: 1,
+            patch: 0,
+            raw: '2.1.0',
+        });
+    });
+    test('returns null when output has no three-part version', () => {
+        expect(parseOpencodeVersion('')).toBeNull();
+        expect(parseOpencodeVersion('opencode')).toBeNull();
+        expect(parseOpencodeVersion('2.0')).toBeNull();
+    });
+});
+describe('isIncompatibleOpencodeMajor', () => {
+    test('rejects the incompatible major and allows every other major', () => {
+        expect(INCOMPATIBLE_OPENCODE_MAJOR_VERSION).toBe(2);
+        expect(isIncompatibleOpencodeMajor({ major: 2 })).toBe(true);
+        expect(isIncompatibleOpencodeMajor({ major: 1 })).toBe(false);
+        expect(isIncompatibleOpencodeMajor({ major: 0 })).toBe(false);
+        expect(isIncompatibleOpencodeMajor({ major: 3 })).toBe(false);
+    });
+});
+describe('getIncompatibleOpencodeVersionError', () => {
+    test('returns a tagged error for OpenCode 2.x', () => {
+        const error = getIncompatibleOpencodeVersionError('2.0.0');
+        expect(error).toBeInstanceOf(OpencodeIncompatibleVersionError);
+        expect(error?.message).toMatchInlineSnapshot(`"Kimaki is not compatible with OpenCode version 2.0.0. Install an OpenCode 1.x release."`);
+    });
+    test('allows 1.x and unparseable output', () => {
+        expect(getIncompatibleOpencodeVersionError('1.4.0')).toBeNull();
+        expect(getIncompatibleOpencodeVersionError('opencode')).toBeNull();
+    });
+});
 describe('splitCommandLookupOutput', () => {
     test('splits windows command lookup output into trimmed lines', () => {
         expect(splitCommandLookupOutput('C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n')).toEqual([
@@ -26,6 +75,65 @@ describe('selectResolvedCommand', () => {
         })).toBe('/usr/local/bin/opencode');
     });
 });
+describe('buildOpencodeServeArgs', () => {
+    test('always passes --hostname so opencode.json cannot bind 0.0.0.0', async () => {
+        const { buildOpencodeServeArgs } = await import('./opencode.js');
+        expect(buildOpencodeServeArgs({ port: 4096 })).toEqual([
+            'serve',
+            '--port',
+            '4096',
+            '--hostname',
+            '127.0.0.1',
+            '--print-logs',
+            '--log-level',
+            'WARN',
+        ]);
+    });
+    test('passes --hostname when set', async () => {
+        const { buildOpencodeServeArgs } = await import('./opencode.js');
+        expect(buildOpencodeServeArgs({ port: 4096, hostname: '0.0.0.0' })).toEqual([
+            'serve',
+            '--port',
+            '4096',
+            '--hostname',
+            '0.0.0.0',
+            '--print-logs',
+            '--log-level',
+            'WARN',
+        ]);
+    });
+});
+describe('published runtime artifacts', () => {
+    test('lists @subrouter/opencode as a runtime dependency', () => {
+        const pkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf8'));
+        expect(pkg.dependencies?.['@subrouter/opencode']).toMatch(/^(workspace:\^|\^)/);
+    });
+});
+describe('resolveSubrouterPluginSpec', () => {
+    test('uses npm package identity in production for OpenCode deduplication', async () => {
+        const { resolveSubrouterPluginSpec } = await import('./opencode.js');
+        const require = createRequire(import.meta.url);
+        const packageJsonPath = require.resolve('@subrouter/opencode/package.json');
+        const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version;
+        expect(resolveSubrouterPluginSpec({ isDev: false })).toBe(`@subrouter/opencode@${version}`);
+    });
+    test('loads workspace source directly in development', async () => {
+        const { resolveSubrouterPluginSpec } = await import('./opencode.js');
+        expect(resolveSubrouterPluginSpec({ isDev: true })).toMatch(/^file:.*\/subrouter\/opencode\/dist\/index\.js$/);
+    });
+});
+describe('publicOpencodeBindRequiresPassword', () => {
+    test('allows loopback without a password', async () => {
+        const { publicOpencodeBindRequiresPassword } = await import('./opencode.js');
+        expect(publicOpencodeBindRequiresPassword({ hostname: null })).toBe(false);
+        expect(publicOpencodeBindRequiresPassword({ hostname: '127.0.0.1' })).toBe(false);
+        expect(publicOpencodeBindRequiresPassword({ hostname: 'localhost' })).toBe(false);
+    });
+    test('requires a password for 0.0.0.0', async () => {
+        const { publicOpencodeBindRequiresPassword } = await import('./opencode.js');
+        expect(publicOpencodeBindRequiresPassword({ hostname: '0.0.0.0' })).toBe(true);
+    });
+});
 describe('getSpawnCommandAndArgs', () => {
     test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
         expect(getSpawnCommandAndArgs({

package/dist/opencode-interrupt-plugin.js

@@ -216,6 +216,10 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 return;
             if (output.parts.length === 0)
                 return;
+            // Hidden context notices are not user turns. Subrouter posts these while
+            // a session is already busy; aborting would cancel running subagents.
+            if (output.parts.every((part) => part.type === 'text' && part.ignored === true))
+                return;
             const messageID = input.messageID || output.message.id;
             if (!messageID)
                 return;

package/dist/opencode-interrupt-plugin.test.js

@@ -205,6 +205,30 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
         expect(stub.abortCalls).toEqual([]);
         expect(stub.promptAsyncCalls).toEqual([]);
     });
+    test('ignored context notices do not abort a busy session', async () => {
+        process.env['KIMAKI_INTERRUPT_STEP_TIMEOUT_MS'] = '20';
+        const { chatHook } = await requireHooks();
+        const sessionID = 'ses-oracle';
+        const messageID = 'msg-fallback-notice';
+        stub.setStatus(sessionID, { type: 'busy' });
+        await chatHook({ sessionID, messageID }, createChatOutput({
+            sessionID,
+            messageID,
+            parts: [
+                {
+                    id: 'prt-fallback',
+                    sessionID,
+                    messageID,
+                    type: 'text',
+                    text: 'Subrouter: Using xai/grok-4.6 because openai/gpt-5.6-sol is rate limited.',
+                    ignored: true,
+                },
+            ],
+        }));
+        await delay({ ms: 80 });
+        expect(stub.abortCalls).toEqual([]);
+        expect(stub.promptAsyncCalls).toEqual([]);
+    });
     test('replayed message does not schedule another interrupt (no abort loop)', async () => {
         process.env['KIMAKI_INTERRUPT_STEP_TIMEOUT_MS'] = '20';
         const { chatHook } = await requireHooks();

package/dist/opencode.js

@@ -40,18 +40,32 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
-import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { createOpencodeClient, } from '@opencode-ai/sdk/v2';
 import { restartGlobalEventListener, waitForGlobalEventListener, } from './session-handler/global-event-listener.js';
-import { getDataDir, getLockPort, getRestrictExternalDirectories, } from './config.js';
+import { getDataDir, getLockPort, getRestrictExternalDirectories, getOpencodeHostname, getOpencodePort, } from './config.js';
 import { store } from './store.js';
 import { getHranaUrl } from './hrana-server.js';
+export function resolveSubrouterPluginSpec({ isDev }) {
+    const require = createRequire(import.meta.url);
+    const entry = require.resolve('@subrouter/opencode');
+    if (isDev)
+        return pathToFileURL(entry).href;
+    const packageJsonPath = require.resolve('@subrouter/opencode/package.json');
+    const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version;
+    if (typeof version !== 'string' || !version) {
+        throw new Error(`Missing @subrouter/opencode version in ${packageJsonPath}`);
+    }
+    return `@subrouter/opencode@${version}`;
+}
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
-import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
-import { ensureKimakiCommandShim, getPathEnvKey, getSpawnCommandAndArgs, prependPathEntry, selectResolvedCommand, } from './opencode-command.js';
+import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, OpencodeIncompatibleVersionError, } from './errors.js';
+import { ensureKimakiCommandShim, getIncompatibleOpencodeVersionError, getPathEnvKey, getSpawnCommandAndArgs, prependPathEntry, selectResolvedCommand, } from './opencode-command.js';
+import { execAsync } from './exec-async.js';
 import { computeSkillPermission } from './skill-filter.js';
 const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 /**
@@ -66,6 +80,26 @@ export function getOpencodeServerAuthHeaders() {
     const encoded = Buffer.from(`${username}:${serverPassword}`).toString('base64');
     return { Authorization: `Basic ${encoded}` };
 }
+const LOOPBACK_HOSTNAMES = new Set(['127.0.0.1', 'localhost', '::1']);
+export function publicOpencodeBindRequiresPassword({ hostname, }) {
+    if (!hostname)
+        return false;
+    return !LOOPBACK_HOSTNAMES.has(hostname);
+}
+// Always pass --hostname so opencode.json server.hostname / mdns cannot bind 0.0.0.0.
+const DEFAULT_OPENCODE_HOSTNAME = '127.0.0.1';
+export function buildOpencodeServeArgs({ port, hostname, }) {
+    return [
+        'serve',
+        '--port',
+        port.toString(),
+        '--hostname',
+        hostname || DEFAULT_OPENCODE_HOSTNAME,
+        '--print-logs',
+        '--log-level',
+        'WARN',
+    ];
+}
 // Tracks directories that have been initialized, to avoid repeated log spam
 // from the external sync polling loop.
 const initializedDirectories = new Set();
@@ -89,6 +123,7 @@ export async function requestHealthcheck({ url, timeoutMs = 2000, }) {
             method: 'GET',
             headers: {
                 connection: 'close',
+                ...getOpencodeServerAuthHeaders(),
             },
         }, (res) => {
             const chunks = [];
@@ -337,6 +372,23 @@ export function resolveOpencodeCommand() {
     opencodeLogger.log(`Resolved opencode binary: ${result}`);
     return result;
 }
+export async function assertCompatibleOpencodeVersion({ resolvedCommand = resolveOpencodeCommand(), } = {}) {
+    const { command, args } = getSpawnCommandAndArgs({
+        resolvedCommand,
+        baseArgs: ['--version'],
+    });
+    const result = await execAsync({ command, args }, { timeout: 5000, encoding: 'utf8' }).catch((cause) => {
+        return new Error('Failed to read OpenCode version', { cause });
+    });
+    if (result instanceof Error) {
+        opencodeLogger.warn(result.message);
+        return true;
+    }
+    const incompatible = getIncompatibleOpencodeVersionError(`${result.stdout}\n${result.stderr}`);
+    if (incompatible)
+        return incompatible;
+    return true;
+}
 async function getOpenPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -462,6 +514,9 @@ async function ensureSingleServer({ directory, } = {}) {
             singleServer = discovered;
             return discovered;
         }
+        const compatibility = await assertCompatibleOpencodeVersion();
+        if (compatibility instanceof Error)
+            return compatibility;
         return startSingleServer({ directory: startupDirectory });
     })();
     try {
@@ -473,15 +528,17 @@ async function ensureSingleServer({ directory, } = {}) {
 }
 async function startSingleServer({ directory, } = {}) {
     ensureProcessCleanupHandlersRegistered();
-    const port = await getOpenPort();
-    const serveArgs = [
-        'serve',
-        '--port',
-        port.toString(),
-        '--print-logs',
-        '--log-level',
-        'WARN',
-    ];
+    const configuredPort = getOpencodePort();
+    const port = configuredPort ?? (await getOpenPort());
+    const hostname = getOpencodeHostname() ?? DEFAULT_OPENCODE_HOSTNAME;
+    if (publicOpencodeBindRequiresPassword({ hostname }) &&
+        !process.env.OPENCODE_SERVER_PASSWORD) {
+        return new ServerStartError({
+            port,
+            reason: `OPENCODE_SERVER_PASSWORD is required when --opencode-hostname is ${hostname}`,
+        });
+    }
+    const serveArgs = buildOpencodeServeArgs({ port, hostname });
     const { command: spawnCommand, args: spawnArgs, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
         resolvedCommand: resolveOpencodeCommand(),
         baseArgs: serveArgs,
@@ -552,6 +609,9 @@ async function startSingleServer({ directory, } = {}) {
         formatter: false,
         plugin: [
             new URL(isDev ? './kimaki-opencode-plugin.ts' : './kimaki-opencode-plugin.js', import.meta.url).href,
+            // npm identity lets opencode dedupe a user-installed copy by package
+            // name. Development still loads this workspace's built package directly.
+            resolveSubrouterPluginSpec({ isDev }),
         ],
         permission: {
             edit: 'allow',
@@ -639,6 +699,8 @@ async function startSingleServer({ directory, } = {}) {
             OPENCODE_CONFIG: opencodeConfigPath,
             OPENCODE_PORT: port.toString(),
             KIMAKI: '1',
+            // The browser is not on this machine, so no localhost callback fires.
+            SUBROUTER_MANUAL_OAUTH: '1',
             OPENCODE_EXPERIMENTAL_WORKSPACES: 'true',
             OPENCODE_ENABLE_EXA: '1',
             KIMAKI_DATA_DIR: getDataDir(),
@@ -661,7 +723,7 @@ async function startSingleServer({ directory, } = {}) {
     const logBuffer = [];
     const startupStderrTail = [];
     let serverReady = false;
-    logBuffer.push(`Spawned opencode serve --port ${port} (pid: ${serverProcess.pid})`);
+    logBuffer.push(`Spawned opencode ${serveArgs.join(' ')} (pid: ${serverProcess.pid})`);
     const stdoutReader = subscribeToProcessLogStream({
         stream: serverProcess.stdout,
         onLine: (line) => {
@@ -1058,7 +1120,9 @@ export function extractSdkErrorMessage(error) {
         return 'Unknown OpenCode API error';
     }
     if (error.data?.message) {
-        return error.data.message;
+        const name = error.name ? `${error.name}: ` : '';
+        const ref = error.data.ref ? ` (${error.data.ref})` : '';
+        return `${name}${error.data.message}${ref}`;
     }
     if (error.message) {
         return error.message;
@@ -1069,6 +1133,9 @@ export function extractSdkErrorMessage(error) {
     if (error._tag) {
         return error._tag;
     }
+    if (error.name) {
+        return error.name;
+    }
     return 'Unknown OpenCode API error';
 }
 /**

package/dist/project-add.test.js

@@ -0,0 +1,62 @@
+// Tests that `kimaki project add` refuses a folder already registered locally.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { setDataDir } from './config.js';
+import { closeDb } from './db.js';
+import { findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError, initDatabase, setChannelDirectory, } from './database.js';
+describe('project add duplicate directory', () => {
+    let tmpDir;
+    let projectDir;
+    beforeEach(async () => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-project-add-'));
+        projectDir = path.join(tmpDir, 'repo');
+        fs.mkdirSync(projectDir);
+        setDataDir(path.join(tmpDir, 'data'));
+        await closeDb();
+        await initDatabase();
+    });
+    afterEach(async () => {
+        await closeDb();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    test('returns the existing text channel for a registered folder', async () => {
+        await setChannelDirectory({
+            channelId: '111',
+            directory: projectDir,
+            channelType: 'text',
+        });
+        const existing = await findRegisteredTextChannelForDirectory(projectDir);
+        expect(existing).toMatchObject({
+            channel_id: '111',
+            directory: projectDir,
+            channel_type: 'text',
+        });
+    });
+    test('matches a symlink to the same registered folder', async () => {
+        await setChannelDirectory({
+            channelId: '222',
+            directory: fs.realpathSync(projectDir),
+            channelType: 'text',
+        });
+        const alias = path.join(tmpDir, 'alias');
+        fs.symlinkSync(projectDir, alias);
+        const existing = await findRegisteredTextChannelForDirectory(alias);
+        expect(existing?.channel_id).toBe('222');
+    });
+    test('returns null when the folder is not registered', async () => {
+        const existing = await findRegisteredTextChannelForDirectory(projectDir);
+        expect(existing).toBe(null);
+    });
+    test('error message tells the user how to remove the mapping', () => {
+        expect(formatProjectAlreadyRegisteredError({
+            channelId: '111',
+            directory: '/tmp/repo',
+        })).toMatchInlineSnapshot(`
+      "Channel already exists for this directory: /tmp/repo
+      Channel ID: 111
+      Remove the mapping first: kimaki project remove 111"
+    `);
+    });
+});