@otto-assistant/bridge 0.4.96 → 0.4.100

package/dist/commands/vscode.js

@@ -0,0 +1,269 @@
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { TunnelClient } from 'traforo/client';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('VSCODE');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
+const TUNNEL_BASE_DOMAIN = 'kimaki.dev';
+const TUNNEL_ID_BYTES = 16;
+const READY_TIMEOUT_MS = 60_000;
+const LOCAL_HOST = '127.0.0.1';
+const activeSessions = new Map();
+export function createVscodeTunnelId() {
+    return crypto.randomBytes(TUNNEL_ID_BYTES).toString('hex');
+}
+export function buildCoderaftArgs({ port, workingDirectory, }) {
+    return [
+        'coderaft',
+        '--port',
+        String(port),
+        '--host',
+        LOCAL_HOST,
+        '--without-connection-token',
+        '--disable-workspace-trust',
+        '--default-folder',
+        workingDirectory,
+    ];
+}
+function createPortWaiter({ port, process: proc, timeoutMs, }) {
+    return new Promise((resolve, reject) => {
+        const maxAttempts = Math.ceil(timeoutMs / 100);
+        let attempts = 0;
+        const check = () => {
+            if (proc.exitCode !== null) {
+                reject(new Error(`coderaft exited with code ${proc.exitCode} before becoming ready`));
+                return;
+            }
+            const socket = net.createConnection(port, LOCAL_HOST);
+            socket.on('connect', () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on('error', () => {
+                socket.destroy();
+                attempts += 1;
+                if (attempts >= maxAttempts) {
+                    reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`));
+                    return;
+                }
+                setTimeout(check, 100);
+            });
+        };
+        check();
+    });
+}
+function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.on('error', reject);
+        server.listen(0, LOCAL_HOST, () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close(() => {
+                    reject(new Error('Failed to resolve an available port'));
+                });
+                return;
+            }
+            const port = address.port;
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(port);
+            });
+        });
+    });
+}
+function cleanupSession(session) {
+    clearTimeout(session.timeoutTimer);
+    try {
+        session.tunnelClient.close();
+    }
+    catch { }
+    if (session.coderaftProcess.exitCode === null) {
+        try {
+            session.coderaftProcess.kill('SIGTERM');
+        }
+        catch { }
+    }
+}
+export function getActiveVscodeSession({ sessionKey }) {
+    return activeSessions.get(sessionKey);
+}
+export function stopVscode({ sessionKey }) {
+    const session = activeSessions.get(sessionKey);
+    if (!session) {
+        return false;
+    }
+    activeSessions.delete(sessionKey);
+    cleanupSession(session);
+    logger.log(`VS Code stopped (key: ${sessionKey})`);
+    return true;
+}
+export async function startVscode({ sessionKey, startedBy, workingDirectory, }) {
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        return existing;
+    }
+    const port = await getAvailablePort();
+    const tunnelId = createVscodeTunnelId();
+    const args = buildCoderaftArgs({
+        port,
+        workingDirectory,
+    });
+    const coderaftProcess = spawn('bunx', args, {
+        cwd: workingDirectory,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            PORT: String(port),
+        },
+    });
+    coderaftProcess.stdout?.on('data', (data) => {
+        logger.log(data.toString().trim());
+    });
+    coderaftProcess.stderr?.on('data', (data) => {
+        logger.error(data.toString().trim());
+    });
+    try {
+        await createPortWaiter({
+            port,
+            process: coderaftProcess,
+            timeoutMs: READY_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const tunnelClient = new TunnelClient({
+        localPort: port,
+        localHost: LOCAL_HOST,
+        tunnelId,
+        baseDomain: TUNNEL_BASE_DOMAIN,
+    });
+    try {
+        await Promise.race([
+            tunnelClient.connect(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Tunnel connection timed out after 15s'));
+                }, 15_000);
+            }),
+        ]);
+    }
+    catch (error) {
+        tunnelClient.close();
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const url = tunnelClient.url;
+    const timeoutTimer = setTimeout(() => {
+        logger.log(`VS Code auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
+        stopVscode({ sessionKey });
+    }, MAX_SESSION_MS);
+    timeoutTimer.unref();
+    const session = {
+        coderaftProcess,
+        tunnelClient,
+        url,
+        workingDirectory,
+        startedBy,
+        startedAt: Date.now(),
+        timeoutTimer,
+    };
+    coderaftProcess.once('exit', (code, signal) => {
+        const current = activeSessions.get(sessionKey);
+        if (current !== session) {
+            return;
+        }
+        logger.log(`VS Code process exited (key: ${sessionKey}, code: ${code}, signal: ${signal ?? 'none'})`);
+        stopVscode({ sessionKey });
+    });
+    activeSessions.set(sessionKey, session);
+    logger.log(`VS Code started by ${startedBy}: ${url}`);
+    return session;
+}
+export async function handleVscodeCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
+    const sessionKey = channel.id;
+    const existing = getActiveVscodeSession({ sessionKey });
+    if (existing) {
+        await command.editReply({
+            content: `VS Code is already running for this thread. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes from startup.\n` +
+                `${existing.url}`,
+        });
+        return;
+    }
+    try {
+        const session = await startVscode({
+            sessionKey,
+            startedBy: command.user.tag,
+            workingDirectory: resolved.workingDirectory,
+        });
+        await command.editReply({
+            content: `VS Code started for \`${session.workingDirectory}\`. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes, so open it before it expires.\n` +
+                `${session.url}`,
+        });
+    }
+    catch (error) {
+        logger.error('Failed to start VS Code:', error);
+        await command.editReply({
+            content: `Failed to start VS Code: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+export function cleanupAllVscodeSessions() {
+    for (const sessionKey of activeSessions.keys()) {
+        stopVscode({ sessionKey });
+    }
+}
+function onProcessExit() {
+    cleanupAllVscodeSessions();
+}
+process.on('SIGINT', onProcessExit);
+process.on('SIGTERM', onProcessExit);
+process.on('exit', onProcessExit);

package/dist/db.js

@@ -201,6 +201,7 @@ async function migrateSchema(prisma) {
     // Also fix NULL worktree status rows that predate the required enum.
     const defensiveMigrations = [
         "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
+        "UPDATE bot_tokens SET proxy_url = REPLACE(proxy_url, 'discord-gateway.kimaki.xyz', 'discord-gateway.kimaki.dev') WHERE bot_mode = 'gateway' AND proxy_url LIKE '%discord-gateway.kimaki.xyz%'",
         "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
     ];
     for (const stmt of defensiveMigrations) {

package/dist/discord-command-registration.js

@@ -110,7 +110,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('new-worktree')
-            .setDescription(truncateCommandDescription('Create a git worktree branch from origin/HEAD (or main). Optionally pick a base branch.'))
+            .setDescription(truncateCommandDescription('Create a git worktree branch from HEAD by default. Optionally pick a base branch.'))
             .addStringOption((option) => {
             option
                 .setName('name')
@@ -121,7 +121,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .addStringOption((option) => {
             option
                 .setName('base-branch')
-                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: origin/HEAD or main)'))
+                .setDescription(truncateCommandDescription('Branch to create the worktree from (default: HEAD)'))
                 .setRequired(false)
                 .setAutocomplete(true);
             return option;
@@ -365,6 +365,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Stop screen sharing'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('vscode')
+            .setDescription(truncateCommandDescription('Open VS Code in the browser for this project or worktree (auto-stops after 30 minutes)'))
+            .setDMPermission(false)
+            .toJSON(),
     ];
     // Dynamic commands are registered in priority order: agents → user commands → skills → MCP prompts.
     // This ordering matters because we slice to MAX_DISCORD_COMMANDS (100) at the end,

package/dist/gateway-proxy-reconnect.e2e.test.js

@@ -6,7 +6,7 @@
 //   Starts a digital-twin + local gateway-proxy binary, kills and restarts the proxy.
 //
 // Production mode (env vars):
-//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.xyz)
+//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.dev)
 //   GATEWAY_TEST_TOKEN      - client token (clientId:secret)
 //   GATEWAY_TEST_REDEPLOY   - if "1", runs `fly deploy` between kill/restart instead of local binary
 //
@@ -15,7 +15,7 @@
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts
 //
 //   # Against production (just connect + kill WS + wait for reconnect):
-//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.xyz \
+//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.dev \
 //   GATEWAY_TEST_TOKEN=myclientid:mysecret \
 //   KIMAKI_TEST_LOGS=1 \
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts -t "production"

package/dist/interaction-handler.js

@@ -39,6 +39,7 @@ import { handleSessionIdCommand } from './commands/session-id.js';
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
+import { handleVscodeCommand } from './commands/vscode.js';
 import { handleModelVariantSelectMenu } from './commands/model.js';
 import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
 import { hasKimakiBotPermission } from './discord-utils.js';
@@ -224,6 +225,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                             appId,
                         });
                         return;
+                    case 'vscode':
+                        await handleVscodeCommand({ command: interaction, appId });
+                        return;
                 }
                 // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
                 if (interaction.commandName.endsWith('-agent') &&

package/dist/system-message.js

@@ -255,7 +255,7 @@ export function getOpencodeSystemMessage({ sessionId, channelId, guildId, thread
             .join('\n')}`
         : '';
     return `
-The user is reading your messages from inside Discord, via kimaki.xyz
+The user is reading your messages from inside Discord, via kimaki.dev
 
 ## bash tool
 
@@ -322,39 +322,40 @@ ${channelId
 
 To start a new thread/session in this channel pro-grammatically, run:
 
-kimaki send --channel ${channelId} --prompt "your prompt here"${userArg}
+kimaki send --channel ${channelId} --prompt "your prompt here" --agent <current_agent>${userArg}
 
 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.
 
 IMPORTANT: NEVER use \`--worktree\` unless the user explicitly asks for a worktree. Default to creating normal threads without worktrees.
 
 To send a prompt to an existing thread instead of creating a new one:
 
-kimaki send --thread <thread_id> --prompt "follow-up prompt"
+kimaki send --thread <thread_id> --prompt "follow-up prompt" --agent <current_agent>
 
 Use this when you already have the Discord thread ID.
 
 To send to the thread associated with a known session:
 
-kimaki send --session <session_id> --prompt "follow-up prompt"
+kimaki send --session <session_id> --prompt "follow-up prompt" --agent <current_agent>
 
 Use this when you have the OpenCode session ID.
 
 Use --notify-only to create a notification thread without starting an AI session:
 
-kimaki send --channel ${channelId} --prompt "User cancelled subscription" --notify-only${userArg}
+kimaki send --channel ${channelId} --prompt "User cancelled subscription" --notify-only --agent <current_agent>${userArg}
 
 Use --user to add a specific Discord user to the new thread:
 
-kimaki send --channel ${channelId} --prompt "Review the latest CI failure"${userArg}
+kimaki send --channel ${channelId} --prompt "Review the latest CI failure" --agent <current_agent>${userArg}
 
 Use --worktree to create a git worktree for the session (ONLY when the user explicitly asks for a worktree):
 
-kimaki send --channel ${channelId} --prompt "Add dark mode support" --worktree dark-mode${userArg}
+kimaki send --channel ${channelId} --prompt "Add dark mode support" --worktree dark-mode --agent <current_agent>${userArg}
 
 Use --cwd to start a session in an existing git worktree directory (must be a worktree of the project):
 
-kimaki send --channel ${channelId} --prompt "Continue work on feature" --cwd /path/to/existing-worktree${userArg}
+kimaki send --channel ${channelId} --prompt "Continue work on feature" --cwd /path/to/existing-worktree --agent <current_agent>${userArg}
 
 Important:
 - NEVER use \`--worktree\` unless the user explicitly requests a worktree. Most tasks should use normal threads without worktrees.
@@ -372,8 +373,8 @@ ${availableAgentsContext}
 
 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"
-kimaki send --channel ${channelId} --prompt "/build-cmd update dependencies"${userArg}
+kimaki send --thread <thread_id> --prompt "/review fix the auth module" --agent <current_agent>
+kimaki send --channel ${channelId} --prompt "/build-cmd update dependencies" --agent <current_agent>${userArg}
 
 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\`).
 
@@ -383,14 +384,14 @@ The user can switch the active agent mid-session using the Discord slash command
 
 You can also switch agents via \`kimaki send\`:
 
-kimaki send --thread <thread_id> --prompt "/<agentname>-agent"
+kimaki send --thread <thread_id> --prompt "/<agentname>-agent" --agent <current_agent>
 
 ## scheduled sends and task management
 
 Use \`--send-at\` to schedule a one-time or recurring task:
 
-kimaki send --channel ${channelId} --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z"${userArg}
-kimaki send --channel ${channelId} --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1"${userArg}
+kimaki send --channel ${channelId} --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z" --agent <current_agent>${userArg}
+kimaki send --channel ${channelId} --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1" --agent <current_agent>${userArg}
 
 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.
@@ -424,13 +425,13 @@ kimaki task delete <id>
 
 Use case patterns:
 - Reminder flows: create deadline reminders in this channel with one-time \`--send-at\`; mention only if action is required.
-- Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel ${channelId} --prompt "Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production." --send-at "2026-05-28T09:00:00Z" --notify-only\`. Always tell the user you scheduled the reminder so they know.
+- Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel ${channelId} --prompt "Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production." --send-at "2026-05-28T09:00:00Z" --notify-only --agent <current_agent>\`. Always tell the user you scheduled the reminder so they know.
 - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username 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.
 - 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 ${sessionId} --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only
+kimaki send --session ${sessionId} --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.
 
@@ -445,12 +446,12 @@ ONLY create worktrees when the user explicitly asks for one. Never proactively u
 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 ${channelId} --prompt "your task description" --worktree worktree-name${userArg}
+kimaki send --channel ${channelId} --prompt "your task description" --worktree worktree-name --agent <current_agent>${userArg}
 \`\`\`
 
 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.
 
-By default, worktrees are created from \`origin/HEAD\` (the remote's default branch). To change the base branch for a project, the user can run \`git remote set-head origin <branch>\` in the project directory. For example, \`git remote set-head origin dev\` makes all new worktrees branch off \`origin/dev\` instead of \`origin/main\`.
+By default, worktrees are created from \`HEAD\`, which means whatever commit or branch the current checkout is on. If you want a different base, pass \`--base-branch\` or use the slash command option explicitly.
 
 Critical recursion guard:
 - If you already are in a worktree thread, do not create another worktree unless the user explicitly asks for a nested worktree.
@@ -461,7 +462,7 @@ Critical recursion guard:
 Use \`--cwd\` to start a session in an existing git worktree directory instead of creating a new one:
 
 \`\`\`bash
-kimaki send --channel ${channelId} --prompt "Continue work on feature X" --cwd /path/to/existing-worktree${userArg}
+kimaki send --channel ${channelId} --prompt "Continue work on feature X" --cwd /path/to/existing-worktree --agent <current_agent>${userArg}
 \`\`\`
 
 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.
@@ -475,7 +476,7 @@ This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
 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 ${channelId} --prompt "Continuing from previous session: <summary of current task and state>"${userArg}
+kimaki send --channel ${channelId} --prompt "Continuing from previous session: <summary of current task and state>" --agent <current_agent>${userArg}
 \`\`\`
 
 The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
@@ -533,10 +534,10 @@ To send a task to another project:
 
 \`\`\`bash
 # Send to a specific channel
-kimaki send --channel <channel_id> --prompt "Plan how to update the API client to v2"
+kimaki send --channel <channel_id> --prompt "Plan how to update the API client to v2" --agent <current_agent>
 
 # Or use --project to resolve from directory
-kimaki send --project /path/to/other-repo --prompt "Plan how to bump version to 1.2.0"
+kimaki send --project /path/to/other-repo --prompt "Plan how to bump version to 1.2.0" --agent <current_agent>
 \`\`\`
 
 When sending prompts to other projects, always ask the agent to plan first, never build upfront. The prompt should start with "Plan how to ..." so the user can review before greenlighting implementation.
@@ -559,10 +560,10 @@ If your Bash tool timeout triggers anyway, fall back to reading the session outp
 
 \`\`\`bash
 # Start a session and wait for it to finish
-kimaki send --channel <channel_id> --prompt "Fix the auth bug" --wait
+kimaki send --channel <channel_id> --prompt "Fix the auth bug" --wait --agent <current_agent>
 
 # Send to an existing thread and wait
-kimaki send --thread <thread_id> --prompt "Run the tests" --wait
+kimaki send --thread <thread_id> --prompt "Run the tests" --wait --agent <current_agent>
 \`\`\`
 
 The command exits with the session markdown on stdout once the model finishes responding.