@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/cli.js

@@ -1,651 +1,4293 @@
 #!/usr/bin/env node
-import { MANIFEST } from "./manifest.js";
-import { getInstalledVersion } from "./detect.js";
-import { readOpenCodeConfigState, writeOpenCodeConfig, ensureAgentMemoryConfig, ensureSubagentThreadSkill, mergePlugins, readOttoConfig, writeOttoConfig, buildSubagentThreadPolicy, mergeAgentPrompts, } from "./config.js";
-import { installMissingPackages, upgradePackage, planStableUpgrades } from "./installer.js";
-import fs from "node:fs";
-import path from "node:path";
-import { hasKimakiBinary, restartKimaki } from "./lifecycle.js";
-import { checkPackagePresence, checkConfigHealth, checkDirectoryHealth, checkTenantHealth } from "./health.js";
-import { syncUpstreams } from "./sync.js";
-import { runCompose } from "./docker.js";
-import { ensureTenantScaffold, resolveTenantMode } from "./tenant.js";
-import { searchSkills, getAllIndexedSkills, listInstalledSkills, installSkillFromIndex, installSkillsBaseline, removeSkill, ensureSkillsIndex, getConfiguredRepos, loadSkillsIndex, } from "./skills.js";
-import { GENTLEMAN_SKILLS_BASELINE } from "./skills-baseline.js";
-const args = process.argv.slice(2);
-const command = args[0] ?? "";
-const subCommand = args[1] ?? "";
-function mergeOttoManagedConfig(config) {
-    let merged = config;
-    for (const plugin of MANIFEST.plugins) {
-        merged = mergePlugins(merged, plugin);
-    }
-    // Read Otto's own config from otto.json (NOT from opencode.json)
-    const ottoConfig = readOttoConfig();
-    merged = mergeAgentPrompts(merged, buildSubagentThreadPolicy(ottoConfig));
-    return merged;
-}
-async function cmdInstall() {
-    console.log("Otto install — conservative mode\n");
-    // 1. Install missing global npm packages (CLI tools only)
-    const installed = installMissingPackages(getInstalledVersion);
-    if (installed.length > 0) {
-        console.log(`Installed: ${installed.join(", ")}`);
+// Main CLI entrypoint for the Otto Discord bot.
+// Handles interactive setup, Discord OAuth, slash command registration,
+// project channel creation, and launching the bot with opencode integration.
+import { goke } from 'goke';
+import { z } from 'zod';
+import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
+import { deduplicateByKey, generateBotInstallUrl, generateDiscordInstallUrlForBot, OTTO_GATEWAY_APP_ID, OTTO_WEBSITE_URL, abbreviatePath, buildOpenUrlCommand, getGatewayInstallTargetName, getGatewayPlatformDisplayName, shouldRegisterSlashCommands, } from './utils.js';
+import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, ensureOttoCategory, createProjectChannels, createDefaultOttoChannel, } from './discord-bot.js';
+import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getPrisma, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, getThreadDeletionSyncMode, setThreadDeletionSyncMode, resetThreadDeletionSyncMode, } from './database.js';
+import { ShareMarkdown } from './markdown.js';
+import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts, } from './session-search.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';
+import { selectResolvedCommand } from './opencode-command.js';
+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';
+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';
+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, validateWorktreeDirectory } from './worktrees.js';
+import { backgroundUpgradeOtto, 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';
+function isTelegramBridgeModule(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const withBridge = value;
+    return typeof withBridge.TelegramBridge === 'function';
+}
+import { accountLabel, accountsFilePath, authFilePath, getCurrentAnthropicAccount, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
+const cliLogger = createLogger(LogPrefix.CLI);
+// Gateway bot mode constants.
+// OTTO_GATEWAY_APP_ID is the Discord Application ID of the gateway bot.
+// OTTO_WEBSITE_URL is the website that handles OAuth callback + onboarding status.
+// OTTO_GATEWAY_PROXY_URL is the default Discord gateway-proxy base URL.
+// Telegram uses a separate OTTO_TELEGRAM_GATEWAY_PROXY_URL to avoid silently
+// connecting to a non-existent hardcoded host.
+const OTTO_GATEWAY_PROXY_URLS = {
+    discord: process.env.OTTO_GATEWAY_PROXY_URL ||
+        'wss://discord-gateway.otto.dev',
+    telegram: process.env.OTTO_TELEGRAM_GATEWAY_PROXY_URL,
+};
+function getGatewayProxyRestBaseUrlForPlatform({ gatewayPlatform, }) {
+    const gatewayUrl = OTTO_GATEWAY_PROXY_URLS[gatewayPlatform];
+    if (!gatewayUrl) {
+        return new Error(`Missing gateway URL for platform "${gatewayPlatform}". Set OTTO_${gatewayPlatform.toUpperCase()}_GATEWAY_PROXY_URL.`);
+    }
+    return getGatewayProxyRestBaseUrl({ gatewayUrl });
+}
+// Strip bracketed paste escape sequences from terminal input.
+// iTerm2 and other terminals wrap pasted content with \x1b[200~ and \x1b[201~
+// which can cause validation to fail on macOS. See: https://github.com/remorses/otto/issues/18
+function stripBracketedPaste(value) {
+    if (!value) {
+        return '';
+    }
+    return value
+        .replace(/\x1b\[200~/g, '')
+        .replace(/\x1b\[201~/g, '')
+        .trim();
+}
+function parseGatewayPlatform(value) {
+    if (value === 'telegram') {
+        return 'telegram';
+    }
+    return 'discord';
+}
+function getGatewayAppId({ gatewayPlatform, }) {
+    if (gatewayPlatform === 'telegram') {
+        return process.env.OTTO_TELEGRAM_GATEWAY_APP_ID || OTTO_GATEWAY_APP_ID;
+    }
+    return OTTO_GATEWAY_APP_ID;
+}
+// Derive the Discord Application ID from a bot token.
+// Discord bot tokens have the format: base64(userId).timestamp.hmac
+// The first segment is the bot's user ID (= Application ID) base64-encoded.
+// For gateway mode tokens (client_id:secret format), this function returns
+// undefined -- the caller should use OTTO_GATEWAY_APP_ID instead.
+function appIdFromToken(token) {
+    // Gateway mode tokens use "client_id:secret" format, not base64.
+    if (token.includes(':')) {
+        return undefined;
+    }
+    const segment = token.split('.')[0];
+    if (!segment) {
+        return undefined;
     }
-    else {
-        console.log("All packages already installed.");
-    }
-    // 2. Merge plugins + Otto policy into opencode.json
-    let configChanged = false;
-    const { config, status } = readOpenCodeConfigState();
-    if (status === "invalid") {
-        console.error("Error: opencode.json exists but is not valid JSON. Fix the file, then run otto again.");
-        process.exit(1);
-    }
-    // 2a. Ensure otto.json exists with defaults
-    const ottoConfig = readOttoConfig();
-    const ottoConfigChanged = writeOttoConfig(ottoConfig);
-    // 2b. Merge plugins + policy into opencode.json (NO otto key!)
-    const merged = mergeOttoManagedConfig(config);
-    configChanged = writeOpenCodeConfig(merged) || configChanged;
-    if (configChanged) {
-        console.log(`Updated opencode.json — added plugins: ${MANIFEST.plugins.join(", ")} + otto subagent policy`);
-    }
-    if (ottoConfigChanged) {
-        console.log("Created otto.json with defaults");
-    }
-    // 3. Ensure agent-memory.json exists
-    const created = ensureAgentMemoryConfig();
-    if (created) {
-        console.log("Created agent-memory.json with defaults");
-    }
-    // 4. Ensure otto-subagent-threads skill exists
-    const skillCreated = ensureSubagentThreadSkill();
-    if (skillCreated) {
-        console.log("Created otto-subagent-threads skill");
-    }
-    // 5. Install Otto-core skills from skills repo (best-effort)
     try {
-        ensureSkillsIndex();
-        const allSkills = getAllIndexedSkills();
-        const installedSkillNames = new Set(listInstalledSkills().map((s) => s.name));
-        const coreSkills = allSkills.filter((s) => s.source === "otto-assistant/skills" && !installedSkillNames.has(s.name));
-        for (const skill of coreSkills) {
-            const ok = installSkillFromIndex(skill.name);
-            if (ok)
-                console.log(`Installed skill: ${skill.name}`);
+        const decoded = Buffer.from(segment, 'base64').toString('utf8');
+        if (/^\d{17,20}$/.test(decoded)) {
+            return decoded;
         }
+        return undefined;
     }
     catch {
-        console.log("⚠ Could not fetch skills from GitHub (offline?). Skipping.");
+        return undefined;
+    }
+}
+// Resolve bot token and app ID from env var or database.
+// Used by CLI subcommands (send, project add) that need credentials
+// but don't run the interactive wizard.
+// In gateway mode, also sets store.discordBaseUrl so REST calls
+// are routed through the gateway-proxy REST endpoint.
+async function resolveBotCredentials({ appIdOverride } = {}) {
+    // DB first: getBotTokenWithMode() sets store.discordBaseUrl which is
+    // required in gateway mode so REST calls route through the proxy.
+    // Without this, inherited OTTO_BOT_TOKEN / OTTO_BOT_TOKEN (a gateway
+    // credential like clientId:clientSecret) would be sent directly to
+    // discord.com → 401.
+    const botRow = await getBotTokenWithMode().catch((e) => {
+        cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
+        return null;
+    });
+    if (botRow) {
+        return { token: botRow.token, appId: appIdOverride || botRow.appId };
+    }
+    // Fall back to env var for CI/headless deployments with no database
+    // Supports both OTTO_BOT_TOKEN (new) and OTTO_BOT_TOKEN (legacy)
+    const envToken = process.env.OTTO_BOT_TOKEN || process.env.OTTO_BOT_TOKEN;
+    if (envToken) {
+        const appId = appIdOverride || appIdFromToken(envToken);
+        return { token: envToken, appId };
+    }
+    cliLogger.error('No bot token found. Set OTTO_BOT_TOKEN env var or run `otto gateway start` first to set up.');
+    process.exit(EXIT_NO_RESTART);
+}
+function isThreadChannelType(type) {
+    return [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(type);
+}
+async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, }) {
+    const discordMaxLength = 2000;
+    if (prompt.length <= discordMaxLength) {
+        return (await rest.post(Routes.channelMessages(channelId), {
+            body: { content: prompt, embeds },
+        }));
     }
-    // 6. Restart kimaki if needed — but NOT if running inside kimaki
-    //    (kimaki restart kills the current opencode session)
-    const runningInsideKimaki = !!process.env.KIMAKI;
-    if (configChanged || installed.length > 0) {
-        if (runningInsideKimaki) {
-            console.log("\n⚠ Changes require kimaki restart. Run `kimaki restart` manually when ready.");
+    const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
+    const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
+    const tmpDir = path.join(process.cwd(), 'tmp');
+    if (!fs.existsSync(tmpDir)) {
+        fs.mkdirSync(tmpDir, { recursive: true });
+    }
+    const tmpFile = path.join(tmpDir, `prompt-${Date.now()}.md`);
+    // Wrap long lines so the file is readable in Discord's preview
+    // (Discord doesn't wrap text in file attachments)
+    const wrappedPrompt = prompt
+        .split('\n')
+        .flatMap((line) => {
+        if (line.length <= 120) {
+            return [line];
         }
-        else if (hasKimakiBinary()) {
-            console.log("Restarting kimaki...");
-            try {
-                restartKimaki();
-                console.log("Kimaki restarted.");
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`Warning: could not restart kimaki: ${msg}`);
-            }
+        const wrapped = [];
+        let remaining = line;
+        const maxCol = 120;
+        // Only soft-break at a space if it's reasonably close to maxCol,
+        // otherwise hard-break to avoid tiny fragments from early spaces
+        const minSoftBreak = 90;
+        while (remaining.length > maxCol) {
+            const lastSpace = remaining.lastIndexOf(' ', maxCol);
+            const useSoftBreak = lastSpace >= minSoftBreak;
+            const breakAt = useSoftBreak ? lastSpace : maxCol;
+            wrapped.push(remaining.slice(0, breakAt));
+            // Only consume the separator space on soft breaks
+            remaining = useSoftBreak
+                ? remaining.slice(breakAt + 1)
+                : remaining.slice(breakAt);
+        }
+        if (remaining.length > 0) {
+            wrapped.push(remaining);
+        }
+        return wrapped;
+    })
+        .join('\n');
+    fs.writeFileSync(tmpFile, wrappedPrompt);
+    try {
+        const formData = new FormData();
+        formData.append('payload_json', JSON.stringify({
+            content: summaryContent,
+            attachments: [{ id: 0, filename: 'prompt.md' }],
+            embeds,
+        }));
+        const buffer = fs.readFileSync(tmpFile);
+        formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
+        const starterMessageResponse = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bot ${botToken}`,
+            },
+            body: formData,
+        });
+        if (!starterMessageResponse.ok) {
+            const error = await starterMessageResponse.text();
+            throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
         }
+        return (await starterMessageResponse.json());
+    }
+    finally {
+        fs.unlinkSync(tmpFile);
     }
-    console.log("\nDone!");
 }
-async function cmdUpgrade(mode) {
-    console.log(`Otto upgrade — mode: ${mode}\n`);
-    const packageNames = Object.keys(MANIFEST.packages);
-    let didUpgradePackages = false;
-    if (mode === "stable") {
-        const upgradePlan = planStableUpgrades(packageNames, getInstalledVersion, MANIFEST.pinned);
-        if (upgradePlan.length === 0) {
-            console.log("Nothing to upgrade — already at pinned stable versions.");
-        }
-        else {
-            console.log("Will upgrade:");
-            for (const { name, current, target } of upgradePlan) {
-                console.log(`  ${name}: ${current ?? "not installed"} → ${target}`);
+function formatRelativeTime(target) {
+    const diffMs = target.getTime() - Date.now();
+    if (diffMs <= 0) {
+        return 'due now';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `${totalMinutes}m`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours < 24) {
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+}
+function formatTaskScheduleLine(schedule) {
+    if (schedule.scheduleKind === 'at') {
+        return `one-time at ${schedule.runAt.toISOString()}`;
+    }
+    return `cron "${schedule.cronExpr}" (${schedule.timezone}) next ${schedule.nextRunAt.toISOString()}`;
+}
+const EXIT_NO_RESTART = 64;
+function canUseInteractivePrompts() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function exitNonInteractiveSetup() {
+    cliLogger.error('Setup requires an interactive terminal (TTY) for prompts. Run `otto gateway start` in an interactive shell to complete setup.');
+    process.exit(EXIT_NO_RESTART);
+}
+async function resolveTelegramRuntimeConfig({ telegramBotToken, telegramChatId, }) {
+    const isInteractive = canUseInteractivePrompts();
+    const envTelegramBotToken = process.env.OTTO_TELEGRAM_BOT_TOKEN;
+    const envTelegramChatId = process.env.OTTO_TELEGRAM_CHAT_ID;
+    const resolvedTelegramBotToken = stripBracketedPaste(telegramBotToken || envTelegramBotToken || '') || (isInteractive
+        ? await (async () => {
+            const input = await password({
+                message: 'Enter Telegram bot token (from @BotFather):',
+                validate(value) {
+                    const cleaned = stripBracketedPaste(value);
+                    if (!cleaned) {
+                        return 'Telegram bot token is required';
+                    }
+                },
+            });
+            if (isCancel(input)) {
+                cancel('Setup cancelled');
+                process.exit(0);
             }
-            for (const { name } of upgradePlan) {
-                console.log(`Upgrading ${name}...`);
-                upgradePackage(name, mode);
+            return stripBracketedPaste(input);
+        })()
+        : '');
+    const resolvedTelegramChatIdRaw = stripBracketedPaste(telegramChatId || envTelegramChatId || '') || (isInteractive
+        ? await (async () => {
+            const input = await text({
+                message: 'Enter Telegram chat ID (supergroup id):',
+                validate(value) {
+                    const cleaned = stripBracketedPaste(value);
+                    if (!cleaned) {
+                        return 'Telegram chat ID is required';
+                    }
+                    if (!/^-?\d+$/.test(cleaned)) {
+                        return 'Telegram chat ID must be numeric';
+                    }
+                },
+            });
+            if (isCancel(input)) {
+                cancel('Setup cancelled');
+                process.exit(0);
             }
-        }
-        didUpgradePackages = upgradePlan.length > 0;
+            return stripBracketedPaste(input);
+        })()
+        : '');
+    if (!resolvedTelegramBotToken || !resolvedTelegramChatIdRaw) {
+        return new Error('Telegram mode requires token and chat id. Provide --telegram-bot-token and --telegram-chat-id (or OTTO_TELEGRAM_BOT_TOKEN and OTTO_TELEGRAM_CHAT_ID).');
     }
-    else {
-        console.log("Will upgrade:");
-        for (const name of packageNames) {
-            const current = getInstalledVersion(name);
-            console.log(`  ${name}: ${current ?? "not installed"} → latest`);
-        }
-        for (const name of packageNames) {
-            console.log(`Upgrading ${name}...`);
-            upgradePackage(name, mode);
-        }
-        didUpgradePackages = packageNames.length > 0;
-    }
-    // Ensure plugins + Otto policy are in config
-    const { config, status } = readOpenCodeConfigState();
-    if (status === "invalid") {
-        console.error("Error: opencode.json exists but is not valid JSON. Fix the file, then run otto again.");
-        process.exit(1);
-    }
-    // Ensure otto.json exists
-    const ottoConfig = readOttoConfig();
-    writeOttoConfig(ottoConfig);
-    const merged = mergeOttoManagedConfig(config);
-    const configChanged = writeOpenCodeConfig(merged);
-    // Ensure skill file is up to date
-    ensureSubagentThreadSkill();
-    // Restart — but NOT inside kimaki session
-    // Only restart if anything actually changed.
-    const runningInsideKimaki = !!process.env.KIMAKI;
-    if (didUpgradePackages || configChanged) {
-        if (runningInsideKimaki) {
-            console.log("\n⚠ Changes require kimaki restart. Run `kimaki restart` manually when ready.");
-        }
-        else if (hasKimakiBinary()) {
-            console.log("Restarting kimaki...");
-            try {
-                restartKimaki();
-                console.log("Kimaki restarted.");
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`Warning: could not restart kimaki: ${msg}`);
-            }
-        }
-    }
-    console.log("\nDone!");
-}
-async function cmdStatus() {
-    console.log("Otto status\n");
-    console.log(`Otto version: ${MANIFEST.version}\n`);
-    console.log("Packages:");
-    const packages = checkPackagePresence();
-    for (const pkg of packages) {
-        const icon = pkg.status === "ok" ? "✓" : "✗";
-        console.log(`  ${icon} ${pkg.name}: ${pkg.installed ?? "not installed"} (requires ${pkg.required})`);
-    }
-    console.log("\nConfig:");
-    const configHealth = checkConfigHealth();
-    console.log(`  opencode.json: ${configHealth.opencodeJson}`);
-    console.log(`  agent-memory.json: ${configHealth.agentMemoryJson}`);
-    console.log(`  otto.json: ${configHealth.ottoJson}`);
-    console.log(`  plugins: ${configHealth.plugins.length > 0 ? configHealth.plugins.join(", ") : "(none)"}`);
-    console.log(`  memory plugin: ${configHealth.memoryPluginEnabled ? "enabled" : "NOT enabled"}`);
-    console.log(`  subagent threads: ${configHealth.subagentThreadsEnabled ? "enabled" : "disabled"}`);
-    console.log(`  ask before thread delete: ${configHealth.subagentThreadsAskBeforeDelete ? "yes" : "no"}`);
-    console.log(`  auto delete thread on complete: ${configHealth.subagentThreadsAutoDelete ? "yes" : "no"}`);
-    console.log(`  kimaki process: ${configHealth.kimakiRunning ? "running" : "not running"}`);
-    console.log("\nSkills:");
-    const skillsInstalled = listInstalledSkills();
-    console.log(`  installed: ${skillsInstalled.length > 0 ? skillsInstalled.map((s) => s.name).join(", ") : "(none)"}`);
-    try {
-        const index = loadSkillsIndex();
-        const repoCount = Object.keys(index.repos).length;
-        const totalIndexed = getAllIndexedSkills().length;
-        console.log(`  indexed: ${totalIndexed} skills from ${repoCount} repos`);
+    const chatId = Number.parseInt(resolvedTelegramChatIdRaw, 10);
+    if (!Number.isFinite(chatId)) {
+        return new Error('Telegram chat ID must be numeric');
     }
-    catch {
-        console.log("  indexed: (unavailable)");
+    return { botToken: resolvedTelegramBotToken, chatId };
+}
+// Emit a structured JSON line on stdout for non-TTY consumers (cloud sandboxes, CI).
+// Each line is a self-contained JSON object with a "type" field for easy parsing.
+// Lines are prefixed with "data: " and terminated with "\n\n" (SSE format) so consumers
+// can use the eventsource-parser npm package to robustly extract JSON events from noisy
+// process output (other log lines, warnings, etc. are ignored by the parser).
+function emitJsonEvent(event) {
+    process.stdout.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+async function resolveGatewayInstallCredentials({ gatewayPlatform, }) {
+    const appId = getGatewayAppId({ gatewayPlatform });
+    if (!appId) {
+        return new Error('Gateway mode is not available yet. OTTO_GATEWAY_APP_ID is not configured.');
     }
+    const prisma = await getPrisma();
+    const gatewayBot = await prisma.bot_tokens.findUnique({
+        where: { app_id: appId },
+    });
+    if (gatewayBot?.client_id && gatewayBot.client_secret) {
+        return {
+            appId,
+            clientId: gatewayBot.client_id,
+            clientSecret: gatewayBot.client_secret,
+            createdNow: false,
+        };
+    }
+    const clientId = crypto.randomUUID();
+    const clientSecret = crypto.randomBytes(32).toString('hex');
+    const gatewayRestBaseUrl = gatewayPlatform === 'telegram'
+        ? null
+        : getGatewayProxyRestBaseUrlForPlatform({
+            gatewayPlatform,
+        });
+    if (gatewayRestBaseUrl instanceof Error) {
+        return gatewayRestBaseUrl;
+    }
+    await setBotMode({
+        appId,
+        mode: 'gateway',
+        clientId,
+        clientSecret,
+        proxyUrl: gatewayRestBaseUrl,
+    });
+    return {
+        appId,
+        clientId,
+        clientSecret,
+        createdNow: true,
+    };
 }
-async function cmdDoctor() {
-    console.log("Otto doctor\n");
-    let hasErrors = false;
-    console.log("Checking packages...");
-    const packages = checkPackagePresence();
-    for (const pkg of packages) {
-        if (pkg.status === "missing") {
-            console.log(`  ✗ ${pkg.name} — not installed (requires ${pkg.required})`);
-            hasErrors = true;
+async function printDiscordInstallUrlAndExit({ gateway, gatewayPlatform = 'discord', gatewayCallbackUrl, } = {}) {
+    await initDatabase();
+    if (gateway) {
+        const gatewayCredentials = await resolveGatewayInstallCredentials({
+            gatewayPlatform,
+        });
+        if (gatewayCredentials instanceof Error) {
+            cliLogger.error(`Failed to resolve gateway install URL: ${gatewayCredentials.message}`);
+            process.exit(EXIT_NO_RESTART);
         }
-        else {
-            console.log(`  ✓ ${pkg.name}: ${pkg.installed}`);
+        const installUrl = generateDiscordInstallUrlForBot({
+            appId: gatewayCredentials.appId,
+            mode: 'gateway',
+            clientId: gatewayCredentials.clientId,
+            clientSecret: gatewayCredentials.clientSecret,
+            gatewayPlatform,
+            gatewayCallbackUrl,
+        });
+        if (installUrl instanceof Error) {
+            cliLogger.error(`Failed to build install URL: ${installUrl.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log(installUrl);
+        if (gatewayCredentials.createdNow) {
+            cliLogger.log('Generated and saved new local gateway client credentials.');
         }
+        cliLogger.log('This gateway install URL contains your client credentials. Do not share it.');
+        process.exit(0);
     }
-    console.log("\nChecking config...");
-    const configHealth = checkConfigHealth();
-    if (configHealth.opencodeJson === "error") {
-        console.log("  ✗ opencode.json is not valid JSON — fix syntax, then run `otto install`");
-        hasErrors = true;
+    const existingBot = await getBotTokenWithMode();
+    if (!existingBot) {
+        cliLogger.error('No bot configured yet. Run `otto gateway start` first to set up.');
+        process.exit(EXIT_NO_RESTART);
     }
-    if (configHealth.memoryPluginEnabled) {
-        console.log("  ✓ mempalace plugin enabled");
+    const installUrl = generateDiscordInstallUrlForBot({
+        appId: existingBot.appId,
+        mode: existingBot.mode,
+        clientId: existingBot.clientId,
+        clientSecret: existingBot.clientSecret,
+    });
+    if (installUrl instanceof Error) {
+        cliLogger.error(`Failed to build install URL: ${installUrl.message}`);
+        process.exit(EXIT_NO_RESTART);
     }
-    else {
-        console.log("  ✗ mempalace plugin NOT enabled — run `otto install`");
-        hasErrors = true;
+    cliLogger.log(installUrl);
+    if (existingBot.mode === 'gateway') {
+        cliLogger.log('This gateway install URL contains your client credentials. Do not share it.');
     }
-    if (configHealth.subagentPolicyInjected) {
-        console.log("  ✓ otto subagent thread policy injected");
+    process.exit(0);
+}
+// Detect if a CLI tool is installed, prompt to install if missing.
+// Uses official install scripts with platform-specific commands for Unix vs Windows.
+// Sets process.env[envPathKey] to the found binary path for the current session.
+// After install, re-checks PATH first, then falls back to common install locations.
+async function ensureCommandAvailable({ name, envPathKey, installUnix, installWindows, possiblePathsUnix, possiblePathsWindows, }) {
+    if (process.env[envPathKey]) {
+        return;
     }
-    else {
-        console.log("  ✗ otto subagent thread policy missing — run `otto install`");
-        hasErrors = true;
+    const isWindows = process.platform === 'win32';
+    const whichCmd = isWindows ? 'where' : 'which';
+    const isInstalled = await execAsync(`${whichCmd} ${name}`, {
+        env: process.env,
+    }).then(() => {
+        return true;
+    }, () => {
+        return false;
+    });
+    if (isInstalled) {
+        return;
     }
-    if (configHealth.kimakiRunning) {
-        console.log("  ✓ kimaki is running");
+    note(`${name} is required but not found in your PATH.`, `${name} Not Found`);
+    // In non-TTY (cloud sandbox, CI), auto-install without prompting.
+    // In interactive mode, ask the user first.
+    if (canUseInteractivePrompts()) {
+        const shouldInstall = await confirm({
+            message: `Would you like to install ${name} right now?`,
+        });
+        if (isCancel(shouldInstall) || !shouldInstall) {
+            cancel(`${name} is required to run this bot`);
+            process.exit(EXIT_NO_RESTART);
+        }
     }
     else {
-        console.log("  ⚠ kimaki is not running");
+        cliLogger.log(`Auto-installing ${name} (non-interactive mode)...`);
+    }
+    cliLogger.log(`Installing ${name}...`);
+    try {
+        // Use explicit shell invocation to avoid Node shell-mode quirks on Windows.
+        // PowerShell needs -NoProfile and -ExecutionPolicy Bypass for install scripts.
+        // Unix uses login shell (-l) so install scripts can update PATH in shell config.
+        const cmd = isWindows ? 'powershell.exe' : '/bin/bash';
+        const args = isWindows
+            ? ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', installWindows]
+            : ['-lc', installUnix];
+        await new Promise((resolve, reject) => {
+            const child = spawn(cmd, args, { stdio: 'inherit', env: process.env });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`${name} install exited with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+        cliLogger.log(`${name} installed successfully!`);
     }
-    console.log("\nChecking directories...");
-    const dirs = checkDirectoryHealth();
-    for (const d of dirs) {
-        const icon = d.status === "ok" ? "✓" : d.status === "warn" ? "⚠" : "✗";
-        console.log(`  ${icon} ${d.name}: ${d.message}`);
-        if (d.status === "error")
-            hasErrors = true;
+    catch (error) {
+        cliLogger.log(`Failed to install ${name}`);
+        cliLogger.error('Installation error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
     }
-    console.log("\nChecking skills...");
-    const skillsInstalled = listInstalledSkills();
-    if (skillsInstalled.length > 0) {
-        console.log(`  ✓ ${skillsInstalled.length} skill(s) installed`);
+    // After install, re-check PATH first (install script may have added it)
+    const foundInPath = await execAsync(`${whichCmd} ${name}`, {
+        env: process.env,
+    }).then((result) => {
+        const resolved = selectResolvedCommand({
+            output: result.stdout,
+            isWindows,
+        });
+        return resolved || '';
+    }, () => {
+        return '';
+    });
+    if (foundInPath) {
+        process.env[envPathKey] = foundInPath;
+        return;
     }
-    else {
-        console.log("  ⚠ No skills installed — run `otto skills add --all`");
+    // Fall back to probing common install locations
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const accessFlag = isWindows ? fs.constants.F_OK : fs.constants.X_OK;
+    const possiblePaths = (isWindows ? possiblePathsWindows : possiblePathsUnix)
+        .filter((p) => {
+        return !p.startsWith('~') || home;
+    })
+        .map((p) => {
+        return p.replace('~', home);
+    });
+    const installedPath = possiblePaths.find((p) => {
+        try {
+            fs.accessSync(p, accessFlag);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!installedPath) {
+        note(`${name} was installed but may not be available in this session.\n` +
+            'Please restart your terminal and run this command again.', 'Restart Required');
+        process.exit(EXIT_NO_RESTART);
+    }
+    process.env[envPathKey] = installedPath;
+}
+// Run opencode upgrade in the background so the user always has the latest version.
+// Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Uses -w to watch the parent PID so caffeinate self-terminates if otto
+// exits for any reason (SIGTERM, crash, process.exit, supervisor stop).
+function startCaffeinate() {
+    if (process.platform !== 'darwin') {
+        return;
     }
     try {
-        const totalIndexed = getAllIndexedSkills().length;
-        if (totalIndexed > 0) {
-            console.log(`  ✓ Skills index available (${totalIndexed} skills)`);
+        const proc = spawn('caffeinate', ['-i', '-w', String(process.pid)], {
+            stdio: 'ignore',
+            detached: false,
+        });
+        proc.unref();
+        proc.on('error', (err) => {
+            cliLogger.warn('Failed to start caffeinate:', err.message);
+        });
+        cliLogger.log('Started caffeinate to prevent system sleep');
+    }
+    catch (err) {
+        cliLogger.warn('Failed to spawn caffeinate:', err instanceof Error ? err.message : String(err));
+    }
+}
+const cli = goke('otto');
+process.title = 'otto';
+import { store } from './store.js';
+import { registerCommands, SKIP_USER_COMMANDS } from './discord-command-registration.js';
+async function collectOttoChannels({ guilds, }) {
+    const guildResults = await Promise.all(guilds.map(async (guild) => {
+        const channels = await getChannelsWithDescriptions(guild);
+        const ottoChans = channels.filter((ch) => ch.ottoDirectory);
+        return { guild, channels: ottoChans };
+    }));
+    return guildResults.filter((result) => {
+        return result.channels.length > 0;
+    });
+}
+/**
+ * Store channel-directory mappings in the database.
+ * Called after Discord login to persist channel configurations.
+ */
+async function storeChannelDirectories({ ottoChannels, }) {
+    for (const { guild, channels } of ottoChannels) {
+        for (const channel of channels) {
+            if (channel.ottoDirectory) {
+                await setChannelDirectory({
+                    channelId: channel.id,
+                    directory: channel.ottoDirectory,
+                    channelType: 'text',
+                    skipIfExists: true,
+                });
+                const voiceChannel = guild.channels.cache.find((ch) => ch.type === ChannelType.GuildVoice && ch.name === channel.name);
+                if (voiceChannel) {
+                    await setChannelDirectory({
+                        channelId: voiceChannel.id,
+                        directory: channel.ottoDirectory,
+                        channelType: 'voice',
+                        skipIfExists: true,
+                    });
+                }
+            }
+        }
+    }
+}
+/**
+ * Show the ready message with channel links.
+ * Called at the end of startup to display available channels.
+ */
+function showReadyMessage({ ottoChannels, createdChannels, gatewayPlatform, }) {
+    const allChannels = [];
+    allChannels.push(...createdChannels);
+    ottoChannels.forEach(({ guild, channels }) => {
+        channels.forEach((ch) => {
+            allChannels.push({
+                name: ch.name,
+                id: ch.id,
+                guildId: guild.id,
+                directory: ch.ottoDirectory,
+            });
+        });
+    });
+    if (allChannels.length > 0) {
+        if (gatewayPlatform === 'telegram') {
+            const channelList = allChannels
+                .map((ch) => {
+                return `• #${ch.name}`;
+            })
+                .join('\n');
+            note(`Your otto channels are ready!\n\n${channelList}\n\nSend a message in your configured Telegram chat to start using OpenCode!`, '🚀 Ready to Use');
         }
         else {
-            console.log("  ⚠ Skills index empty — run `otto skills update`");
+            const channelLinks = allChannels
+                .map((ch) => `• #${ch.name}: https://discord.com/channels/${ch.guildId}/${ch.id}`)
+                .join('\n');
+            note(`Your otto channels are ready! Click any link below to open in Discord:\n\n${channelLinks}\n\nSend a message in any channel to start using OpenCode!`, '🚀 Ready to Use');
         }
     }
-    catch {
-        console.log("  ⚠ Skills index unavailable");
-    }
-    console.log(hasErrors ? "\n✗ Issues found. Run `otto install` to fix." : "\n✓ All checks passed!");
-}
-// ---------------------------------------------------------------------------
-// otto skills sub-commands
-// ---------------------------------------------------------------------------
-async function cmdSkills(subArgs) {
-    const skillCommand = subArgs[0] ?? "";
-    switch (skillCommand) {
-        case "list":
-            cmdSkillsList();
-            break;
-        case "search": {
-            const query = subArgs.slice(1).join(" ");
-            if (!query) {
-                console.log("Usage: otto skills search <query>");
-                process.exit(1);
+    note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `otto gateway start` again to start the gateway.', '⚠️  Keep Running');
+}
+/**
+ * Create the default otto channel in each guild and send a welcome message.
+ * Idempotent: skips guilds that already have the channel.
+ * Extracted so both the interactive and headless startup paths share the same logic.
+ */
+async function ensureDefaultChannelsWithWelcome({ guilds, discordClient, appId, isGatewayMode, installerDiscordUserId, }) {
+    const created = [];
+    for (const guild of guilds) {
+        try {
+            const result = await createDefaultOttoChannel({
+                guild,
+                botName: discordClient.user?.username,
+                appId,
+                isGatewayMode,
+            });
+            if (result) {
+                created.push({
+                    name: result.channelName,
+                    id: result.textChannelId,
+                    guildId: guild.id,
+                });
+                // Send welcome message to the newly created default channel.
+                // Mention the installer so they get a notification.
+                const mentionUserId = installerDiscordUserId || guild.ownerId;
+                await sendWelcomeMessage({
+                    channel: result.textChannel,
+                    mentionUserId,
+                });
             }
-            cmdSkillsSearch(query);
-            break;
         }
-        case "browse":
-            cmdSkillsBrowse();
-            break;
-        case "add": {
-            const arg = subArgs[1];
-            if (!arg || arg === "--all") {
-                await cmdSkillsAddAll();
-            }
-            else {
-                await cmdSkillsAddOne(arg);
-            }
-            break;
+        catch (error) {
+            cliLogger.warn(`Failed to create default otto channel in ${guild.name}: ${error instanceof Error ? error.stack : String(error)}`);
         }
-        case "remove": {
-            const name = subArgs[1];
-            if (!name) {
-                console.log("Usage: otto skills remove <name>");
-                process.exit(1);
+    }
+    return created;
+}
+/**
+ * Background initialization for quick start mode.
+ * Starts OpenCode server and registers slash commands without blocking bot startup.
+ */
+async function backgroundInit({ currentDir, token, appId, guildIds, gatewayPlatform, }) {
+    try {
+        const shouldRegisterForPlatform = shouldRegisterSlashCommands({
+            gatewayPlatform,
+        });
+        const opencodeResult = await initializeOpencodeForDirectory(currentDir);
+        if (opencodeResult instanceof Error) {
+            cliLogger.warn('Background OpenCode init failed:', opencodeResult.message);
+            if (shouldRegisterForPlatform) {
+                // Still try to register basic commands without user commands/agents
+                await registerCommands({
+                    token,
+                    appId,
+                    guildIds,
+                    userCommands: [],
+                    agents: [],
+                });
             }
-            cmdSkillsRemove(name);
-            break;
+            return;
+        }
+        const getClient = opencodeResult;
+        const [userCommands, agents] = await Promise.all([
+            getClient()
+                .command.list({ directory: currentDir })
+                .then((r) => r.data || [])
+                .catch((error) => {
+                cliLogger.warn('Failed to load user commands during background init:', error instanceof Error ? error.stack : String(error));
+                return [];
+            }),
+            getClient()
+                .app.agents({ directory: currentDir })
+                .then((r) => r.data || [])
+                .catch((error) => {
+                cliLogger.warn('Failed to load agents during background init:', error instanceof Error ? error.stack : String(error));
+                return [];
+            }),
+        ]);
+        if (shouldRegisterForPlatform) {
+            await registerCommands({ token, appId, guildIds, userCommands, agents });
+            cliLogger.log('Slash commands registered!');
+        }
+        else {
+            const platformName = getGatewayPlatformDisplayName({ gatewayPlatform });
+            cliLogger.log(`Skipping slash command registration in ${platformName} gateway mode`);
         }
-        case "update":
-            cmdSkillsUpdate();
-            break;
-        case "repos":
-            cmdSkillsRepos();
-            break;
-        default:
-            console.log(`Otto skills — discover and install agent skills from public repos
-
-Usage:
-  otto skills search <query>     Search skills by name/description
-  otto skills browse             Browse all available skills
-  otto skills list               List installed skills
-  otto skills add <name>         Install a skill
-  otto skills add --all          Install all skills from otto-assistant/skills
-  otto skills update             Refresh skills index from GitHub
-  otto skills remove <name>      Remove an installed skill
-  otto skills repos              Show configured skill repositories
-`);
-            break;
+    }
+    catch (error) {
+        cliLogger.error('Background init failed:', error instanceof Error ? error.stack : String(error));
+        void notifyError(error, 'Background init failed');
     }
 }
-function cmdSkillsSearch(query) {
-    console.log(`Searching: "${query}"\n`);
-    const { refreshed } = ensureSkillsIndex();
-    if (refreshed > 0) {
-        console.log(`Updated index (${refreshed} repo(s) refreshed).\n`);
+// Resolve bot credentials from (in priority order):
+// 1. OTTO_BOT_TOKEN env var (headless/CI deployments)
+// 2. Saved credentials in the database (self-hosted or gateway mode)
+// 3. Interactive wizard (gateway OAuth or self-hosted token entry)
+//
+// credentialSource tells the caller how creds were obtained:
+//   'env'    — OTTO_BOT_TOKEN env var
+//   'saved'  — reused from database
+//   'wizard' — user just completed onboarding (gateway OAuth or self-hosted)
+async function resolveCredentials({ forceRestartOnboarding, forceGateway, gatewayPlatform, gatewayCallbackUrl, telegramBotToken, telegramChatId, }) {
+    const envToken = process.env.OTTO_BOT_TOKEN;
+    const existingBot = await getBotTokenWithMode();
+    // When --gateway is requested and the resolved bot is still self-hosted,
+    // check if saved gateway credentials exist by looking up the gateway app_id
+    // directly. This lets users switch back and forth between modes without
+    // re-running the onboarding wizard each time.
+    const gatewayAppId = getGatewayAppId({ gatewayPlatform });
+    const hasGatewayCreds = (forceGateway && existingBot?.mode !== 'gateway')
+        ? await (await getPrisma()).bot_tokens.findUnique({
+            where: { app_id: gatewayAppId },
+        })
+        : undefined;
+    // 1. Env var takes precedence (headless deployments)
+    if (envToken && !forceRestartOnboarding && !forceGateway) {
+        const derivedAppId = appIdFromToken(envToken);
+        if (!derivedAppId) {
+            cliLogger.error('Could not derive Application ID from OTTO_BOT_TOKEN. The token appears malformed.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        await setBotToken(derivedAppId, envToken);
+        cliLogger.log(`Using OTTO_BOT_TOKEN env var (App ID: ${derivedAppId})`);
+        return { appId: derivedAppId, token: envToken, credentialSource: 'env', isGatewayMode: false };
     }
-    const results = searchSkills(query);
-    if (results.length === 0) {
-        console.log("No skills found.");
-        return;
+    // 2. Saved credentials in the database
+    // Reuse saved creds unless: --restart-onboarding forces re-setup, or --gateway
+    // overrides saved self-hosted creds (saved gateway creds are still used).
+    const canReuseSavedCreds = existingBot && !forceRestartOnboarding
+        && !(forceGateway && existingBot.mode !== 'gateway');
+    if (canReuseSavedCreds) {
+        const modeLabel = existingBot.mode === 'gateway' ? ' (gateway mode)' : '';
+        note(`Using saved bot credentials${modeLabel}:\nApp ID: ${existingBot.appId}\n\nTo use different credentials, run with --restart-onboarding`, 'Existing Bot Found');
+        if (existingBot.mode !== 'gateway') {
+            note(`Bot install URL (in case you need to add it to another server):\n${generateBotInstallUrl({ clientId: existingBot.appId })}`, 'Install URL');
+        }
+        return { appId: existingBot.appId, token: existingBot.token, credentialSource: 'saved', isGatewayMode: existingBot.mode === 'gateway' };
     }
-    for (const skill of results) {
-        console.log(`  ${skill.name} — ${skill.description}`);
-        console.log(`    source: ${skill.source}`);
+    // 2b. Switching to gateway: saved gateway credentials exist from a previous
+    // gateway setup. Reuse them without re-running the onboarding wizard.
+    if (hasGatewayCreds && !forceRestartOnboarding) {
+        const gatewayToken = (hasGatewayCreds.client_id && hasGatewayCreds.client_secret)
+            ? `${hasGatewayCreds.client_id}:${hasGatewayCreds.client_secret}`
+            : hasGatewayCreds.token;
+        note(`Switching to saved gateway credentials:\nApp ID: ${hasGatewayCreds.app_id}`, 'Mode Switch');
+        return {
+            appId: hasGatewayCreds.app_id,
+            token: gatewayToken,
+            credentialSource: 'saved',
+            isGatewayMode: true,
+        };
     }
-    console.log(`\n${results.length} skill(s) found. Install with: otto skills add <name>`);
-}
-function cmdSkillsBrowse() {
-    console.log("Otto skills — browsing all available\n");
-    const { refreshed } = ensureSkillsIndex();
-    if (refreshed > 0) {
-        console.log(`Updated index (${refreshed} repo(s) refreshed).\n`);
+    // 3. Interactive setup wizard (first-time users, --restart-onboarding, or --gateway override).
+    //    Non-TTY: gateway mode proceeds headlessly (JSON events on stdout),
+    //    self-hosted mode requires interactive prompts so we exit.
+    if (!canUseInteractivePrompts() && !forceGateway) {
+        exitNonInteractiveSetup();
+    }
+    if (existingBot && forceGateway && existingBot.mode !== 'gateway') {
+        note('Ignoring saved self-hosted credentials due to --gateway flag.\nSwitching to gateway mode.', 'Gateway Mode');
     }
-    const allSkills = getAllIndexedSkills();
-    const installed = new Set(listInstalledSkills().map((s) => s.name));
-    // Group by source repo
-    const byRepo = {};
-    for (const skill of allSkills) {
-        if (!byRepo[skill.source])
-            byRepo[skill.source] = [];
-        byRepo[skill.source].push(skill);
+    else if (forceRestartOnboarding && existingBot) {
+        note('Ignoring saved credentials due to --restart-onboarding flag', 'Restart Onboarding');
     }
-    for (const [repo, skills] of Object.entries(byRepo)) {
-        console.log(`${repo} (${skills.length} skills):`);
-        for (const skill of skills) {
-            const icon = installed.has(skill.name) ? "✓" : "•";
-            console.log(`  ${icon} ${skill.name} — ${skill.description}`);
+    // When --gateway is passed or we're in non-TTY mode, skip the mode selector.
+    // Non-TTY without --gateway was already rejected above.
+    const modeChoice = forceGateway
+        ? 'gateway'
+        : await (async () => {
+            const choice = await select({
+                message: 'How do you want to connect to Discord?\n\nGateway: uses Otto\'s pre-built bot — no setup, instant. Self-hosted: you create your own Discord bot at discord.com/developers.',
+                options: [
+                    {
+                        value: 'gateway',
+                        disabled: true,
+                        label: 'Gateway (pre-built Otto bot, currently disabled because of Discord verification process. will be re-enabled soon)',
+                    },
+                    {
+                        value: 'self_hosted',
+                        label: 'Self-hosted (your own Discord bot, 5-10 min setup)',
+                    },
+                ],
+            });
+            if (isCancel(choice)) {
+                cancel('Setup cancelled');
+                process.exit(0);
+            }
+            return choice;
+        })();
+    // ── Gateway mode flow ──
+    if (modeChoice === 'gateway') {
+        if (!gatewayAppId) {
+            cliLogger.error('Gateway mode is not available yet. OTTO_GATEWAY_APP_ID is not configured.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const gatewayCredentials = await resolveGatewayInstallCredentials({
+            gatewayPlatform,
+        });
+        if (gatewayCredentials instanceof Error) {
+            throw gatewayCredentials;
+        }
+        const { appId, clientId, clientSecret } = gatewayCredentials;
+        const oauthUrlResult = generateDiscordInstallUrlForBot({
+            appId,
+            mode: 'gateway',
+            clientId,
+            clientSecret,
+            gatewayPlatform,
+            gatewayCallbackUrl,
+            reachableUrl: getInternetReachableBaseUrl() || undefined,
+        });
+        if (oauthUrlResult instanceof Error) {
+            throw oauthUrlResult;
+        }
+        const oauthUrl = oauthUrlResult;
+        const isInteractive = canUseInteractivePrompts();
+        const platformName = getGatewayPlatformDisplayName({ gatewayPlatform });
+        const installTargetName = getGatewayInstallTargetName({ gatewayPlatform });
+        if (gatewayPlatform === 'telegram') {
+            const telegramConfig = await resolveTelegramRuntimeConfig({
+                telegramBotToken,
+                telegramChatId,
+            });
+            if (telegramConfig instanceof Error) {
+                cliLogger.error(telegramConfig.message);
+                process.exit(EXIT_NO_RESTART);
+            }
+            const resolvedTelegramBotToken = telegramConfig.botToken;
+            const resolvedTelegramChatId = telegramConfig.chatId.toString();
+            const installResponse = await fetch(new URL('/api/telegram/install', OTTO_WEBSITE_URL), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    client_id: clientId,
+                    secret: clientSecret,
+                    bot_token: resolvedTelegramBotToken,
+                    chat_id: resolvedTelegramChatId,
+                }),
+            }).catch((cause) => {
+                return new Error('Failed to call Telegram install API', { cause });
+            });
+            if (installResponse instanceof Error) {
+                throw installResponse;
+            }
+            if (!installResponse.ok) {
+                const details = await installResponse.text().catch(() => {
+                    return 'unknown_error';
+                });
+                throw new Error(`Telegram install failed: ${details}`);
+            }
+            if (!isInteractive) {
+                emitJsonEvent({ type: 'authorized', guild_id: resolvedTelegramChatId });
+            }
+            return {
+                appId,
+                token: `${clientId}:${clientSecret}`,
+                credentialSource: 'wizard',
+                isGatewayMode: true,
+            };
+        }
+        if (isInteractive) {
+            note(`Open this URL to install Otto in your ${platformName} ${installTargetName}:\n\n${oauthUrl}\n\nDo not share this URL with anyone — it contains your credentials.${gatewayPlatform === 'discord' ? "\n\nIf you don't have a server, create one first (+ button in Discord sidebar)." : ''}`, 'Install Otto');
+            // Open URL in default browser without shell interpolation.
+            const openUrlCommand = buildOpenUrlCommand({
+                platform: process.platform,
+                url: oauthUrl,
+            });
+            const spawnOptions = process.platform === 'win32'
+                ? { stdio: 'ignore', detached: true, shell: false, windowsHide: true }
+                : { stdio: 'ignore', detached: true, shell: false };
+            const openProcess = spawn(openUrlCommand.command, openUrlCommand.args, spawnOptions);
+            openProcess.on('error', (error) => {
+                cliLogger.warn(`[onboard] failed to open browser automatically: ${formatErrorWithStack(error)}`);
+            });
+            openProcess.unref();
+        }
+        else {
+            // Non-TTY: emit structured JSON so the host process can show the URL to the user.
+            emitJsonEvent({ type: 'install_url', url: oauthUrl });
+        }
+        // Poll until the user installs the bot in a Discord server.
+        // 100 attempts x 3s = 5 minutes timeout.
+        const s = isInteractive ? spinner() : undefined;
+        s?.start(`Waiting for a ${platformName} ${installTargetName} with Otto installed...`);
+        const pollUrl = new URL('/api/onboarding/status', OTTO_WEBSITE_URL);
+        pollUrl.searchParams.set('client_id', clientId);
+        pollUrl.searchParams.set('secret', clientSecret);
+        let guildId;
+        let installerDiscordUserId;
+        for (let attempt = 0; attempt < 100; attempt++) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 3000);
+            });
+            // Progressive hints for interactive users who may be stuck
+            if (isInteractive) {
+                if (attempt === 15) {
+                    s?.message('Still waiting... Select a server in the authorization page and click "Authorize"');
+                }
+                else if (attempt === 45) {
+                    s?.message(`Still waiting... If you don't see any servers, create one first (+ button in Discord sidebar), then reopen the URL above`);
+                }
+                else if (attempt === 150) {
+                    s?.message(`Still waiting... Reopen the install URL if you closed it:\n${oauthUrl}`);
+                }
+            }
+            try {
+                const resp = await fetch(pollUrl.toString());
+                if (resp.ok) {
+                    const data = (await resp.json());
+                    if (data.guild_id) {
+                        guildId = data.guild_id;
+                        installerDiscordUserId = data.discord_user_id;
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Network error, retry
+            }
         }
-        console.log();
+        if (!guildId) {
+            if (isInteractive) {
+                s?.stop('Authorization timed out');
+            }
+            else {
+                emitJsonEvent({ type: 'error', message: `${platformName} authorization timed out after 5 minutes` });
+            }
+            cliLogger.error(`${platformName} authorization timed out after 5 minutes. Please try again.`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (isInteractive) {
+            s?.stop('Bot authorized successfully!');
+            const syncSpinner = spinner();
+            syncSpinner.start('Waiting for gateway sync...');
+            await new Promise((resolve) => {
+                setTimeout(resolve, 2000);
+            });
+            syncSpinner.stop('Gateway sync completed');
+        }
+        else {
+            emitJsonEvent({ type: 'authorized', guild_id: guildId });
+            await new Promise((resolve) => {
+                setTimeout(resolve, 2000);
+            });
+        }
+        return {
+            appId,
+            token: `${clientId}:${clientSecret}`,
+            credentialSource: 'wizard',
+            isGatewayMode: true,
+            installerDiscordUserId,
+        };
+    }
+    // ── Self-hosted mode flow (existing wizard) ──
+    note('1. Go to https://discord.com/developers/applications\n' +
+        '2. Click "New Application"\n' +
+        '3. Give your application a name', 'Step 1: Create Discord Application');
+    note('1. Go to the "Bot" section in the left sidebar\n' +
+        '2. Scroll down to "Privileged Gateway Intents"\n' +
+        '3. Enable these intents by toggling them ON:\n' +
+        '   • SERVER MEMBERS INTENT\n' +
+        '   • MESSAGE CONTENT INTENT\n' +
+        '4. Click "Save Changes" at the bottom', 'Step 2: Enable Required Intents');
+    const intentsConfirmed = await text({
+        message: 'Press Enter after enabling both intents:',
+        placeholder: 'Enter',
+    });
+    if (isCancel(intentsConfirmed)) {
+        cancel('Setup cancelled');
+        process.exit(0);
     }
-    const totalAvailable = allSkills.filter((s) => !installed.has(s.name)).length;
-    console.log(`${allSkills.length} total, ${totalAvailable} available to install.`);
+    note('1. Still in the "Bot" section\n' +
+        '2. Click "Reset Token" to generate a new bot token (in case of errors try again)\n' +
+        "3. Copy the token (you won't be able to see it again!)", 'Step 3: Get Bot Token');
+    const tokenInput = await password({
+        message: 'Enter your Discord Bot Token (from "Bot" section - click "Reset Token" if needed):',
+        validate(value) {
+            const cleaned = stripBracketedPaste(value);
+            if (!cleaned) {
+                return 'Bot token is required';
+            }
+            if (cleaned.length < 50) {
+                return 'Invalid token format (too short)';
+            }
+        },
+    });
+    if (isCancel(tokenInput)) {
+        cancel('Setup cancelled');
+        process.exit(0);
+    }
+    const wizardToken = stripBracketedPaste(tokenInput);
+    const derivedAppId = appIdFromToken(wizardToken);
+    if (!derivedAppId) {
+        cliLogger.error('Could not derive Application ID from the bot token. The token appears malformed.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    await setBotToken(derivedAppId, wizardToken);
+    note(`Bot install URL:\n${generateBotInstallUrl({ clientId: derivedAppId })}\n\nYou MUST install the bot in your Discord server before continuing.`, 'Step 4: Install Bot to Server');
+    const installed = await text({
+        message: 'Press Enter AFTER you have installed the bot in your server:',
+        placeholder: 'Enter',
+    });
+    if (isCancel(installed)) {
+        cancel('Setup cancelled');
+        process.exit(0);
+    }
+    return { appId: derivedAppId, token: wizardToken, credentialSource: 'wizard', isGatewayMode: false };
 }
-function cmdSkillsList() {
-    console.log("Otto skills\n");
-    const installed = listInstalledSkills();
-    if (installed.length > 0) {
-        console.log("Installed:");
-        for (const s of installed) {
-            console.log(`  ✓ ${s.name} — ${s.description}`);
+async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceChannels, gateway, gatewayPlatform, gatewayCallbackUrl, telegramBotToken, telegramChatId, }) {
+    startCaffeinate();
+    const forceRestartOnboarding = Boolean(restartOnboarding);
+    const forceGateway = Boolean(gateway);
+    const resolvedGatewayPlatform = parseGatewayPlatform(gatewayPlatform);
+    // Step 0: Ensure required CLI tools are installed (OpenCode + Bun).
+    // Run checks in parallel since they're independent `which` calls.
+    await Promise.all([
+        ensureCommandAvailable({
+            name: 'opencode',
+            envPathKey: 'OPENCODE_PATH',
+            installUnix: 'curl -fsSL https://opencode.ai/install | bash',
+            installWindows: 'irm https://opencode.ai/install.ps1 | iex',
+            possiblePathsUnix: [
+                '~/.local/bin/opencode',
+                '~/.opencode/bin/opencode',
+                '/usr/local/bin/opencode',
+                '/opt/opencode/bin/opencode',
+            ],
+            possiblePathsWindows: [
+                '~\\.local\\bin\\opencode.exe',
+                '~\\AppData\\Local\\opencode\\opencode.exe',
+                '~\\.opencode\\bin\\opencode.exe',
+            ],
+        }),
+        ensureCommandAvailable({
+            name: 'bun',
+            envPathKey: 'BUN_PATH',
+            installUnix: 'curl -fsSL https://bun.sh/install | bash',
+            installWindows: 'irm bun.sh/install.ps1 | iex',
+            possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
+            possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
+        }),
+    ]);
+    backgroundUpgradeOtto();
+    // Start in-process Hrana server before database init. Required for the bot
+    // process because it serves as both the DB server and the single-instance
+    // lock (binds the fixed lock port). Without it, IPC and lock enforcement
+    // don't work. CLI subcommands skip the server and use file: directly.
+    const hranaResult = await startHranaServer({
+        dbPath: path.join(getDataDir(), 'discord-sessions.db'),
+        bindAll: getInternetReachableBaseUrl() !== null,
+    });
+    if (hranaResult instanceof Error) {
+        cliLogger.error('Failed to start hrana server:', hranaResult.message);
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Initialize database (connects to hrana server via HTTP)
+    await initDatabase();
+    const { appId, token, credentialSource, isGatewayMode, installerDiscordUserId } = await resolveCredentials({
+        forceRestartOnboarding,
+        forceGateway,
+        gatewayPlatform: resolvedGatewayPlatform,
+        gatewayCallbackUrl,
+        telegramBotToken,
+        telegramChatId,
+    });
+    const selectedPlatformName = getGatewayPlatformDisplayName({
+        gatewayPlatform: resolvedGatewayPlatform,
+    });
+    const selectedInstallTargetName = getGatewayInstallTargetName({
+        gatewayPlatform: resolvedGatewayPlatform,
+    });
+    const runtimeLabel = isGatewayMode && resolvedGatewayPlatform === 'telegram'
+        ? 'Telegram gateway runtime'
+        : 'Discord bot';
+    const gatewayToken = await ensureServiceAuthToken({
+        appId,
+        preferredGatewayToken: isGatewayMode ? token : undefined,
+    });
+    // Always set service auth token so local and internet control-plane paths
+    // share one auth model (/otto/wake and future service endpoints). (/otto/wake is kept as infrastructure endpoint)
+    store.setState({ gatewayToken });
+    let telegramBridge = null;
+    if (isGatewayMode && resolvedGatewayPlatform === 'telegram') {
+        const telegramConfig = await resolveTelegramRuntimeConfig({
+            telegramBotToken,
+            telegramChatId,
+        });
+        if (telegramConfig instanceof Error) {
+            cliLogger.error(telegramConfig.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const telegramBridgeSpecifier = 'discord-telegram-bridge';
+        const telegramBridgeModule = await import(telegramBridgeSpecifier).catch((error) => {
+            return new Error('Failed to load optional telegram bridge module', { cause: error });
+        });
+        if (telegramBridgeModule instanceof Error) {
+            cliLogger.error(`${telegramBridgeModule.message}: ${telegramBridgeModule.cause instanceof Error ? telegramBridgeModule.cause.message : String(telegramBridgeModule.cause)}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!isTelegramBridgeModule(telegramBridgeModule)) {
+            cliLogger.error('Failed to load optional telegram bridge module: invalid module shape');
+            process.exit(EXIT_NO_RESTART);
         }
+        telegramBridge = new telegramBridgeModule.TelegramBridge({
+            botToken: telegramConfig.botToken,
+            chatId: telegramConfig.chatId,
+            port: 0,
+            discordToken: token,
+            authorize: async ({ token: incomingToken }) => {
+                return {
+                    allow: incomingToken === token,
+                    clientId: appId,
+                };
+            },
+        });
+        try {
+            await telegramBridge.start();
+        }
+        catch (error) {
+            cliLogger.error(`Failed to start local Telegram bridge: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        store.setState({
+            discordBaseUrl: telegramBridge.restUrl,
+        });
+        cliLogger.log(`Local Telegram bridge started at ${telegramBridge.restUrl}`);
+        const stopBridge = () => {
+            if (!telegramBridge) {
+                return;
+            }
+            const bridgeToStop = telegramBridge;
+            telegramBridge = null;
+            void bridgeToStop.stop().catch((error) => {
+                cliLogger.warn(`Failed to stop Telegram bridge cleanly: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        };
+        process.once('SIGINT', stopBridge);
+        process.once('SIGTERM', stopBridge);
+        process.once('beforeExit', stopBridge);
     }
-    else {
-        console.log("Installed: (none)");
-    }
-    console.log(`\nUse "otto skills browse" to see all available skills.`);
-    console.log(`Use "otto skills search <query>" to search.`);
-}
-async function cmdSkillsAddOne(name) {
-    console.log(`Installing skill: ${name}\n`);
-    ensureSkillsIndex();
-    const success = installSkillFromIndex(name);
-    if (!success) {
-        console.error(`Error: skill "${name}" not found. Run "otto skills search <query>" to find skills.`);
-        process.exit(1);
-    }
-    console.log(`Installed ${name} → ~/.config/opencode/skills/${name}/`);
-    console.log("Done!");
-}
-async function cmdSkillsAddAll() {
-    console.log("Installing all skills from otto-assistant/skills...\n");
-    ensureSkillsIndex();
-    const allSkills = getAllIndexedSkills();
-    const ottoSkills = allSkills.filter((s) => s.source === "otto-assistant/skills");
-    if (ottoSkills.length === 0) {
-        console.log("No skills found in otto-assistant/skills. Check your connection.");
-        return;
+    // In gateway mode, ensure REST calls route through the selected gateway.
+    // Telegram uses a local in-process bridge so no external host config is needed.
+    if (isGatewayMode && credentialSource === 'wizard' && resolvedGatewayPlatform !== 'telegram') {
+        const gatewayRestBaseUrl = getGatewayProxyRestBaseUrlForPlatform({
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
+        if (gatewayRestBaseUrl instanceof Error) {
+            cliLogger.error(gatewayRestBaseUrl.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        store.setState({
+            discordBaseUrl: gatewayRestBaseUrl,
+        });
     }
-    const installed = new Set(listInstalledSkills().map((s) => s.name));
-    let added = 0;
-    for (const skill of ottoSkills) {
-        if (installed.has(skill.name)) {
-            console.log(`  ✓ ${skill.name} (already installed)`);
-            continue;
+    // When OTTO_INTERNET_REACHABLE_URL is set, the hrana server exposes
+    // a /otto/wake endpoint for the gateway-proxy to wake this instance and
+    // wait until discord.js is connected. Keep Discord traffic on the normal
+    // configured base URL (gateway-proxy in gateway mode).
+    if (getInternetReachableBaseUrl()) {
+        cliLogger.log('Internet-reachable mode: enabling /otto/wake endpoint on hrana server');
+    }
+    // Start OpenCode server as early as possible — non-blocking.
+    // All dependencies are met (dataDir, lockPort, gatewayToken, hranaUrl set).
+    // Runs in parallel with last_used_at update, skipChannelSetup check, and
+    // Discord Gateway login so cold start is not blocked by OpenCode spawn.
+    const currentDir = process.cwd();
+    cliLogger.log('Starting OpenCode server...');
+    const opencodePromise = initializeOpencodeForDirectory(currentDir).then((result) => {
+        if (result instanceof Error) {
+            throw new Error(result.message);
         }
-        const success = installSkillFromIndex(skill.name);
-        if (success) {
-            console.log(`  + ${skill.name}`);
-            added++;
+        cliLogger.log('OpenCode server ready!');
+        return result;
+    });
+    // Prevent unhandled rejection if OpenCode fails before backgroundInit
+    // or the channel setup path awaits it. Errors are handled by the
+    // respective consumers (backgroundInit catches, channel setup re-throws).
+    opencodePromise.catch(() => { });
+    // Mark this bot as the most recently used so subcommands in separate
+    // processes (send, upload-to-discord, project list) pick the correct bot.
+    // getBotTokenWithMode() orders by last_used_at DESC as cross-process
+    // source of truth.
+    await (await getPrisma()).bot_tokens.update({
+        where: { app_id: appId },
+        data: { last_used_at: new Date() },
+    });
+    // skipChannelSetup: when true, skip interactive project/channel selection
+    // and go straight to bot startup. Channel sync happens in the background.
+    //
+    // Skip when: creds came from env/saved (not first-time wizard), OR non-TTY
+    // gateway (headless), OR user didn't pass --add-channels/--restart-onboarding.
+    // Force channel setup when: first-time quick-start with no channels configured
+    // and TTY is available, or user explicitly passed --add-channels.
+    const isHeadlessGateway = isGatewayMode && !canUseInteractivePrompts();
+    const hasConfiguredTextChannels = Boolean(await (await getPrisma()).channel_directories.findFirst({
+        where: { channel_type: 'text' },
+        select: { channel_id: true },
+    }));
+    const skipChannelSetup = isHeadlessGateway || (() => {
+        // Wizard source always shows channel setup (user just completed onboarding)
+        if (credentialSource === 'wizard') {
+            return false;
         }
-        else {
-            console.log(`  ✗ ${skill.name} (failed)`);
+        // Env/saved source: skip unless user explicitly asked for channels
+        if (forceRestartOnboarding || Boolean(addChannels)) {
+            return false;
+        }
+        // First-time quick start with no channels: force setup if TTY is available
+        if (!hasConfiguredTextChannels && canUseInteractivePrompts()) {
+            return false;
         }
+        return true;
+    })();
+    cliLogger.log(`Connecting ${runtimeLabel} to ${getDiscordRestApiUrl()}...`);
+    const discordClient = await createDiscordClient();
+    const guilds = [];
+    const ottoChannels = [];
+    const createdChannels = [];
+    try {
+        await new Promise((resolve, reject) => {
+            discordClient.once(Events.ClientReady, async (c) => {
+                // Guild discovery comes from the Gateway WebSocket READY payload, not
+                // from a separate REST fetch. discord.js consumes READY and hydrates
+                // client.guilds.cache from d.guilds. In gateway mode, gateway-proxy
+                // already filters this list to authorized guilds for client_id:secret.
+                // Example payload fragment received over WS:
+                // {
+                //   "op": 0,
+                //   "t": "READY",
+                //   "d": {
+                //     "guilds": [
+                //       { "id": "123456789012345678", "unavailable": false }
+                //     ]
+                //   }
+                // }
+                guilds.push(...Array.from(c.guilds.cache.values()));
+                if (isGatewayMode && resolvedGatewayPlatform === 'telegram') {
+                    await Promise.all(guilds.map(async (guild) => {
+                        await setChannelDirectory({
+                            channelId: guild.id,
+                            directory: currentDir,
+                            channelType: 'text',
+                            skipIfExists: true,
+                        });
+                    }));
+                }
+                if (skipChannelSetup) {
+                    resolve(null);
+                    return;
+                }
+                // Process guild metadata when setup flow needs channel prompts.
+                const guildResults = await collectOttoChannels({ guilds });
+                // Collect results
+                for (const result of guildResults) {
+                    ottoChannels.push(result);
+                }
+                resolve(null);
+            });
+            discordClient.once(Events.Error, reject);
+            discordClient.login(token).catch(reject);
+        });
+        cliLogger.log(`Connected ${runtimeLabel}!`);
+        // Start IPC polling now that Discord client is ready.
+        // Register cleanup on process exit since the shutdown handler lives in discord-bot.ts.
+        await startIpcPolling({ discordClient });
+        process.on('exit', stopIpcPolling);
     }
-    if (added === 0) {
-        console.log("\nAll skills already installed.");
+    catch (error) {
+        cliLogger.log(`Failed to connect ${runtimeLabel}`, discordClient.ws.gateway);
+        cliLogger.error('Error: ' + (error instanceof Error ? error.stack : String(error)));
+        process.exit(EXIT_NO_RESTART);
     }
-    else {
-        console.log(`\nInstalled ${added} skill(s).`);
+    await setBotToken(appId, token);
+    // In gateway mode the bot only sees chats/servers the user has installed
+    // it in. Zero guilds means the install callback never completed or the
+    // user removed Otto from all targets — there is nothing the bot can do.
+    if (isGatewayMode && guilds.length === 0) {
+        // Rebuild the install URL from the current credentials so the user can
+        // add the bot to a server without going through the full --restart-onboarding flow.
+        const [clientId, clientSecret] = token.split(':');
+        if (!clientId || !clientSecret) {
+            throw new Error('Malformed gateway token: expected clientId:clientSecret format');
+        }
+        const installUrlResult = generateDiscordInstallUrlForBot({
+            appId: OTTO_GATEWAY_APP_ID,
+            mode: 'gateway',
+            clientId,
+            clientSecret,
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
+        if (installUrlResult instanceof Error) {
+            throw installUrlResult;
+        }
+        const installUrl = installUrlResult;
+        const installTargetName = getGatewayInstallTargetName({
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
+        const platformName = getGatewayPlatformDisplayName({
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
+        if (!canUseInteractivePrompts()) {
+            emitJsonEvent({
+                type: 'error',
+                message: `No ${platformName} ${installTargetName}s found`,
+                install_url: installUrl,
+            });
+        }
+        cliLogger.error(`No ${platformName} ${installTargetName}s found. Otto must be installed in at least one ${installTargetName}.\n` +
+            `Install URL: ${installUrl}\n` +
+            'Do not share this URL with anyone — it contains your credentials.\n' +
+            `Open the URL above to add Otto to a ${installTargetName}, then run \`otto gateway start\` again.`);
+        discordClient.destroy();
+        process.exit(EXIT_NO_RESTART);
     }
-    console.log("Done!");
-}
-function cmdSkillsUpdate() {
-    console.log("Refreshing skills index from GitHub...\n");
-    const { refreshed, total } = ensureSkillsIndex(0); // force refresh all
-    if (refreshed === 0 && total === 0) {
-        console.log("No repos configured.");
-        return;
+    if (skipChannelSetup) {
+        // Start bot immediately — channel sync happens in the background.
+        cliLogger.log(`Starting ${runtimeLabel}...`);
+        await startDiscordBot({ token, appId, discordClient, useWorktrees });
+        cliLogger.log(`${runtimeLabel} is running!`);
+        // Background channel sync + role reconciliation + default channel creation.
+        // Never blocks ready state.
+        void (async () => {
+            try {
+                const backgroundChannels = await collectOttoChannels({ guilds });
+                await storeChannelDirectories({ ottoChannels: backgroundChannels });
+                cliLogger.log(`Background channel sync completed for ${backgroundChannels.length} guild(s)`);
+            }
+            catch (error) {
+                cliLogger.warn('Background channel sync failed:', error instanceof Error ? error.stack : String(error));
+            }
+            // Create default otto channel + welcome message in each guild.
+            // Runs after channel sync so existing channels are detected correctly.
+            try {
+                await ensureDefaultChannelsWithWelcome({
+                    guilds,
+                    discordClient,
+                    appId,
+                    isGatewayMode,
+                    installerDiscordUserId,
+                });
+            }
+            catch (error) {
+                cliLogger.warn('Background default channel creation failed:', error instanceof Error ? error.stack : String(error));
+            }
+        })();
+        // Background: OpenCode init + slash command registration (non-blocking)
+        void backgroundInit({
+            currentDir,
+            token,
+            appId,
+            guildIds: guilds.map((guild) => {
+                return guild.id;
+            }),
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
     }
-    console.log(`Refreshed ${refreshed}/${total} repo(s).`);
-    const allSkills = getAllIndexedSkills();
-    console.log(`Index now has ${allSkills.length} skills.`);
-    console.log("Done!");
-}
-function cmdSkillsRemove(name) {
-    console.log(`Removing skill: ${name}\n`);
-    const success = removeSkill(name);
-    if (!success) {
-        console.error(`Error: skill "${name}" is not installed.`);
-        process.exit(1);
-    }
-    console.log(`Removed ${name}.`);
-    console.log("Done!");
-}
-function cmdSkillsRepos() {
-    console.log("Configured skill repositories:\n");
-    const repos = getConfiguredRepos();
-    for (const repo of repos) {
-        console.log(`  ${repo}`);
-    }
-    console.log(`\n${repos.length} repo(s) configured.`);
-}
-async function cmdTenant(subArgs) {
-    const tenantCommand = subArgs[0] ?? "";
-    const tenantPathArg = subArgs[1];
-    if (tenantCommand === "skills") {
-        const action = subArgs[1] ?? "";
-        const pathArg = subArgs[2];
-        if (action !== "bootstrap" || !pathArg) {
-            console.log("Usage: otto tenant skills bootstrap <path>");
-            process.exit(1);
+    else {
+        // ── Channel setup flow ──
+        // Store channel-directory mappings discovered during Discord login.
+        await storeChannelDirectories({ ottoChannels });
+        if (!hasConfiguredTextChannels) {
+            note('No Otto project channels are configured yet. Opening project/channel setup.', 'Channel Setup');
+        }
+        if (ottoChannels.length > 0) {
+            const channelList = ottoChannels
+                .flatMap(({ guild, channels }) => channels.map((ch) => {
+                return `#${ch.name} in ${guild.name}: ${ch.ottoDirectory}`;
+            }))
+                .join('\n');
+            note(channelList, 'Existing Otto Channels');
+        }
+        // Wait for OpenCode, fetch projects, show prompts, create channels if needed
+        cliLogger.log('Waiting for OpenCode server...');
+        const getClient = await opencodePromise;
+        cliLogger.log('Fetching OpenCode data...');
+        // Fetch projects, commands, and agents in parallel
+        const [projects, allUserCommands, allAgents] = await Promise.all([
+            getClient()
+                .project.list()
+                .then((r) => r.data || [])
+                .catch((error) => {
+                cliLogger.log('Failed to fetch projects');
+                cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+                discordClient.destroy();
+                process.exit(EXIT_NO_RESTART);
+            }),
+            getClient()
+                .command.list({ directory: currentDir })
+                .then((r) => r.data || [])
+                .catch((error) => {
+                cliLogger.warn('Failed to load user commands during setup:', error instanceof Error ? error.stack : String(error));
+                return [];
+            }),
+            getClient()
+                .app.agents({ directory: currentDir })
+                .then((r) => r.data || [])
+                .catch((error) => {
+                cliLogger.warn('Failed to load agents during setup:', error instanceof Error ? error.stack : String(error));
+                return [];
+            }),
+        ]);
+        cliLogger.log(`Found ${projects.length} OpenCode project(s)`);
+        const existingDirs = ottoChannels.flatMap(({ channels }) => channels
+            .filter((ch) => ch.ottoDirectory)
+            .map((ch) => ch.ottoDirectory)
+            .filter(Boolean));
+        const availableProjects = deduplicateByKey(projects.filter((project) => {
+            if (existingDirs.includes(project.worktree)) {
+                return false;
+            }
+            if (path.basename(project.worktree).startsWith('opencode-test-')) {
+                return false;
+            }
+            return true;
+        }), (x) => x.worktree);
+        if (availableProjects.length === 0) {
+            note('All OpenCode projects already have channels', 'No New Projects');
+        }
+        if (availableProjects.length > 0) {
+            if (!canUseInteractivePrompts()) {
+                exitNonInteractiveSetup();
+            }
+            const selectedProjects = await multiselect({
+                message: 'Select projects to create channels for:',
+                options: availableProjects.map((project) => ({
+                    value: project.id,
+                    label: `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`,
+                })),
+                required: false,
+            });
+            if (!isCancel(selectedProjects) && selectedProjects.length > 0) {
+                let targetGuild;
+                if (guilds.length === 0) {
+                    cliLogger.error(`No ${selectedPlatformName} ${selectedInstallTargetName}s found. Otto must be installed in at least one ${selectedInstallTargetName}.`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+                if (guilds.length === 1) {
+                    targetGuild = guilds[0];
+                    note(`Using ${selectedInstallTargetName}: ${targetGuild.name}`, 'Target Selected');
+                }
+                else {
+                    const guildSelection = await multiselect({
+                        message: `Select a ${selectedPlatformName} ${selectedInstallTargetName} to create channels in:`,
+                        options: guilds.map((guild) => ({
+                            value: guild.id,
+                            label: `${guild.name} (${guild.memberCount} members)`,
+                        })),
+                        required: true,
+                        maxItems: 1,
+                    });
+                    if (isCancel(guildSelection)) {
+                        cancel('Setup cancelled');
+                        process.exit(0);
+                    }
+                    targetGuild = guilds.find((g) => g.id === guildSelection[0]);
+                }
+                cliLogger.log('Creating Discord channels...');
+                for (const projectId of selectedProjects) {
+                    const project = projects.find((p) => p.id === projectId);
+                    if (!project)
+                        continue;
+                    try {
+                        const { textChannelId, channelName } = await createProjectChannels({
+                            guild: targetGuild,
+                            projectDirectory: project.worktree,
+                            botName: discordClient.user?.username,
+                            enableVoiceChannels,
+                        });
+                        createdChannels.push({
+                            name: channelName,
+                            id: textChannelId,
+                            guildId: targetGuild.id,
+                        });
+                    }
+                    catch (error) {
+                        cliLogger.error(`Failed to create channels for ${path.basename(project.worktree)}:`, error);
+                    }
+                }
+                cliLogger.log(`Created ${createdChannels.length} channel(s)`);
+                if (createdChannels.length > 0) {
+                    note(createdChannels.map((ch) => `#${ch.name}`).join('\n'), 'Created Channels');
+                }
+            }
         }
-        const tenantPath = path.resolve(pathArg);
-        const skillsDir = path.join(tenantPath, "memory", "opencode", "skills");
-        ensureSkillsIndex();
-        const report = installSkillsBaseline(GENTLEMAN_SKILLS_BASELINE, skillsDir);
-        console.log(`Skills baseline bootstrap: ${tenantPath}`);
-        console.log(`  Installed: ${report.installed.length > 0 ? report.installed.join(", ") : "(none)"}`);
-        console.log(`  Already present: ${report.alreadyPresent.length > 0 ? report.alreadyPresent.join(", ") : "(none)"}`);
-        if (report.failed.length > 0) {
-            console.log(`  Failed: ${report.failed.join(", ")}`);
-            process.exitCode = 2;
+        // Create default otto channel for general-purpose tasks.
+        // Runs for every guild the bot is in, idempotent (skips if already exists).
+        const defaultChannelResults = await ensureDefaultChannelsWithWelcome({
+            guilds,
+            discordClient,
+            appId,
+            isGatewayMode,
+            installerDiscordUserId,
+        });
+        createdChannels.push(...defaultChannelResults);
+        // Log available user commands
+        const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
+        if (registrableCommands.length > 0) {
+            note(`Found ${registrableCommands.length} user-defined command(s)`, 'OpenCode Commands/Skills');
+        }
+        if (shouldRegisterSlashCommands({ gatewayPlatform: resolvedGatewayPlatform })) {
+            cliLogger.log('Registering slash commands asynchronously...');
+            void registerCommands({
+                token,
+                appId,
+                guildIds: guilds.map((guild) => {
+                    return guild.id;
+                }),
+                userCommands: allUserCommands,
+                agents: allAgents,
+            })
+                .then(() => {
+                cliLogger.log('Slash commands registered!');
+            })
+                .catch((error) => {
+                cliLogger.error('Failed to register slash commands:', error instanceof Error ? error.stack : String(error));
+            });
         }
         else {
-            console.log("  Failed: (none)");
+            const platformName = getGatewayPlatformDisplayName({ gatewayPlatform: resolvedGatewayPlatform });
+            cliLogger.log(`Skipping slash command registration in ${platformName} gateway mode`);
         }
-        return;
+        // Start bot after channel setup is complete so it doesn't handle
+        // messages/interactions while the user is still going through prompts.
+        cliLogger.log(`Starting ${runtimeLabel}...`);
+        await startDiscordBot({ token, appId, discordClient, useWorktrees });
+        cliLogger.log(`${runtimeLabel} is running!`);
+    }
+    // ── Ready ──
+    if (!canUseInteractivePrompts()) {
+        emitJsonEvent({
+            type: 'ready',
+            app_id: appId,
+            guild_ids: guilds.map((g) => { return g.id; }),
+        });
+    }
+    else {
+        showReadyMessage({
+            ottoChannels,
+            createdChannels,
+            gatewayPlatform: resolvedGatewayPlatform,
+        });
+        outro('✨ Bot ready! Listening for messages...');
     }
-    if (!tenantPathArg) {
-        console.log("Usage: otto tenant <init|up|down|status|logs> <path>");
-        process.exit(1);
+}
+async function runMenuSubcommand({ args, }) {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return new Error('Unable to resolve current CLI script path');
     }
-    const tenantPath = path.resolve(tenantPathArg);
-    switch (tenantCommand) {
-        case "init": {
-            const result = ensureTenantScaffold(tenantPath);
-            if (result.created.length === 0) {
-                console.log(`Tenant scaffold already exists: ${tenantPath}`);
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [scriptPath, ...args], {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.once('error', (error) => {
+            resolve(new Error(`Failed to start command: ${error.message}`, { cause: error }));
+        });
+        child.once('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            resolve(new Error(`Command failed (${code ?? signal ?? 'unknown'}): otto ${args.join(' ')}`));
+        });
+    });
+}
+function spawnDetachedGatewayStart({ extraArgs = [], }) {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return new Error('Unable to resolve current CLI script path');
+    }
+    const sanitizedEnv = {
+        ...process.env,
+        OTTO_OPENCODE_PROCESS: undefined,
+        __OTTO_CHILD: undefined,
+        OTTO_GATEWAY_DAEMON: undefined,
+    };
+    const child = spawn(process.execPath, [scriptPath, 'gateway', 'start', ...extraArgs], {
+        stdio: 'ignore',
+        detached: true,
+        env: sanitizedEnv,
+        shell: false,
+        windowsHide: process.platform === 'win32',
+    });
+    child.unref();
+    return child;
+}
+const RESTART_LOG_WAIT_MS = 3_500;
+const RESTART_LOG_POLL_MS = 200;
+const RESTART_LOG_MAX_LINES = 24;
+function resolveGatewayDataDir({ dataDir, }) {
+    if (!dataDir) {
+        return getDataDir();
+    }
+    return path.resolve(dataDir);
+}
+async function printGatewayStartupLogs({ dataDir, }) {
+    const logPath = path.join(dataDir, 'otto.log');
+    let linesPrinted = 0;
+    const seenLineKeys = new Set();
+    const deadline = Date.now() + RESTART_LOG_WAIT_MS;
+    while (Date.now() < deadline && linesPrinted < RESTART_LOG_MAX_LINES) {
+        if (fs.existsSync(logPath)) {
+            const content = fs.readFileSync(logPath, 'utf8');
+            const lines = content
+                .split(/\r?\n/)
+                .map((entry) => {
+                return entry.trim();
+            })
+                .filter((entry) => {
+                return entry.length > 0;
+            });
+            for (const [index, line] of lines.entries()) {
+                const lineKey = `${index}:${line}`;
+                if (seenLineKeys.has(lineKey)) {
+                    continue;
+                }
+                seenLineKeys.add(lineKey);
+                cliLogger.log(`[gateway] ${line}`);
+                linesPrinted += 1;
+                if (linesPrinted >= RESTART_LOG_MAX_LINES) {
+                    return;
+                }
             }
-            else {
-                console.log(`Tenant scaffold ready: ${tenantPath}`);
-                console.log(`Created: ${result.created.join(", ")}`);
-            }
-            console.log(`
-Next steps — get your tenant running in 3 steps:
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Step 1: Create a Discord Bot
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  1. Open https://discord.com/developers/applications
-  2. Click "New Application" → give it a name → Create
-  3. Go to "Bot" tab → Click "Reset Token" → Copy the token
-  4. Under "Privileged Gateway Intents" enable:
-     ✅ Message Content Intent
-     ✅ Server Members Intent (optional)
-  5. Go to "OAuth2" tab → "URL Generator"
-     Scopes: bot
-     Permissions: Send Messages, Read Message History, Add Reactions
-  6. Open the generated URL → add bot to your Discord server
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Step 2: Configure your tenant
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  Edit ${tenantPath}/.env with your bot token:
-
-    KIMAKI_BOT_TOKEN=your-bot-token-here
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Step 3: Start your tenant
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  docker compose -f ${tenantPath}/compose.yml up -d
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Useful commands:
-  otto tenant status ${tenantPathArg}   — check health
-  otto tenant logs ${tenantPathArg}     — view logs
-  otto tenant down ${tenantPathArg}     — stop tenant
-  otto tenant skills bootstrap ${tenantPathArg} — install baseline skills
-`);
-            return;
         }
-        case "up": {
-            const mode = resolveTenantMode(process.env.OTTO_MODE);
-            if (mode === "admin") {
-                console.log("⚠ OTTO_MODE=admin enabled: tenant has elevated runtime profile.");
+        await new Promise((resolve) => {
+            setTimeout(resolve, RESTART_LOG_POLL_MS);
+        });
+    }
+}
+function trimPromptValue(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+}
+async function promptRequiredText({ message, placeholder, }) {
+    const value = await text({
+        message,
+        ...(placeholder ? { placeholder } : {}),
+        validate: (raw) => {
+            if (!trimPromptValue(raw)) {
+                return 'Value is required';
             }
-            runCompose(tenantPath, ["up", "-d"]);
+        },
+    });
+    if (isCancel(value)) {
+        return new Error('Cancelled');
+    }
+    return trimPromptValue(value);
+}
+async function promptOptionalText({ message, placeholder, }) {
+    const value = await text({
+        message,
+        ...(placeholder ? { placeholder } : {}),
+    });
+    if (isCancel(value)) {
+        return new Error('Cancelled');
+    }
+    const trimmed = trimPromptValue(value);
+    return trimmed || null;
+}
+async function runInteractiveMenu() {
+    const categories = [
+        {
+            label: 'Bot Management',
+            actions: [
+                {
+                    label: 'Start',
+                    run: async () => runMenuSubcommand({ args: ['gateway', 'start'] }),
+                },
+                {
+                    label: 'Restart',
+                    run: async () => runMenuSubcommand({ args: ['gateway', 'restart'] }),
+                },
+                {
+                    label: 'Status Set',
+                    run: async () => {
+                        const textValue = await promptRequiredText({ message: 'Status text' });
+                        if (textValue instanceof Error)
+                            return textValue;
+                        const type = await select({
+                            message: 'Activity type',
+                            options: [
+                                { label: 'Custom', value: 'custom' },
+                                { label: 'Playing', value: 'playing' },
+                                { label: 'Watching', value: 'watching' },
+                                { label: 'Listening', value: 'listening' },
+                                { label: 'Competing', value: 'competing' },
+                            ],
+                        });
+                        if (isCancel(type))
+                            return new Error('Cancelled');
+                        const status = await select({
+                            message: 'Online status',
+                            options: [
+                                { label: 'Online', value: 'online' },
+                                { label: 'Idle', value: 'idle' },
+                                { label: 'DnD', value: 'dnd' },
+                                { label: 'Invisible', value: 'invisible' },
+                            ],
+                        });
+                        if (isCancel(status))
+                            return new Error('Cancelled');
+                        return runMenuSubcommand({ args: ['bot', 'status', 'set', textValue, '--type', String(type), '--status', String(status)] });
+                    },
+                },
+                { label: 'Status Clear', run: async () => runMenuSubcommand({ args: ['bot', 'status', 'clear'] }) },
+                { label: 'Install URL', run: async () => runMenuSubcommand({ args: ['bot', 'install-url'] }) },
+            ],
+        },
+        {
+            label: 'Session Management',
+            actions: [
+                { label: 'List', run: async () => runMenuSubcommand({ args: ['session', 'list'] }) },
+                {
+                    label: 'Read',
+                    run: async () => {
+                        const id = await promptRequiredText({ message: 'Session ID' });
+                        if (id instanceof Error)
+                            return id;
+                        return runMenuSubcommand({ args: ['session', 'read', id] });
+                    },
+                },
+                {
+                    label: 'Search',
+                    run: async () => {
+                        const query = await promptRequiredText({ message: 'Search query' });
+                        if (query instanceof Error)
+                            return query;
+                        return runMenuSubcommand({ args: ['session', 'search', query] });
+                    },
+                },
+                {
+                    label: 'Archive',
+                    run: async () => {
+                        const sessionId = await promptOptionalText({ message: 'Session ID (optional)' });
+                        if (sessionId instanceof Error)
+                            return sessionId;
+                        if (sessionId)
+                            return runMenuSubcommand({ args: ['session', 'archive', '--session', sessionId] });
+                        const threadId = await promptRequiredText({ message: 'Thread ID' });
+                        if (threadId instanceof Error)
+                            return threadId;
+                        return runMenuSubcommand({ args: ['session', 'archive', threadId] });
+                    },
+                },
+                {
+                    label: 'Discord URL',
+                    run: async () => {
+                        const id = await promptRequiredText({ message: 'Session ID' });
+                        if (id instanceof Error)
+                            return id;
+                        return runMenuSubcommand({ args: ['session', 'discord-url', id] });
+                    },
+                },
+                {
+                    label: 'Export Events',
+                    run: async () => {
+                        const id = await promptRequiredText({ message: 'Session ID' });
+                        if (id instanceof Error)
+                            return id;
+                        const outPath = await promptRequiredText({ message: 'Output file (.jsonl)', placeholder: './tmp/session-events.jsonl' });
+                        if (outPath instanceof Error)
+                            return outPath;
+                        return runMenuSubcommand({ args: ['session', 'export-events-jsonl', '--session', id, '--out', outPath] });
+                    },
+                },
+            ],
+        },
+        {
+            label: 'Project Management',
+            actions: [
+                { label: 'Add', run: async () => runMenuSubcommand({ args: ['project', 'add'] }) },
+                { label: 'List', run: async () => runMenuSubcommand({ args: ['project', 'list'] }) },
+                { label: 'Open In Discord', run: async () => runMenuSubcommand({ args: ['project', 'open-in-discord'] }) },
+                {
+                    label: 'Create',
+                    run: async () => {
+                        const name = await promptRequiredText({ message: 'Project name', placeholder: 'my-project' });
+                        if (name instanceof Error)
+                            return name;
+                        return runMenuSubcommand({ args: ['project', 'create', name] });
+                    },
+                },
+                {
+                    label: 'Remove (not available)',
+                    run: async () => {
+                        note('No dedicated `project remove` command is currently available.', 'Info');
+                    },
+                },
+            ],
+        },
+        {
+            label: 'Task Management',
+            actions: [
+                { label: 'List Tasks', run: async () => runMenuSubcommand({ args: ['task', 'list'] }) },
+                {
+                    label: 'Schedule Send',
+                    run: async () => {
+                        const project = await promptRequiredText({ message: 'Project path', placeholder: '.' });
+                        if (project instanceof Error)
+                            return project;
+                        const promptValue = await promptRequiredText({ message: 'Prompt' });
+                        if (promptValue instanceof Error)
+                            return promptValue;
+                        const sendAt = await promptRequiredText({ message: 'Send at (UTC ISO or cron)' });
+                        if (sendAt instanceof Error)
+                            return sendAt;
+                        return runMenuSubcommand({ args: ['send', '--project', project, '--prompt', promptValue, '--send-at', sendAt] });
+                    },
+                },
+                {
+                    label: 'Edit Task',
+                    run: async () => {
+                        const id = await promptRequiredText({ message: 'Task ID' });
+                        if (id instanceof Error)
+                            return id;
+                        const args = ['task', 'edit', id];
+                        const promptValue = await promptOptionalText({ message: 'New prompt (optional)' });
+                        if (promptValue instanceof Error)
+                            return promptValue;
+                        if (promptValue)
+                            args.push('--prompt', promptValue);
+                        const sendAt = await promptOptionalText({ message: 'New send-at (optional)' });
+                        if (sendAt instanceof Error)
+                            return sendAt;
+                        if (sendAt)
+                            args.push('--send-at', sendAt);
+                        return runMenuSubcommand({ args });
+                    },
+                },
+                {
+                    label: 'Delete Task',
+                    run: async () => {
+                        const id = await promptRequiredText({ message: 'Task ID' });
+                        if (id instanceof Error)
+                            return id;
+                        return runMenuSubcommand({ args: ['task', 'delete', id] });
+                    },
+                },
+            ],
+        },
+        {
+            label: 'Worktree Management',
+            actions: [
+                {
+                    label: 'New Worktree',
+                    run: async () => {
+                        const project = await promptRequiredText({ message: 'Project path', placeholder: '.' });
+                        if (project instanceof Error)
+                            return project;
+                        const promptValue = await promptRequiredText({ message: 'Initial prompt' });
+                        if (promptValue instanceof Error)
+                            return promptValue;
+                        const name = await promptOptionalText({ message: 'Worktree name (optional)' });
+                        if (name instanceof Error)
+                            return name;
+                        const args = ['send', '--project', project, '--prompt', promptValue, '--worktree'];
+                        if (name)
+                            args.push(name);
+                        return runMenuSubcommand({ args });
+                    },
+                },
+                { label: 'Merge Worktree', run: async () => runMenuSubcommand({ args: ['worktree', 'merge'] }) },
+                {
+                    label: 'List Worktrees',
+                    run: async () => {
+                        const result = await execAsync('git worktree list', { timeout: 15_000 }).catch((cause) => new Error('Failed to list worktrees', { cause }));
+                        if (result instanceof Error)
+                            return result;
+                        note(result.stdout.trim() || '(no worktrees)', 'Worktrees');
+                    },
+                },
+            ],
+        },
+        {
+            label: 'Account Management',
+            actions: [
+                { label: 'Anthropic List', run: async () => runMenuSubcommand({ args: ['anthropic-accounts', 'list'] }) },
+                { label: 'Anthropic Current', run: async () => runMenuSubcommand({ args: ['anthropic-accounts', 'current'] }) },
+                {
+                    label: 'Anthropic Remove',
+                    run: async () => {
+                        const value = await promptRequiredText({ message: 'Index or email' });
+                        if (value instanceof Error)
+                            return value;
+                        return runMenuSubcommand({ args: ['anthropic-accounts', 'remove', value] });
+                    },
+                },
+                {
+                    label: 'Login',
+                    run: async () => runMenuSubcommand({
+                        args: ['gateway', 'start', '--restart-onboarding'],
+                    }),
+                },
+            ],
+        },
+        {
+            label: 'Tools',
+            actions: [
+                {
+                    label: 'Tunnel',
+                    run: async () => {
+                        const port = await promptRequiredText({ message: 'Port', placeholder: '3000' });
+                        if (port instanceof Error)
+                            return port;
+                        return runMenuSubcommand({ args: ['tunnel', '--port', port] });
+                    },
+                },
+                { label: 'Screenshare', run: async () => runMenuSubcommand({ args: ['screenshare'] }) },
+                { label: 'Sqlitedb', run: async () => runMenuSubcommand({ args: ['sqlitedb'] }) },
+                { label: 'Upgrade', run: async () => runMenuSubcommand({ args: ['upgrade'] }) },
+            ],
+        },
+        {
+            label: 'User Management',
+            actions: [
+                {
+                    label: 'User List',
+                    run: async () => {
+                        const guild = await promptRequiredText({ message: 'Guild ID' });
+                        if (guild instanceof Error)
+                            return guild;
+                        const query = await promptOptionalText({ message: 'Search query (optional)' });
+                        if (query instanceof Error)
+                            return query;
+                        const args = ['user', 'list', '--guild', guild];
+                        if (query)
+                            args.push('--query', query);
+                        return runMenuSubcommand({ args });
+                    },
+                },
+            ],
+        },
+    ];
+    while (true) {
+        const category = await select({
+            message: 'Otto main menu',
+            options: [
+                ...categories.map((x) => ({ label: x.label, value: x.label })),
+                { label: 'Quit', value: '__quit__' },
+            ],
+        });
+        if (isCancel(category) || category === '__quit__') {
+            outro('Goodbye.');
             return;
         }
-        case "down":
-            runCompose(tenantPath, ["down"]);
-            return;
-        case "logs": {
-            const follow = subArgs.includes("--follow") ? ["--follow"] : [];
-            runCompose(tenantPath, ["logs", ...follow]);
-            return;
+        const selectedCategory = categories.find((x) => x.label === category);
+        if (!selectedCategory) {
+            continue;
+        }
+        const action = await select({
+            message: `${selectedCategory.label} actions`,
+            options: [
+                ...selectedCategory.actions.map((x) => ({ label: x.label, value: x.label })),
+                { label: 'Back', value: '__back__' },
+            ],
+        });
+        if (isCancel(action) || action === '__back__') {
+            continue;
+        }
+        const selectedAction = selectedCategory.actions.find((x) => x.label === action);
+        if (!selectedAction) {
+            continue;
+        }
+        const result = await selectedAction.run();
+        if (result instanceof Error && result.message !== 'Cancelled') {
+            note(result.message, 'Command Failed');
+            continue;
+        }
+        note('Command completed. Returning to menu.', 'Done');
+    }
+}
+cli
+    .command('menu', 'Interactive command menu for all otto commands')
+    .action(async () => {
+    try {
+        intro('Otto interactive menu');
+        await runInteractiveMenu();
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Menu failed:', formatErrorWithStack(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('', 'Open the interactive Otto menu')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+            cliLogger.log(`Using data directory: ${getDataDir()}`);
+        }
+        if (options.projectsDir) {
+            setProjectsDir(options.projectsDir);
+            cliLogger.log(`Using projects directory: ${getProjectsDir()}`);
+        }
+        intro('Otto interactive menu');
+        await runInteractiveMenu();
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Menu failed:', formatErrorWithStack(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('gateway start', 'Connect Otto to Discord and keep the long-running gateway session active')
+    .option('--restart-onboarding', 'Prompt for new credentials even if saved')
+    .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
+    .option('--install-url', 'Print the bot install URL and exit')
+    .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
+    .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
+    .option('--verbosity <level>', 'Default verbosity for all channels (tools_and_text, text_and_essential_tools, or text_only)')
+    .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', 'Reserved for compatibility; crash recovery is handled by the supervisor around `otto gateway start`')
+    .option('--no-sentry', 'Disable Sentry error reporting')
+    .option('--gateway', 'Force gateway mode (use the gateway Otto 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('--gateway-platform <platform>', 'Gateway platform to use (discord or telegram). Default: discord')
+    .option('--telegram-bot-token <token>', 'Telegram BotFather token used for telegram gateway onboarding')
+    .option('--telegram-chat-id <id>', 'Telegram supergroup chat ID used for telegram gateway onboarding')
+    .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/otto-assistant/bridge/tree/main/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/otto-assistant/bridge/tree/main/skills for available skills.'))
+    .action(async (options) => {
+    if (process.env.OTTO_OPENCODE_PROCESS) {
+        cliLogger.log('Detected OpenCode session. Launching OpenCode TUI instead of restarting the otto bot process.');
+        const exitCode = await new Promise((resolve, reject) => {
+            const tuiProcess = spawn('opencode', [], {
+                stdio: 'inherit',
+                env: process.env,
+            });
+            tuiProcess.once('error', (error) => {
+                reject(error);
+            });
+            tuiProcess.once('exit', (code, signal) => {
+                if (signal) {
+                    reject(new Error(`OpenCode TUI exited due to signal: ${signal}`));
+                    return;
+                }
+                resolve(code ?? 0);
+            });
+        }).catch((error) => {
+            cliLogger.error('Failed to launch OpenCode TUI:', formatErrorWithStack(error));
+            return EXIT_NO_RESTART;
+        });
+        process.exit(exitCode);
+    }
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+            cliLogger.log(`Using data directory: ${getDataDir()}`);
+        }
+        if (options.projectsDir) {
+            setProjectsDir(options.projectsDir);
+            cliLogger.log(`Using projects directory: ${getProjectsDir()}`);
         }
-        case "status": {
-            const health = checkTenantHealth({ tenantPath });
-            console.log(`Tenant status: ${tenantPath}`);
-            for (const item of health) {
-                const icon = item.status === "ok" ? "✓" : item.status === "warn" ? "⚠" : "✗";
-                console.log(`  ${icon} ${item.name}: ${item.message}`);
+        initLogFile(getDataDir());
+        if (options.verbosity) {
+            const validLevels = [
+                'tools_and_text',
+                'text_and_essential_tools',
+                'text_only',
+            ];
+            if (!validLevels.includes(options.verbosity)) {
+                cliLogger.error(`Invalid verbosity level: ${options.verbosity}. Use one of: ${validLevels.join(', ')}`);
+                process.exit(EXIT_NO_RESTART);
             }
-            const composeExists = fs.existsSync(path.join(tenantPath, "compose.yml"));
-            const skipComposePs = process.env.OTTO_SKIP_COMPOSE_PS === "1";
-            if (composeExists && !skipComposePs) {
+        }
+        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);
+        }
+        if (enabledSkills.length > 0 || disabledSkills.length > 0) {
+            const bundledSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'skills');
+            const availableBundledSkills = (() => {
                 try {
-                    runCompose(tenantPath, ["ps"]);
+                    return fs
+                        .readdirSync(bundledSkillsDir, { withFileTypes: true })
+                        .filter((entry) => entry.isDirectory())
+                        .map((entry) => entry.name);
                 }
                 catch {
-                    console.log("  ⚠ docker compose ps failed");
+                    return [];
+                }
+            })();
+            const availableSet = new Set(availableBundledSkills);
+            for (const name of [...enabledSkills, ...disabledSkills]) {
+                if (!availableSet.has(name)) {
+                    cliLogger.warn(`Skill "${name}" is not a bundled otto skill. Rule will still apply (user-provided skills from .opencode/.claude/.agents dirs may match). Available bundled skills: ${availableBundledSkills.join(', ')}`);
                 }
             }
-            return;
         }
-        default:
-            console.log("Usage: otto tenant <init|up|down|status|logs> <path> | otto tenant skills bootstrap <path>");
-            process.exit(1);
+        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}`);
+        }
+        if (options.mentionMode) {
+            cliLogger.log('Default mention mode: enabled (bot only responds when @mentioned)');
+        }
+        if (options.noCritique) {
+            cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
+        }
+        if (options.noSentry) {
+            process.env.OTTO_SENTRY_DISABLED = '1';
+            cliLogger.log('Sentry error reporting disabled (--no-sentry)');
+        }
+        else {
+            initSentry();
+        }
+        if (options.installUrl) {
+            await printDiscordInstallUrlAndExit({
+                gateway: options.gateway,
+                gatewayPlatform: parseGatewayPlatform(options.gatewayPlatform),
+                gatewayCallbackUrl: options.gatewayCallbackUrl,
+            });
+        }
+        await run({
+            restartOnboarding: options.restartOnboarding,
+            addChannels: options.addChannels,
+            dataDir: options.dataDir,
+            useWorktrees: options.useWorktrees,
+            enableVoiceChannels: options.enableVoiceChannels,
+            gateway: options.gateway,
+            gatewayPlatform: parseGatewayPlatform(options.gatewayPlatform),
+            gatewayCallbackUrl: options.gatewayCallbackUrl,
+            telegramBotToken: options.telegramBotToken,
+            telegramChatId: options.telegramChatId,
+        });
     }
-}
-// ---------------------------------------------------------------------------
-// Main router
-// ---------------------------------------------------------------------------
-async function main() {
-    switch (command) {
-        case "install":
-            await cmdInstall();
-            break;
-        case "upgrade":
-            await cmdUpgrade(subCommand === "latest" ? "latest" : "stable");
-            break;
-        case "status":
-            await cmdStatus();
-            break;
-        case "doctor":
-            await cmdDoctor();
-            break;
-        case "sync":
-            await syncUpstreams();
-            break;
-        case "skills":
-            await cmdSkills(args.slice(1));
-            break;
-        case "tenant":
-            await cmdTenant(args.slice(1));
-            break;
-        default:
-            console.log(`Otto — terminal UI distribution for opencode + kimaki + mempalace
-
-Usage:
-  otto tenant init <path>   Create compose-first tenant scaffold
-  otto tenant up <path>     Start tenant with docker compose
-  otto tenant down <path>   Stop tenant with docker compose
-  otto tenant status <path> Show tenant preflight + compose status
-  otto tenant logs <path>   Show tenant logs (add --follow)
-  otto tenant skills bootstrap <path> Install baseline skills for tenant
-
-  otto install              Legacy: install missing npm packages + configure
-  otto upgrade              Legacy: upgrade to stable (manifest-pinned) versions
-  otto upgrade stable       Legacy: upgrade to manifest-pinned versions
-  otto upgrade latest       Legacy: upgrade to npm latest versions
-  otto status               Show installed versions + config health
-  otto doctor               Validate all integration points
-  otto sync                 Trigger upstream sync for all forked repos
-  otto skills search <q>    Search skills across public repos
-  otto skills browse        Browse all available skills
-  otto skills list          List installed skills
-  otto skills add <name>    Install a skill
-  otto skills add --all     Install all skills from otto-assistant/skills
-  otto skills update        Refresh skills index
-  otto skills remove <name> Remove an installed skill
-  otto skills repos         Show configured skill repositories
-`);
-            break;
+    catch (error) {
+        cliLogger.error('Unhandled error:', formatErrorWithStack(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('gateway restart', 'Spawn a fresh `gateway start` process; replaces the existing instance via the single-instance lock')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
+    .action(async (options) => {
+    try {
+        const spawnArgs = ['gateway', 'start'];
+        if (options.dataDir) {
+            spawnArgs.push('--data-dir', options.dataDir);
+        }
+        if (options.projectsDir) {
+            spawnArgs.push('--projects-dir', options.projectsDir);
+        }
+        const detachedGateway = spawnDetachedGatewayStart({ extraArgs: spawnArgs.slice(2) });
+        if (detachedGateway instanceof Error) {
+            throw detachedGateway;
+        }
+        cliLogger.log('Restarting Otto gateway...');
+        await printGatewayStartupLogs({
+            dataDir: resolveGatewayDataDir({
+                dataDir: options.dataDir,
+            }),
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Gateway restart failed:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('discord-install-url', 'Print the bot install URL and exit')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--gateway', 'Print the gateway install URL and create local gateway credentials if missing')
+    .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
+    .option('--gateway-platform <platform>', 'Gateway platform to use for install URL (discord or telegram). Default: discord')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+            cliLogger.log(`Using data directory: ${getDataDir()}`);
+        }
+        initLogFile(getDataDir());
+        await printDiscordInstallUrlAndExit({
+            gateway: options.gateway,
+            gatewayPlatform: parseGatewayPlatform(options.gatewayPlatform),
+            gatewayCallbackUrl: options.gatewayCallbackUrl,
+        });
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+// ── bot command group ────────────────────────────────────────────────────
+const ACTIVITY_TYPE_MAP = {
+    playing: ActivityType.Playing,
+    watching: ActivityType.Watching,
+    listening: ActivityType.Listening,
+    competing: ActivityType.Competing,
+    custom: ActivityType.Custom,
+};
+const STATUS_MAP = {
+    online: 'online',
+    idle: 'idle',
+    dnd: 'dnd',
+    invisible: 'invisible',
+};
+cli
+    .command('bot install-url', 'Print the bot install URL')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--gateway', 'Print the gateway install URL and create local gateway credentials if missing')
+    .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
+    .option('--gateway-platform <platform>', 'Gateway platform to use for install URL (discord or telegram). Default: discord')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+            cliLogger.log(`Using data directory: ${getDataDir()}`);
+        }
+        initLogFile(getDataDir());
+        await printDiscordInstallUrlAndExit({
+            gateway: options.gateway,
+            gatewayPlatform: parseGatewayPlatform(options.gatewayPlatform),
+            gatewayCallbackUrl: options.gatewayCallbackUrl,
+        });
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+// Max length for activity name/state — Discord silently truncates beyond 128 chars.
+const MAX_STATUS_TEXT_LENGTH = 128;
+// Login timeout for temporary discord.js clients (10s).
+const BOT_LOGIN_TIMEOUT_MS = 10_000;
+// Wait for gateway opcode 3 websocket frame to flush before destroying the client.
+const PRESENCE_FLUSH_DELAY_MS = 1200;
+/**
+ * Create a temporary discord.js client, connect to gateway, run a callback,
+ * then tear down. Includes a login timeout so the command doesn't hang forever.
+ */
+async function withTempDiscordClient({ token, onReady, }) {
+    const client = await createDiscordClient();
+    try {
+        await Promise.race([
+            new Promise((resolve, reject) => {
+                client.once(Events.ClientReady, () => {
+                    resolve();
+                });
+                client.once(Events.Error, reject);
+                client.login(token).catch(reject);
+            }),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Discord login timed out (10s)'));
+                }, BOT_LOGIN_TIMEOUT_MS);
+            }),
+        ]);
+        if (!client.isReady() || !client.user) {
+            throw new Error('Discord client ready but user is missing');
+        }
+        await onReady(client);
+    }
+    finally {
+        client.destroy();
+    }
+}
+cli
+    .command('bot status set <text>', 'Set the bot presence/status in Discord')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .option('--type <activityType>', 'Activity type: playing, watching, listening, competing, custom (default: custom)')
+    .option('--status <onlineStatus>', 'Online status: online, idle, dnd, invisible (default: online)')
+    .action(async (text, options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+        }
+        initLogFile(getDataDir());
+        await initDatabase();
+        const botRow = await getBotTokenWithMode();
+        if (!botRow) {
+            cliLogger.error('No bot configured. Run `otto gateway start` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (botRow.mode === 'gateway') {
+            cliLogger.error('Cannot set status in gateway mode — it would change the shared bot status for all users.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (text.length > MAX_STATUS_TEXT_LENGTH) {
+            cliLogger.error(`Status text too long (${text.length} chars, max ${MAX_STATUS_TEXT_LENGTH}).`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const activityTypeKey = (options.type || 'custom').toLowerCase();
+        const activityType = ACTIVITY_TYPE_MAP[activityTypeKey];
+        if (activityType === undefined) {
+            cliLogger.error(`Unknown activity type: ${options.type}. Use: playing, watching, listening, competing, custom`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const statusKey = (options.status || 'online').toLowerCase();
+        const onlineStatus = STATUS_MAP[statusKey];
+        if (!onlineStatus) {
+            cliLogger.error(`Unknown status: ${options.status}. Use: online, idle, dnd, invisible`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log('Connecting to Discord...');
+        await withTempDiscordClient({
+            token: botRow.token,
+            onReady: async (client) => {
+                // For custom activity type, use state field (shows as the status text).
+                // For other types, use name field (shows as "Playing X", "Watching X", etc).
+                const activity = activityType === ActivityType.Custom
+                    ? { name: 'Custom Status', type: activityType, state: text }
+                    : { name: text, type: activityType };
+                client.user.setPresence({
+                    activities: [activity],
+                    status: onlineStatus,
+                });
+                // setPresence queues a gateway opcode 3 over websocket.
+                // Wait so the frame flushes before we tear down the connection.
+                await new Promise((resolve) => {
+                    setTimeout(resolve, PRESENCE_FLUSH_DELAY_MS);
+                });
+                cliLogger.log(`Status set: ${activityTypeKey === 'custom' ? text : `${activityTypeKey} ${text}`} (${statusKey})`);
+            },
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('bot status clear', 'Clear the bot presence/status')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.otto)')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+        }
+        initLogFile(getDataDir());
+        await initDatabase();
+        const botRow = await getBotTokenWithMode();
+        if (!botRow) {
+            cliLogger.error('No bot configured. Run `otto gateway start` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (botRow.mode === 'gateway') {
+            cliLogger.error('Cannot clear status in gateway mode — it would change the shared bot status for all users.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log('Connecting to Discord...');
+        await withTempDiscordClient({
+            token: botRow.token,
+            onReady: async (client) => {
+                client.user.setPresence({
+                    activities: [],
+                    status: 'online',
+                });
+                await new Promise((resolve) => {
+                    setTimeout(resolve, PRESENCE_FLUSH_DELAY_MS);
+                });
+                cliLogger.log('Status cleared');
+            },
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('upload-to-discord [...files]', 'Upload files to a Discord thread for a session')
+    .option('-s, --session <sessionId>', 'OpenCode session ID')
+    .action(async (files, options) => {
+    try {
+        const { session: sessionId } = options;
+        if (!sessionId) {
+            cliLogger.error('Session ID is required. Use --session <sessionId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!files || files.length === 0) {
+            cliLogger.error('At least one file path is required');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const resolvedFiles = files.map((f) => path.resolve(f));
+        for (const file of resolvedFiles) {
+            if (!fs.existsSync(file)) {
+                cliLogger.error(`File not found: ${file}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
+        await initDatabase();
+        const threadId = await getThreadIdBySessionId(sessionId);
+        if (!threadId) {
+            cliLogger.error(`No Discord thread found for session: ${sessionId}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const botRow = await getBotTokenWithMode();
+        if (!botRow) {
+            cliLogger.error('No bot credentials found. Run `otto gateway start` first to set up the bot.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log(`Uploading ${resolvedFiles.length} file(s)...`);
+        await uploadFilesToDiscord({
+            threadId: threadId,
+            botToken: botRow.token,
+            files: resolvedFiles,
+        });
+        cliLogger.log(`Uploaded ${resolvedFiles.length} file(s)!`);
+        note(`Files uploaded to Discord thread!\n\nFiles: ${resolvedFiles.map((f) => path.basename(f)).join(', ')}`, '✅ Success');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('send', 'Send a message to a Discord channel/thread. Default creates a thread; use --thread/--session to continue existing.')
+    .alias('start-session') // backwards compatibility
+    .option('-c, --channel <channelId>', 'Discord channel ID')
+    .option('-d, --project <path>', 'Project directory (alternative to --channel)')
+    .option('-p, --prompt <prompt>', 'Message content')
+    .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
+    .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
+    .option('--notify-only', 'Create notification thread without starting AI session')
+    .option('--silent-prompt', 'Hide prompt text from Discord thread (send as hidden attachment)')
+    .option('--no-message', 'Create thread without visible prompt message (agent responds first)')
+    .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)')
+    .option('--permission <rule>', z.array(z.string()).describe('Session permission rule (repeatable). Format: "tool:action" or "tool:pattern:action". ' +
+    'Actions: allow, deny, ask. Examples: --permission "bash:deny" --permission "edit:deny"'))
+    .option('--injection-guard <pattern>', z.array(z.string()).describe('Injection guard scan pattern (repeatable). Enables prompt injection detection for this session. ' +
+    'Format: "tool:argsGlob". Examples: --injection-guard "bash:*" --injection-guard "webfetch:*"'))
+    .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
+    .option('--thread <threadId>', 'Post prompt to an existing thread')
+    .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
+    .option('--wait', 'Wait for session to complete, then print session text to stdout')
+    .option('--report', 'Wait and stream incremental session updates for follow-ups')
+    .action(async (options) => {
+    try {
+        // `--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 noMessage = options.noMessage;
+        let silentPrompt = options.silentPrompt;
+        let name = options.name || undefined;
+        const { project: projectPath } = options;
+        const sendAt = options.sendAt;
+        const existingThreadMode = Boolean(threadId || sessionId);
+        if (threadId && sessionId) {
+            cliLogger.error('Use either --thread or --session, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (existingThreadMode && (channelId || projectPath)) {
+            cliLogger.error('Cannot combine --thread/--session with --channel/--project');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Default to current directory if neither --channel nor --project provided
+        const resolvedProjectPath = existingThreadMode
+            ? undefined
+            : projectPath || (!channelId ? '.' : undefined);
+        // For immediate new-thread sends, --silent-prompt should be fully silent:
+        // no visible starter prompt, and agent response should be first.
+        // Reuse the existing agent-first path by switching to noMessage mode.
+        if (silentPrompt && !existingThreadMode && !sendAt) {
+            noMessage = true;
+            silentPrompt = false;
+        }
+        if (!prompt) {
+            cliLogger.error('Prompt is required. Use --prompt <prompt>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (options.wait && options.report) {
+            cliLogger.error('Use either --wait or --report, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (sendAt) {
+            if (options.wait) {
+                cliLogger.error('Cannot use --wait with --send-at');
+                process.exit(EXIT_NO_RESTART);
+            }
+            if (options.report) {
+                cliLogger.error('Cannot use --report with --send-at');
+                process.exit(EXIT_NO_RESTART);
+            }
+            if (prompt.length > 1900) {
+                cliLogger.error('--send-at currently supports prompts up to 1900 characters');
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
+        const parsedSchedule = (() => {
+            if (!sendAt) {
+                return null;
+            }
+            // Cron expressions use UTC so the schedule is consistent regardless of
+            // which machine runs the bot. The system message tells the model to use UTC.
+            return parseSendAtValue({
+                value: sendAt,
+                now: new Date(),
+                timezone: 'UTC',
+            });
+        })();
+        if (parsedSchedule instanceof Error) {
+            cliLogger.error(parsedSchedule.message);
+            if (parsedSchedule.cause instanceof Error) {
+                cliLogger.error(parsedSchedule.cause.message);
+            }
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!existingThreadMode && options.worktree && notifyOnly) {
+            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);
+        }
+        if (options.report && notifyOnly) {
+            cliLogger.error('Cannot use --report with --notify-only');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (silentPrompt && notifyOnly) {
+            cliLogger.error('Cannot use --silent-prompt with --notify-only');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (noMessage && notifyOnly) {
+            cliLogger.error('Cannot use --no-message with --notify-only');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (existingThreadMode) {
+            const incompatibleFlags = [];
+            if (notifyOnly) {
+                incompatibleFlags.push('--notify-only');
+            }
+            if (options.worktree) {
+                incompatibleFlags.push('--worktree');
+            }
+            if (options.cwd) {
+                incompatibleFlags.push('--cwd');
+            }
+            if (name) {
+                incompatibleFlags.push('--name');
+            }
+            if (options.user) {
+                incompatibleFlags.push('--user');
+            }
+            if (noMessage) {
+                incompatibleFlags.push('--no-message');
+            }
+            if (!sendAt && options.agent) {
+                incompatibleFlags.push('--agent');
+            }
+            if (!sendAt && options.model) {
+                incompatibleFlags.push('--model');
+            }
+            if (incompatibleFlags.length > 0) {
+                cliLogger.error(`Incompatible options with --thread/--session: ${incompatibleFlags.join(', ')}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
+        // Initialize database first
+        await initDatabase();
+        const { token: botToken, appId } = await resolveBotCredentials({
+            appIdOverride: optionAppId,
+        });
+        // If --project provided (or defaulting to cwd), resolve to channel ID
+        if (resolvedProjectPath) {
+            const absolutePath = path.resolve(resolvedProjectPath);
+            if (!fs.existsSync(absolutePath)) {
+                cliLogger.error(`Directory does not exist: ${absolutePath}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            cliLogger.log('Looking up channel for project...');
+            // Check if channel already exists for this directory or a parent directory
+            // This allows running from subfolders of a registered project
+            try {
+                // Helper to find channel for a path.
+                const findChannelForPath = async (dirPath) => {
+                    const channels = await findChannelsByDirectory({
+                        directory: dirPath,
+                        channelType: 'text',
+                    });
+                    return channels[0];
+                };
+                // Try exact match first, then walk up parent directories
+                let existingChannel;
+                let searchPath = absolutePath;
+                while (searchPath !== path.dirname(searchPath)) {
+                    existingChannel = await findChannelForPath(searchPath);
+                    if (existingChannel)
+                        break;
+                    searchPath = path.dirname(searchPath);
+                }
+                if (existingChannel) {
+                    channelId = existingChannel.channel_id;
+                    if (existingChannel.directory !== absolutePath) {
+                        cliLogger.log(`Found parent project channel: ${existingChannel.directory}`);
+                    }
+                    else {
+                        cliLogger.log(`Found existing channel: ${channelId}`);
+                    }
+                }
+                else {
+                    // Need to create a new channel
+                    cliLogger.log('Creating new channel...');
+                    if (!appId) {
+                        cliLogger.log('Missing app ID');
+                        cliLogger.error('App ID is required to create channels. Use --app-id or run `otto gateway start` first.');
+                        process.exit(EXIT_NO_RESTART);
+                    }
+                    const client = await createDiscordClient();
+                    await new Promise((resolve, reject) => {
+                        client.once(Events.ClientReady, () => {
+                            resolve();
+                        });
+                        client.once(Events.Error, reject);
+                        client.login(botToken);
+                    });
+                    // Get guild from existing channels or first available
+                    const guild = await (async () => {
+                        const existingChannelId = await (await getPrisma()).channel_directories.findFirst({
+                            where: { channel_type: 'text' },
+                            orderBy: { created_at: 'desc' },
+                            select: { channel_id: true },
+                        }).then((row) => row?.channel_id);
+                        if (existingChannelId) {
+                            try {
+                                const ch = await client.channels.fetch(existingChannelId);
+                                if (ch && 'guild' in ch && ch.guild) {
+                                    return ch.guild;
+                                }
+                            }
+                            catch (error) {
+                                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.stack : String(error));
+                            }
+                        }
+                        // Fall back to first guild the bot is in
+                        let firstGuild = client.guilds.cache.first();
+                        if (!firstGuild) {
+                            // Cache might be empty, try fetching guilds from API
+                            const fetched = await client.guilds.fetch();
+                            const firstOAuth2Guild = fetched.first();
+                            if (firstOAuth2Guild) {
+                                firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                            }
+                        }
+                        if (!firstGuild) {
+                            throw new Error('No guild found. Add the bot to a server first.');
+                        }
+                        return firstGuild;
+                    })();
+                    const { textChannelId } = await createProjectChannels({
+                        guild,
+                        projectDirectory: absolutePath,
+                        botName: client.user?.username,
+                    });
+                    channelId = textChannelId;
+                    cliLogger.log(`Created channel: ${channelId}`);
+                    client.destroy();
+                }
+            }
+            catch (e) {
+                cliLogger.log('Failed to resolve project');
+                throw e;
+            }
+        }
+        const rest = createDiscordRest(botToken);
+        if (existingThreadMode) {
+            const targetThreadId = await (async () => {
+                if (threadId) {
+                    return threadId;
+                }
+                if (!sessionId) {
+                    throw new Error('Thread ID not resolved');
+                }
+                const resolvedThreadId = await getThreadIdBySessionId(sessionId);
+                if (!resolvedThreadId) {
+                    throw new Error(`No Discord thread found for session: ${sessionId}`);
+                }
+                return resolvedThreadId;
+            })();
+            const threadData = (await rest.get(Routes.channel(targetThreadId)));
+            if (!isThreadChannelType(threadData.type)) {
+                throw new Error(`Channel is not a thread: ${targetThreadId}`);
+            }
+            if (!threadData.parent_id) {
+                throw new Error(`Thread has no parent channel: ${targetThreadId}`);
+            }
+            const channelConfig = await getChannelDirectory(threadData.parent_id);
+            if (!channelConfig) {
+                throw new Error('Thread parent channel is not configured with a project directory');
+            }
+            if (parsedSchedule) {
+                const payload = {
+                    kind: 'thread',
+                    threadId: targetThreadId,
+                    prompt,
+                    silentPrompt: Boolean(silentPrompt),
+                    agent: options.agent || null,
+                    model: options.model || null,
+                    username: null,
+                    userId: null,
+                    permissions: options.permission?.length ? options.permission : null,
+                    injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+                };
+                const taskId = await createScheduledTask({
+                    scheduleKind: parsedSchedule.scheduleKind,
+                    runAt: parsedSchedule.runAt,
+                    cronExpr: parsedSchedule.cronExpr,
+                    timezone: parsedSchedule.timezone,
+                    nextRunAt: parsedSchedule.nextRunAt,
+                    payloadJson: serializeScheduledTaskPayload(payload),
+                    promptPreview: getPromptPreview(prompt),
+                    channelId: threadData.parent_id,
+                    threadId: targetThreadId,
+                    sessionId: sessionId || undefined,
+                    projectDirectory: channelConfig.directory,
+                });
+                const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
+                note(`Task ID: ${taskId}\nTarget thread: ${threadData.name}\nSchedule: ${formatTaskScheduleLine(parsedSchedule)}\n\nURL: ${threadUrl}`, '✅ Task Scheduled');
+                cliLogger.log(threadUrl);
+                process.exit(0);
+            }
+            const threadPromptMarker = {
+                start: true,
+                ...(options.permission?.length ? { permissions: options.permission } : {}),
+                ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
+            };
+            const promptEmbed = [
+                {
+                    color: 0x2b2d31,
+                    footer: { text: YAML.stringify(threadPromptMarker) },
+                },
+            ];
+            // 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 = `» **otto:**\n${prompt}`;
+            await sendDiscordMessageWithOptionalAttachment({
+                channelId: targetThreadId,
+                prompt: prefixedPrompt,
+                botToken,
+                embeds: promptEmbed,
+                rest,
+            });
+            const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
+            note(`Prompt sent to thread: ${threadData.name}\n\nURL: ${threadUrl}`, '✅ Message Sent');
+            cliLogger.log(threadUrl);
+            if (options.report) {
+                const { waitAndReportSession } = await import('./wait-session.js');
+                await waitAndReportSession({
+                    threadId: targetThreadId,
+                    projectDirectory: channelConfig.directory,
+                });
+            }
+            else if (options.wait) {
+                const { waitAndOutputSession } = await import('./wait-session.js');
+                await waitAndOutputSession({
+                    threadId: targetThreadId,
+                    projectDirectory: channelConfig.directory,
+                });
+            }
+            process.exit(0);
+        }
+        cliLogger.log('Fetching channel info...');
+        if (!channelId) {
+            throw new Error('Channel ID not resolved');
+        }
+        // Get channel info to extract directory from topic
+        const channelData = (await rest.get(Routes.channel(channelId)));
+        const channelConfig = await getChannelDirectory(channelData.id);
+        if (!channelConfig) {
+            cliLogger.log('Channel not configured');
+            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) {
+                return undefined;
+            }
+            cliLogger.log(`Searching for user "${options.user}" in guild...`);
+            const searchResults = (await rest.get(Routes.guildMembersSearch(channelData.guild_id), {
+                query: new URLSearchParams({ query: options.user, limit: '10' }),
+            }));
+            // Find exact match by display name, nickname, or username
+            const exactMatch = searchResults.find((member) => {
+                const displayName = member.nick || member.user.global_name || member.user.username;
+                return (displayName.toLowerCase() === options.user.toLowerCase() ||
+                    member.user.username.toLowerCase() === options.user.toLowerCase());
+            });
+            const member = exactMatch || searchResults[0];
+            if (!member) {
+                throw new Error(`User "${options.user}" not found in guild`);
+            }
+            const username = member.nick || member.user.global_name || member.user.username;
+            cliLogger.log(`Found user: ${username} (${member.user.id})`);
+            return { id: member.user.id, username };
+        })();
+        cliLogger.log('Creating starter message...');
+        // Compute thread name and worktree name early (needed for embed)
+        const cleanPrompt = stripMentions(prompt);
+        const baseThreadName = name ||
+            (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
+            ? typeof options.worktree === 'string'
+                ? formatWorktreeName(options.worktree)
+                : formatAutoWorktreeName(baseThreadName)
+            : undefined;
+        const threadName = worktreeName
+            ? `${WORKTREE_PREFIX}${baseThreadName}`
+            : baseThreadName;
+        if (parsedSchedule) {
+            const payload = {
+                kind: 'channel',
+                channelId,
+                prompt,
+                name: name || null,
+                notifyOnly: Boolean(notifyOnly),
+                silentPrompt: Boolean(silentPrompt),
+                worktreeName: worktreeName || null,
+                cwd: resolvedCwd || null,
+                agent: options.agent || null,
+                model: options.model || null,
+                username: resolvedUser?.username || null,
+                userId: resolvedUser?.id || null,
+                permissions: options.permission?.length ? options.permission : null,
+                injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
+            };
+            const taskId = await createScheduledTask({
+                scheduleKind: parsedSchedule.scheduleKind,
+                runAt: parsedSchedule.runAt,
+                cronExpr: parsedSchedule.cronExpr,
+                timezone: parsedSchedule.timezone,
+                nextRunAt: parsedSchedule.nextRunAt,
+                payloadJson: serializeScheduledTaskPayload(payload),
+                promptPreview: getPromptPreview(prompt),
+                channelId,
+                projectDirectory,
+            });
+            const channelUrl = `https://discord.com/channels/${channelData.guild_id}/${channelId}`;
+            note(`Task ID: ${taskId}\nTarget channel: #${channelData.name}\nSchedule: ${formatTaskScheduleLine(parsedSchedule)}\n\nURL: ${channelUrl}`, '✅ Task Scheduled');
+            cliLogger.log(channelUrl);
+            process.exit(0);
+        }
+        // ── New thread creation ──────────────────────────────────
+        // CLI creates Discord thread with embed marker, bot's ThreadCreate
+        // handler picks it up and starts the session. No IPC needed —
+        // CLI and bot are separate processes with separate opencode servers.
+        // Notify-only: create empty visible starter + thread, then exit
+        if (notifyOnly) {
+            cliLogger.log('Creating notify-only starter message...');
+            const notifyStarter = (await rest.post(Routes.channelMessages(channelId), { body: { content: '' } }));
+            cliLogger.log('Creating thread...');
+            const notifyThread = (await rest.post(Routes.threads(channelId, notifyStarter.id), {
+                body: {
+                    name: threadName.slice(0, 100),
+                    auto_archive_duration: 1440,
+                },
+            }));
+            if (resolvedUser) {
+                cliLogger.log(`Adding user ${resolvedUser.username} to thread...`);
+                await rest
+                    .put(Routes.threadMembers(notifyThread.id, resolvedUser.id))
+                    .catch(() => { });
+            }
+            const notifyUrl = `https://discord.com/channels/${channelData.guild_id}/${notifyThread.id}`;
+            note(`Thread: ${notifyThread.name || notifyThread.id}\n\nURL: ${notifyUrl}`, '✅ Thread Created');
+            cliLogger.log(notifyUrl);
+            process.exit(0);
+        }
+        // Embed marker for auto-start sessions.
+        // Bot's ThreadCreate handler parses this YAML to start a session,
+        // optionally create a worktree, set initial user, etc.
+        const embedMarker = {
+            start: true,
+            ...(noMessage && { prompt }),
+            ...(worktreeName && { worktree: worktreeName }),
+            ...(resolvedCwd && { cwd: resolvedCwd }),
+            ...(resolvedUser && {
+                username: resolvedUser.username,
+                userId: resolvedUser.id,
+            }),
+            ...(options.agent && { agent: options.agent }),
+            ...(options.model && { model: options.model }),
+            ...(options.permission?.length && { permissions: options.permission }),
+            ...(options.injectionGuard?.length && { injectionGuardPatterns: options.injectionGuard }),
+        };
+        const autoStartEmbed = [
+            { color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } },
+        ];
+        // Create starter message
+        const starterBody = noMessage
+            ? { content: '\u200B', flags: 4096, embeds: autoStartEmbed }
+            : {
+                content: prompt,
+                embeds: autoStartEmbed,
+            };
+        cliLogger.log(noMessage
+            ? 'Creating invisible starter message...'
+            : 'Creating starter message...');
+        const starterMessage = (await rest.post(Routes.channelMessages(channelId), { body: starterBody }));
+        // Create thread from starter
+        cliLogger.log('Creating thread...');
+        const threadData = (await rest.post(Routes.threads(channelId, starterMessage.id), {
+            body: {
+                name: threadName.slice(0, 100),
+                auto_archive_duration: 1440,
+            },
+        }));
+        cliLogger.log('Thread created!');
+        // Add user to thread
+        if (resolvedUser) {
+            cliLogger.log(`Adding user ${resolvedUser.username} to thread...`);
+            await rest
+                .put(Routes.threadMembers(threadData.id, resolvedUser.id))
+                .catch(() => { });
+        }
+        // Remove the embed marker from the starter message after the bot's
+        // ThreadCreate handler has had time to read it (~1.5s). This prevents
+        // the YAML marker from being visible to users in Discord.
+        if (!notifyOnly) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1500);
+            });
+            const editBody = noMessage
+                ? { content: '\u200B', flags: 4096, embeds: [] }
+                : { embeds: [] };
+            await rest
+                .patch(Routes.channelMessage(channelId, starterMessage.id), {
+                body: editBody,
+            })
+                .catch(() => { });
+        }
+        // Success output
+        const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
+        const worktreeNote = worktreeName
+            ? `\nWorktree: ${worktreeName}`
+            : resolvedCwd
+                ? `\nWorking directory: ${resolvedCwd}`
+                : '';
+        note(`Thread: ${threadData.name || threadData.id}\nDirectory: ${projectDirectory}${worktreeNote}\n\nBot will start session automatically.\n\nURL: ${threadUrl}`, '✅ Thread Created');
+        cliLogger.log(threadUrl);
+        // Wait for session completion if --wait/--report
+        if (options.report) {
+            const { waitAndReportSession } = await import('./wait-session.js');
+            await waitAndReportSession({
+                threadId: threadData.id,
+                projectDirectory,
+            });
+        }
+        else if (options.wait) {
+            const { waitAndOutputSession } = await import('./wait-session.js');
+            await waitAndOutputSession({
+                threadId: threadData.id,
+                projectDirectory,
+            });
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('task list', 'List scheduled tasks created via send --send-at')
+    .option('--all', 'Include terminal tasks (completed, cancelled, failed)')
+    .action(async (options) => {
+    try {
+        await initDatabase();
+        const statuses = options.all
+            ? undefined
+            : ['planned', 'running'];
+        const tasks = await listScheduledTasks({ statuses });
+        if (tasks.length === 0) {
+            cliLogger.log('No scheduled tasks found');
+            process.exit(0);
+        }
+        console.log('id | status | message | channelId | projectName | folderName | timeRemaining | firesAt | cron');
+        tasks.forEach((task) => {
+            const projectDirectory = task.project_directory || '';
+            const projectName = projectDirectory
+                ? path.basename(projectDirectory)
+                : '-';
+            const folderName = projectDirectory
+                ? path.basename(path.dirname(projectDirectory))
+                : '-';
+            const firesAt = task.schedule_kind === 'at' && task.run_at
+                ? task.run_at.toISOString()
+                : '-';
+            const cronValue = task.schedule_kind === 'cron' ? task.cron_expr || '-' : '-';
+            console.log(`${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${projectName} | ${folderName} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`);
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('task delete <id>', 'Cancel a scheduled task by ID')
+    .action(async (id) => {
+    try {
+        const taskId = Number.parseInt(id, 10);
+        if (Number.isNaN(taskId) || taskId < 1) {
+            cliLogger.error(`Invalid task ID: ${id}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        await initDatabase();
+        const cancelled = await cancelScheduledTask(taskId);
+        if (!cancelled) {
+            cliLogger.error(`Task ${taskId} not found or already finalized`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log(`Cancelled task ${taskId}`);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('task edit <id>', 'Edit prompt or schedule of a planned task')
+    .option('--prompt <prompt>', 'New prompt text')
+    .option('--send-at <sendAt>', 'New schedule (UTC ISO date or cron expression)')
+    .action(async (id, options) => {
+    try {
+        const trimmedPrompt = options.prompt === undefined ? undefined : options.prompt.trim();
+        if (!trimmedPrompt && !options.sendAt) {
+            cliLogger.error('Provide at least --prompt or --send-at');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (trimmedPrompt !== undefined && trimmedPrompt.length === 0) {
+            cliLogger.error('--prompt cannot be empty');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (trimmedPrompt !== undefined && trimmedPrompt.length > 1900) {
+            cliLogger.error('--prompt currently supports up to 1900 characters');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const taskId = Number.parseInt(id, 10);
+        if (Number.isNaN(taskId) || taskId < 1) {
+            cliLogger.error(`Invalid task ID: ${id}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        await initDatabase();
+        const task = await getScheduledTask(taskId);
+        if (!task) {
+            cliLogger.error(`Task ${taskId} not found`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (task.status !== 'planned') {
+            cliLogger.error(`Task ${taskId} is ${task.status}, only planned tasks can be edited`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const existingPayload = parseScheduledTaskPayload(task.payload_json);
+        if (existingPayload instanceof Error) {
+            cliLogger.error(`Failed to parse task payload: ${existingPayload.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const newPrompt = trimmedPrompt ?? existingPayload.prompt;
+        const updatedPayload = {
+            ...existingPayload,
+            prompt: newPrompt,
+        };
+        const updateData = {
+            taskId,
+            payloadJson: serializeScheduledTaskPayload(updatedPayload),
+            promptPreview: getPromptPreview(newPrompt),
+        };
+        if (options.sendAt) {
+            const parsed = parseSendAtValue({
+                value: options.sendAt,
+                now: new Date(),
+                timezone: 'UTC',
+            });
+            if (parsed instanceof Error) {
+                cliLogger.error(`Invalid --send-at: ${parsed.message}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            updateData.scheduleKind = parsed.scheduleKind;
+            updateData.runAt = parsed.runAt;
+            updateData.cronExpr = parsed.cronExpr;
+            updateData.timezone = parsed.timezone;
+            updateData.nextRunAt = parsed.nextRunAt;
+        }
+        const updated = await updateScheduledTask(updateData);
+        if (!updated) {
+            cliLogger.error(`Task ${taskId} could not be updated (status may have changed)`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log(`Updated task ${taskId}`);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('anthropic-accounts list', 'List stored Anthropic OAuth accounts used for automatic rotation')
+    .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 ? '*' : ' ';
+        console.log(`${active} ${index + 1}. ${accountLabel(account)}`);
+    });
+    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) => {
+    const value = Number(indexOrEmail);
+    const store = await loadAccountStore();
+    const resolvedIndex = (() => {
+        if (Number.isInteger(value) && value >= 1) {
+            return value - 1;
+        }
+        const email = indexOrEmail.trim().toLowerCase();
+        if (!email) {
+            return -1;
+        }
+        return store.accounts.findIndex((account) => {
+            return account.email?.toLowerCase() === email;
+        });
+    })();
+    if (resolvedIndex < 0) {
+        cliLogger.error('Usage: otto anthropic-accounts remove <index-or-email>');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const removed = store.accounts[resolvedIndex];
+    await removeAccount(resolvedIndex);
+    cliLogger.log(`Removed Anthropic account ${removed ? accountLabel(removed, resolvedIndex) : indexOrEmail}`);
+    process.exit(0);
+});
+cli
+    .command('project add [directory]', 'Create Discord channels for a project directory (replaces legacy add-project)')
+    .alias('add-project')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
+    .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
+    .action(async (directory, options) => {
+    const absolutePath = path.resolve(directory || '.');
+    if (!fs.existsSync(absolutePath)) {
+        cliLogger.error(`Directory does not exist: ${absolutePath}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Initialize database
+    await initDatabase();
+    const { token: botToken, appId } = await resolveBotCredentials({
+        appIdOverride: options.appId,
+    });
+    if (!appId) {
+        cliLogger.error('App ID is required to create channels. Use --app-id or run `otto gateway start` first.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    cliLogger.log('Connecting to Discord...');
+    const client = await createDiscordClient();
+    await new Promise((resolve, reject) => {
+        client.once(Events.ClientReady, () => {
+            resolve();
+        });
+        client.once(Events.Error, reject);
+        client.login(botToken);
+    });
+    cliLogger.log('Finding guild...');
+    // Find guild
+    let guild;
+    if (options.guild) {
+        const guildId = String(options.guild);
+        const foundGuild = client.guilds.cache.get(guildId);
+        if (!foundGuild) {
+            cliLogger.log('Guild not found');
+            cliLogger.error(`Guild not found: ${guildId}`);
+            client.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        guild = foundGuild;
+    }
+    else {
+        const existingChannelId = await (await getPrisma()).channel_directories.findFirst({
+            where: { channel_type: 'text' },
+            orderBy: { created_at: 'desc' },
+            select: { channel_id: true },
+        }).then((row) => row?.channel_id);
+        if (existingChannelId) {
+            try {
+                const ch = await client.channels.fetch(existingChannelId);
+                if (ch && 'guild' in ch && ch.guild) {
+                    guild = ch.guild;
+                }
+                else {
+                    throw new Error('Channel has no guild');
+                }
+            }
+            catch (error) {
+                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.stack : String(error));
+                let firstGuild = client.guilds.cache.first();
+                if (!firstGuild) {
+                    // Cache might be empty, try fetching guilds from API
+                    const fetched = await client.guilds.fetch();
+                    const firstOAuth2Guild = fetched.first();
+                    if (firstOAuth2Guild) {
+                        firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                    }
+                }
+                if (!firstGuild) {
+                    cliLogger.log('No guild found');
+                    cliLogger.error('No guild found. Add the bot to a server first.');
+                    client.destroy();
+                    process.exit(EXIT_NO_RESTART);
+                }
+                guild = firstGuild;
+            }
+        }
+        else {
+            let firstGuild = client.guilds.cache.first();
+            if (!firstGuild) {
+                // Cache might be empty, try fetching guilds from API
+                const fetched = await client.guilds.fetch();
+                const firstOAuth2Guild = fetched.first();
+                if (firstOAuth2Guild) {
+                    firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
+                }
+            }
+            if (!firstGuild) {
+                cliLogger.log('No guild found');
+                cliLogger.error('No guild found. Add the bot to a server first.');
+                client.destroy();
+                process.exit(EXIT_NO_RESTART);
+            }
+            guild = firstGuild;
+        }
+    }
+    // Check if channel already exists in this guild
+    cliLogger.log('Checking for existing channel...');
+    try {
+        const existingChannels = await findChannelsByDirectory({
+            directory: absolutePath,
+            channelType: 'text',
+        });
+        for (const existingChannel of existingChannels) {
+            try {
+                const ch = await client.channels.fetch(existingChannel.channel_id);
+                if (ch && 'guild' in ch && ch.guild?.id === guild.id) {
+                    client.destroy();
+                    cliLogger.error(`Channel already exists for this directory in ${guild.name}. Channel ID: ${existingChannel.channel_id}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+            }
+            catch (error) {
+                cliLogger.debug(`Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`, error instanceof Error ? error.stack : String(error));
+            }
+        }
+    }
+    catch (error) {
+        cliLogger.debug('Database lookup failed while checking existing channels:', error instanceof Error ? error.stack : String(error));
+    }
+    cliLogger.log(`Creating channels in ${guild.name}...`);
+    const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory: absolutePath,
+        botName: client.user?.username,
+    });
+    client.destroy();
+    cliLogger.log('Channels created!');
+    const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
+    note(`Created channels for project:\n\n📝 Text: #${channelName}\n🔊 Voice: #${channelName}\n📁 Directory: ${absolutePath}\n\nURL: ${channelUrl}`, '✅ Success');
+    cliLogger.log(channelUrl);
+    process.exit(0);
+});
+cli
+    .command('project list', 'List all registered projects with their Discord channels')
+    .option('--json', 'Output as JSON')
+    .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
+    .action(async (options) => {
+    await initDatabase();
+    const prisma = await getPrisma();
+    const channels = await prisma.channel_directories.findMany({
+        where: { channel_type: 'text' },
+        orderBy: { created_at: 'desc' },
+    });
+    if (channels.length === 0) {
+        cliLogger.log('No projects registered');
+        process.exit(0);
+    }
+    // Fetch Discord channel names via REST API
+    const botRow = await getBotTokenWithMode();
+    const rest = botRow ? createDiscordRest(botRow.token) : null;
+    const enriched = await Promise.all(channels.map(async (ch) => {
+        let channelName = '';
+        let deleted = false;
+        if (rest) {
+            try {
+                const data = (await rest.get(Routes.channel(ch.channel_id)));
+                channelName = data.name || '';
+            }
+            catch (error) {
+                // Only mark as deleted for Unknown Channel (10003) or 404,
+                // not transient errors like rate limits or 5xx
+                const isUnknownChannel = error instanceof Error &&
+                    'code' in error &&
+                    'status' in error &&
+                    (error.code === 10003 ||
+                        error.status === 404);
+                deleted = isUnknownChannel;
+            }
+        }
+        return { ...ch, channelName, deleted };
+    }));
+    // Prune stale entries if requested
+    if (options.prune) {
+        const stale = enriched.filter((ch) => {
+            return ch.deleted;
+        });
+        if (stale.length === 0) {
+            cliLogger.log('No stale channels to prune');
+        }
+        else {
+            for (const ch of stale) {
+                await deleteChannelDirectoryById(ch.channel_id);
+                cliLogger.log(`Pruned stale channel ${ch.channel_id} (${path.basename(ch.directory)})`);
+            }
+            cliLogger.log(`Pruned ${stale.length} stale channel(s)`);
+        }
+        // Re-filter to only show live entries after pruning
+        const live = enriched.filter((ch) => {
+            return !ch.deleted;
+        });
+        if (live.length === 0) {
+            cliLogger.log('No projects registered');
+            process.exit(0);
+        }
+        enriched.length = 0;
+        enriched.push(...live);
+    }
+    if (options.json) {
+        const output = enriched.map((ch) => ({
+            channel_id: ch.channel_id,
+            channel_name: ch.channelName,
+            directory: ch.directory,
+            folder_name: path.basename(ch.directory),
+            deleted: ch.deleted,
+        }));
+        console.log(JSON.stringify(output, null, 2));
+        process.exit(0);
+    }
+    for (const ch of enriched) {
+        const folderName = path.basename(ch.directory);
+        const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
+        const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
+        console.log(`\n${channelLabel}${deletedTag}`);
+        console.log(`   Folder: ${folderName}`);
+        console.log(`   Directory: ${ch.directory}`);
+        console.log(`   Channel ID: ${ch.channel_id}`);
+    }
+    process.exit(0);
+});
+cli
+    .command('project open-in-discord', 'Open the current project channel in Discord')
+    .action(async () => {
+    await initDatabase();
+    const botRow = await getBotTokenWithMode();
+    if (!botRow) {
+        cliLogger.error('No bot configured. Run `otto gateway start` first.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const { token: botToken } = botRow;
+    const absolutePath = path.resolve('.');
+    // Walk up parent directories to find a matching channel
+    const findChannelForPath = async (dirPath) => {
+        const channels = await findChannelsByDirectory({
+            directory: dirPath,
+            channelType: 'text',
+        });
+        return channels[0];
+    };
+    let existingChannel;
+    let searchPath = absolutePath;
+    do {
+        existingChannel = await findChannelForPath(searchPath);
+        if (existingChannel) {
+            break;
+        }
+        const parent = path.dirname(searchPath);
+        if (parent === searchPath) {
+            break;
+        }
+        searchPath = parent;
+    } while (true);
+    if (!existingChannel) {
+        cliLogger.error(`No project channel found for ${absolutePath}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Fetch channel from Discord to get guild_id
+    const rest = createDiscordRest(botToken);
+    const channelData = (await rest.get(Routes.channel(existingChannel.channel_id)));
+    const channelUrl = `https://discord.com/channels/${channelData.guild_id}/${channelData.id}`;
+    cliLogger.log(channelUrl);
+    // Open in browser if running in a TTY
+    if (process.stdout.isTTY) {
+        if (process.platform === 'win32') {
+            spawn('cmd', ['/c', 'start', '', channelUrl], {
+                detached: true,
+                stdio: 'ignore',
+            }).unref();
+        }
+        else {
+            const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+            spawn(openCmd, [channelUrl], {
+                detached: true,
+                stdio: 'ignore',
+            }).unref();
+        }
+    }
+    process.exit(0);
+});
+cli
+    .command('project create <name>', 'Create a new project folder with git and Discord channels')
+    .option('-g, --guild <guildId>', 'Discord guild ID')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
+    .action(async (name, options) => {
+    if (options.projectsDir) {
+        setProjectsDir(options.projectsDir);
+    }
+    const sanitizedName = name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 100);
+    if (!sanitizedName) {
+        cliLogger.error('Invalid project name');
+        process.exit(EXIT_NO_RESTART);
+    }
+    await initDatabase();
+    const botRow = await getBotTokenWithMode();
+    if (!botRow) {
+        cliLogger.error('No bot configured. Run `otto gateway start` first.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const { token: botToken } = botRow;
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
+    if (!fs.existsSync(projectsDir)) {
+        fs.mkdirSync(projectsDir, { recursive: true });
+    }
+    if (fs.existsSync(projectDirectory)) {
+        cliLogger.error(`Directory already exists: ${projectDirectory}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    cliLogger.log(`Created: ${projectDirectory}`);
+    execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+    cliLogger.log('Initialized git');
+    cliLogger.log('Connecting to Discord...');
+    const client = await createDiscordClient();
+    await new Promise((resolve, reject) => {
+        client.once(Events.ClientReady, () => {
+            resolve();
+        });
+        client.once(Events.Error, reject);
+        client.login(botToken).catch(reject);
+    });
+    let guild;
+    if (options.guild) {
+        const found = client.guilds.cache.get(options.guild);
+        if (!found) {
+            cliLogger.error(`Guild not found: ${options.guild}`);
+            client.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        guild = found;
+    }
+    else {
+        const first = client.guilds.cache.first();
+        if (!first) {
+            cliLogger.error('No guild found. Add the bot to a server first.');
+            client.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        guild = first;
+    }
+    const { textChannelId, channelName } = await createProjectChannels({
+        guild,
+        projectDirectory,
+        botName: client.user?.username,
+    });
+    client.destroy();
+    const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
+    note(`Created project: ${sanitizedName}\n\nDirectory: ${projectDirectory}\nChannel: #${channelName}\nURL: ${channelUrl}`, '✅ Success');
+    cliLogger.log(channelUrl);
+    process.exit(0);
+});
+cli
+    .command('user list', 'Search for Discord users in a guild/server. Returns user IDs for mentions.')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID (required)')
+    .option('-q, --query [query]', 'Search query to filter users by name')
+    .action(async (options) => {
+    try {
+        if (!options.guild) {
+            cliLogger.error('Guild ID is required. Use --guild <guildId>');
+            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 (query) {
+                return (await rest.get(Routes.guildMembersSearch(guildId), {
+                    query: new URLSearchParams({ query, limit: '20' }),
+                }));
+            }
+            return (await rest.get(Routes.guildMembers(guildId), {
+                query: new URLSearchParams({ limit: '20' }),
+            }));
+        })();
+        if (members.length === 0) {
+            const msg = query
+                ? `No users found matching "${query}"`
+                : 'No users found in guild';
+            cliLogger.log(msg);
+            process.exit(0);
+        }
+        const userList = members
+            .map((m) => {
+            const displayName = m.nick || m.user.global_name || m.user.username;
+            return `- ${displayName} (ID: ${m.user.id}) - mention: <@${m.user.id}>`;
+        })
+            .join('\n');
+        const header = query
+            ? `Found ${members.length} users matching "${query}":`
+            : `Found ${members.length} users:`;
+        console.log(`${header}\n${userList}`);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('tunnel', 'Expose a local port via tunnel')
+    .option('-p, --port <port>', 'Local port to expose (required)')
+    .option('-t, --tunnel-id [id]', 'Custom tunnel ID (only for services safe to expose publicly; prefer random default)')
+    .option('-h, --host [host]', 'Local host (default: localhost)')
+    .option('-s, --server [url]', 'Tunnel server URL')
+    .option('-k, --kill', 'Kill any existing process on the port before starting')
+    .action(async (options) => {
+    const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import('traforo/run-tunnel');
+    if (!options.port) {
+        cliLogger.error('Error: --port is required');
+        cliLogger.error(`\nUsage: otto tunnel -p <port> [-- command]`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const port = parseInt(options.port, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        cliLogger.error(`Error: Invalid port number: ${options.port}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Parse command after -- from argv
+    const { command } = parseCommandFromArgv(process.argv);
+    await runTunnel({
+        port,
+        tunnelId: options.tunnelId || undefined,
+        localHost: options.host || undefined,
+        baseDomain: 'otto.dev',
+        serverUrl: options.server || undefined,
+        command: command.length > 0 ? command : undefined,
+        kill: options.kill,
+    });
+});
+cli
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. For background usage, start with bunx tuistory --help, then run it in a tuistory session.')
+    .action(async () => {
+    const { startScreenshare } = await import('./commands/screenshare.js');
+    try {
+        const session = await startScreenshare({
+            sessionKey: 'cli',
+            startedBy: 'cli',
+        });
+        cliLogger.log(`Screen sharing started: ${session.noVncUrl}`);
+        cliLogger.log('Press Ctrl+C to stop');
+    }
+    catch (err) {
+        cliLogger.error('Failed to start screen share:', err instanceof Error ? err.message : String(err));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('sqlitedb', 'Show the location of the SQLite database file')
+    .action(() => {
+    const dataDir = getDataDir();
+    const dbPath = path.join(dataDir, 'discord-sessions.db');
+    cliLogger.log(dbPath);
+});
+cli
+    .command('session list', 'List all OpenCode sessions, marking which were started via Otto')
+    .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const projectDirectory = path.resolve(options.project || '.');
+        await initDatabase();
+        cliLogger.log('Connecting to OpenCode server...');
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionsResponse = await getClient().session.list();
+        const sessions = sessionsResponse.data || [];
+        if (sessions.length === 0) {
+            cliLogger.log('No sessions found');
+            process.exit(0);
+        }
+        // Look up which sessions were started via otto (have a thread mapping)
+        const prisma = await getPrisma();
+        const threadSessions = await prisma.thread_sessions.findMany({
+            select: { thread_id: true, session_id: true },
+        });
+        const sessionToThread = new Map(threadSessions
+            .filter((row) => row.session_id !== '')
+            .map((row) => [row.session_id, row.thread_id]));
+        const sessionStartSources = await getSessionStartSourcesBySessionIds(sessions.map((session) => session.id));
+        const scheduleModeLabel = ({ scheduleKind, }) => {
+            if (scheduleKind === 'at') {
+                return 'delay';
+            }
+            return 'cron';
+        };
+        if (options.json) {
+            const output = sessions.map((session) => {
+                const startSource = sessionStartSources.get(session.id);
+                const startedBy = startSource
+                    ? `scheduled-${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}`
+                    : null;
+                return {
+                    id: session.id,
+                    title: session.title || 'Untitled Session',
+                    directory: session.directory,
+                    updated: new Date(session.time.updated).toISOString(),
+                    source: sessionToThread.has(session.id) ? 'otto' : 'opencode',
+                    threadId: sessionToThread.get(session.id) || null,
+                    startedBy,
+                    scheduledTaskId: startSource?.scheduled_task_id || null,
+                };
+            });
+            console.log(JSON.stringify(output, null, 2));
+            process.exit(0);
+        }
+        for (const session of sessions) {
+            const threadId = sessionToThread.get(session.id);
+            const startSource = sessionStartSources.get(session.id);
+            const source = threadId ? '(otto)' : '(opencode)';
+            const startedBy = startSource
+                ? ` | started-by: ${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}${startSource.scheduled_task_id ? ` (#${startSource.scheduled_task_id})` : ''}`
+                : '';
+            const updatedAt = new Date(session.time.updated).toISOString();
+            const threadInfo = threadId ? ` | thread: ${threadId}` : '';
+            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}${startedBy}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
+    .option('--project <path>', 'Project directory (defaults to cwd)')
+    .action(async (sessionId, options) => {
+    try {
+        const projectDirectory = path.resolve(options.project || '.');
+        await initDatabase();
+        cliLogger.log('Connecting to OpenCode server...');
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Try current project first (fast path)
+        const markdown = new ShareMarkdown(getClient());
+        const result = await markdown.generate({ sessionID: sessionId });
+        if (!(result instanceof Error)) {
+            process.stdout.write(result);
+            process.exit(0);
+        }
+        // Session not found in current project, search across all projects.
+        // project.list() returns all known projects globally from any OpenCode server,
+        // but session.list/get are scoped to the server's own project. So we try each.
+        cliLogger.log('Session not in current project, searching all projects...');
+        const projectsResponse = await getClient().project.list();
+        const projects = projectsResponse.data || [];
+        const otherProjects = projects
+            .filter((p) => path.resolve(p.worktree) !== projectDirectory)
+            .filter((p) => {
+            try {
+                fs.accessSync(p.worktree, fs.constants.R_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })
+            // Sort by most recently created first to find sessions faster
+            .sort((a, b) => b.time.created - a.time.created);
+        for (const project of otherProjects) {
+            const dir = project.worktree;
+            cliLogger.log(`Trying project: ${dir}`);
+            const otherClient = await initializeOpencodeForDirectory(dir);
+            if (otherClient instanceof Error) {
+                continue;
+            }
+            const otherMarkdown = new ShareMarkdown(otherClient());
+            const otherResult = await otherMarkdown.generate({
+                sessionID: sessionId,
+            });
+            if (!(otherResult instanceof Error)) {
+                process.stdout.write(otherResult);
+                process.exit(0);
+            }
+        }
+        cliLogger.error(`Session ${sessionId} not found in any project`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session search <query>', 'Search past sessions for text or /regex/flags in the selected project')
+    .option('--project <path>', 'Project directory (defaults to cwd)')
+    .option('--channel <channelId>', 'Resolve project from a Discord channel ID')
+    .option('--limit <n>', 'Maximum matched sessions to return (default: 20)')
+    .option('--json', 'Output as JSON')
+    .action(async (query, options) => {
+    try {
+        await initDatabase();
+        if (options.project && options.channel) {
+            cliLogger.error('Use either --project or --channel, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const limit = (() => {
+            const rawLimit = typeof options.limit === 'string' ? options.limit : '20';
+            const parsed = Number.parseInt(rawLimit, 10);
+            if (Number.isNaN(parsed) || parsed < 1) {
+                return new Error(`Invalid --limit value: ${rawLimit}`);
+            }
+            return parsed;
+        })();
+        if (limit instanceof Error) {
+            cliLogger.error(limit.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const projectDirectoryResult = await (async () => {
+            if (options.channel) {
+                const channelConfig = await getChannelDirectory(options.channel);
+                if (!channelConfig) {
+                    return new Error(`No project mapping found for channel: ${options.channel}`);
+                }
+                return path.resolve(channelConfig.directory);
+            }
+            return path.resolve(options.project || '.');
+        })();
+        if (projectDirectoryResult instanceof Error) {
+            cliLogger.error(projectDirectoryResult.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const projectDirectory = projectDirectoryResult;
+        if (!fs.existsSync(projectDirectory)) {
+            cliLogger.error(`Directory does not exist: ${projectDirectory}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const searchPattern = parseSessionSearchPattern(query);
+        if (searchPattern instanceof Error) {
+            cliLogger.error(searchPattern.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        cliLogger.log('Connecting to OpenCode server...');
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionsResponse = await getClient().session.list();
+        const sessions = sessionsResponse.data || [];
+        if (sessions.length === 0) {
+            cliLogger.log('No sessions found');
+            process.exit(0);
+        }
+        const prisma = await getPrisma();
+        const threadSessions = await prisma.thread_sessions.findMany({
+            select: { thread_id: true, session_id: true },
+        });
+        const sessionToThread = new Map(threadSessions
+            .filter((row) => row.session_id !== '')
+            .map((row) => [row.session_id, row.thread_id]));
+        const sortedSessions = [...sessions].sort((a, b) => {
+            return b.time.updated - a.time.updated;
+        });
+        const matchedSessions = [];
+        let scannedSessions = 0;
+        for (const session of sortedSessions) {
+            scannedSessions++;
+            const messagesResponse = await getClient().session.messages({
+                sessionID: session.id,
+            });
+            const messages = messagesResponse.data || [];
+            const snippets = messages
+                .flatMap((message) => {
+                const rolePrefix = message.info.role === 'assistant'
+                    ? 'assistant'
+                    : message.info.role === 'user'
+                        ? 'user'
+                        : 'message';
+                return message.parts.filter((p) => !(p.type === 'text' && p.synthetic)).flatMap((part) => {
+                    return getPartSearchTexts(part).flatMap((text) => {
+                        const hit = findFirstSessionSearchHit({
+                            text,
+                            searchPattern,
+                        });
+                        if (!hit) {
+                            return [];
+                        }
+                        const snippet = buildSessionSearchSnippet({ text, hit });
+                        if (!snippet) {
+                            return [];
+                        }
+                        return [`${rolePrefix}: ${snippet}`];
+                    });
+                });
+            })
+                .slice(0, 3);
+            if (snippets.length === 0) {
+                continue;
+            }
+            const threadId = sessionToThread.get(session.id);
+            matchedSessions.push({
+                id: session.id,
+                title: session.title || 'Untitled Session',
+                directory: session.directory,
+                updated: new Date(session.time.updated).toISOString(),
+                source: threadId ? 'otto' : 'opencode',
+                threadId: threadId || null,
+                snippets,
+            });
+            if (matchedSessions.length >= limit) {
+                break;
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                query: searchPattern.raw,
+                mode: searchPattern.mode,
+                projectDirectory,
+                scannedSessions,
+                matches: matchedSessions,
+            }, null, 2));
+            process.exit(0);
+        }
+        if (matchedSessions.length === 0) {
+            cliLogger.log(`No matches found for ${searchPattern.raw} in ${projectDirectory} (${scannedSessions} sessions scanned)`);
+            process.exit(0);
+        }
+        cliLogger.log(`Found ${matchedSessions.length} matching session(s) for ${searchPattern.raw} in ${projectDirectory}`);
+        for (const match of matchedSessions) {
+            const threadInfo = match.threadId ? ` | thread: ${match.threadId}` : '';
+            console.log(`${match.id} | ${match.title} | ${match.updated} | ${match.source}${threadInfo}`);
+            console.log(`  Directory: ${match.directory}`);
+            match.snippets.forEach((snippet) => {
+                console.log(`  - ${snippet}`);
+            });
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session export-events-jsonl', 'Export persisted session events from SQLite to JSONL for debugging Otto runtime bugs')
+    .option('--session <sessionId>', 'Session ID whose persisted event stream should be exported')
+    .option('--out <file>', 'Output .jsonl path (useful for reproducing Otto issues in event-stream-state tests)')
+    .action(async (options) => {
+    const sessionId = typeof options.session === 'string' ? options.session.trim() : '';
+    if (!sessionId) {
+        cliLogger.error('Missing --session value');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const outFile = typeof options.out === 'string' ? options.out.trim() : '';
+    if (!outFile) {
+        cliLogger.error('Missing --out value');
+        process.exit(EXIT_NO_RESTART);
+    }
+    if (path.extname(outFile).toLowerCase() !== '.jsonl') {
+        cliLogger.error('--out must point to a .jsonl file');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const outPath = path.resolve(outFile);
+    const rows = await getSessionEventSnapshot({ sessionId });
+    if (rows.length === 0) {
+        cliLogger.error(`No persisted events found for session ${sessionId}. The session may not have emitted events yet.`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const parsedRows = rows.flatMap((row) => {
+        const parsed = errore.try({
+            try: () => {
+                return JSON.parse(row.event_json);
+            },
+            catch: (error) => {
+                return new Error('Failed to parse persisted event JSON', {
+                    cause: error,
+                });
+            },
+        });
+        if (parsed instanceof Error) {
+            cliLogger.warn(`Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
+            return [];
+        }
+        return [{ row, event: parsed }];
+    });
+    if (parsedRows.length === 0) {
+        cliLogger.error(`No valid persisted events found for session ${sessionId}.`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const projectDirectory = parsedRows.reduce((directory, { event }) => {
+        if (directory) {
+            return directory;
+        }
+        if (event.type !== 'session.updated') {
+            return directory;
+        }
+        return event.properties.info.directory;
+    }, '');
+    const lines = parsedRows.map(({ row, event }) => {
+        return JSON.stringify(buildOpencodeEventLogLine({
+            timestamp: Number(row.timestamp),
+            threadId: row.thread_id,
+            projectDirectory,
+            event,
+        }));
+    });
+    const jsonl = `${lines.join('\n')}${lines.length > 0 ? '\n' : ''}`;
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, jsonl, 'utf8');
+    cliLogger.log(`Exported ${lines.length} events from ${sessionId} to ${outPath}`);
+    process.exit(0);
+});
+cli
+    .command('thread-deletion-sync [mode]', 'Get or set OpenCode sync behavior when Discord threads are deleted')
+    .option('--reset', 'Reset to default soft mode')
+    .action(async (modeArg, options) => {
+    try {
+        await initDatabase();
+        const credentials = await getBotTokenWithMode();
+        if (!credentials?.appId) {
+            cliLogger.error('No bot configured. Start otto first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (options.reset) {
+            await resetThreadDeletionSyncMode({ appId: credentials.appId });
+            note('Thread deletion sync mode reset to soft (default).', 'Thread deletion sync');
+            process.exit(0);
+        }
+        if (!modeArg) {
+            const currentMode = await getThreadDeletionSyncMode({
+                appId: credentials.appId,
+            });
+            note(`Current mode: ${currentMode}`, 'Thread deletion sync');
+            process.exit(0);
+        }
+        if (modeArg !== 'soft' && modeArg !== 'hard') {
+            cliLogger.error('Invalid mode. Use "soft" or "hard".');
+            process.exit(EXIT_NO_RESTART);
+        }
+        await setThreadDeletionSyncMode({
+            appId: credentials.appId,
+            mode: modeArg,
+        });
+        note(`Set mode to ${modeArg}`, 'Thread deletion sync');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session archive [threadId]', 'Archive a Discord thread and stop its mapped OpenCode session')
+    .option('--session <sessionId>', 'Resolve thread from an OpenCode session ID')
+    .action(async (threadIdArg, options) => {
+    try {
+        await initDatabase();
+        // Resolve threadId from --session or positional arg
+        if (threadIdArg && options.session) {
+            cliLogger.error('Use either a thread ID or --session, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const resolvedThreadId = await (async () => {
+            if (threadIdArg) {
+                return threadIdArg;
+            }
+            if (options.session) {
+                const id = await getThreadIdBySessionId(options.session);
+                if (!id) {
+                    cliLogger.error(`No Discord thread found for session: ${options.session}`);
+                    process.exit(EXIT_NO_RESTART);
+                }
+                return id;
+            }
+            cliLogger.error('Provide a thread ID or --session <sessionId>');
+            process.exit(EXIT_NO_RESTART);
+        })();
+        const { token: botToken } = await resolveBotCredentials();
+        const rest = createDiscordRest(botToken);
+        const threadData = (await rest.get(Routes.channel(resolvedThreadId)));
+        if (!isThreadChannelType(threadData.type)) {
+            cliLogger.error(`Channel is not a thread: ${resolvedThreadId}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionId = options.session || await getThreadSession(resolvedThreadId);
+        let client = null;
+        if (sessionId && threadData.parent_id) {
+            const channelConfig = await getChannelDirectory(threadData.parent_id);
+            if (!channelConfig) {
+                cliLogger.warn(`No channel directory mapping found for parent channel ${threadData.parent_id}`);
+            }
+            else {
+                const getClient = await initializeOpencodeForDirectory(channelConfig.directory);
+                if (getClient instanceof Error) {
+                    cliLogger.warn(`Could not initialize OpenCode for ${channelConfig.directory}: ${getClient.message}`);
+                }
+                else {
+                    client = getClient();
+                }
+            }
+        }
+        else {
+            cliLogger.warn(`No mapped OpenCode session found for thread ${resolvedThreadId}`);
+        }
+        await archiveThread({
+            rest,
+            threadId: resolvedThreadId,
+            parentChannelId: threadData.parent_id,
+            sessionId,
+            client,
+        });
+        const threadLabel = threadData.name || resolvedThreadId;
+        note(`Archived thread: ${threadLabel}\nThread ID: ${resolvedThreadId}`, '✅ Archived');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session discord-url <sessionId>', 'Print the Discord thread URL for a session')
+    .option('--json', 'Output as JSON')
+    .action(async (sessionId, options) => {
+    await initDatabase();
+    const threadId = await getThreadIdBySessionId(sessionId);
+    if (!threadId) {
+        cliLogger.error(`No Discord thread found for session: ${sessionId}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const { token: botToken } = await resolveBotCredentials();
+    const rest = createDiscordRest(botToken);
+    const threadData = (await rest.get(Routes.channel(threadId)));
+    const url = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
+    if (options.json) {
+        console.log(JSON.stringify({
+            url,
+            threadId: threadData.id,
+            guildId: threadData.guild_id,
+            sessionId,
+            threadName: threadData.name,
+        }));
+    }
+    else {
+        console.log(url);
+    }
+    process.exit(0);
+});
+cli
+    .command('upgrade', 'Upgrade otto to the latest version and restart the running bot')
+    .option('--skip-restart', 'Only upgrade, do not restart the running bot')
+    .action(async (options) => {
+    try {
+        const current = getCurrentVersion();
+        cliLogger.log(`Current version: v${current}`);
+        const newVersion = await upgrade();
+        if (!newVersion) {
+            cliLogger.log('Already on latest version');
+            process.exit(0);
+        }
+        cliLogger.log(`Upgraded to v${newVersion}`);
+        if (options.skipRestart) {
+            process.exit(0);
+        }
+        // Spawn `otto gateway start`; the new process evicts the prior instance via the
+        // single-instance lock. No extra subcommands so we never re-enter `upgrade`.
+        const detachedGateway = spawnDetachedGatewayStart({});
+        if (detachedGateway instanceof Error) {
+            throw detachedGateway;
+        }
+        cliLogger.log('Restarting bot with new version...');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Upgrade failed:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('worktree merge', 'Merge worktree branch into default branch using worktrunk-style pipeline')
+    .option('-d, --directory <path>', 'Worktree directory (defaults to cwd)')
+    .option('-m, --main-repo <path>', 'Main repository directory (auto-detected from worktree)')
+    .option('-n, --name <name>', 'Worktree/branch name (auto-detected from branch)')
+    .action(async (options) => {
+    try {
+        const { mergeWorktree } = await import('./worktrees.js');
+        const worktreeDir = path.resolve(options.directory || '.');
+        // Auto-detect main repo: find the main worktree's toplevel.
+        // For linked worktrees, --git-common-dir points to the shared .git,
+        // and the main worktree's toplevel is one level up from that (non-bare)
+        // or the dir itself (bare). We use git's worktree list to get the
+        // main worktree path reliably.
+        let mainRepoDir = options.mainRepo;
+        if (!mainRepoDir) {
+            try {
+                // `git worktree list --porcelain` first line is always the main worktree
+                const { stdout } = await execAsync(`git -C "${worktreeDir}" worktree list --porcelain`);
+                const firstLine = stdout.split('\n')[0] || '';
+                // Format: "worktree /path/to/main"
+                mainRepoDir = firstLine.replace(/^worktree\s+/, '').trim();
+            }
+            catch {
+                // Fallback: derive from git common dir
+                const { stdout: commonDir } = await execAsync(`git -C "${worktreeDir}" rev-parse --git-common-dir`);
+                const resolved = path.isAbsolute(commonDir.trim())
+                    ? commonDir.trim()
+                    : path.resolve(worktreeDir, commonDir.trim());
+                mainRepoDir = path.dirname(resolved);
+            }
+        }
+        // Auto-detect branch name if not provided
+        let worktreeName = options.name;
+        if (!worktreeName) {
+            try {
+                const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`);
+                worktreeName = stdout.trim();
+            }
+            catch {
+                worktreeName = path.basename(worktreeDir);
+            }
+        }
+        cliLogger.log(`Worktree: ${worktreeDir}`);
+        cliLogger.log(`Main repo: ${mainRepoDir}`);
+        cliLogger.log(`Branch: ${worktreeName}`);
+        const { RebaseConflictError } = await import('./errors.js');
+        const result = await mergeWorktree({
+            worktreeDir,
+            mainRepoDir,
+            worktreeName,
+            onProgress: (msg) => {
+                cliLogger.log(msg);
+            },
+        });
+        if (result instanceof Error) {
+            cliLogger.error(`Merge failed: ${result.message}`);
+            if (result instanceof RebaseConflictError) {
+                cliLogger.log('Resolve the rebase conflicts, then run this command again.');
+            }
+            process.exit(1);
+        }
+        cliLogger.log(`Merged ${result.branchName} into ${result.defaultBranch} @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Merge failed:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
     }
-}
-main().catch((err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${msg}`);
-    process.exit(1);
 });
-//# sourceMappingURL=cli.js.map
+cli.version(getCurrentVersion());
+cli.help();
+cli.parse();