kimaki 0.27.0 → 0.28.0

package/dist/bash-tool-schema-plugin.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import { extendBashToolDefinition, } from './bash-tool-schema-plugin.js';
+describe('extendBashToolDefinition', () => {
+    test('keeps parameters and assigns jsonSchema from bashParameters', () => {
+        const parameters = { keep: true };
+        const output = {
+            description: 'Execute a shell command',
+            parameters,
+        };
+        extendBashToolDefinition(output);
+        expect(output.parameters).toBe(parameters);
+        expect(output.jsonSchema).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": false,
+        "properties": {
+          "command": {
+            "description": "The command to execute",
+            "type": "string",
+          },
+          "description": {
+            "description": "Short 5-10 word summary shown in Discord when the command is longer than 50 characters",
+            "type": "string",
+          },
+          "hasSideEffect": {
+            "description": "True if the command writes files, modifies state, installs packages, or triggers external effects",
+            "type": "boolean",
+          },
+          "timeout": {
+            "description": "Optional timeout in milliseconds",
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer",
+          },
+          "workdir": {
+            "description": "Working directory. Defaults to the current directory.",
+            "type": "string",
+          },
+        },
+        "required": [
+          "command",
+          "description",
+          "hasSideEffect",
+        ],
+        "type": "object",
+      }
+    `);
+    });
+});

package/dist/cli-commands/project.js

@@ -12,7 +12,7 @@ import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
 import { getDefaultKimakiDirectory } from '../channel-management.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError } 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';
@@ -39,8 +39,15 @@ cli
         cliLogger.error(`Directory does not exist: ${absolutePath}`);
         process.exit(EXIT_NO_RESTART);
     }
-    // Initialize database
     await initDatabase();
+    const existingChannel = await findRegisteredTextChannelForDirectory(absolutePath);
+    if (existingChannel) {
+        cliLogger.error(formatProjectAlreadyRegisteredError({
+            channelId: existingChannel.channel_id,
+            directory: absolutePath,
+        }));
+        process.exit(EXIT_NO_RESTART);
+    }
     const { token: botToken, appId } = await resolveBotCredentials({
         appIdOverride: options.appId,
     });
@@ -62,30 +69,6 @@ cli
     });
     cliLogger.log('Finding guild...');
     const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
-    // 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 && !ch.isDMBased() && ch.guild.id === guild.id) {
-                    void 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));
-    }
     const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
         guild,
         projectDirectory: absolutePath,
@@ -131,7 +114,8 @@ cli
             }
             catch (error) {
                 // Only mark as deleted for Unknown Channel (10003) or 404,
-                // not transient errors like rate limits or 5xx
+                // not transient errors like rate limits or 5xx.
+                // Gateway-proxy must return Discord 404 for unknown channels, not 403.
                 const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
                 const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
                 const isUnknownChannel = code === 10003 || status === 404;

package/dist/cli-commands/send.js

@@ -21,6 +21,7 @@ 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 { QUEUE_PREFIX } from '../message-formatting.js';
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, ensureThreadMember, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
@@ -394,6 +395,10 @@ cli
             }
             const threadPromptMarker = {
                 start: true,
+                ...(threadTargetUser && {
+                    userId: threadTargetUser.id,
+                    ...(threadTargetUser.username && { username: threadTargetUser.username }),
+                }),
                 ...(options.agent && { agent: options.agent }),
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
@@ -409,7 +414,7 @@ cli
             // Prefix the prompt so it's clear who sent it (matches /queue format).
             // Use a newline between prefix and prompt so leading /command
             // detection can find the command on its own line.
-            const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
+            const prefixedPrompt = `${QUEUE_PREFIX}**kimaki-cli:**\n${prompt}`;
             if (threadTargetUser) {
                 cliLogger.log(`Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`);
                 const addMemberResult = await ensureThreadMember({

package/dist/cli-commands/session.js

@@ -12,9 +12,9 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktreeOrWorkspace } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktreeOrWorkspace, getAllTextChannelDirectories } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
-import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
+import { parseSessionSearchPattern, collectSessionSearchMatches, validateSessionSearchScope, resolveSessionSearchDirectories, parseSessionSearchDays, sessionSearchMinUpdated, SESSION_SEARCH_DEFAULT_DAYS } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
 import { formatTimeAgo } from '../commands/worktrees.js';
 import { editorsForFile, loadFileEditEvents } from '../file-edit-log.js';
@@ -319,16 +319,26 @@ cli
     }
 });
 cli
-    .command('session search <query>', 'Search past sessions for text or /regex/flags in the selected project')
+    .command('session search <query>', `Search past sessions for text or /regex/flags. Defaults to the last ${SESSION_SEARCH_DEFAULT_DAYS} days; use --days 0 for all time. Add --all for every locally registered project.`)
     .option('--project <path>', 'Project directory (defaults to cwd)')
     .option('--channel <channelId>', 'Resolve project from a Discord channel ID')
+    .option('--all', 'Search every locally registered project')
+    .option('--days <n>', `Only search sessions updated in the last n days (default: ${SESSION_SEARCH_DEFAULT_DAYS}; 0 = all time)`)
     .option('--limit <n>', 'Maximum matched sessions to return (default: 20)')
     .option('--json', 'Output as JSON')
+    .example('kimaki session search "auth timeout"')
+    .example('kimaki session search "auth timeout" --days 0')
+    .example('kimaki session search "auth timeout" --all')
     .action(async (query, options) => {
     try {
         await initDatabase();
-        if (options.project && options.channel) {
-            cliLogger.error('Use either --project or --channel, not both');
+        const scopeError = validateSessionSearchScope({
+            all: options.all,
+            project: options.project,
+            channel: options.channel,
+        });
+        if (scopeError) {
+            cliLogger.error(scopeError.message);
             process.exit(EXIT_NO_RESTART);
         }
         const limit = (() => {
@@ -343,7 +353,16 @@ cli
             cliLogger.error(limit.message);
             process.exit(EXIT_NO_RESTART);
         }
-        const projectDirectoryResult = await (async () => {
+        const days = parseSessionSearchDays(typeof options.days === 'string' ? options.days : undefined);
+        if (days instanceof Error) {
+            cliLogger.error(days.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const minUpdated = sessionSearchMinUpdated({ days });
+        const explicitDirectory = await (async () => {
+            if (options.all) {
+                return undefined;
+            }
             if (options.channel) {
                 const channelConfig = await getChannelDirectory(options.channel);
                 if (!channelConfig) {
@@ -351,15 +370,45 @@ cli
                 }
                 return path.resolve(channelConfig.directory);
             }
-            return path.resolve(options.project || '.');
+            if (options.project) {
+                return path.resolve(options.project);
+            }
+            return undefined;
         })();
-        if (projectDirectoryResult instanceof Error) {
-            cliLogger.error(projectDirectoryResult.message);
+        if (explicitDirectory instanceof Error) {
+            cliLogger.error(explicitDirectory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const registeredDirectories = options.all
+            ? (await getAllTextChannelDirectories()).map((directory) => {
+                return path.resolve(directory);
+            })
+            : [];
+        const projectDirectories = resolveSessionSearchDirectories({
+            all: Boolean(options.all),
+            registeredDirectories,
+            cwd: path.resolve('.'),
+            explicitDirectory,
+        });
+        if (projectDirectories instanceof Error) {
+            cliLogger.error(projectDirectories.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const existingDirectories = [];
+        for (const directory of projectDirectories) {
+            if (fs.existsSync(directory)) {
+                existingDirectories.push(directory);
+                continue;
+            }
+            if (options.all) {
+                cliLogger.warn(`Skipping missing directory: ${directory}`);
+                continue;
+            }
+            cliLogger.error(`Directory does not exist: ${directory}`);
             process.exit(EXIT_NO_RESTART);
         }
-        const projectDirectory = projectDirectoryResult;
-        if (!fs.existsSync(projectDirectory)) {
-            cliLogger.error(`Directory does not exist: ${projectDirectory}`);
+        if (existingDirectories.length === 0) {
+            cliLogger.error('No searchable project directories found. Add a project with `kimaki project add`, or pass --project.');
             process.exit(EXIT_NO_RESTART);
         }
         const searchPattern = parseSessionSearchPattern(query);
@@ -367,15 +416,43 @@ cli
             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 clientsBySessionId = new Map();
+        const searchedDirectories = [];
+        const searchableSessions = [];
+        const listedDirectories = await Promise.all(existingDirectories.map(async (projectDirectory) => {
+            cliLogger.log(`Connecting to OpenCode server for ${projectDirectory}...`);
+            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+            if (getClient instanceof Error) {
+                return { projectDirectory, getClient, sessions: [] };
+            }
+            const sessionsResponse = await getClient().session.list();
+            return {
+                projectDirectory,
+                getClient,
+                sessions: sessionsResponse.data || [],
+            };
+        }));
+        for (const listed of listedDirectories) {
+            if (listed.getClient instanceof Error) {
+                if (options.all) {
+                    cliLogger.warn(`Skipping ${listed.projectDirectory}: failed to connect to OpenCode: ${listed.getClient.message}`);
+                    continue;
+                }
+                cliLogger.error('Failed to connect to OpenCode:', listed.getClient.message);
+                process.exit(EXIT_NO_RESTART);
+            }
+            searchedDirectories.push(listed.projectDirectory);
+            for (const session of listed.sessions) {
+                clientsBySessionId.set(session.id, listed.getClient);
+                searchableSessions.push({
+                    id: session.id,
+                    title: session.title || 'Untitled Session',
+                    directory: session.directory || listed.projectDirectory,
+                    updated: session.time.updated,
+                });
+            }
         }
-        const sessionsResponse = await getClient().session.list();
-        const sessions = sessionsResponse.data || [];
-        if (sessions.length === 0) {
+        if (searchableSessions.length === 0) {
             cliLogger.log('No sessions found');
             process.exit(0);
         }
@@ -386,82 +463,62 @@ cli
         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 scopeLabel = options.all
+            ? `${searchedDirectories.length} project(s)`
+            : searchedDirectories[0] || path.resolve('.');
+        const daysLabel = days === 0 ? 'all time' : `the last ${days} day${days === 1 ? '' : 's'}`;
+        const printMatch = (match) => {
+            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}`);
             });
-            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}`];
-                    });
+        };
+        let printedHeader = false;
+        const { matches: matchedSessions, scannedSessions } = await collectSessionSearchMatches({
+            sessions: searchableSessions,
+            searchPattern,
+            sessionToThread,
+            limit,
+            minUpdated,
+            onMatch: options.json
+                ? undefined
+                : (match) => {
+                    if (!printedHeader) {
+                        printedHeader = true;
+                        cliLogger.log(`Found matching session(s) for ${searchPattern.raw} in ${scopeLabel} (${daysLabel})`);
+                    }
+                    printMatch(match);
+                },
+            loadMessages: async (session) => {
+                const getClient = clientsBySessionId.get(session.id);
+                if (!getClient) {
+                    return [];
+                }
+                const messagesResponse = await getClient().session.messages({
+                    sessionID: session.id,
                 });
-            })
-                .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 ? 'kimaki' : 'opencode',
-                threadId: threadId || null,
-                snippets,
-            });
-            if (matchedSessions.length >= limit) {
-                break;
-            }
-        }
+                return messagesResponse.data || [];
+            },
+        });
         if (options.json) {
             console.log(JSON.stringify({
                 query: searchPattern.raw,
                 mode: searchPattern.mode,
-                projectDirectory,
+                all: Boolean(options.all),
+                days,
+                projectDirectories: searchedDirectories,
                 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)`);
+            const cutoffHint = days === 0 ? '' : '. Use --days 0 to search all time';
+            cliLogger.log(`No matches found for ${searchPattern.raw} in ${scopeLabel} (${scannedSessions} sessions scanned, ${daysLabel})${cutoffHint}`);
             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) {

package/dist/cli-commands/task.js

@@ -22,7 +22,7 @@ import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-u
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
 import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
-import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
+import { applyScheduledTaskUserEdit, getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, getDiscordUserIdFromUserOption, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
 import { validateCliModelOption } from '../session-handler/model-utils.js';
 const cliLogger = createLogger(LogPrefix.CLI);
@@ -135,7 +135,7 @@ cli
     .option('--model <model>', 'Model for the scheduled session, format provider/model (empty string clears)')
     .option('--pre-run <command>', 'New pre-run command (empty string clears)')
     .option('--allow-concurrency <enabled>', z.enum(['true', 'false']).describe('Allow concurrent sessions: true or false'))
-    .option('-u, --user <user>', 'Discord user ID, mention, or username added to the task thread')
+    .option('-u, --user <user>', 'Discord user ID, mention, or username added to the task thread (empty string clears)')
     .action(async (id, options) => {
     try {
         const trimmedPrompt = options.prompt === undefined ? undefined : options.prompt.trim();
@@ -143,9 +143,10 @@ cli
         const hasModel = options.model !== undefined;
         const hasPreRun = options.preRun !== undefined;
         const hasAllowConcurrency = options.allowConcurrency !== undefined;
+        const hasUser = options.user !== undefined;
         if (!trimmedPrompt &&
             !options.sendAt &&
-            !options.user &&
+            !hasUser &&
             !hasAgent &&
             !hasModel &&
             !hasPreRun &&
@@ -181,7 +182,7 @@ cli
             cliLogger.error(`Failed to parse task payload: ${existingPayload.message}`);
             process.exit(EXIT_NO_RESTART);
         }
-        const resolvedUser = options.user
+        const resolvedUser = hasUser && options.user.trim()
             ? await resolveTaskUser({
                 user: options.user,
                 channelId: task.channel_id,
@@ -207,9 +208,6 @@ cli
         const updatedPayload = {
             ...existingPayload,
             prompt: newPrompt,
-            ...(resolvedUser
-                ? { userId: resolvedUser.id, username: resolvedUser.username || null }
-                : {}),
             ...(hasAgent ? { agent: options.agent.trim() || null } : {}),
             ...(hasModel ? { model: nextModel } : {}),
             ...(hasPreRun ? { preRunCommand: options.preRun.trim() || null } : {}),
@@ -217,9 +215,16 @@ cli
                 ? { allowConcurrency: options.allowConcurrency === 'true' }
                 : {}),
         };
+        const payloadWithUser = hasUser
+            ? applyScheduledTaskUserEdit({
+                payload: updatedPayload,
+                userOption: options.user,
+                resolvedUser,
+            })
+            : updatedPayload;
         const updateData = {
             taskId,
-            payloadJson: serializeScheduledTaskPayload(updatedPayload),
+            payloadJson: serializeScheduledTaskPayload(payloadWithUser),
             promptPreview: getPromptPreview(newPrompt),
         };
         if (options.sendAt) {
@@ -245,19 +250,21 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const parts = [`Updated task ${taskId}`];
-        if (resolvedUser) {
-            parts.push(`user ${resolvedUser.username || resolvedUser.id} will be added to the thread`);
+        if (hasUser) {
+            parts.push(payloadWithUser.userId
+                ? `user ${payloadWithUser.username || payloadWithUser.userId} will be added to the thread`
+                : 'user cleared; nobody will be added to the thread');
         }
         if (hasAgent) {
-            parts.push(`agent=${updatedPayload.agent || '-'}`);
+            parts.push(`agent=${payloadWithUser.agent || '-'}`);
         }
         if (hasModel) {
-            parts.push(`model=${updatedPayload.model || '-'}`);
+            parts.push(`model=${payloadWithUser.model || '-'}`);
         }
         if (hasPreRun)
-            parts.push(`preRun=${updatedPayload.preRunCommand || '-'}`);
+            parts.push(`preRun=${payloadWithUser.preRunCommand || '-'}`);
         if (hasAllowConcurrency) {
-            parts.push(`allowConcurrency=${updatedPayload.allowConcurrency}`);
+            parts.push(`allowConcurrency=${payloadWithUser.allowConcurrency}`);
         }
         cliLogger.log(parts.join(' | '));
         process.exit(0);

package/dist/cli-parsing.test.js

@@ -9,10 +9,11 @@ async function parseWithGoke(argv) {
         "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 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')",
+        "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')",
@@ -112,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';
@@ -142,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']);

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';
@@ -767,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,
@@ -1148,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();
     }
@@ -1351,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({
@@ -1506,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,