kimaki 0.26.0 → 0.27.0

package/dist/cli-commands/session.js

@@ -1,6 +1,7 @@
 // Session inspection and archival terminal commands.
 import { goke } from 'goke';
 import { z } from 'zod';
+import dedent from 'string-dedent';
 import { note } from '@clack/prompts';
 import YAML from 'yaml';
 import * as errore from 'errore';
@@ -15,10 +16,13 @@ import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessi
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } 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';
 import { WORKTREE_PREFIX } from '../commands/merge-worktree.js';
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
+import { OpenCodeSdkError } from '../errors.js';
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js';
 import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
@@ -53,6 +57,8 @@ async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
 cli
     .command('session list', 'List all OpenCode sessions, marking which were started via Kimaki')
     .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
+    .option('--active', 'Only list active sessions; exits 1 when none remain')
+    .option('--exclude <sessionId>', 'Exclude one session ID from the results')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     try {
@@ -66,9 +72,32 @@ cli
         }
         const sessionsResponse = await getClient().session.list();
         const sessions = sessionsResponse.data || [];
-        if (sessions.length === 0) {
-            cliLogger.log('No sessions found');
-            process.exit(0);
+        const statuses = await (async () => {
+            if (!options.active)
+                return null;
+            const response = await getClient().session.status({
+                directory: projectDirectory,
+            });
+            if (response.error) {
+                cliLogger.error('Failed to list active sessions');
+                process.exit(EXIT_NO_RESTART);
+            }
+            return response.data || {};
+        })();
+        const selectedSessions = sessions.filter((session) => {
+            if (session.id === options.exclude)
+                return false;
+            if (!options.active)
+                return true;
+            const status = statuses?.[session.id];
+            return Boolean(status && status.type !== 'idle');
+        });
+        if (selectedSessions.length === 0) {
+            if (options.json)
+                console.log('[]');
+            else
+                cliLogger.log(options.active ? 'No active sessions found' : 'No sessions found');
+            process.exit(options.active ? 1 : 0);
         }
         // Look up which sessions were started via kimaki (have a thread mapping)
         const db = await getDb();
@@ -78,7 +107,7 @@ cli
         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 sessionStartSources = await getSessionStartSourcesBySessionIds(selectedSessions.map((session) => session.id));
         const scheduleModeLabel = ({ scheduleKind, }) => {
             if (scheduleKind === 'at') {
                 return 'delay';
@@ -86,7 +115,7 @@ cli
             return 'cron';
         };
         if (options.json) {
-            const output = sessions.map((session) => {
+            const output = selectedSessions.map((session) => {
                 const startSource = sessionStartSources.get(session.id);
                 const startedBy = startSource
                     ? `scheduled-${scheduleModeLabel({ scheduleKind: startSource.schedule_kind })}`
@@ -100,12 +129,13 @@ cli
                     threadId: sessionToThread.get(session.id) || null,
                     startedBy,
                     scheduledTaskId: startSource?.scheduled_task_id || null,
+                    status: options.active ? statuses?.[session.id]?.type || 'busy' : undefined,
                 };
             });
             console.log(JSON.stringify(output, null, 2));
             process.exit(0);
         }
-        for (const session of sessions) {
+        for (const session of selectedSessions) {
             const threadId = sessionToThread.get(session.id);
             const startSource = sessionStartSources.get(session.id);
             const source = threadId ? '(kimaki)' : '(opencode)';
@@ -114,7 +144,10 @@ cli
                 : '';
             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}`);
+            const statusInfo = options.active
+                ? ` | status: ${statuses?.[session.id]?.type || 'busy'}`
+                : '';
+            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}${startedBy}${statusInfo}`);
         }
         process.exit(0);
     }
@@ -123,6 +156,79 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session editors <file>', dedent `
+      List sessions that last edited a file, newest first.
+
+      Use this before a commit in another session so the \`Session:\` line
+      uses the session that actually edited the file.
+    `)
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', z.number().default(20).describe('Max sessions to show'))
+    .example('kimaki session editors src/cli.ts')
+    .example('kimaki session editors src/cli.ts --json')
+    .action(async (file, options, { console, process }) => {
+    try {
+        const cwd = process.cwd;
+        const loaded = loadFileEditEvents({ dataDir: getDataDir() });
+        if (loaded instanceof Error) {
+            console.error(loaded.message);
+            process.exit(EXIT_NO_RESTART);
+            return;
+        }
+        const editors = editorsForFile({
+            events: loaded,
+            filePath: file,
+            cwd,
+        }).slice(0, options.limit);
+        if (editors.length === 0) {
+            console.error(`No recorded editors for ${path.resolve(cwd, file)}`);
+            process.exit(1);
+            return;
+        }
+        const titles = new Map();
+        try {
+            await initDatabase();
+            const db = await getDb();
+            const sessionRows = await db.query.thread_sessions.findMany({
+                columns: { session_id: true, last_synced_name: true },
+                where: { session_id: { in: editors.map((editor) => editor.sessionId) } },
+                orderBy: { updated_at: 'desc' },
+            });
+            for (const row of sessionRows) {
+                if (!titles.has(row.session_id) && row.last_synced_name) {
+                    titles.set(row.session_id, row.last_synced_name);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+        }
+        const rows = editors.map((editor) => {
+            const title = titles.get(editor.sessionId) || '-';
+            const editedAt = new Date(editor.at);
+            return {
+                sessionId: editor.sessionId,
+                title,
+                editedAt: editedAt.toISOString(),
+                ago: formatTimeAgo(editedAt),
+            };
+        });
+        if (options.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            process.exit(0);
+            return;
+        }
+        for (const row of rows) {
+            console.log(`${row.sessionId} | ${row.title} | ${row.ago}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.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)')
@@ -430,7 +536,7 @@ cli
     process.exit(0);
 });
 cli
-    .command('session archive [threadId]', 'Archive a Discord thread and stop its mapped OpenCode session')
+    .command('session archive [threadId]', 'Archive a Discord thread without stopping its mapped OpenCode session')
     .option('--session <sessionId>', 'Resolve thread from an OpenCode session ID')
     .action(async (threadIdArg, options) => {
     try {
@@ -544,6 +650,75 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session title <title>', 'Update the OpenCode session title. Discord thread name follows automatically.')
+    .option('--session <sessionId>', 'OpenCode session ID')
+    .option('--thread <threadId>', 'Discord thread ID')
+    .example("kimaki session title 'Fix queue draining' --session ses_xxx")
+    .action(async (title, options) => {
+    try {
+        await initDatabase();
+        const trimmedTitle = title.trim();
+        if (!trimmedTitle) {
+            cliLogger.error('Title must not be empty');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (options.session && options.thread) {
+            cliLogger.error('Use either --session or --thread, not both');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!options.session && !options.thread) {
+            cliLogger.error('Provide --session <sessionId> or --thread <threadId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionId = await (async () => {
+            if (options.session)
+                return options.session;
+            const threadId = options.thread;
+            if (!threadId)
+                return null;
+            return getThreadSession(threadId);
+        })();
+        if (!sessionId) {
+            cliLogger.error(options.thread
+                ? `No OpenCode session found for thread: ${options.thread}`
+                : 'Provide --session <sessionId> or --thread <threadId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const directory = await resolveSessionDirectoryFromDatabase({
+            sessionId,
+        });
+        if (directory instanceof Error) {
+            cliLogger.error(directory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const serverResult = await initializeOpencodeForDirectory(directory);
+        if (serverResult instanceof Error) {
+            cliLogger.error(`Failed to initialize OpenCode: ${serverResult.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const updateResult = await serverResult()
+            .session.update({
+            sessionID: sessionId,
+            title: trimmedTitle,
+        })
+            .catch((e) => new OpenCodeSdkError({ operation: 'session.update', cause: e }));
+        if (updateResult instanceof Error) {
+            cliLogger.error(updateResult.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (updateResult.error) {
+            cliLogger.error('OpenCode rejected the session title update');
+            process.exit(EXIT_NO_RESTART);
+        }
+        note(`Updated OpenCode title: ${trimmedTitle}`, 'Title updated');
+        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')

package/dist/cli-commands/task.js

@@ -24,6 +24,7 @@ import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { 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);
 const cli = goke();
 cli
@@ -191,6 +192,17 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const newPrompt = trimmedPrompt ?? existingPayload.prompt;
+        const nextModel = hasModel ? options.model.trim() || null : existingPayload.model;
+        if (nextModel) {
+            const modelCheck = await validateCliModelOption({
+                model: nextModel,
+                directory: task.project_directory ?? undefined,
+            });
+            if (modelCheck instanceof Error) {
+                cliLogger.error(modelCheck.message);
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
         // Match send --model/--agent: empty string clears the override (null).
         const updatedPayload = {
             ...existingPayload,
@@ -199,7 +211,7 @@ cli
                 ? { userId: resolvedUser.id, username: resolvedUser.username || null }
                 : {}),
             ...(hasAgent ? { agent: options.agent.trim() || null } : {}),
-            ...(hasModel ? { model: options.model.trim() || null } : {}),
+            ...(hasModel ? { model: nextModel } : {}),
             ...(hasPreRun ? { preRunCommand: options.preRun.trim() || null } : {}),
             ...(hasAllowConcurrency
                 ? { allowConcurrency: options.allowConcurrency === 'true' }

package/dist/cli-parsing.test.js

@@ -1,12 +1,14 @@
 // 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 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 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')",
@@ -47,7 +49,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 +80,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]);
@@ -136,12 +155,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

@@ -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;
@@ -1271,12 +1293,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);
     }

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

@@ -321,7 +321,7 @@ describe('kimaki send --channel thread creation', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ caught-by-model
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ 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.

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/agent.js

@@ -487,14 +487,12 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
                 rest: command.client.rest,
             });
         }
-        const sessionDirectory = await (async () => {
-            if (!worktreePromise)
-                return projectDirectory;
-            const result = await worktreePromise;
-            if (result instanceof Error)
-                return projectDirectory;
-            return result;
-        })();
+        const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory;
+        if (worktreeResult instanceof Error) {
+            await command.editReply(`Worktree creation failed: ${worktreeResult.message}`);
+            return;
+        }
+        const sessionDirectory = worktreeResult;
         await command
             .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
             .catch(() => {