kimaki 0.26.0 → 0.28.0

package/dist/cli-parsing.test.js

@@ -1,16 +1,19 @@
 // Regression tests for CLI argument parsing around Discord ID string preservation.
 import { describe, expect, test } from 'vitest';
 import { execAsync } from './exec-async.js';
+import maintenanceCommands from './cli-commands/maintenance.js';
 async function parseWithGoke(argv) {
     const script = [
         "import { goke } from 'goke'",
         'const cli = goke(\'kimaki\')',
         "cli.command('send', 'Send a message').option('-c, --channel <channelId>', 'Discord channel ID').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--send-at <schedule>', 'Schedule')",
         "cli.command('session archive <threadId>', 'Archive a thread')",
-        "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path')",
+        "cli.command('session title <title>', 'Update title').option('--session <sessionId>', 'Session ID').option('--thread <threadId>', 'Thread ID')",
+        "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path').option('--all', 'Search all registered projects').option('--days <n>', 'Only search recent sessions')",
         "cli.command('session export-events-jsonl', 'Export in-memory events to JSONL').option('--session <sessionId>', 'Session ID').option('--out <file>', 'Output path')",
         "cli.command('add-project', 'Add a project').option('-g, --guild <guildId>', 'Discord guild/server ID')",
         "cli.command('task delete <id>', 'Delete task')",
+        "cli.command('task edit <id>', 'Edit task').option('-u, --user <user>', 'Discord user')",
         "cli.command('multioauth anthropic list', 'List stored Anthropic accounts')",
         "cli.command('multioauth anthropic remove <indexOrEmail>', 'Remove stored Anthropic account')",
         "cli.command('multioauth openai list', 'List stored OpenAI accounts')",
@@ -47,7 +50,7 @@ async function parseRootBotOptions(argv) {
     const script = [
         "import { goke } from 'goke'",
         'const cli = goke(\'kimaki\')',
-        "cli.command('', 'bot').option('--no-analytics', 'Disable analytics')",
+        "cli.command('', 'bot').option('--no-analytics', 'Disable analytics').option('--skip-footer-mentions', 'Do not mention the thread creator in final footers')",
         `const result = await cli.parse(${JSON.stringify(argv)}, { run: false })`,
         'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
     ].join(';');
@@ -78,6 +81,23 @@ describe('goke CLI ID parsing', () => {
         expect(result.options.guild).toBe(guildId);
         expect(typeof result.options.guild).toBe('string');
     });
+    test('keeps session title and session ID as strings', async () => {
+        const sessionId = '001111222233334444';
+        const title = 'Fix queue draining';
+        const result = await parseWithGoke([
+            'node',
+            'kimaki',
+            'session',
+            'title',
+            title,
+            '--session',
+            sessionId,
+        ]);
+        expect(result.args[0]).toBe(title);
+        expect(typeof result.args[0]).toBe('string');
+        expect(result.options.session).toBe(sessionId);
+        expect(typeof result.options.session).toBe('string');
+    });
     test('keeps session archive thread ID as string', async () => {
         const threadId = '0098765432109876543';
         const result = await parseWithGoke(['node', 'kimaki', 'session', 'archive', threadId]);
@@ -93,6 +113,15 @@ describe('goke CLI ID parsing', () => {
         expect(result.options.channel).toBe(channelId);
         expect(typeof result.options.channel).toBe('string');
     });
+    test('parses session search --all as a boolean', async () => {
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'search', 'auth timeout', '--all']);
+        expect(result.args[0]).toBe('auth timeout');
+        expect(result.options.all).toBe(true);
+    });
+    test('parses session search --days as a string', async () => {
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'search', 'auth timeout', '--days', '0']);
+        expect(result.options.days).toBe('0');
+    });
     test('keeps session export options as strings', async () => {
         const sessionId = '001111222233334444';
         const outPath = './tmp/session-events.jsonl';
@@ -123,6 +152,19 @@ describe('goke CLI ID parsing', () => {
         expect(result.args[0]).toBe(taskId);
         expect(typeof result.args[0]).toBe('string');
     });
+    test('parses empty --user on task edit so the stored user can be cleared', async () => {
+        const result = await parseWithGoke([
+            'node',
+            'kimaki',
+            'task',
+            'edit',
+            '11',
+            '--user',
+            '',
+        ]);
+        expect(result.args[0]).toBe('11');
+        expect(result.options.user).toBe('');
+    });
     test('multioauth account remove parses index and email as strings', async () => {
         const indexResult = await parseWithGoke(['node', 'kimaki', 'multioauth', 'anthropic', 'remove', '2']);
         const emailResult = await parseWithGoke(['node', 'kimaki', 'multioauth', 'openai', 'remove', 'user@example.com']);
@@ -136,12 +178,49 @@ describe('goke CLI ID parsing', () => {
         expect(stdout).toContain('send');
         expect(stdout).toContain('multioauth');
     });
-    test('parses --no-analytics as a boolean flag on the root bot command', async () => {
+    test('merge-worktree parses strategy and target branch', async () => {
+        const result = await maintenanceCommands.parse([
+            'node',
+            'kimaki',
+            'merge-worktree',
+            '--strategy',
+            'squash',
+            '--target-branch',
+            'release',
+            '--thread',
+            '123456789012345678',
+            '--thread-name',
+            'feature work',
+        ], { run: false });
+        expect({
+            command: maintenanceCommands.matchedCommandName,
+            strategy: result.options.strategy,
+            targetBranch: result.options.targetBranch,
+            thread: result.options.thread,
+            threadName: result.options.threadName,
+        }).toMatchInlineSnapshot(`
+      {
+        "command": "merge-worktree",
+        "strategy": "squash",
+        "targetBranch": "release",
+        "thread": "123456789012345678",
+        "threadName": "feature work",
+      }
+    `);
+    });
+    test('parses root bot boolean flags', async () => {
         const result = await parseRootBotOptions([
             'node',
             'kimaki',
             '--no-analytics',
+            '--skip-footer-mentions',
         ]);
-        expect(result.options.noAnalytics).toBe(true);
+        expect(result.options).toMatchInlineSnapshot(`
+      {
+        "--": [],
+        "noAnalytics": true,
+        "skipFooterMentions": true,
+      }
+    `);
     });
 });

package/dist/cli-runner.js

@@ -2,7 +2,7 @@
 // Keeps cli.ts focused on command composition while preserving the bot onboarding flow.
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, select, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl, generateDiscordInstallUrlForBot, KIMAKI_GATEWAY_APP_ID, KIMAKI_WEBSITE_URL, abbreviatePath, } from './utils.js';
-import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
+import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, assertCompatibleOpencodeVersion, createProjectChannels, createDefaultKimakiChannel, } from './discord-bot.js';
 import { getBotTokenWithMode, ensureServiceAuthToken, setBotToken, setBotMode, setChannelDirectory, findChannelsByDirectory, getDb, } from './database.js';
 import * as orm from 'drizzle-orm';
 import * as dbSchema from './schema.js';
@@ -312,6 +312,10 @@ export function formatTaskScheduleLine(schedule) {
     return `cron "${schedule.cronExpr}" (${schedule.timezone}) next ${schedule.nextRunAt.toISOString()}`;
 }
 export const EXIT_NO_RESTART = 64;
+// Temporary failure (sysexits EX_TEMPFAIL). Wrapper retries forever with
+// backoff and does not count this toward the crash-loop detector. Used when
+// Discord login fails because the network is down.
+export const EXIT_TEMPFAIL = 75;
 export function isGuildMemberSearchResult(value) {
     if (!value) {
         return false;
@@ -378,12 +382,28 @@ const TRANSIENT_ERROR_CODES = new Set([
     'DEPTH_ZERO_SELF_SIGNED_CERT',
     'SELF_SIGNED_CERT_IN_CHAIN',
     'ERR_TLS_CERT_ALTNAME_INVALID',
+    // undici fetch/WebSocket connect failures when the network is down.
+    // Without these, Discord login exits EXIT_NO_RESTART and the wrapper never
+    // comes back after a connect timeout to discord-gateway.kimaki.dev.
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+const TRANSIENT_ERROR_NAMES = new Set([
+    'ConnectTimeoutError',
+    'HeadersTimeoutError',
+    'BodyTimeoutError',
+    'SocketError',
 ]);
 const TRANSIENT_ERROR_MESSAGE_PATTERNS = [
     /unable to verify the first certificate/i,
     /certificate has expired/i,
     /self[- ]signed certificate/i,
     /unable to get local issuer certificate/i,
+    /connect timeout error/i,
+    /headers timeout error/i,
+    /body timeout error/i,
 ];
 export function isTransientNetworkError(error) {
     if (!(error instanceof Error))
@@ -391,6 +411,8 @@ export function isTransientNetworkError(error) {
     const code = error.code;
     if (code && TRANSIENT_ERROR_CODES.has(code))
         return true;
+    if (TRANSIENT_ERROR_NAMES.has(error.name))
+        return true;
     // Fallback when code is stripped by wrappers (discord.js sometimes rethrows by message only).
     if (TRANSIENT_ERROR_MESSAGE_PATTERNS.some((pattern) => pattern.test(error.message))) {
         return true;
@@ -745,16 +767,23 @@ export function showReadyMessage({ kimakiChannels, createdChannels, }) {
     note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
 }
 /**
- * Create the default kimaki channel in each guild and send a welcome message.
+ * Create default channels in locally configured guilds, or proxy-authorized gateway guilds.
  * Idempotent: skips guilds that already have the channel.
  * Extracted so both the interactive and headless startup paths share the same logic.
  */
 export async function ensureDefaultChannelsWithWelcome({ guilds, discordClient, appId, isGatewayMode, installerDiscordUserId, }) {
     if (process.env['KIMAKI_NO_DEFAULT_CHANNEL'] === '1')
         return [];
+    const localMappings = isGatewayMode ? [] : await findChannelsByDirectory({});
     const created = [];
     for (const guild of guilds) {
         try {
+            if (!isGatewayMode) {
+                // Match live channel IDs: older local mappings have no guild_id.
+                const channels = await guild.channels.fetch();
+                if (!localMappings.some((row) => channels.has(row.channel_id)))
+                    continue;
+            }
             const result = await createDefaultKimakiChannel({
                 guild,
                 botName: discordClient.user?.username,
@@ -1126,6 +1155,11 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
             possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
         }),
     ]);
+    const opencodeVersionCheck = await assertCompatibleOpencodeVersion();
+    if (opencodeVersionCheck instanceof Error) {
+        cliLogger.error(opencodeVersionCheck.message);
+        process.exit(EXIT_NO_RESTART);
+    }
     if (store.getState().autoUpgradeEnabled) {
         void backgroundUpgradeKimaki();
     }
@@ -1271,12 +1305,14 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     catch (error) {
         cliLogger.log('Failed to connect to Discord', discordClient.ws.gateway);
         cliLogger.error('Error: ' + (error instanceof Error ? error.stack : String(error)));
-        // Transient network errors (DNS down, gateway unreachable) should allow
-        // the bin.ts wrapper to restart us after a delay. Only truly fatal errors
-        // (bad token, invalid intent, etc.) should use EXIT_NO_RESTART.
+        // Transient network errors (DNS down, gateway unreachable, connect
+        // timeout) should allow the bin.ts wrapper to restart us after a delay.
+        // EXIT_TEMPFAIL skips the crash-loop detector so a long outage cannot
+        // permanently stop the bot. Only truly fatal errors (bad token, invalid
+        // intent, etc.) should use EXIT_NO_RESTART.
         if (isTransientNetworkError(error)) {
             cliLogger.error('Transient network error, exiting for wrapper restart...');
-            process.exit(1);
+            process.exit(EXIT_TEMPFAIL);
         }
         process.exit(EXIT_NO_RESTART);
     }
@@ -1327,7 +1363,7 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
             catch (error) {
                 cliLogger.warn('Background channel sync failed:', error instanceof Error ? error.stack : String(error));
             }
-            // Create default kimaki channel + welcome message in each guild.
+            // Create default channels only in locally configured or gateway-authorized guilds.
             // Runs after channel sync so existing channels are detected correctly.
             try {
                 await ensureDefaultChannelsWithWelcome({
@@ -1482,7 +1518,7 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
             }
         }
         // Create default kimaki channel for general-purpose tasks.
-        // Runs for every guild the bot is in, idempotent (skips if already exists).
+        // Only locally configured or gateway-authorized guilds are eligible.
         const defaultChannelResults = await ensureDefaultChannelsWithWelcome({
             guilds,
             discordClient,

package/dist/cli-runner.test.js

@@ -56,4 +56,31 @@ describe('isTransientNetworkError', () => {
         });
         expect(isTransientNetworkError(error)).toBe(true);
     });
+    test('treats undici connect timeouts as transient', () => {
+        const error = Object.assign(new Error('Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)'), {
+            name: 'ConnectTimeoutError',
+            code: 'UND_ERR_CONNECT_TIMEOUT',
+        });
+        expect(isTransientNetworkError(error)).toBe(true);
+    });
+    test('matches undici connect timeouts by message when code is missing', () => {
+        expect(isTransientNetworkError(new Error('Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)'))).toBe(true);
+    });
+    test('walks cause chains for nested undici connect timeouts', () => {
+        const cause = Object.assign(new Error('Connect Timeout Error (attempted address: discord-gateway.kimaki.dev:443, timeout: 10000ms)'), {
+            name: 'ConnectTimeoutError',
+            code: 'UND_ERR_CONNECT_TIMEOUT',
+        });
+        expect(isTransientNetworkError(new Error('Failed to connect to Discord', { cause }))).toBe(true);
+    });
+    test('treats other undici timeout and socket codes as transient', () => {
+        for (const [name, code] of [
+            ['HeadersTimeoutError', 'UND_ERR_HEADERS_TIMEOUT'],
+            ['BodyTimeoutError', 'UND_ERR_BODY_TIMEOUT'],
+            ['SocketError', 'UND_ERR_SOCKET'],
+        ]) {
+            const error = Object.assign(new Error(name), { name, code });
+            expect(isTransientNetworkError(error)).toBe(true);
+        }
+    });
 });

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

@@ -319,9 +319,9 @@ describe('kimaki send --channel thread creation', () => {
         "--- from: user (cli-send-tester)
         thread empty content seed
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ caught-by-model
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > caught-by-model
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000830>
         --- from: user (cli-send-tester)
         --- from: assistant (TestBot)
         I can see you sent a message, but Discord did not include its text.
@@ -436,13 +436,13 @@ describe('kimaki send --channel thread creation', () => {
         }));
         // Add test user to thread
         await botClient.rest.put(Routes.threadMembers(threadData.id, TEST_USER_ID));
-        // Wait for the bot to reply with the ⬥ prefix (proves ThreadCreate
-        // handler picked up the starter message and started a session)
+        // Wait for the bot to reply (proves ThreadCreate handler picked up
+        // the starter message and started a session)
         await waitForBotMessageContaining({
             discord,
             threadId: threadData.id,
             userId: discord.botUserId,
-            text: '⬥',
+            text: 'ok',
             timeout: 4_000,
         });
         // Wait for footer message (proves session completed successfully)
@@ -450,7 +450,7 @@ describe('kimaki send --channel thread creation', () => {
             discord,
             threadId: threadData.id,
             timeout: 4_000,
-            afterMessageIncludes: '⬥',
+            afterMessageIncludes: 'ok',
             afterAuthorId: discord.botUserId,
         });
         // Verify no DiscordAPIError[160004] or other errors in the thread.
@@ -461,9 +461,9 @@ describe('kimaki send --channel thread creation', () => {
             return m.content.includes('Error:') || m.content.includes('160004');
         });
         expect(errorMessages).toHaveLength(0);
-        // Verify at least one ⬥ reply exists (session produced output)
+        // Verify at least one reply exists (session produced output)
         const botReplies = messages.filter((m) => {
-            return (m.author.id === discord.botUserId && m.content.startsWith('⬥'));
+            return m.author.id === discord.botUserId;
         });
         expect(botReplies.length).toBeGreaterThanOrEqual(1);
     }, 15_000);

package/dist/cli.js

@@ -11,6 +11,7 @@ import { createLogger, formatErrorWithStack, initLogFile, LogPrefix } from './lo
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir, } from './config.js';
 import { getCurrentVersion } from './upgrade.js';
 import { store } from './store.js';
+import { publicOpencodeBindRequiresPassword } from './opencode.js';
 import multioauthCommands from './commands/multioauth.js';
 import botCommands from './cli-commands/bot.js';
 import maintenanceCommands from './cli-commands/maintenance.js';
@@ -37,6 +38,7 @@ cli
     .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('--skip-footer-mentions', 'Do not mention the thread creator in final session footers')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
     .option('--restrict-directories', 'Only allow the agent to access the session working directory and a few known-safe paths. Any other folder asks for permission. By default every directory is allowed and you protect folders with deny/ask rules in opencode.json')
@@ -44,6 +46,8 @@ cli
     .option('--disable-sync', 'Disable background sync of external OpenCode sessions into Discord')
     .option('--no-analytics', 'Disable anonymous product analytics (Strada). Same as KIMAKI_STRADA_ENABLED=0')
     .option('--no-auto-upgrade', 'Disable background auto-upgrade on startup')
+    .option('--opencode-hostname <host>', 'Hostname the OpenCode server listens on (default: 127.0.0.1). Use 0.0.0.0 to expose it on a VPS')
+    .option('--opencode-port <port>', 'Port the OpenCode server listens on (default: a random free port)')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
     .option('--allow-mention <type>', z
@@ -149,12 +153,29 @@ cli
             }
             return parsed * 60_000;
         })();
+        const opencodeHostname = options.opencodeHostname?.trim() || undefined;
+        const opencodePort = (() => {
+            if (!options.opencodePort)
+                return undefined;
+            const parsed = Number(options.opencodePort);
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+                cliLogger.error(`Invalid --opencode-port: ${options.opencodePort}. Must be an integer between 1 and 65535.`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            return parsed;
+        })();
+        if (publicOpencodeBindRequiresPassword({ hostname: opencodeHostname }) &&
+            !process.env.OPENCODE_SERVER_PASSWORD) {
+            cliLogger.error(`OPENCODE_SERVER_PASSWORD is required when --opencode-hostname is ${opencodeHostname}. Binding the OpenCode server on a public address without a password lets anyone control the agent.`);
+            process.exit(EXIT_NO_RESTART);
+        }
         store.setState({
             ...(defaultVerbosity && {
                 defaultVerbosity,
             }),
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
+            ...(options.skipFooterMentions && { footerMentionsEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
             ...(options.restrictDirectories && { restrictExternalDirectories: true }),
             ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
@@ -163,6 +184,8 @@ cli
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
             ...(options.allowMention && { allowedMentions: options.allowMention }),
+            ...(opencodeHostname && { opencodeHostname }),
+            ...(opencodePort !== undefined && { opencodePort }),
         });
         if (enabledSkills.length > 0) {
             cliLogger.log(`Skill whitelist enabled: only [${enabledSkills.join(', ')}] will be injected`);
@@ -188,6 +211,9 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
+        if (options.skipFooterMentions) {
+            cliLogger.log('Footer mentions disabled: final session footers will not mention thread creators');
+        }
         if (options.noAutoUpgrade) {
             cliLogger.log('Auto-upgrade disabled: kimaki will not check for updates on startup');
         }
@@ -198,6 +224,12 @@ cli
             process.env.KIMAKI_STRADA_ENABLED = '0';
             cliLogger.log('Anonymous product analytics disabled (--no-analytics)');
         }
+        if (opencodeHostname) {
+            cliLogger.log(`OpenCode server hostname: ${opencodeHostname}`);
+        }
+        if (opencodePort !== undefined) {
+            cliLogger.log(`OpenCode server port: ${opencodePort}`);
+        }
         if (options.installUrl) {
             await printDiscordInstallUrlAndExit({
                 gateway: options.gateway,

package/dist/commands/abort.js

@@ -1,6 +1,6 @@
 // /abort command - Abort the current OpenCode request in this thread.
 import { ChannelType, MessageFlags, } from 'discord.js';
-import { getThreadSession } from '../database.js';
+import { cancelSessionSleepForThread, getThreadSession } from '../database.js';
 import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
@@ -41,6 +41,10 @@ export async function handleAbortCommand({ command, }) {
         await command.editReply('No active session in this thread');
         return;
     }
+    // Aborting is an explicit "stop waiting" from the user, and it never goes
+    // through enqueueIncoming, so cancel any pending sleep here too. Otherwise the
+    // wake would still fire later and restart a session the user just stopped.
+    await cancelSessionSleepForThread({ threadId: channel.id });
     // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
     const runtime = getRuntime(channel.id);
     if (runtime) {

package/dist/commands/action-buttons.js

@@ -6,6 +6,7 @@ import crypto from 'node:crypto';
 import { getThreadSession } from '../database.js';
 import { NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS, resolveWorkingDirectory, sendThreadMessage, } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { notifyError } from '../sentry.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 const logger = createLogger('ACT_BTN');
@@ -214,7 +215,7 @@ export async function handleActionButton(interaction) {
     });
     const username = interaction.user.globalName || interaction.user.username;
     const prompt = `User clicked: ${button.label}`;
-    await sendThreadMessage(thread, `» **${username}:** ${button.label}`);
+    await sendThreadMessage(thread, `${QUEUE_PREFIX}**${username}:** ${button.label}`);
     try {
         await sendClickedActionToModel({
             interaction,

package/dist/commands/add-project.js

@@ -1,7 +1,7 @@
 // /add-project command - Create Discord channels for an existing OpenCode project.
 import fs from 'node:fs';
 import path from 'node:path';
-import { findChannelsByDirectory, getAllTextChannelDirectories, } from '../database.js';
+import { findRegisteredTextChannelForDirectory, getAllTextChannelDirectories, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -38,12 +38,9 @@ export async function handleAddProjectCommand({ command, }) {
             await command.editReply(`Directory does not exist: ${directory}`);
             return;
         }
-        const existingChannels = await findChannelsByDirectory({
-            directory,
-            channelType: 'text',
-        });
-        if (existingChannels.length > 0) {
-            await command.editReply(`A channel already exists for this directory: <#${existingChannels[0].channel_id}>`);
+        const existingChannel = await findRegisteredTextChannelForDirectory(directory);
+        if (existingChannel) {
+            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
             return;
         }
         const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({