kimaki 0.4.90 → 0.4.91

package/dist/anthropic-auth-plugin.test.js

@@ -0,0 +1,125 @@
+// Tests for Anthropic OAuth multi-account persistence and rotation.
+import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
+const firstAccount = {
+    type: 'oauth',
+    refresh: 'refresh-first',
+    access: 'access-first',
+    expires: 1,
+};
+const secondAccount = {
+    type: 'oauth',
+    refresh: 'refresh-second',
+    access: 'access-second',
+    expires: 2,
+};
+let originalXdgDataHome;
+let tempDir = '';
+beforeEach(async () => {
+    originalXdgDataHome = process.env.XDG_DATA_HOME;
+    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
+    process.env.XDG_DATA_HOME = tempDir;
+});
+afterEach(async () => {
+    if (originalXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+    }
+    else {
+        process.env.XDG_DATA_HOME = originalXdgDataHome;
+    }
+    await rm(tempDir, { force: true, recursive: true });
+});
+describe('rememberAnthropicOAuth', () => {
+    test('stores accounts and updates existing entries by refresh token', async () => {
+        await rememberAnthropicOAuth(firstAccount);
+        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
+        const store = await loadAccountStore();
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]).toMatchObject({
+            refresh: 'refresh-first',
+            access: 'access-first-new',
+            expires: 3,
+        });
+    });
+});
+describe('rotateAnthropicAccount', () => {
+    test('rotates to the next stored account and syncs auth state', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        const authSetCalls = [];
+        const client = {
+            auth: {
+                set: async (input) => {
+                    authSetCalls.push(input);
+                },
+            },
+        };
+        const rotated = await rotateAnthropicAccount(firstAccount, client);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(rotated).toMatchObject({ refresh: 'refresh-second' });
+        expect(store.activeIndex).toBe(1);
+        expect(authJson.anthropic?.refresh).toBe('refresh-second');
+        expect(authSetCalls).toEqual([
+            {
+                path: { id: 'anthropic' },
+                body: {
+                    type: 'oauth',
+                    refresh: 'refresh-second',
+                    access: 'access-second',
+                    expires: 2,
+                },
+            },
+        ]);
+    });
+});
+describe('removeAccount', () => {
+    test('removing the active account promotes the next stored account', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 1,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        await removeAccount(1);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]?.refresh).toBe('refresh-first');
+        expect(authJson.anthropic?.refresh).toBe('refresh-first');
+    });
+    test('removing the last account clears active Anthropic auth', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
+        });
+        await mkdir(path.dirname(authFilePath()), { recursive: true });
+        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
+        await removeAccount(0);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.accounts).toHaveLength(0);
+        expect(authJson.anthropic).toBeUndefined();
+    });
+});
+describe('shouldRotateAuth', () => {
+    test('only rotates on rate limit or auth failures', () => {
+        expect(shouldRotateAuth(429, '')).toBe(true);
+        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
+        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+    });
+});

package/dist/anthropic-auth-state.js

@@ -0,0 +1,231 @@
+import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const AUTH_LOCK_STALE_MS = 30_000;
+const AUTH_LOCK_RETRY_MS = 100;
+async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+    await fs.chmod(filePath, 0o600);
+}
+function getErrorCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    return error.code;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function authFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'auth.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'auth.json');
+}
+export function accountsFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'anthropic-oauth-accounts.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'anthropic-oauth-accounts.json');
+}
+export async function withAuthStateLock(fn) {
+    const file = authFilePath();
+    const lockDir = `${file}.lock`;
+    const deadline = Date.now() + AUTH_LOCK_STALE_MS;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    while (true) {
+        try {
+            await fs.mkdir(lockDir);
+            break;
+        }
+        catch (error) {
+            const code = getErrorCode(error);
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            const stats = await fs.stat(lockDir).catch(() => {
+                return null;
+            });
+            if (stats && Date.now() - stats.mtimeMs > AUTH_LOCK_STALE_MS) {
+                await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for auth lock: ${lockDir}`);
+            }
+            await sleep(AUTH_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+    }
+}
+export function normalizeAccountStore(input) {
+    const accounts = Array.isArray(input?.accounts)
+        ? input.accounts.filter((account) => !!account &&
+            account.type === 'oauth' &&
+            typeof account.refresh === 'string' &&
+            typeof account.access === 'string' &&
+            typeof account.expires === 'number' &&
+            typeof account.addedAt === 'number' &&
+            typeof account.lastUsed === 'number')
+        : [];
+    const rawIndex = typeof input?.activeIndex === 'number' ? Math.floor(input.activeIndex) : 0;
+    const activeIndex = accounts.length === 0 ? 0 : ((rawIndex % accounts.length) + accounts.length) % accounts.length;
+    return { version: 1, activeIndex, accounts };
+}
+export async function loadAccountStore() {
+    const raw = await readJson(accountsFilePath(), null);
+    return normalizeAccountStore(raw);
+}
+export async function saveAccountStore(store) {
+    await writeJson(accountsFilePath(), normalizeAccountStore(store));
+}
+function findCurrentAccountIndex(store, auth) {
+    if (!store.accounts.length)
+        return 0;
+    const byRefresh = store.accounts.findIndex((account) => {
+        return account.refresh === auth.refresh;
+    });
+    if (byRefresh >= 0)
+        return byRefresh;
+    const byAccess = store.accounts.findIndex((account) => {
+        return account.access === auth.access;
+    });
+    if (byAccess >= 0)
+        return byAccess;
+    return store.activeIndex;
+}
+export function upsertAccount(store, auth, now = Date.now()) {
+    const index = store.accounts.findIndex((account) => {
+        return account.refresh === auth.refresh || account.access === auth.access;
+    });
+    const nextAccount = {
+        type: 'oauth',
+        refresh: auth.refresh,
+        access: auth.access,
+        expires: auth.expires,
+        addedAt: now,
+        lastUsed: now,
+    };
+    if (index < 0) {
+        store.accounts.push(nextAccount);
+        store.activeIndex = store.accounts.length - 1;
+        return store.activeIndex;
+    }
+    const existing = store.accounts[index];
+    if (!existing)
+        return index;
+    store.accounts[index] = {
+        ...existing,
+        ...nextAccount,
+        addedAt: existing.addedAt,
+    };
+    store.activeIndex = index;
+    return index;
+}
+export async function rememberAnthropicOAuth(auth) {
+    await withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        upsertAccount(store, auth);
+        await saveAccountStore(store);
+    });
+}
+async function writeAnthropicAuthFile(auth) {
+    const file = authFilePath();
+    const data = await readJson(file, {});
+    if (auth) {
+        data.anthropic = auth;
+    }
+    else {
+        delete data.anthropic;
+    }
+    await writeJson(file, data);
+}
+export async function setAnthropicAuth(auth, client) {
+    await writeAnthropicAuthFile(auth);
+    await client.auth.set({ path: { id: 'anthropic' }, body: auth });
+}
+export async function rotateAnthropicAccount(auth, client) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (store.accounts.length < 2)
+            return undefined;
+        const currentIndex = findCurrentAccountIndex(store, auth);
+        const nextIndex = (currentIndex + 1) % store.accounts.length;
+        const nextAccount = store.accounts[nextIndex];
+        if (!nextAccount)
+            return undefined;
+        nextAccount.lastUsed = Date.now();
+        store.activeIndex = nextIndex;
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: nextAccount.refresh,
+            access: nextAccount.access,
+            expires: nextAccount.expires,
+        };
+        await setAnthropicAuth(nextAuth, client);
+        return nextAuth;
+    });
+}
+export async function removeAccount(index) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (!Number.isInteger(index) || index < 0 || index >= store.accounts.length) {
+            throw new Error(`Account ${index + 1} does not exist`);
+        }
+        store.accounts.splice(index, 1);
+        if (store.accounts.length === 0) {
+            store.activeIndex = 0;
+            await saveAccountStore(store);
+            await writeAnthropicAuthFile(undefined);
+            return { store, active: undefined };
+        }
+        if (store.activeIndex > index) {
+            store.activeIndex -= 1;
+        }
+        else if (store.activeIndex >= store.accounts.length) {
+            store.activeIndex = 0;
+        }
+        const active = store.accounts[store.activeIndex];
+        if (!active)
+            throw new Error('Active Anthropic account disappeared during removal');
+        active.lastUsed = Date.now();
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: active.refresh,
+            access: active.access,
+            expires: active.expires,
+        };
+        await writeAnthropicAuthFile(nextAuth);
+        return { store, active: nextAuth };
+    });
+}
+export function shouldRotateAuth(status, bodyText) {
+    const haystack = bodyText.toLowerCase();
+    if (status === 429)
+        return true;
+    if (status === 401 || status === 403)
+        return true;
+    return (haystack.includes('rate_limit') ||
+        haystack.includes('rate limit') ||
+        haystack.includes('invalid api key') ||
+        haystack.includes('authentication_error') ||
+        haystack.includes('permission_error') ||
+        haystack.includes('oauth'));
+}

package/dist/bin.js

@@ -24,11 +24,13 @@ const HEAP_SNAPSHOT_DIR = path.join(os.homedir(), '.kimaki', 'heap-snapshots');
 // If it doesn't start with '-', it's a subcommand (e.g. "send", "tunnel", "project").
 const firstArg = process.argv[2];
 const isSubcommand = firstArg && !firstArg.startsWith('-');
-const hasAutoRestart = process.argv.includes('--auto-restart');
-if (process.env.__KIMAKI_CHILD || isSubcommand || !hasAutoRestart) {
+const isHelpFlag = process.argv.includes('--help');
+if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
     await import('./cli.js');
 }
 else {
+    console.error('no subcommand detected. kimaki will automatically restart on crash');
+    console.error();
     const EXIT_NO_RESTART = 64;
     const MAX_RAPID_RESTARTS = 5;
     const RAPID_RESTART_WINDOW_MS = 60_000;
@@ -45,7 +47,8 @@ else {
             `--heapsnapshot-near-heap-limit=3`,
             `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
         ];
-        child = spawn(process.argv[0], [...heapArgs, ...process.execArgv, ...process.argv.slice(1)], {
+        const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)];
+        child = spawn(process.argv[0], args, {
             stdio: 'inherit',
             env: { ...process.env, __KIMAKI_CHILD: '1' },
         });

package/dist/cli-parsing.test.js

@@ -22,6 +22,8 @@ function createCliForIdParsing() {
         .command('add-project', 'Add a project')
         .option('-g, --guild <guildId>', 'Discord guild/server ID');
     cli.command('task delete <id>', 'Delete task');
+    cli.command('anthropic-accounts list', 'List stored Anthropic accounts').hidden();
+    cli.command('anthropic-accounts remove <index>', 'Remove stored Anthropic account').hidden();
     return cli;
 }
 describe('goke CLI ID parsing', () => {
@@ -111,4 +113,25 @@ describe('goke CLI ID parsing', () => {
         expect(result.args[0]).toBe(taskId);
         expect(typeof result.args[0]).toBe('string');
     });
+    test('hidden anthropic account commands still parse', () => {
+        const cli = createCliForIdParsing();
+        const result = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', '2'], { run: false });
+        expect(result.args[0]).toBe('2');
+        expect(typeof result.args[0]).toBe('string');
+    });
+    test('hidden anthropic account commands are excluded from help output', () => {
+        const stdout = {
+            text: '',
+            write(data) {
+                this.text += String(data);
+            },
+        };
+        const cli = goke('kimaki', { stdout: stdout });
+        cli.command('send', 'Send a message');
+        cli.command('anthropic-accounts list', 'List stored Anthropic accounts').hidden();
+        cli.help();
+        cli.parse(['node', 'kimaki', '--help'], { run: false });
+        expect(stdout.text).toContain('send');
+        expect(stdout.text).not.toContain('anthropic-accounts');
+    });
 });

package/dist/cli-send-thread.e2e.test.js

@@ -24,7 +24,7 @@ import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChann
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
 import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 const TEST_USER_ID = '200000000000000830';
 const TEXT_CHANNEL_ID = '200000000000000831';
 const BOT_USER_ID = '200000000000000832';
@@ -212,7 +212,7 @@ describe('kimaki send --channel thread creation', () => {
             body: {
                 content: prompt,
                 embeds: [
-                    { color: 0x2b2d31, footer: { text: yaml.dump(embedMarker) } },
+                    { color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } },
                 ],
             },
         }));

package/dist/cli.js

@@ -15,7 +15,7 @@ import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { sendWelcomeMessage } from './onboarding-welcome.js';
 import { buildOpencodeEventLogLine } from './session-handler/opencode-session-event-log.js';
 import { selectResolvedCommand } from './opencode-command.js';
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import { Events, ChannelType, ActivityType, Routes, AttachmentBuilder, } from 'discord.js';
 import { createDiscordRest, discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInternetReachableBaseUrl } from './discord-urls.js';
 import crypto from 'node:crypto';
@@ -27,11 +27,12 @@ import { initSentry, notifyError } from './sentry.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions, } from './discord-utils.js';
 import { spawn, execSync } from 'node:child_process';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir, } from './config.js';
-import { execAsync } from './worktrees.js';
+import { execAsync, validateWorktreeDirectory } from './worktrees.js';
 import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.js';
 import { startHranaServer } from './hrana-server.js';
 import { startIpcPolling, stopIpcPolling } from './ipc-polling.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, } from './task-schedule.js';
+import { accountsFilePath, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 // Gateway bot mode constants.
 // KIMAKI_GATEWAY_APP_ID is the Discord Application ID of the gateway bot.
@@ -438,33 +439,8 @@ const cli = goke('kimaki');
 process.title = 'kimaki';
 import { store } from './store.js';
 import { registerCommands, SKIP_USER_COMMANDS } from './discord-command-registration.js';
-async function reconcileKimakiRole({ guild }) {
-    try {
-        const roles = await guild.roles.fetch();
-        const existingRole = roles.find((role) => role.name.toLowerCase() === 'kimaki');
-        if (existingRole) {
-            if (existingRole.position > 1) {
-                await existingRole.setPosition(1);
-                cliLogger.info(`Moved "Kimaki" role to bottom in ${guild.name}`);
-            }
-            return;
-        }
-        await guild.roles.create({
-            name: 'Kimaki',
-            position: 1,
-            reason: 'Kimaki bot permission role - assign to users who can start sessions, send messages in threads, and use voice features',
-        });
-        cliLogger.info(`Created "Kimaki" role in ${guild.name}`);
-    }
-    catch (error) {
-        cliLogger.warn(`Could not reconcile Kimaki role in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function collectKimakiChannels({ guilds, reconcileRoles, }) {
+async function collectKimakiChannels({ guilds, }) {
     const guildResults = await Promise.all(guilds.map(async (guild) => {
-        if (reconcileRoles) {
-            void reconcileKimakiRole({ guild });
-        }
         const channels = await getChannelsWithDescriptions(guild);
         const kimakiChans = channels.filter((ch) => ch.kimakiDirectory);
         return { guild, channels: kimakiChans };
@@ -1023,10 +999,7 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
                     return;
                 }
                 // Process guild metadata when setup flow needs channel prompts.
-                const guildResults = await collectKimakiChannels({
-                    guilds,
-                    reconcileRoles: true,
-                });
+                const guildResults = await collectKimakiChannels({ guilds });
                 // Collect results
                 for (const result of guildResults) {
                     kimakiChannels.push(result);
@@ -1087,10 +1060,7 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
         // Never blocks ready state.
         void (async () => {
             try {
-                const backgroundChannels = await collectKimakiChannels({
-                    guilds,
-                    reconcileRoles: true,
-                });
+                const backgroundChannels = await collectKimakiChannels({ guilds });
                 await storeChannelDirectories({ kimakiChannels: backgroundChannels });
                 cliLogger.log(`Background channel sync completed for ${backgroundChannels.length} guild(s)`);
             }
@@ -1313,7 +1283,6 @@ cli
     .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
-    .option('--verbose-opencode-server', 'Forward OpenCode server stdout/stderr to kimaki.log')
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
@@ -1357,7 +1326,6 @@ cli
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
-            ...(options.verboseOpencodeServer && { verboseOpencodeServer: true }),
         });
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
@@ -1368,9 +1336,6 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
-        if (options.verboseOpencodeServer) {
-            cliLogger.log('Verbose OpenCode server: stdout/stderr will be forwarded to kimaki.log');
-        }
         if (options.noSentry) {
             process.env.KIMAKI_SENTRY_DISABLED = '1';
             cliLogger.log('Sentry error reporting disabled (--no-sentry)');
@@ -1657,6 +1622,7 @@ cli
     .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
     .option('--notify-only', 'Create notification thread without starting AI session')
     .option('--worktree [name]', 'Create git worktree for session (name optional, derives from thread name)')
+    .option('--cwd <path>', 'Start session in an existing git worktree directory instead of the main project directory')
     .option('-u, --user <username>', 'Discord username to add to thread')
     .option('--agent <agent>', 'Agent to use for the session')
     .option('--model <model>', 'Model to use (format: provider/model)')
@@ -1723,6 +1689,14 @@ cli
             cliLogger.error('Cannot use --worktree with --notify-only');
             process.exit(EXIT_NO_RESTART);
         }
+        if (options.cwd && options.worktree) {
+            cliLogger.error('Cannot use --cwd with --worktree');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (options.cwd && notifyOnly) {
+            cliLogger.error('Cannot use --cwd with --notify-only');
+            process.exit(EXIT_NO_RESTART);
+        }
         if (options.wait && notifyOnly) {
             cliLogger.error('Cannot use --wait with --notify-only');
             process.exit(EXIT_NO_RESTART);
@@ -1735,6 +1709,9 @@ cli
             if (options.worktree) {
                 incompatibleFlags.push('--worktree');
             }
+            if (options.cwd) {
+                incompatibleFlags.push('--cwd');
+            }
             if (name) {
                 incompatibleFlags.push('--name');
             }
@@ -1922,11 +1899,13 @@ cli
             const promptEmbed = [
                 {
                     color: 0x2b2d31,
-                    footer: { text: yaml.dump(threadPromptMarker) },
+                    footer: { text: YAML.stringify(threadPromptMarker) },
                 },
             ];
-            // Prefix the prompt so it's clear who sent it (matches /queue format)
-            const prefixedPrompt = `» **kimaki-cli:** ${prompt}`;
+            // Prefix the prompt so it's clear who sent it (matches /queue format).
+            // Use a newline between prefix and prompt so leading /command
+            // detection can find the command on its own line.
+            const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
             await sendDiscordMessageWithOptionalAttachment({
                 channelId: targetThreadId,
                 prompt: prefixedPrompt,
@@ -1958,6 +1937,19 @@ cli
             throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
         }
         const projectDirectory = channelConfig.directory;
+        // Validate --cwd is an existing git worktree of the project
+        let resolvedCwd;
+        if (options.cwd) {
+            const cwdResult = await validateWorktreeDirectory({
+                projectDirectory,
+                candidatePath: options.cwd,
+            });
+            if (cwdResult instanceof Error) {
+                cliLogger.error(cwdResult.message);
+                process.exit(EXIT_NO_RESTART);
+            }
+            resolvedCwd = cwdResult;
+        }
         // Resolve username to user ID if provided
         const resolvedUser = await (async () => {
             if (!options.user) {
@@ -2004,6 +1996,7 @@ cli
                 name: name || null,
                 notifyOnly: Boolean(notifyOnly),
                 worktreeName: worktreeName || null,
+                cwd: resolvedCwd || null,
                 agent: options.agent || null,
                 model: options.model || null,
                 username: resolvedUser?.username || null,
@@ -2034,6 +2027,7 @@ cli
             : {
                 start: true,
                 ...(worktreeName && { worktree: worktreeName }),
+                ...(resolvedCwd && { cwd: resolvedCwd }),
                 ...(resolvedUser && {
                     username: resolvedUser.username,
                     userId: resolvedUser.id,
@@ -2044,7 +2038,7 @@ cli
                 ...(options.injectionGuard?.length && { injectionGuardPatterns: options.injectionGuard }),
             };
         const autoStartEmbed = embedMarker
-            ? [{ color: 0x2b2d31, footer: { text: yaml.dump(embedMarker) } }]
+            ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } }]
             : undefined;
         const starterMessage = await sendDiscordMessageWithOptionalAttachment({
             channelId,
@@ -2069,7 +2063,9 @@ cli
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
         const worktreeNote = worktreeName
             ? `\nWorktree: ${worktreeName} (will be created by bot)`
-            : '';
+            : resolvedCwd
+                ? `\nWorking directory: ${resolvedCwd}`
+                : '';
         const successMessage = notifyOnly
             ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
             : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}${worktreeNote}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
@@ -2226,6 +2222,36 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('anthropic-accounts list', 'List stored Anthropic OAuth accounts used for automatic rotation')
+    .hidden()
+    .action(async () => {
+    const store = await loadAccountStore();
+    console.log(`Store: ${accountsFilePath()}`);
+    if (store.accounts.length === 0) {
+        console.log('No Anthropic OAuth accounts configured.');
+        process.exit(0);
+    }
+    store.accounts.forEach((account, index) => {
+        const active = index === store.activeIndex ? '*' : ' ';
+        const label = `${account.refresh.slice(0, 8)}...${account.refresh.slice(-4)}`;
+        console.log(`${active} ${index + 1}. ${label}`);
+    });
+    process.exit(0);
+});
+cli
+    .command('anthropic-accounts remove <index>', 'Remove a stored Anthropic OAuth account from the rotation pool')
+    .hidden()
+    .action(async (index) => {
+    const value = Number(index);
+    if (!Number.isInteger(value) || value < 1) {
+        cliLogger.error('Usage: kimaki anthropic-accounts remove <index>');
+        process.exit(EXIT_NO_RESTART);
+    }
+    await removeAccount(value - 1);
+    cliLogger.log(`Removed Anthropic account ${value}`);
+    process.exit(0);
+});
 cli
     .command('project add [directory]', 'Create Discord channels for a project directory (replaces legacy add-project)')
     .alias('add-project')