kimaki 0.20.1 → 0.22.0

package/dist/system-message.test.js

@@ -14,6 +14,32 @@ describe('system-message', () => {
         expect(message).toContain('- failed commands');
         expect(message).toContain('<callout accent="#f59e0b">');
     });
+    test('includes parent session context when parentSessionId is set', () => {
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_child',
+            channelId: 'chan_123',
+            parentSessionId: 'ses_parent',
+        });
+        expect(message).toContain('Your parent OpenCode session ID is: ses_parent');
+        expect(message).toContain("kimaki send --session ses_parent --prompt 'your update here' --agent <current_agent>");
+        expect(message).toContain('Do NOT message the parent session unless the user explicitly asks you to.');
+        expect(message).toContain('--parent-session ses_child');
+    });
+    test('omits parent session system block by default (btw/task/fork cache)', () => {
+        // /btw, task subagents, and normal sessions must not get a parent block in
+        // the system message. That block is opt-in via --parent-session only.
+        const message = getOpencodeSystemMessage({
+            sessionId: 'ses_btw_or_task',
+            channelId: 'chan_123',
+            threadId: 'thread_123',
+            guildId: 'guild_123',
+        });
+        expect(message).not.toContain('Your parent OpenCode session ID is:');
+        expect(message).not.toContain('Do NOT message the parent session unless the user explicitly asks you to.');
+        // Spawn examples still mention --parent-session for agents that start
+        // children via kimaki send; that is not the same as injecting a parent.
+        expect(message).toContain('--parent-session ses_btw_or_task');
+    });
     test('keeps the system prompt session-scoped', () => {
         const message = getOpencodeSystemMessage({
             sessionId: 'ses_123',
@@ -111,7 +137,7 @@ describe('system-message', () => {
 
       To archive the current Discord thread (hide it from sidebar) and stop the session, run:
 
-      kimaki session archive --session ses_123
+      kimaki session archive thread_123 (or --session ses_123)
 
       Only do this when the user explicitly asks to close or archive the thread, and only after your final message.
 
@@ -139,9 +165,10 @@ describe('system-message', () => {
 
       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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'your prompt here' --agent <current_agent> --parent-session ses_123 --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.
+      ALWAYS pass \`--parent-session ses_123\` (your current session ID) when starting a new session from this one. The child system message will include the parent session ID so it can message back only if the user asks.
       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. Prefer \`--user '<discord-user-id>'\` over \`--user 'name'\` because name lookup depends on optional Server Members Intent.
 
@@ -155,13 +182,13 @@ describe('system-message', () => {
 
       kimaki send --thread <thread_id> --prompt 'follow-up prompt' --agent <current_agent>
 
-      Use this when you already have the Discord thread ID.
+      Use this when you already have the Discord thread ID. Prefer \`--thread\` over \`--session\` because thread IDs work across machines while session IDs only resolve on the machine that created the session.
 
-      To send to the thread associated with a known session:
+      To send to the thread associated with a known session (same machine only):
 
       kimaki send --session <session_id> --prompt 'follow-up prompt' --agent <current_agent>
 
-      Use this when you have the OpenCode session ID.
+      Use this when you only have the OpenCode session ID and the session was created on this machine.
 
       Use --notify-only to create a notification thread without starting an AI session:
 
@@ -169,26 +196,32 @@ describe('system-message', () => {
 
       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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Review the latest CI failure' --agent <current_agent> --parent-session ses_123 --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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Add dark mode support' --worktree dark-mode --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
 
       Use --cwd to start a session in an existing project subfolder or git worktree directory:
 
-      kimaki send --channel chan_123 --prompt 'Run the restricted task' --cwd /path/to/project/restricted-task --agent <current_agent> --user '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Run the restricted task' --cwd /path/to/project/restricted-task --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
 
       Important:
+      - ALWAYS pass \`--parent-session ses_123\` when spawning a new session from this one so the child knows who started it.
       - NEVER use \`--worktree\` unless the user explicitly requests a worktree. Most tasks should use normal threads without worktrees.
       - Use \`--cwd\` to reuse an existing project subfolder or worktree directory. Use \`--worktree\` to create a new worktree.
       - The prompt passed to \`--worktree\` is the task for the new thread running inside that worktree.
       - Do NOT tell that prompt to "create a new worktree" again, or it can create recursive worktree threads.
       - Ask the new session to operate on its current checkout only (e.g. "validate current worktree", "run checks in this repo").
 
+      Use --file to attach local files (images, text files, PDFs) to the message:
+
+      kimaki send --channel chan_123 --prompt 'Review this screenshot' --file /path/to/screenshot.png --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
+      kimaki send --thread <thread_id> --prompt 'Here is the error log' --file ./error.log --file ./stack-trace.txt --agent <current_agent>
+
       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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Plan the refactor of the auth module' --agent plan --parent-session ses_123 --user '<discord-user-id>'
 
 
       Available agents:
@@ -200,7 +233,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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt '/build-cmd update dependencies' --agent <current_agent> --parent-session ses_123 --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\`).
 
@@ -216,8 +249,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 '<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>'
+      kimaki send --channel chan_123 --prompt 'Reminder: review open PRs' --send-at '2026-03-01T09:00:00Z' --agent <current_agent> --parent-session ses_123 --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> --parent-session ses_123 --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.
@@ -226,6 +259,7 @@ describe('system-message', () => {
       - \`--notify-only\` to create a reminder thread without auto-starting a session
       - \`--worktree\` to create the scheduled thread as a worktree session (only if the user explicitly asks for a worktree)
       - \`--agent\` and \`--model\` to control scheduled session behavior
+      - \`--parent-session\` to pass this session as parent of the scheduled child
       - \`--user\` to add a specific user to the scheduled thread
 
       \`--wait\` is incompatible with \`--send-at\` because scheduled tasks run in the future.
@@ -241,7 +275,7 @@ describe('system-message', () => {
       - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
       - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
       - If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
-      - Example no-op cleanup command: \`kimaki session archive --session ses_123\`
+      - Example no-op cleanup command: \`kimaki session archive thread_123 (or --session ses_123)\`
 
       Manage scheduled tasks with:
 
@@ -257,10 +291,10 @@ describe('system-message', () => {
       - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention the user via Discord ID only when failures require review".
       - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
       - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
-      - Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive --session ses_123\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
+      - Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive thread_123 (or --session ses_123)\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
       - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
-      kimaki send --session ses_123 --prompt 'Reminder: <@USER_ID> you asked to be reminded about this thread.' --send-at '<future_UTC_time>' --notify-only --agent <current_agent>
+      kimaki send --thread thread_123 (or --session ses_123) --prompt 'Reminder: <@USER_ID> you asked to be reminded about this thread.' --send-at '<future_UTC_time>' --notify-only --agent <current_agent>
 
       Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp. The \`--notify-only\` flag creates just a notification message without starting a new AI session. The \`<@userId>\` mention ensures the user gets a Discord notification.
 
@@ -275,7 +309,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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'your task description' --worktree worktree-name --agent <current_agent> --parent-session ses_123 --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.
@@ -291,7 +325,7 @@ describe('system-message', () => {
       Use \`--cwd\` to start a session in an existing project subfolder or git worktree directory instead of the project root:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt 'Run restricted task X' --cwd /path/to/project/restricted-task --agent <current_agent> --user '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Run restricted task X' --cwd /path/to/project/restricted-task --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
       \`\`\`
 
       The path must be inside the project or be a git worktree of the project (validated via \`git worktree list\`). The session resolves to the correct project channel but uses that path as its working directory, so subfolder \`opencode.json\` config can apply. Passing the project root itself is allowed and behaves like the default. Use \`--worktree\` to create a new worktree, \`--cwd\` to reuse an existing directory.
@@ -305,7 +339,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 '<discord-user-id>'
+      kimaki send --channel chan_123 --prompt 'Continuing from previous session: <summary of current task and state>' --agent <current_agent> --parent-session ses_123 --user '<discord-user-id>'
       \`\`\`
 
       The command automatically handles long prompts (over 2000 chars) by sending them as file attachments. With \`--notify-only\`, long prompts are split into multiple messages instead so the content is directly visible.
@@ -347,7 +381,7 @@ describe('system-message', () => {
 
       When the user references another project by name, run \`kimaki project list\` to find its directory path and channel ID. Then read files, search code, or run commands directly in that directory. If the project is not listed, use \`kimaki project add /path/to/repo\` to register it and create a Discord channel for it. Do not add subfolders of an existing project — only add root project directories.
 
-      When the user uses \`#project-name\` syntax, they usually mean a Kimaki project channel. Use \`kimaki project list --json\` to resolve the \`channel_name\` to its repo working directory. Try the lookup yourself before acting, for example filter by \`channel_name\` with jq: \`kimaki project list --json | jq -r '.[] | select(.channel_name == "project-name") | .directory'\`.
+      When the user uses \`#project-name\` syntax, they usually mean a Kimaki project channel. Use \`kimaki project list --json\` to resolve the \`channel_name\` to its repo working directory. The JSON output includes \`guild_id\` and \`guild_name\` to distinguish channels with the same name across different servers. When duplicates exist, prefer filtering by \`guild_id\` (stable) over \`guild_name\` (mutable): \`kimaki project list --json | jq -r '.[] | select(.channel_name == "project-name" and .guild_id == "123456") | .channel_id'\`.
 
       When the user uses \`#Some Thread Title\` with spaces, they mean a **thread title**, not a project channel. Find the session by searching across projects, then read the session markdown:
 
@@ -362,16 +396,25 @@ describe('system-message', () => {
       If you don't know which project the thread belongs to, try each project from \`kimaki project list --json\`.
 
       \`\`\`bash
-      # List all registered projects with their channel IDs
+      # List all registered projects with their channel IDs and guild names
       kimaki project list
-      kimaki project list --json  # machine-readable output
-      kimaki project list --json | jq -r '.[] | select(.channel_name == "project-name") | .directory'
+      kimaki project list --json  # machine-readable output with guild_id, guild_name, is_local
+
+      # Include projects from other machines (scans Kimaki category in Discord)
+      kimaki project list --all
+      kimaki project list --all --json  # remote projects have is_local: false and directory: null
+
+      # Resolve by channel name (prefer adding guild_name filter if duplicates exist)
+      kimaki project list --json | jq -r '.[] | select(.channel_name == "project-name") | .channel_id + " " + .guild_name + " " + .directory'
 
       # Create a new project in ~/.kimaki/projects/<name> (folder + git init + Discord channel)
       kimaki project create my-new-app
 
       # Add an existing directory as a project
       kimaki project add /path/to/repo
+
+      # Remove a stale or duplicate channel mapping (local DB only, does not delete Discord channel)
+      kimaki project remove <channel_id>
       \`\`\`
 
       To send a task to another project:
@@ -501,45 +544,6 @@ describe('system-message', () => {
       reassure them: their data is safe, URLs are unique and not indexed, and they can disable
       this feature by restarting kimaki with the \`--no-critique\` flag.
 
-      ### reviewing diffs with AI
-
-      \`bunx critique review --web\` generates an AI-powered review of a diff and uploads it as a shareable URL.
-      It spawns a separate opencode session that analyzes the diff, groups related changes, and produces
-      a structured review with explanations, diagrams, and suggestions. This is useful when the user
-      asks you to explain or review a diff — the output is much richer than a plain diff URL.
-
-      **WARNING: This command is very slow (up to 20 minutes for large diffs).** Only run it when the
-      user explicitly asks for a code review or diff explanation. Always warn the user it will take
-      a while before running it. Set Bash tool timeout to at least 25 minutes (\`timeout: 1_500_000\`).
-
-      Always pass \`--agent opencode\` and \`--session ses_123\` so the reviewer has context about
-      why the changes were made. If you know other session IDs that produced the diff (e.g. from
-      \`kimaki session list\` or from the thread history), pass them too with additional \`--session\` flags.
-
-      Examples:
-
-      \`\`\`bash
-      # Review working tree changes
-      bunx critique review --web --agent opencode --session ses_123
-
-      # Review staged changes
-      bunx critique review --staged --web --agent opencode --session ses_123
-
-      # Review a specific commit
-      bunx critique review --commit HEAD --web --agent opencode --session ses_123
-
-      # Review branch changes compared to main
-      bunx critique review main...HEAD --web --agent opencode --session ses_123
-
-      # Review with multiple session contexts (current + the session that made the changes)
-      bunx critique review --commit abc1234 --web --agent opencode --session ses_123 --session ses_other_session_id
-
-      # Review only specific files
-      bunx critique review --web --agent opencode --session ses_123 --filter "src/**/*.ts"
-      \`\`\`
-
-      The command prints a preview URL when done — share that URL with the user.
-
 
       ## running dev servers with tunnel access
 

package/dist/task-runner.js

@@ -2,7 +2,7 @@
 import { Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
 import YAML from 'yaml';
-import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, markScheduledTaskOneShotCompleted, recoverStaleRunningScheduledTasks, } from './database.js';
+import { claimScheduledTaskRunning, getDuePlannedScheduledTasks, getScheduledTask, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, markScheduledTaskOneShotCompleted, recoverStaleRunningScheduledTasks, } from './database.js';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 import { getNextCronRun, getPromptPreview, parseScheduledTaskPayload, } from './task-schedule.js';
@@ -32,6 +32,7 @@ async function executeThreadScheduledTask({ rest, task, payload, }) {
         ...(payload.injectionGuardPatterns?.length
             ? { injectionGuardPatterns: payload.injectionGuardPatterns }
             : {}),
+        ...(payload.parentSessionId ? { parentSessionId: payload.parentSessionId } : {}),
     };
     const embed = [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }];
     // Newline between prefix and prompt so leading /command detection can
@@ -69,6 +70,7 @@ async function executeChannelScheduledTask({ rest, task, payload, }) {
             ...(payload.injectionGuardPatterns?.length
                 ? { injectionGuardPatterns: payload.injectionGuardPatterns }
                 : {}),
+            ...(payload.parentSessionId ? { parentSessionId: payload.parentSessionId } : {}),
         };
     const embeds = marker
         ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }]
@@ -211,7 +213,7 @@ async function processDueTask({ rest, task, }) {
         startedAt,
     });
     if (!claimed) {
-        return;
+        return { kind: 'skipped' };
     }
     const executeResult = await executeScheduledTask({ rest, task });
     const finishedAt = new Date();
@@ -222,9 +224,22 @@ async function processDueTask({ rest, task, }) {
             failedAt: finishedAt,
             error: executeResult,
         });
-        return;
+        return { kind: 'failed', error: executeResult };
     }
     await finalizeSuccessfulTask({ task, completedAt: finishedAt });
+    return { kind: 'success' };
+}
+// Same claim → execute → finalize path as the poller. Used by /tasks Run now.
+export async function runScheduledTaskNow({ token, taskId, }) {
+    const task = await getScheduledTask(taskId);
+    if (!task) {
+        return new Error(`Task #${taskId} not found`);
+    }
+    if (task.status !== 'planned') {
+        return new Error(`Task #${taskId} is ${task.status}; only planned tasks can be run now`);
+    }
+    const rest = createDiscordRest(token);
+    return processDueTask({ rest, task });
 }
 async function runTaskRunnerTick({ rest, staleRunningMs, dueBatchSize, }) {
     const staleBefore = new Date(Date.now() - staleRunningMs);

package/dist/task-schedule.js

@@ -144,6 +144,7 @@ export function parseScheduledTaskPayload(payloadJson) {
         const userId = asString(parsed.userId);
         const permissions = asStringArray(parsed.permissions);
         const injectionGuardPatterns = asStringArray(parsed.injectionGuardPatterns);
+        const parentSessionId = asString(parsed.parentSessionId);
         if (!threadId || !prompt) {
             return new Error('Thread task payload requires threadId and prompt');
         }
@@ -157,6 +158,7 @@ export function parseScheduledTaskPayload(payloadJson) {
             userId,
             permissions,
             injectionGuardPatterns,
+            parentSessionId,
         };
     }
     if (kind === 'channel') {
@@ -173,6 +175,7 @@ export function parseScheduledTaskPayload(payloadJson) {
         const userId = asString(parsed.userId);
         const permissions = asStringArray(parsed.permissions);
         const injectionGuardPatterns = asStringArray(parsed.injectionGuardPatterns);
+        const parentSessionId = asString(parsed.parentSessionId);
         if (!channelId || !prompt) {
             return new Error('Channel task payload requires channelId and prompt');
         }
@@ -190,6 +193,7 @@ export function parseScheduledTaskPayload(payloadJson) {
             userId,
             permissions,
             injectionGuardPatterns,
+            parentSessionId,
         };
     }
     return new Error('Task payload has unknown kind');

package/dist/thread-message-queue.e2e.test.js

@@ -1135,8 +1135,8 @@ e2eTest('thread message queue ordering', () => {
             },
         });
         const th = discord.thread(thread.id);
-        // 2. While session is busy (race-final has 500ms delay), queue a message
-        // with queue suffix. The queue suffix forces local-queue mode.
+        // 2. Wait until the bot has replied, then queue while the slow stream is busy.
+        await th.waitForBotReply({ timeout: 4_000 });
         const queuedMsg = await th.user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: original-queued. queue',
         });
@@ -1200,7 +1200,7 @@ e2eTest('thread message queue ordering', () => {
         --- from: user (queue-tester)
         Reply with exactly: edited-queued. queue
         --- from: assistant (TestBot)
-        Queued at position 1. Edit your message to update it in queue
+        Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-tester** edited queued message
         ⬥ slow-busy-reply
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
@@ -1293,7 +1293,7 @@ e2eTest('thread message queue ordering', () => {
         --- from: user (queue-tester)
         Reply with exactly: will-be-removed
         --- from: assistant (TestBot)
-        Queued at position 1. Edit your message to update it in queue
+        Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-tester** removed message from queue
         ⬥ slow-busy-reply
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"

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

@@ -779,7 +779,7 @@ e2eTest('voice message handling', () => {
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Queue this task for later
-        Queued at position 1. Edit your message to update it in queue
+        Queued at position 1. Edit or delete your message to update the queue
         ⬥ slow-response-done
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         » **voice-tester:** Voice message transcription from Discord user:

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

@@ -9,7 +9,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 import { describe, beforeAll, afterAll, test, expect } from 'vitest';
-import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { ChannelType, Client, GatewayIntentBits, Partials, Routes } from 'discord.js';
+import YAML from 'yaml';
 import { DigitalDiscord } from 'discord-digital-twin/src';
 import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
 import { setDataDir } from './config.js';
@@ -35,6 +36,7 @@ function normalizeWorktreeLifecycleText(text) {
         .replaceAll(CHANNEL_WORKTREE_NAME, 'CHANNEL_WORKTREE_NAME')
         .replaceAll(AUTO_WORKTREE_SUFFIX, 'AUTO_WORKTREE_NAME')
         .replaceAll(WORKTREE_NAME, 'WORKTREE_NAME')
+        .replaceAll(WORKTREE_SUFFIX, 'SUFFIX')
         .replace(/ses_[a-zA-Z0-9]+/g, 'ses_TEST')
         .replace(/<#\d+>/g, '<#THREAD_ID>')
         .replace(/`[^`\n]*\/worktrees\/[^`\n]*`/g, '`/tmp/worktrees/WORKTREE_NAME`');
@@ -630,4 +632,71 @@ describe('worktree lifecycle', () => {
         const okCount = (text.match(/⬥ ok/g) || []).length;
         expect(okCount).toBe(2);
     }, 20_000);
+    test('kimaki send --channel auto-creates worktree when channel toggle is enabled', async () => {
+        // Simulate `kimaki send --channel AUTO_WORKTREE_CHANNEL_ID --prompt '...'`
+        // WITHOUT --worktree flag. The bot-side ThreadCreate handler should detect
+        // the channel toggle and auto-create a worktree.
+        const prompt = `Reply with exactly: send-auto-wt-${WORKTREE_SUFFIX}`;
+        const embedMarker = {
+            start: true,
+            username: 'worktree-tester',
+            userId: TEST_USER_ID,
+        };
+        // Post starter message (what `kimaki send` does)
+        const starterMessage = await discord
+            .channel(AUTO_WORKTREE_CHANNEL_ID)
+            .bot()
+            .sendMessage({
+            content: `» **kimaki-cli:**\n${prompt}`,
+            embeds: [
+                { color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } },
+            ],
+        });
+        // Create thread on that message (what `kimaki send` does via REST)
+        const threadData = (await botClient.rest.post(Routes.threads(AUTO_WORKTREE_CHANNEL_ID, starterMessage.id), {
+            body: {
+                name: prompt.slice(0, 80),
+                auto_archive_duration: 1440,
+            },
+        }));
+        // Wait for worktree creation status message (Branch:)
+        await waitForBotMessageContaining({
+            discord,
+            threadId: threadData.id,
+            userId: TEST_USER_ID,
+            text: 'Branch:',
+            timeout: 25_000,
+        });
+        // Wait for the bot reply to the prompt. The starter message is from
+        // the bot (kimaki-cli), not a user, so just wait for the text to appear.
+        await waitForBotMessageContaining({
+            discord,
+            threadId: threadData.id,
+            userId: discord.botUserId,
+            text: '⬥ ok',
+            timeout: 10_000,
+        });
+        // Snapshot the thread content
+        const th = discord.thread(threadData.id);
+        expect(normalizeWorktreeLifecycleText(await th.text())).toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        » **kimaki-cli:**
+        Reply with exactly: send-auto-wt-SUFFIX
+        [embed]
+        🌳 **Worktree: opencode/kimaki-rply-wth-exctly-snd-at-wt-l8kct**
+        📁 \`/tmp/worktrees/WORKTREE_NAME\`
+        🌿 Branch: \`opencode/kimaki-rply-wth-exctly-snd-at-wt-l8kct\`
+        *using deterministic-provider/deterministic-v2*
+        ⬥ ok"
+      `);
+        // Verify DB has worktree info
+        const worktreeInfo = await getThreadWorktreeOrWorkspace(threadData.id);
+        expect(worktreeInfo?.status).toBe('ready');
+        expect(worktreeInfo?.workspace_directory).toBeTruthy();
+        // Verify runtime is in the worktree directory
+        const runtime = getRuntime(threadData.id);
+        expect(runtime).toBeDefined();
+        expect(runtime.sdkDirectory).toContain(`${path.sep}worktrees${path.sep}`);
+        expect(runtime.sdkDirectory).not.toBe(directories.projectDirectory);
+    }, 35_000);
 });

package/dist/worktrees.js

@@ -713,6 +713,69 @@ export async function mergeWorktree({ worktreeDir, mainRepoDir, worktreeName, ta
         shortSha: shortSha instanceof Error ? 'unknown' : shortSha,
     };
 }
+/**
+ * Resolve the best git ref for a base branch by checking remote tracking refs.
+ * Prefers upstream/<branch> over origin/<branch> over local <branch>.
+ * Fetches the remote first so tracking refs are up to date.
+ *
+ * If the remote is strictly ahead of local, returns the remote ref.
+ * If local and remote have diverged (local is both ahead and behind),
+ * returns the local branch to avoid needing a merge/rebase.
+ * If the branch is already an explicit remote ref (e.g. `origin/main`), skips resolution.
+ * Uses `git remote` to distinguish real remote prefixes from local branches
+ * containing `/` like `feature/foo`.
+ */
+export async function resolveBestBaseRef({ directory, branch, }) {
+    // Check if branch is already an explicit remote ref like "origin/main".
+    // Local branches can contain `/` (e.g. "feature/foo"), so we check
+    // against actual remote names instead of a naive slash check.
+    if (branch.includes('/')) {
+        const remotes = await git(directory, 'remote');
+        if (!(remotes instanceof Error)) {
+            const prefix = branch.slice(0, branch.indexOf('/'));
+            if (remotes.split('\n').some((r) => r.trim() === prefix)) {
+                return branch;
+            }
+        }
+    }
+    for (const remote of ['upstream', 'origin']) {
+        // Best-effort fetch with short timeout
+        const fetchResult = await git(directory, `fetch ${remote} ${branch}`, {
+            timeout: 15_000,
+        });
+        if (fetchResult instanceof Error)
+            continue;
+        const remoteRef = `${remote}/${branch}`;
+        const refExists = await git(directory, `rev-parse --verify refs/remotes/${remoteRef}`);
+        if (refExists instanceof Error)
+            continue;
+        // Check if local branch exists
+        const localExists = await git(directory, `rev-parse --verify refs/heads/${branch}`);
+        if (localExists instanceof Error) {
+            // No local branch but remote exists — use remote
+            return remoteRef;
+        }
+        // Count commits: remote ahead of local, and local ahead of remote
+        const [remoteAhead, localAhead] = await Promise.all([
+            git(directory, `rev-list --count refs/heads/${branch}..refs/remotes/${remoteRef}`),
+            git(directory, `rev-list --count refs/remotes/${remoteRef}..refs/heads/${branch}`),
+        ]);
+        if (remoteAhead instanceof Error || localAhead instanceof Error)
+            continue;
+        const remoteAheadCount = parseInt(remoteAhead, 10);
+        const localAheadCount = parseInt(localAhead, 10);
+        // Diverged (both ahead): use local to avoid needing a merge
+        if (remoteAheadCount > 0 && localAheadCount > 0)
+            return branch;
+        // Remote is strictly ahead: use remote ref
+        if (remoteAheadCount > 0)
+            return remoteRef;
+        // Equal or local is ahead — check next remote instead of returning early,
+        // because origin might be ahead even when upstream is equal.
+    }
+    // No usable remote found — use local branch as-is
+    return branch;
+}
 /**
  * List branches sorted by most recent commit date.
  * Returns branch short names (e.g. "main", "origin/feature-x").

package/package.json

@@ -2,9 +2,16 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
+  "exports": {
+    "./package.json": "./package.json",
+    "./anthropic-auth-plugin": {
+      "types": "./dist/anthropic-auth-plugin.d.ts",
+      "default": "./dist/anthropic-auth-plugin.js"
+    }
+  },
   "files": [
     "dist",
     "src",
@@ -24,7 +31,7 @@
     "lintcn": "^0.7.1",
     "tsx": "^4.20.5",
     "undici": "^8.0.2",
-    "discord-digital-twin": "^0.1.0",
+    "discord-digital-twin": "^0.1.1",
     "opencode-deterministic-provider": "^0.0.1",
     "opencode-cached-provider": "^0.0.1",
     "db": "^0.0.0"
@@ -63,9 +70,9 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
+    "traforo": "^0.7.1",
     "opencode-injection-guard": "^0.2.1",
-    "libsqlproxy": "^0.1.0",
-    "traforo": "^0.7.1"
+    "libsqlproxy": "^0.1.0"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",