kimaki 0.9.0 → 0.9.1

package/dist/cli-commands/user.js

@@ -89,25 +89,25 @@ cli
 });
 cli
     .command('tunnel', 'Expose a local port via tunnel')
-    .option('-p, --port <port>', 'Local port to expose (required)')
+    .option('-p, --port <port>', 'Local port to expose (optional when command output reveals one)')
     .option('-t, --tunnel-id [id]', 'Custom tunnel ID (only for services safe to expose publicly; prefer random default)')
     .option('-h, --host [host]', 'Local host (default: localhost)')
     .option('-s, --server [url]', 'Tunnel server URL')
     .option('-k, --kill', 'Kill any existing process on the port before starting')
     .action(async (options) => {
-    const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import('traforo/run-tunnel');
-    if (!options.port) {
-        cliLogger.error('Error: --port is required');
-        cliLogger.error(`\nUsage: kimaki tunnel -p <port> [-- command]`);
+    const { runTunnel, parseCommandFromArgv } = await import('traforo/run-tunnel');
+    const { command } = parseCommandFromArgv(process.argv);
+    if (!options.port && command.length === 0) {
+        cliLogger.error('Error: --port is required unless a command is provided after --');
+        cliLogger.error(`\nUsage: kimaki tunnel [-- command]`);
+        cliLogger.error(`   or: kimaki tunnel --port <port>`);
         process.exit(EXIT_NO_RESTART);
     }
-    const port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 1 || port > 65535) {
+    const port = options.port ? parseInt(options.port, 10) : undefined;
+    if (options.port && (!port || port < 1 || port > 65535)) {
         cliLogger.error(`Error: Invalid port number: ${options.port}`);
         process.exit(EXIT_NO_RESTART);
     }
-    // Parse command after -- from argv
-    const { command } = parseCommandFromArgv(process.argv);
     await runTunnel({
         port,
         tunnelId: options.tunnelId || undefined,

package/dist/discord-bot.js

@@ -4,7 +4,7 @@
 import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorktree, setWorktreeReady, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
-import { validateWorktreeDirectory, git } from './worktrees.js';
+import { validateWorktreeDirectory, git, isGitRepositoryRoot } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
@@ -634,8 +634,16 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     : stripMentions(message.content || '')
                         .replace(/\s+/g, ' ')
                         .trim() || 'kimaki thread';
-                // Check if worktrees should be enabled (CLI flag OR channel setting)
-                const shouldUseWorktrees = useWorktrees || (await getChannelWorktreesEnabled(channel.id));
+                // Check if worktrees should be enabled (CLI flag OR channel setting).
+                // Only create worktrees from the configured project directory when that
+                // directory is itself the git root. If the user registered a non-git
+                // workspace folder under a larger repo, git would create the worktree
+                // from the parent repo and strand follow-up messages on failure.
+                const wantsWorktrees = useWorktrees || (await getChannelWorktreesEnabled(channel.id));
+                const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+                if (wantsWorktrees && !shouldUseWorktrees) {
+                    discordLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+                }
                 // Add worktree prefix if worktrees are enabled
                 const threadName = shouldUseWorktrees
                     ? `${WORKTREE_PREFIX}${baseThreadName}`
@@ -800,7 +808,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             // The runtime is created immediately so follow-up messages queue
             // naturally; the worktree promise is awaited inside enqueueIncoming.
             let worktreePromise;
-            if (marker.worktree) {
+            if (marker.worktree && (await isGitRepositoryRoot(projectDirectory))) {
                 discordLogger.log(`[BOT_SESSION] Creating worktree: ${marker.worktree}`);
                 const worktreeStatusMessage = await thread
                     .send({
@@ -816,6 +824,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     rest: discordClient.rest,
                 });
             }
+            else if (marker.worktree) {
+                discordLogger.warn(`[BOT_SESSION] Skipping requested worktree for non-git project directory: ${projectDirectory}`);
+            }
             // --cwd: reuse an existing worktree directory. Revalidate at bot-time
             // (CLI validated at send-time but the path could become stale).
             // Store in thread_worktrees as ready with origin=external so

package/dist/onboarding-tutorial.js

@@ -132,7 +132,7 @@ Pick a random port between 3000-9000 to avoid conflicts:
 
 ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
-bunx tuistory launch "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" -s game-dev --cwd "$PWD"
+bunx tuistory launch "PORT=$PORT kimaki tunnel -- bun run server.ts" -s game-dev --cwd "$PWD"
 ${backticks}
 
 Wait a moment, then get the tunnel URL:

package/dist/system-message.js

@@ -136,11 +136,11 @@ Use a tuistory session with a descriptive name like \`projectname-dev\` so you c
 
 Use random tunnel IDs by default. Only pass \`-t\` when exposing a service that is safe to be publicly discoverable.
 
-\`kimaki tunnel\` injects \`TRAFORO_URL\` into the child process. Prefer wiring your app to that URL so OAuth callbacks, webhook URLs, and absolute links use the public tunnel instead of localhost.
+\`kimaki tunnel\` injects \`TRAFORO_URL\` into the child process. Prefer wiring your app to that URL so OAuth callbacks, webhook URLs, and absolute links use the public tunnel instead of localhost. The local port is detected from the child process output, so do not pass \`-p\` when launching a dev server command unless detection fails.
 
 \`\`\`bash
 # Start the dev server in a named background session
-bunx tuistory launch "kimaki tunnel -p 3000 -- pnpm dev" -s myapp-dev
+bunx tuistory launch "kimaki tunnel -- pnpm dev" -s myapp-dev
 
 # Wait until the dev server prints something useful, then inspect it
 bunx tuistory -s myapp-dev wait "/ready|local|tunnel/i" --timeout 30000
@@ -149,7 +149,7 @@ bunx tuistory read -s myapp-dev
 
 ### passing the public URL to your app
 
-If you launch the server command through \`kimaki tunnel -- ...\`, the local port is auto-detected from the child process logs in many common dev-server setups, so \`--port\` is often unnecessary.
+If you launch the server command through \`kimaki tunnel -- ...\`, the local port is auto-detected from the child process logs in many common dev-server setups. Use \`--port\` only when the dev server does not print a detectable localhost URL or port line.
 
 \`\`\`bash
 # Your app can read process.env.TRAFORO_URL directly
@@ -176,13 +176,13 @@ bunx tuistory read -s myapp-dev
 
 \`\`\`bash
 # Next.js project
-bunx tuistory launch "kimaki tunnel -p 3000 -- pnpm dev" -s projectname-nextjs-dev-3000
+bunx tuistory launch "kimaki tunnel -- pnpm dev" -s projectname-nextjs-dev
 
-# Vite project on port 5173
-bunx tuistory launch "kimaki tunnel -p 5173 -- pnpm dev" -s vite-dev-5173
+# Vite project
+bunx tuistory launch "kimaki tunnel -- pnpm dev" -s vite-dev
 
 # Custom tunnel ID (only for intentionally public-safe services)
-bunx tuistory launch "kimaki tunnel -p 3000 -t holocron -- pnpm dev" -s holocron-dev
+bunx tuistory launch "kimaki tunnel -t holocron -- pnpm dev" -s holocron-dev
 \`\`\`
 
 ### stopping the dev server

package/dist/system-message.test.js

@@ -87,23 +87,26 @@ describe('system-message', () => {
 
       Only do this when the user explicitly asks to close or archive the thread, and only after your final message.
 
-      ## searching discord users
+      ## discord user mentions
 
-      To search for Discord users in a guild (needed for mentions like <@userId>), run:
+      Prefer Discord user IDs for mentions. Discord bots cannot ping by @name; use \`<@userId>\` in message text or pass the ID to \`--user\`.
+      The current user's ID is available in the per-turn \`<discord-user ... user-id="..." />\` metadata.
+
+      To search for Discord users in a guild as a best-effort fallback, run:
 
       kimaki user list --guild guild_123 --query "username"
 
-      This returns user IDs you can use for Discord mentions.
+      This returns user IDs you can use for Discord mentions. It can fail when Server Members Intent is disabled, so prefer IDs from existing Discord metadata or raw mentions when possible.
 
       ## starting new sessions from CLI
 
       To start a new thread/session in this channel pro-grammatically, run:
 
-      kimaki send --channel chan_123 --prompt 'your prompt here' --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'your prompt here' --agent <current_agent> --user '<discord-user-id>'
 
       You can use this to "spawn" parallel helper sessions like teammates: start new threads with focused prompts, then come back and collect the results.
       Prefer passing the current agent with \`--agent <current_agent>\` so spawned or scheduled sessions keep the same agent unless you are intentionally switching. Replace \`<current_agent>\` with the value from the per-turn \`Current agent\` reminder.
-      When writing \`kimaki send\` shell commands, use single quotes around \`--prompt\`, \`--user\`, \`--send-at\`, and other literal arguments so backticks inside prompts are not interpreted by the shell.
+      When writing \`kimaki send\` shell commands, use single quotes around \`--prompt\`, \`--user\`, \`--send-at\`, and other literal arguments so backticks inside prompts are not interpreted by the shell. Prefer \`--user '<discord-user-id>'\` over \`--user 'name'\` because name lookup depends on optional Server Members Intent.
 
       IMPORTANT: NEVER use \`--worktree\` unless the user explicitly asks for a worktree. Default to creating normal threads without worktrees.
 
@@ -121,19 +124,19 @@ describe('system-message', () => {
 
       Use --notify-only to create a notification thread without starting an AI session:
 
-      kimaki send --channel chan_123 --prompt 'User cancelled subscription' --notify-only --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'User cancelled subscription' --notify-only --agent <current_agent> --user '<discord-user-id>'
 
-      Use --user to add a specific Discord user to the new thread:
+      Use --user with a Discord user ID or raw mention to add a specific Discord user to the new thread:
 
-      kimaki send --channel chan_123 --prompt 'Review the latest CI failure' --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Review the latest CI failure' --agent <current_agent> --user '<discord-user-id>'
 
       Use --worktree to create a git worktree for the session (ONLY when the user explicitly asks for a worktree):
 
-      kimaki send --channel chan_123 --prompt 'Add dark mode support' --worktree dark-mode --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Add dark mode support' --worktree dark-mode --agent <current_agent> --user '<discord-user-id>'
 
       Use --cwd to start a session in an existing git worktree directory (must be a worktree of the project):
 
-      kimaki send --channel chan_123 --prompt 'Continue work on feature' --cwd /path/to/existing-worktree --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Continue work on feature' --cwd /path/to/existing-worktree --agent <current_agent> --user '<discord-user-id>'
 
       Important:
       - NEVER use \`--worktree\` unless the user explicitly requests a worktree. Most tasks should use normal threads without worktrees.
@@ -144,7 +147,7 @@ describe('system-message', () => {
 
       Use --agent to specify which agent to use for the session:
 
-      kimaki send --channel chan_123 --prompt 'Plan the refactor of the auth module' --agent plan --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Plan the refactor of the auth module' --agent plan --user '<discord-user-id>'
 
 
       Available agents:
@@ -156,7 +159,7 @@ describe('system-message', () => {
       You can trigger registered opencode commands (slash commands, skills, MCP prompts) by starting the \`--prompt\` with \`/commandname\`:
 
       kimaki send --thread <thread_id> --prompt '/review fix the auth module' --agent <current_agent>
-      kimaki send --channel chan_123 --prompt '/build-cmd update dependencies' --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt '/build-cmd update dependencies' --agent <current_agent> --user '<discord-user-id>'
 
       The command name must match a registered opencode command. If the command is not recognized, the prompt is sent as plain text to the model. This works for both new threads (\`--channel\`) and existing threads (\`--thread\`/\`--session\`).
 
@@ -172,8 +175,8 @@ describe('system-message', () => {
 
       Use \`--send-at\` to schedule a one-time or recurring task:
 
-      kimaki send --channel chan_123 --prompt 'Reminder: review open PRs' --send-at '2026-03-01T09:00:00Z' --agent <current_agent> --user 'Tommy'
-      kimaki send --channel chan_123 --prompt 'Run weekly test suite and summarize failures' --send-at '0 9 * * 1' --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Reminder: review open PRs' --send-at '2026-03-01T09:00:00Z' --agent <current_agent> --user '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Run weekly test suite and summarize failures' --send-at '0 9 * * 1' --agent <current_agent> --user '<discord-user-id>'
 
       ALL scheduling is in UTC. Dates must be UTC ISO format ending with \`Z\`. Cron expressions also fire in UTC (e.g. \`0 9 * * 1\` means 9:00 UTC every Monday).
       When the user specifies a time without a timezone, ask them to confirm their timezone or the UTC equivalent. Never guess the user's timezone.
@@ -231,7 +234,7 @@ describe('system-message', () => {
       When the user asks to "create a worktree" or "make a worktree", they mean you should use the kimaki CLI to create it. Do NOT use raw \`git worktree add\` commands. Instead use:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt 'your task description' --worktree worktree-name --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'your task description' --worktree worktree-name --agent <current_agent> --user '<discord-user-id>'
       \`\`\`
 
       This creates a new Discord thread with an isolated git worktree and starts a session in it. The worktree name should be kebab-case and descriptive of the task.
@@ -247,7 +250,7 @@ describe('system-message', () => {
       Use \`--cwd\` to start a session in an existing git worktree directory instead of creating a new one:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt 'Continue work on feature X' --cwd /path/to/existing-worktree --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Continue work on feature X' --cwd /path/to/existing-worktree --agent <current_agent> --user '<discord-user-id>'
       \`\`\`
 
       The path must be a git worktree of the project (validated via \`git worktree list\`). The session resolves to the correct project channel but uses the worktree as its working directory. Use \`--worktree\` to create a new worktree, \`--cwd\` to reuse an existing one.
@@ -261,7 +264,7 @@ describe('system-message', () => {
       When you are approaching the **context window limit** or the user explicitly asks to **handoff to a new thread**, use the \`kimaki send\` command to start a fresh session with context:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent> --user 'Tommy'
+      kimaki send --channel chan_123 --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent> --user '<discord-user-id>'
       \`\`\`
 
       The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
@@ -494,11 +497,11 @@ describe('system-message', () => {
 
       Use random tunnel IDs by default. Only pass \`-t\` when exposing a service that is safe to be publicly discoverable.
 
-      \`kimaki tunnel\` injects \`TRAFORO_URL\` into the child process. Prefer wiring your app to that URL so OAuth callbacks, webhook URLs, and absolute links use the public tunnel instead of localhost.
+      \`kimaki tunnel\` injects \`TRAFORO_URL\` into the child process. Prefer wiring your app to that URL so OAuth callbacks, webhook URLs, and absolute links use the public tunnel instead of localhost. The local port is detected from the child process output, so do not pass \`-p\` when launching a dev server command unless detection fails.
 
       \`\`\`bash
       # Start the dev server in a named background session
-      bunx tuistory launch "kimaki tunnel -p 3000 -- pnpm dev" -s myapp-dev
+      bunx tuistory launch "kimaki tunnel -- pnpm dev" -s myapp-dev
 
       # Wait until the dev server prints something useful, then inspect it
       bunx tuistory -s myapp-dev wait "/ready|local|tunnel/i" --timeout 30000
@@ -507,7 +510,7 @@ describe('system-message', () => {
 
       ### passing the public URL to your app
 
-      If you launch the server command through \`kimaki tunnel -- ...\`, the local port is auto-detected from the child process logs in many common dev-server setups, so \`--port\` is often unnecessary.
+      If you launch the server command through \`kimaki tunnel -- ...\`, the local port is auto-detected from the child process logs in many common dev-server setups. Use \`--port\` only when the dev server does not print a detectable localhost URL or port line.
 
       \`\`\`bash
       # Your app can read process.env.TRAFORO_URL directly
@@ -534,13 +537,13 @@ describe('system-message', () => {
 
       \`\`\`bash
       # Next.js project
-      bunx tuistory launch "kimaki tunnel -p 3000 -- pnpm dev" -s projectname-nextjs-dev-3000
+      bunx tuistory launch "kimaki tunnel -- pnpm dev" -s projectname-nextjs-dev
 
-      # Vite project on port 5173
-      bunx tuistory launch "kimaki tunnel -p 5173 -- pnpm dev" -s vite-dev-5173
+      # Vite project
+      bunx tuistory launch "kimaki tunnel -- pnpm dev" -s vite-dev
 
       # Custom tunnel ID (only for intentionally public-safe services)
-      bunx tuistory launch "kimaki tunnel -p 3000 -t holocron -- pnpm dev" -s holocron-dev
+      bunx tuistory launch "kimaki tunnel -t holocron -- pnpm dev" -s holocron-dev
       \`\`\`
 
       ### stopping the dev server

package/dist/voice-message.e2e.test.js

@@ -689,6 +689,13 @@ e2eTest('voice message handling', () => {
             transcription: 'Queue this task for later',
             queueMessage: true,
         });
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'using deterministic-provider/deterministic-v2',
+            timeout: 4_000,
+        });
         await th.user(TEST_USER_ID).sendVoiceMessage();
         // 3. Transcription should appear, followed by queue notification
         await waitForBotMessageContaining({

package/dist/worktree-lifecycle.e2e.test.js

@@ -17,13 +17,14 @@ import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
 import { getRuntime } from './session-handler/thread-session-runtime.js';
-import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelWorktreesEnabled, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
 import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
 import { execAsync } from './worktrees.js';
 const TEST_USER_ID = '200000000000000901';
 const TEXT_CHANNEL_ID = '200000000000000902';
+const NON_GIT_CHANNEL_ID = '200000000000000903';
 // Unique worktree name per run to avoid collisions with leftover worktrees
 const WORKTREE_SUFFIX = Date.now().toString(36).slice(-6);
 const WORKTREE_NAME = `wt-e2e-${WORKTREE_SUFFIX}`;
@@ -32,8 +33,10 @@ function createRunDirectories() {
     fs.mkdirSync(root, { recursive: true });
     const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
     const projectDirectory = path.join(root, 'project');
+    const nonGitDirectory = path.join(root, 'non-git-project');
     fs.mkdirSync(projectDirectory, { recursive: true });
-    return { root, dataDir, projectDirectory };
+    fs.mkdirSync(nonGitDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory, nonGitDirectory };
 }
 function createDiscordJsClient({ restUrl }) {
     return new Client({
@@ -77,7 +80,7 @@ function createDeterministicMatchers() {
         priority: 10,
         when: {
             lastMessageRole: 'user',
-            rawPromptIncludes: 'Reply with exactly:',
+            latestUserTextIncludes: 'Reply with exactly:',
         },
         then: {
             parts: [
@@ -122,6 +125,11 @@ describe('worktree lifecycle', () => {
                     name: 'worktree-e2e',
                     type: ChannelType.GuildText,
                 },
+                {
+                    id: NON_GIT_CHANNEL_ID,
+                    name: 'non-git-worktree-e2e',
+                    type: ChannelType.GuildText,
+                },
             ],
             users: [
                 {
@@ -146,6 +154,7 @@ describe('worktree lifecycle', () => {
             },
         });
         fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        fs.writeFileSync(path.join(directories.nonGitDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
         // Initialize git repo after writing opencode.json so the initial commit
         // includes it. Worktrees require at least one commit.
         await initGitRepo(directories.projectDirectory);
@@ -162,7 +171,14 @@ describe('worktree lifecycle', () => {
             directory: directories.projectDirectory,
             channelType: 'text',
         });
+        await setChannelDirectory({
+            channelId: NON_GIT_CHANNEL_ID,
+            directory: directories.nonGitDirectory,
+            channelType: 'text',
+        });
         await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools_and_text');
+        await setChannelVerbosity(NON_GIT_CHANNEL_ID, 'tools_and_text');
+        await setChannelWorktreesEnabled(NON_GIT_CHANNEL_ID, true);
         botClient = createDiscordJsClient({ restUrl: discord.restUrl });
         await startDiscordBot({
             token: discord.botToken,
@@ -213,7 +229,11 @@ describe('worktree lifecycle', () => {
                 }
             }).catch(() => { return; });
             await execAsync(`git branch -D ${JSON.stringify(`opencode/kimaki-${WORKTREE_NAME}`)}`, { cwd: directories.projectDirectory }).catch(() => { return; });
-            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+            fs.rmSync(directories.dataDir, {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+            });
         }
     }, 5_000);
     test('session responds after /new-worktree switches sdkDirectory in existing thread', async () => {
@@ -308,4 +328,60 @@ describe('worktree lifecycle', () => {
         const okCount = (text.match(/⬥ ok/g) || []).length;
         expect(okCount).toBe(2);
     }, 30_000);
+    test('auto-worktrees fall back to normal sessions outside git repositories', async () => {
+        await discord.channel(NON_GIT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: non-git-first',
+        });
+        const thread = await discord.channel(NON_GIT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return Boolean(t.name?.includes('Reply with exactly: non-git-first'));
+            },
+        });
+        const th = discord.thread(thread.id);
+        await waitForBotReplyAfterUserMessage({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'non-git-first',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: non-git-second',
+        });
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '⬥ ok',
+            afterUserMessageIncludes: 'non-git-second',
+            timeout: 4_000,
+        });
+        let text = await th.text();
+        for (let attempt = 0; attempt < 40; attempt++) {
+            if ((text.match(/⬥ ok/g) || []).length >= 2) {
+                break;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 100);
+            });
+            text = await th.text();
+        }
+        expect(text).toMatchInlineSnapshot(`
+        "--- from: user (worktree-tester)
+        Reply with exactly: non-git-first
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        --- from: user (worktree-tester)
+        Reply with exactly: non-git-second
+        --- from: assistant (TestBot)
+        ⬥ ok
+        ⬥ ok"
+      `);
+        expect(text).toContain('Reply with exactly: non-git-first');
+        expect(text).toContain('Reply with exactly: non-git-second');
+        expect(text).not.toContain('Worktree creation failed');
+        const okCount = (text.match(/⬥ ok/g) || []).length;
+        expect(okCount).toBe(2);
+    }, 20_000);
 });

package/dist/worktrees.js

@@ -574,6 +574,13 @@ export async function isDirty(dir, opts) {
     }
     return status.length > 0;
 }
+export async function isGitRepositoryRoot(directory) {
+    const topLevel = await git(directory, 'rev-parse --show-toplevel');
+    if (topLevel instanceof Error) {
+        return false;
+    }
+    return path.resolve(topLevel) === path.resolve(directory);
+}
 async function getGitCommonDir(dir) {
     const commonDir = await git(dir, 'rev-parse --git-common-dir');
     if (commonDir instanceof Error) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -26,8 +26,8 @@
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.0",
-    "opencode-deterministic-provider": "^0.0.1",
     "opencode-cached-provider": "^0.0.1",
+    "opencode-deterministic-provider": "^0.0.1",
     "db": "^0.0.0"
   },
   "dependencies": {
@@ -65,9 +65,9 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
-    "opencode-injection-guard": "^0.2.1",
     "libsqlproxy": "^0.1.0",
-    "traforo": "^0.5.0"
+    "traforo": "^0.5.0",
+    "opencode-injection-guard": "^0.2.1"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",