kimaki 0.4.102 → 0.4.103

package/dist/agent-model.e2e.test.js

@@ -742,6 +742,7 @@ describe('agent model resolution', () => {
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2*
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg

package/dist/anthropic-auth-plugin.js

@@ -460,6 +460,20 @@ function buildAuthorizeHandler(mode) {
 function toClaudeCodeToolName(name) {
     return OPENCODE_TO_CLAUDE_CODE_TOOL_NAME[name.toLowerCase()] ?? name;
 }
+/**
+ * Strips the OpenCode identity block (from "You are OpenCode…" up to the
+ * Anthropic prompt marker "Skills provide specialized instructions") and
+ * re-injects essential environment context as a small XML tag.
+ *
+ * The original OpenCode prompt between those markers contains the current
+ * working directory and other runtime context. Stripping it wholesale loses
+ * that info, so we add back what the model needs (cwd) in a compact form.
+ *
+ * Original OpenCode Anthropic prompt structure (for reference):
+ *   "You are OpenCode, the best coding agent on the planet."
+ *   + environment block (cwd, OS, shell, date, etc.)
+ *   + "Skills provide specialized instructions …"
+ */
 function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
     if (startIdx === -1)
@@ -470,7 +484,14 @@ function sanitizeAnthropicSystemText(text, onError) {
         onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
         return text;
     }
-    return (text.slice(0, startIdx) + text.slice(endIdx)).replaceAll("opencode", "openc0de");
+    // Re-inject the process working directory that was inside the stripped block.
+    const envContext = `\n<environment>\n<cwd>${process.cwd()}</cwd>\n</environment>\n`;
+    // Replace all case-insensitive whole-word occurrences of "opencode" with "openc0de"
+    const result = text.slice(0, startIdx) +
+        envContext +
+        text.slice(endIdx);
+    // Use a regex with global, case-insensitive, and word boundary flags
+    return result.replace(/\bopencode\b/gi, "openc0de");
 }
 function mapSystemTextPart(part, onError) {
     if (typeof part === "string") {

package/dist/anthropic-auth-state.js

@@ -186,6 +186,37 @@ async function writeAnthropicAuthFile(auth) {
     }
     await writeJson(file, data);
 }
+function isOAuthStored(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    return (record.type === 'oauth' &&
+        typeof record.refresh === 'string' &&
+        typeof record.access === 'string' &&
+        typeof record.expires === 'number');
+}
+export async function getCurrentAnthropicAccount() {
+    const authJson = await readJson(authFilePath(), {});
+    const auth = authJson.anthropic;
+    if (!isOAuthStored(auth)) {
+        return null;
+    }
+    const store = await loadAccountStore();
+    const index = findCurrentAccountIndex(store, auth);
+    const account = store.accounts[index];
+    if (!account) {
+        return { auth };
+    }
+    if (account.refresh !== auth.refresh && account.access !== auth.access) {
+        return { auth };
+    }
+    return {
+        auth,
+        account,
+        index,
+    };
+}
 export async function setAnthropicAuth(auth, client) {
     await writeAnthropicAuthFile(auth);
     await client.auth.set({ path: { id: 'anthropic' }, body: auth });

package/dist/bash-tool.js

@@ -0,0 +1,194 @@
+// Bash tool for the GenAI worker.
+// Executes shell commands in the project directory and can preload remote
+// SKILL.md files into a local cache so their metadata can be exposed to the model.
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { tool } from './ai-tool.js';
+import { getDataDir } from './config.js';
+import { execAsync } from './exec-async.js';
+import { parseFrontmatter } from './forum-sync/markdown.js';
+import { createLogger, LogPrefix } from './logger.js';
+const bashToolLogger = createLogger(LogPrefix.TOOLS);
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_SHELL = process.env['SHELL'] || '/bin/zsh';
+const bashToolGlobalState = (() => {
+    const key = '__kimakiBashToolState';
+    const state = globalThis;
+    if (!state[key]) {
+        state[key] = {
+            skills: new Map(),
+        };
+    }
+    return state[key];
+})();
+function getExecErrorFields({ error, }) {
+    if (!(error instanceof Error)) {
+        return {
+            exitCode: 1,
+            stderr: String(error),
+            stdout: '',
+        };
+    }
+    const execError = error;
+    return {
+        exitCode: typeof execError.code === 'number' ? execError.code : 1,
+        stderr: typeof execError.stderr === 'string' ? execError.stderr : error.message,
+        stdout: typeof execError.stdout === 'string' ? execError.stdout : '',
+    };
+}
+function sanitizeSkillName({ name }) {
+    return (name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'skill');
+}
+export function normalizeSkillMarkdownUrl({ url }) {
+    const parsed = new URL(url);
+    if (parsed.hostname !== 'github.com') {
+        return parsed.toString();
+    }
+    const parts = parsed.pathname.replace(/^\/+|\/+$/g, '').split('/');
+    if (parts.length < 5) {
+        return parsed.toString();
+    }
+    const [owner, repo, kind, ref, ...rest] = parts;
+    if (kind !== 'blob' || rest.length === 0) {
+        return parsed.toString();
+    }
+    return new URL(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${rest.join('/')}`).toString();
+}
+async function fetchSkillMarkdown({ url }) {
+    const normalizedUrl = normalizeSkillMarkdownUrl({ url });
+    const candidates = normalizedUrl === url ? [url] : [normalizedUrl, url];
+    let lastStatus = null;
+    for (const candidate of candidates) {
+        const response = await fetch(candidate);
+        if (!response.ok) {
+            lastStatus = response.status;
+            continue;
+        }
+        return response.text();
+    }
+    throw new Error(`Failed to fetch skill markdown from ${url}${lastStatus ? ` (last status ${lastStatus})` : ''}`);
+}
+async function cacheSkillMarkdown({ url, }) {
+    const markdown = await fetchSkillMarkdown({ url });
+    const parsed = parseFrontmatter({ markdown });
+    const name = parsed.frontmatter['name'];
+    const description = parsed.frontmatter['description'];
+    if (typeof name !== 'string' || name.trim().length === 0) {
+        throw new Error(`Skill at ${url} is missing a valid frontmatter name`);
+    }
+    if (typeof description !== 'string' || description.trim().length === 0) {
+        throw new Error(`Skill at ${url} is missing a valid frontmatter description`);
+    }
+    const root = path.join(getDataDir(), 'remote-skills', sanitizeSkillName({ name }));
+    await fs.promises.mkdir(root, { recursive: true });
+    const location = path.join(root, 'SKILL.md');
+    await fs.promises.writeFile(location, markdown, 'utf-8');
+    return {
+        content: parsed.body,
+        description,
+        location,
+        name,
+    };
+}
+export async function loadRemoteSkills({ skillUrls, }) {
+    const uniqueUrls = Array.from(new Set(skillUrls));
+    const loaded = await Promise.all(uniqueUrls.map(async (url) => {
+        const cached = bashToolGlobalState.skills.get(url);
+        if (cached) {
+            return cached;
+        }
+        const promise = cacheSkillMarkdown({ url }).catch((error) => {
+            bashToolGlobalState.skills.delete(url);
+            throw error;
+        });
+        bashToolGlobalState.skills.set(url, promise);
+        return promise;
+    }));
+    return loaded.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function formatAvailableSkillsXml({ skills, }) {
+    if (skills.length === 0) {
+        return 'No skills are currently available.';
+    }
+    return [
+        '<available_skills>',
+        ...skills.flatMap((skill) => {
+            return [
+                '  <skill>',
+                `    <name>${skill.name}</name>`,
+                `    <description>${skill.description}</description>`,
+                `    <location>${pathToFileURL(skill.location).href}</location>`,
+                '  </skill>',
+            ];
+        }),
+        '</available_skills>',
+    ].join('\n');
+}
+function buildDescription({ directory, skills, }) {
+    const lines = [
+        `Execute a shell command in ${directory}.`,
+        'Use `workdir` instead of `cd` commands when you need a different directory.',
+        'Return fields include `stdout`, `stderr`, and `exitCode`.',
+    ];
+    if (skills.length === 0) {
+        return lines.join('\n');
+    }
+    return [
+        ...lines,
+        '',
+        'Skills provide specialized instructions and workflows for specific tasks.',
+        'If a task matches a skill, read that SKILL.md file with bash before continuing.',
+        formatAvailableSkillsXml({ skills }),
+    ].join('\n');
+}
+export async function createBashTool({ directory, skillUrls = [], }) {
+    const skills = await loadRemoteSkills({ skillUrls });
+    const description = buildDescription({ directory, skills });
+    if (skills.length > 0) {
+        bashToolLogger.info('Loaded cached remote skills for bash tool', skills.map((skill) => {
+            return skill.name;
+        }));
+    }
+    return tool({
+        description,
+        inputSchema: z.object({
+            command: z.string().describe('The shell command to execute'),
+            timeout: z.number().optional().describe('Optional timeout in milliseconds'),
+            workdir: z
+                .string()
+                .optional()
+                .describe('Optional working directory. Use this instead of cd commands.'),
+            description: z.string().describe('Short explanation of what the command does'),
+            hasSideEffect: z
+                .boolean()
+                .optional()
+                .describe('Whether this command writes files or changes external state'),
+        }),
+        execute: async ({ command, timeout, workdir }) => {
+            const cwd = workdir || directory;
+            const result = await execAsync(command, {
+                cwd,
+                shell: DEFAULT_SHELL,
+                timeout: timeout ?? DEFAULT_TIMEOUT_MS,
+                maxBuffer: 1024 * 1024 * 10,
+            })
+                .then(({ stdout, stderr }) => {
+                return {
+                    exitCode: 0,
+                    stderr,
+                    stdout,
+                };
+            })
+                .catch((error) => {
+                return getExecErrorFields({ error });
+            });
+            return result;
+        },
+    });
+}

package/dist/bash-tool.test.js

@@ -0,0 +1,82 @@
+// Tests for the GenAI bash tool helper and remote skill loading cache.
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { setDataDir } from './config.js';
+import { formatAvailableSkillsXml, loadRemoteSkills, normalizeSkillMarkdownUrl, } from './bash-tool.js';
+const tempRoot = path.join(process.cwd(), 'tmp', 'bash-tool-tests');
+let server;
+let serverUrl = '';
+let requestCount = 0;
+beforeAll(async () => {
+    await fs.promises.mkdir(tempRoot, { recursive: true });
+    setDataDir(tempRoot);
+    server = http.createServer((request, response) => {
+        if (request.url !== '/skill.md') {
+            response.statusCode = 404;
+            response.end('missing');
+            return;
+        }
+        requestCount += 1;
+        response.setHeader('content-type', 'text/markdown; charset=utf-8');
+        response.end(`---
+name: remote-skill
+description: Remote cached skill for bash tool tests
+---
+
+# Remote skill
+
+Use this skill in tests.
+`);
+    });
+    await new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (typeof address === 'object' && address) {
+                serverUrl = `http://127.0.0.1:${address.port}/skill.md`;
+            }
+            resolve();
+        });
+    });
+});
+afterAll(async () => {
+    await new Promise((resolve, reject) => {
+        if (!server) {
+            resolve();
+            return;
+        }
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+});
+describe('normalizeSkillMarkdownUrl', () => {
+    test('converts GitHub blob URLs to raw content URLs', () => {
+        expect(normalizeSkillMarkdownUrl({
+            url: 'https://github.com/remorses/kimaki/blob/main/cli/skills/errore/SKILL.md',
+        })).toBe('https://raw.githubusercontent.com/remorses/kimaki/main/cli/skills/errore/SKILL.md');
+    });
+});
+describe('loadRemoteSkills', () => {
+    test('fetches once, caches, writes SKILL.md, and formats skill XML', async () => {
+        const first = await loadRemoteSkills({ skillUrls: [serverUrl] });
+        const second = await loadRemoteSkills({ skillUrls: [serverUrl] });
+        expect(requestCount).toBe(1);
+        expect(second[0]?.location).toBe(first[0]?.location);
+        expect(await fs.promises.readFile(first[0].location, 'utf-8')).toContain('name: remote-skill');
+        expect(formatAvailableSkillsXml({ skills: first })).toMatchInlineSnapshot(`
+      "<available_skills>
+        <skill>
+          <name>remote-skill</name>
+          <description>Remote cached skill for bash tool tests</description>
+          <location>file:///Users/morse/Documents/GitHub/kimakivoice/cli/tmp/bash-tool-tests/remote-skills/remote-skill/SKILL.md</location>
+        </skill>
+      </available_skills>"
+    `);
+    });
+});

package/dist/btw-prefix-detection.js

@@ -0,0 +1,17 @@
+// Detects the raw `btw ` Discord message shortcut used to fork a side-question
+// thread without invoking the /btw slash command UI.
+export function extractBtwPrefix(content) {
+    if (!content) {
+        return null;
+    }
+    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
+    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
+    if (!match) {
+        return null;
+    }
+    const prompt = match[1]?.trim();
+    if (!prompt) {
+        return null;
+    }
+    return { prompt };
+}

package/dist/btw-prefix-detection.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { extractBtwPrefix } from './btw-prefix-detection.js';
+describe('extractBtwPrefix', () => {
+    test('matches lowercase prefix', () => {
+        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches uppercase prefix', () => {
+        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "check this",
+      }
+    `);
+    });
+    test('keeps multiline content', () => {
+        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+      {
+        "prompt": "first line
+      second line",
+      }
+    `);
+    });
+    test('matches dot separator', () => {
+        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches comma separator', () => {
+        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches colon separator', () => {
+        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('matches punctuation without trailing space', () => {
+        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+      {
+        "prompt": "fix this",
+      }
+    `);
+    });
+    test('does not match without separating whitespace', () => {
+        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match mid-message', () => {
+        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    });
+    test('does not match empty payload', () => {
+        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    });
+});

package/dist/cli.js

@@ -10,7 +10,7 @@ import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChan
 import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, } from './database.js';
 import { ShareMarkdown } from './markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts, } from './session-search.js';
-import { formatWorktreeName } from './commands/new-worktree.js';
+import { formatWorktreeName, formatAutoWorktreeName } from './commands/new-worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { sendWelcomeMessage } from './onboarding-welcome.js';
 import { buildOpencodeEventLogLine } from './session-handler/opencode-session-event-log.js';
@@ -21,6 +21,7 @@ import { createDiscordRest, discordApiUrl, getDiscordRestApiUrl, getGatewayProxy
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import * as errore from 'errore';
 import { createLogger, formatErrorWithStack, initLogFile, LogPrefix } from './logger.js';
 import { initSentry, notifyError } from './sentry.js';
@@ -32,7 +33,7 @@ import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.
 import { startHranaServer } from './hrana-server.js';
 import { startIpcPolling, stopIpcPolling } from './ipc-polling.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, } from './task-schedule.js';
-import { accountLabel, accountsFilePath, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
+import { accountLabel, accountsFilePath, authFilePath, getCurrentAnthropicAccount, 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.
@@ -1287,6 +1288,14 @@ cli
     .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>)')
+    .option('--enable-skill <name>', z
+    .array(z.string())
+    .optional()
+    .describe('Whitelist a built-in skill by name. Only the listed skills are injected into the model (all others are hidden via an opencode permission.skill deny-all rule). Repeatable: pass --enable-skill multiple times. Mutually exclusive with --disable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
+    .option('--disable-skill <name>', z
+    .array(z.string())
+    .optional()
+    .describe('Blacklist a built-in skill by name. Listed skills are hidden from the model. Repeatable: pass --disable-skill multiple times. Mutually exclusive with --enable-skill. See https://github.com/remorses/kimaki/tree/main/cli/skills for available skills.'))
     .action(async (options) => {
     // Guard: only one kimaki bot process can run at a time (they share a lock
     // port). Running `kimaki` here would kill the already-running bot process
@@ -1321,13 +1330,54 @@ cli
                 process.exit(EXIT_NO_RESTART);
             }
         }
+        // --enable-skill and --disable-skill are mutually exclusive: the user
+        // either whitelists a small allowlist or blacklists a few unwanted
+        // skills, never both. Applied later in opencode.ts as permission.skill
+        // rules via computeSkillPermission().
+        const enabledSkills = options.enableSkill ?? [];
+        const disabledSkills = options.disableSkill ?? [];
+        if (enabledSkills.length > 0 && disabledSkills.length > 0) {
+            cliLogger.error('Cannot use --enable-skill and --disable-skill at the same time. Use one or the other.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Soft-validate skill names against the bundled skills/ folder. Users
+        // may rely on skills loaded from their own .opencode / .claude / .agents
+        // dirs, so unknown names only emit a warning rather than hard-failing.
+        if (enabledSkills.length > 0 || disabledSkills.length > 0) {
+            const bundledSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'skills');
+            const availableBundledSkills = (() => {
+                try {
+                    return fs
+                        .readdirSync(bundledSkillsDir, { withFileTypes: true })
+                        .filter((entry) => entry.isDirectory())
+                        .map((entry) => entry.name);
+                }
+                catch {
+                    return [];
+                }
+            })();
+            const availableSet = new Set(availableBundledSkills);
+            for (const name of [...enabledSkills, ...disabledSkills]) {
+                if (!availableSet.has(name)) {
+                    cliLogger.warn(`Skill "${name}" is not a bundled kimaki skill. Rule will still apply (user-provided skills from .opencode/.claude/.agents dirs may match). Available bundled skills: ${availableBundledSkills.join(', ')}`);
+                }
+            }
+        }
         store.setState({
             ...(options.verbosity && {
                 defaultVerbosity: options.verbosity,
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
+            ...(enabledSkills.length > 0 && { enabledSkills }),
+            ...(disabledSkills.length > 0 && { disabledSkills }),
         });
+        if (enabledSkills.length > 0) {
+            cliLogger.log(`Skill whitelist enabled: only [${enabledSkills.join(', ')}] will be injected`);
+        }
+        if (disabledSkills.length > 0) {
+            cliLogger.log(`Skill blacklist enabled: [${disabledSkills.join(', ')}] will be hidden`);
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }
@@ -1637,7 +1687,12 @@ cli
     .option('--wait', 'Wait for session to complete, then print session text to stdout')
     .action(async (options) => {
     try {
-        let { channel: channelId, prompt, name, appId: optionAppId, notifyOnly, thread: threadId, session: sessionId, } = options;
+        // `--name` / `--app-id` are optional-value flags: `undefined` when
+        // omitted, `''` when passed bare, a real string when given a value.
+        // `||` collapses `''` to `undefined` for downstream consumers.
+        const optionAppId = options.appId || undefined;
+        let { channel: channelId, prompt, notifyOnly, thread: threadId, session: sessionId, } = options;
+        let name = options.name || undefined;
         const { project: projectPath } = options;
         const sendAt = options.sendAt;
         const existingThreadMode = Boolean(threadId || sessionId);
@@ -1981,10 +2036,12 @@ cli
             (cleanPrompt.length > 80
                 ? cleanPrompt.slice(0, 77) + '...'
                 : cleanPrompt);
+        // Explicit string => use as-is via formatWorktreeName (no vowel strip).
+        // Boolean true => derived from thread/prompt, compress via formatAutoWorktreeName.
         const worktreeName = options.worktree
-            ? formatWorktreeName(typeof options.worktree === 'string'
-                ? options.worktree
-                : baseThreadName)
+            ? typeof options.worktree === 'string'
+                ? formatWorktreeName(options.worktree)
+                : formatAutoWorktreeName(baseThreadName)
             : undefined;
         const threadName = worktreeName
             ? `${WORKTREE_PREFIX}${baseThreadName}`
@@ -2238,6 +2295,33 @@ cli
     });
     process.exit(0);
 });
+cli
+    .command('anthropic-accounts current', 'Show the current Anthropic OAuth account being used, if any')
+    .action(async () => {
+    const current = await getCurrentAnthropicAccount();
+    console.log(`Store: ${accountsFilePath()}`);
+    console.log(`Auth: ${authFilePath()}`);
+    if (!current) {
+        console.log('No active Anthropic OAuth account configured.');
+        process.exit(0);
+    }
+    const lines = [];
+    lines.push(`Current: ${accountLabel(current.account || current.auth, current.index)}`);
+    if (current.account?.email) {
+        lines.push(`Email: ${current.account.email}`);
+    }
+    else {
+        lines.push('Email: unavailable');
+    }
+    if (current.account?.accountId) {
+        lines.push(`Account ID: ${current.account.accountId}`);
+    }
+    if (!current.account) {
+        lines.push('Rotation pool entry: not found');
+    }
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
 cli
     .command('anthropic-accounts remove <indexOrEmail>', 'Remove a stored Anthropic OAuth account from the rotation pool by index or email')
     .action(async (indexOrEmail) => {
@@ -2633,13 +2717,15 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const guildId = String(options.guild);
+        // Bare `--query` comes through as `''`; collapse it to undefined
+        const query = options.query || undefined;
         await initDatabase();
         const { token: botToken } = await resolveBotCredentials();
         const rest = createDiscordRest(botToken);
         const members = await (async () => {
-            if (options.query) {
+            if (query) {
                 return (await rest.get(Routes.guildMembersSearch(guildId), {
-                    query: new URLSearchParams({ query: options.query, limit: '20' }),
+                    query: new URLSearchParams({ query, limit: '20' }),
                 }));
             }
             return (await rest.get(Routes.guildMembers(guildId), {
@@ -2647,8 +2733,8 @@ cli
             }));
         })();
         if (members.length === 0) {
-            const msg = options.query
-                ? `No users found matching "${options.query}"`
+            const msg = query
+                ? `No users found matching "${query}"`
                 : 'No users found in guild';
             cliLogger.log(msg);
             process.exit(0);
@@ -2659,8 +2745,8 @@ cli
             return `- ${displayName} (ID: ${m.user.id}) - mention: <@${m.user.id}>`;
         })
             .join('\n');
-        const header = options.query
-            ? `Found ${members.length} users matching "${options.query}":`
+        const header = query
+            ? `Found ${members.length} users matching "${query}":`
             : `Found ${members.length} users:`;
         console.log(`${header}\n${userList}`);
         process.exit(0);
@@ -2693,10 +2779,10 @@ cli
     const { command } = parseCommandFromArgv(process.argv);
     await runTunnel({
         port,
-        tunnelId: options.tunnelId,
-        localHost: options.host,
+        tunnelId: options.tunnelId || undefined,
+        localHost: options.host || undefined,
         baseDomain: 'kimaki.dev',
-        serverUrl: options.server,
+        serverUrl: options.server || undefined,
         command: command.length > 0 ? command : undefined,
         kill: options.kill,
     });