kimaki 0.4.90 → 0.4.91

package/dist/session-handler/thread-session-runtime.js

@@ -21,7 +21,7 @@ import { showAskUserQuestionDropdowns, pendingQuestionContexts, cancelPendingQue
 import { showActionButtons, waitForQueuedActionButtonsRequest, pendingActionButtonContexts, cancelPendingActionButtons, } from '../commands/action-buttons.js';
 import { pendingFileUploadContexts, cancelPendingFileUpload, } from '../commands/file-upload.js';
 import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, } from '../commands/model.js';
-import { getOpencodeSystemMessage, } from '../system-message.js';
+import { getOpencodePromptContext, getOpencodeSystemMessage, } from '../system-message.js';
 import { resolveValidatedAgentPreference } from './agent-utils.js';
 import { appendOpencodeSessionEventLog, getOpencodeEventSessionId, isOpencodeSessionEventLogEnabled, } from './opencode-session-event-log.js';
 import { doesLatestUserTurnHaveNaturalCompletion, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getLatestAssistantMessageIdForLatestUserTurn, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, } from './event-stream-state.js';
@@ -36,6 +36,7 @@ import { notifyError } from '../sentry.js';
 import { createDebouncedProcessFlush } from '../debounced-process-flush.js';
 import { cancelHtmlActionsForThread } from '../html-actions.js';
 import { createDebouncedTimeout } from '../debounce-timeout.js';
+import { extractLeadingOpencodeCommand } from '../opencode-command-detection.js';
 const logger = createLogger(LogPrefix.SESSION);
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const DETERMINISTIC_CONTEXT_LIMIT = 100_000;
@@ -226,6 +227,58 @@ export function isEssentialToolPart(part) {
     }
     return true;
 }
+// ── Thread title derivation ──────────────────────────────────────
+const DISCORD_THREAD_NAME_MAX = 100;
+const WORKTREE_THREAD_PREFIX = '⬦ ';
+// Pure derivation: given an OpenCode session title and the current thread name,
+// return the new thread name to apply, or undefined when no rename is needed.
+// - Skips placeholder titles ("New Session - ...") to match external-sync.
+// - Preserves worktree prefix when the current name carries it.
+// - Returns undefined when the candidate matches currentName already.
+export function deriveThreadNameFromSessionTitle({ sessionTitle, currentName, }) {
+    const trimmed = sessionTitle?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (/^new session\s*-/i.test(trimmed)) {
+        return undefined;
+    }
+    const hasWorktreePrefix = currentName.startsWith(WORKTREE_THREAD_PREFIX);
+    const prefix = hasWorktreePrefix ? WORKTREE_THREAD_PREFIX : '';
+    const candidate = `${prefix}${trimmed}`.slice(0, DISCORD_THREAD_NAME_MAX);
+    if (candidate === currentName) {
+        return undefined;
+    }
+    return candidate;
+}
+// Rewrite `{ prompt: "/build foo" }` → `{ prompt: "", command: { name, arguments }, mode: "local-queue" }`
+// when the prompt's leading token matches a registered opencode command.
+// Skip if a command is already set or there's no prompt to inspect.
+function maybeConvertLeadingCommand(input) {
+    if (input.command)
+        return input;
+    if (!input.prompt)
+        return input;
+    const extracted = extractLeadingOpencodeCommand(input.prompt);
+    if (!extracted)
+        return input;
+    return {
+        ...input,
+        prompt: '',
+        command: extracted.command,
+        mode: 'local-queue',
+    };
+}
+function getWorktreePromptKey(worktree) {
+    if (!worktree) {
+        return null;
+    }
+    return [
+        worktree.worktreeDirectory,
+        worktree.branch,
+        worktree.mainRepoDirectory,
+    ].join('::');
+}
 // ── Runtime class ────────────────────────────────────────────────
 export class ThreadSessionRuntime {
     threadId;
@@ -255,11 +308,19 @@ export class ThreadSessionRuntime {
     // Notification throttles for retry/context notices.
     lastDisplayedContextPercentage = 0;
     lastRateLimitDisplayTime = 0;
+    // Last OpenCode-generated session title we successfully applied to the
+    // Discord thread name. Used to dedupe repeated session.updated events so
+    // we only call thread.setName() once per distinct title. Discord rate-limits
+    // channel/thread renames to ~2 per 10 minutes per thread, so we must avoid
+    // retrying. Not persisted — worst case on restart we re-apply the same title
+    // once (which is a no-op via deriveThreadNameFromSessionTitle).
+    appliedOpencodeTitle;
     // Part output buffering (write-side cache, not domain state)
     partBuffer = new Map();
     // Derivable cache (perf optimization for provider.list API call)
     modelContextLimit;
     modelContextLimitKey;
+    lastPromptWorktreeKey;
     // Bounded buffer of recent SSE events with timestamps.
     // Used by waitForEvent() to scan for specific events that arrived
     // after a given point in time (e.g. wait for session.idle after abort).
@@ -312,6 +373,12 @@ export class ThreadSessionRuntime {
             },
         });
     }
+    consumeWorktreePromptChange(worktree) {
+        const nextKey = getWorktreePromptKey(worktree);
+        const changed = this.lastPromptWorktreeKey !== nextKey;
+        this.lastPromptWorktreeKey = nextKey;
+        return changed;
+    }
     // Read own state from global store
     get state() {
         return threadState.getThreadState(this.threadId);
@@ -948,6 +1015,9 @@ export class ThreadSessionRuntime {
             case 'session.status':
                 await this.handleSessionStatus(event.properties);
                 break;
+            case 'session.updated':
+                await this.handleSessionUpdated(event.properties.info);
+                break;
             case 'tui.toast.show':
                 await this.handleTuiToast(event.properties);
                 break;
@@ -1895,6 +1965,60 @@ export class ThreadSessionRuntime {
             discordLogger.error('Failed to send retry notice:', retryResult);
         }
     }
+    // Rename the Discord thread to match the OpenCode-generated session title.
+    //
+    // Discord rate-limits channel/thread renames heavily — reported as ~2 per
+    // 10 minutes per thread (discord/discord-api-docs#1900, discordjs/discord.js#6651)
+    // and discord.js setName() can block silently on the 3rd attempt. We therefore:
+    // - rename at most once per distinct title (deduped via appliedOpencodeTitle)
+    // - race setName() against an AbortSignal.timeout() so a throttled call never
+    //   blocks the event loop
+    // - fail soft (log + continue) on timeout, 429, or any other error
+    async handleSessionUpdated(info) {
+        // Only act on the main session for this thread
+        if (info.id !== this.state?.sessionId) {
+            return;
+        }
+        const desiredName = deriveThreadNameFromSessionTitle({
+            sessionTitle: info.title,
+            currentName: this.thread.name,
+        });
+        if (!desiredName) {
+            return;
+        }
+        const normalizedTitle = info.title.trim();
+        if (this.appliedOpencodeTitle === normalizedTitle) {
+            return;
+        }
+        // Mark before the call so concurrent session.updated events don't stack
+        // rename attempts. On failure we keep the mark — a retry won't help
+        // because the failure is almost always a rate limit.
+        this.appliedOpencodeTitle = normalizedTitle;
+        const RENAME_TIMEOUT_MS = 3000;
+        const timeoutSignal = AbortSignal.timeout(RENAME_TIMEOUT_MS);
+        const renameResult = await Promise.race([
+            errore.tryAsync({
+                try: () => this.thread.setName(desiredName),
+                catch: (e) => new Error('Failed to rename thread from OpenCode title', {
+                    cause: e,
+                }),
+            }),
+            new Promise((resolve) => {
+                timeoutSignal.addEventListener('abort', () => {
+                    resolve('timeout');
+                });
+            }),
+        ]);
+        if (renameResult === 'timeout') {
+            logger.warn(`[TITLE] setName timed out after ${RENAME_TIMEOUT_MS}ms for thread ${this.threadId} (likely rate-limited)`);
+            return;
+        }
+        if (renameResult instanceof Error) {
+            logger.warn(`[TITLE] Could not rename thread ${this.threadId}: ${renameResult.message}`);
+            return;
+        }
+        logger.log(`[TITLE] Renamed thread ${this.threadId} to "${desiredName}" from OpenCode session title`);
+    }
     async handleTuiToast(properties) {
         if (properties.variant === 'warning') {
             return;
@@ -2069,18 +2193,7 @@ export class ThreadSessionRuntime {
                     .join('\n');
                 return `${input.prompt}\n\n**The following images are already included in this message as inline content (do not use Read tool on these):**\n${imageList}`;
             })();
-            let syntheticContext = '';
-            if (input.username) {
-                const msgAttr = input.sourceMessageId ? ` message-id="${input.sourceMessageId}"` : '';
-                const thrAttr = input.sourceThreadId ? ` thread-id="${input.sourceThreadId}"` : '';
-                syntheticContext += `<discord-user name="${input.username}"${msgAttr}${thrAttr} />`;
-            }
-            const parts = [
-                { type: 'text', text: promptWithImagePaths },
-                { type: 'text', text: syntheticContext, synthetic: true },
-                ...images,
-            ];
-            // ── Worktree + channel topic for system message ─────────
+            // ── Worktree + channel topic for per-turn prompt context ──
             const worktreeInfo = await getThreadWorktree(this.thread.id);
             const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
                 ? {
@@ -2107,6 +2220,22 @@ export class ThreadSessionRuntime {
                 }
                 return fetched.topic?.trim() || undefined;
             })();
+            const worktreeChanged = this.consumeWorktreePromptChange(worktree);
+            const syntheticContext = getOpencodePromptContext({
+                username: input.username,
+                userId: input.userId,
+                sourceMessageId: input.sourceMessageId,
+                sourceThreadId: input.sourceThreadId,
+                repliedMessage: input.repliedMessage,
+                worktree,
+                currentAgent: resolvedAgent,
+                worktreeChanged,
+            });
+            const parts = [
+                { type: 'text', text: promptWithImagePaths },
+                { type: 'text', text: syntheticContext, synthetic: true },
+                ...images,
+            ];
             const request = {
                 sessionID: session.id,
                 directory: this.sdkDirectory,
@@ -2116,12 +2245,9 @@ export class ThreadSessionRuntime {
                     channelId,
                     guildId: this.thread.guildId,
                     threadId: this.thread.id,
-                    worktree,
                     channelTopic,
-                    username: input.username,
-                    userId: input.userId,
                     agents: availableAgents,
-                    currentAgent: resolvedAgent,
+                    username: this.state?.sessionUsername || input.username,
                 }),
                 ...(resolvedAgent ? { agent: resolvedAgent } : {}),
                 ...(modelField ? { model: modelField } : {}),
@@ -2184,6 +2310,7 @@ export class ThreadSessionRuntime {
             injectionGuardPatterns: input.injectionGuardPatterns,
             sourceMessageId: input.sourceMessageId,
             sourceThreadId: input.sourceThreadId,
+            repliedMessage: input.repliedMessage,
             sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
             sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
         };
@@ -2219,11 +2346,18 @@ export class ThreadSessionRuntime {
      * discord-bot.ts.
      */
     async enqueueIncoming(input) {
+        threadState.setSessionUsername(this.threadId, input.username);
         // When a preprocessor is provided, we must resolve it inside
         // dispatchAction before we know the final mode for routing.
         if (input.preprocess) {
             return this.enqueueWithPreprocess(input);
         }
+        // If the prompt starts with `/cmdname ...` (and no explicit command is
+        // already set), rewrite it into a command invocation so it goes through
+        // opencode's session.command API instead of being sent to the model as
+        // plain text. Covers Discord chat messages, /new-session, /queue, CLI
+        // `kimaki send --prompt`, and scheduled tasks — all funnel through here.
+        input = maybeConvertLeadingCommand(input);
         if (input.mode === 'local-queue') {
             return this.enqueueViaLocalQueue(input);
         }
@@ -2264,13 +2398,17 @@ export class ThreadSessionRuntime {
                     resolveOuter({ queued: false });
                     return;
                 }
-                const resolvedInput = {
+                const resolvedInput = maybeConvertLeadingCommand({
                     ...input,
                     prompt: result.prompt,
                     images: result.images,
                     mode: result.mode,
+                    // Voice transcription can extract an agent name — apply it only if
+                    // no explicit agent was already set (CLI --agent flag wins).
+                    agent: input.agent || result.agent,
+                    repliedMessage: result.repliedMessage,
                     preprocess: undefined,
-                };
+                });
                 const hasPromptText = resolvedInput.prompt.trim().length > 0;
                 const hasImages = (resolvedInput.images?.length || 0) > 0;
                 if (!hasPromptText && !hasImages && !resolvedInput.command) {
@@ -2612,18 +2750,7 @@ export class ThreadSessionRuntime {
                 .join('\n');
             return `${input.prompt}\n\n**The following images are already included in this message as inline content (do not use Read tool on these):**\n${imageList}`;
         })();
-        let syntheticContext = '';
-        if (input.username) {
-            const msgAttr = input.sourceMessageId ? ` message-id="${input.sourceMessageId}"` : '';
-            const thrAttr = input.sourceThreadId ? ` thread-id="${input.sourceThreadId}"` : '';
-            syntheticContext += `<discord-user name="${input.username}"${msgAttr}${thrAttr} />`;
-        }
-        const parts = [
-            { type: 'text', text: promptWithImagePaths },
-            { type: 'text', text: syntheticContext, synthetic: true },
-            ...images,
-        ];
-        // ── Worktree info for system message ──────────────────────
+        // ── Worktree info for per-turn prompt context ─────────────
         const worktreeInfo = await getThreadWorktree(this.thread.id);
         const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
             ? {
@@ -2650,6 +2777,22 @@ export class ThreadSessionRuntime {
             }
             return fetched.topic?.trim() || undefined;
         })();
+        const worktreeChanged = this.consumeWorktreePromptChange(worktree);
+        const syntheticContext = getOpencodePromptContext({
+            username: input.username,
+            userId: input.userId,
+            sourceMessageId: input.sourceMessageId,
+            sourceThreadId: input.sourceThreadId,
+            repliedMessage: input.repliedMessage,
+            worktree,
+            currentAgent: earlyAgentPreference,
+            worktreeChanged,
+        });
+        const parts = [
+            { type: 'text', text: promptWithImagePaths },
+            { type: 'text', text: syntheticContext, synthetic: true },
+            ...images,
+        ];
         const variantField = earlyThinkingValue
             ? { variant: earlyThinkingValue }
             : {};
@@ -2678,15 +2821,19 @@ export class ThreadSessionRuntime {
             // session.command() only accepts FilePart in parts, not text parts.
             // Append <discord-user /> tag to arguments so external sync can
             // detect this message came from Discord (same tag as promptAsync).
-            const discordTag = input.username
-                ? `\n<discord-user name="${input.username}" />`
-                : '';
+            const discordTag = getOpencodePromptContext({
+                username: input.username,
+                userId: input.userId,
+                sourceMessageId: input.sourceMessageId,
+                sourceThreadId: input.sourceThreadId,
+                repliedMessage: input.repliedMessage,
+            });
             const commandResponse = await errore.tryAsync(() => {
                 return getClient().session.command({
                     sessionID: session.id,
                     directory: this.sdkDirectory,
                     command: queuedCommand.name,
-                    arguments: queuedCommand.arguments + discordTag,
+                    arguments: queuedCommand.arguments + (discordTag ? `\n${discordTag}` : ''),
                     agent: earlyAgentPreference,
                     ...variantField,
                 }, { signal: commandSignal });
@@ -2752,12 +2899,9 @@ export class ThreadSessionRuntime {
                     channelId,
                     guildId: this.thread.guildId,
                     threadId: this.thread.id,
-                    worktree,
                     channelTopic,
-                    username: input.username,
-                    userId: input.userId,
                     agents: earlyAvailableAgents,
-                    currentAgent: earlyAgentPreference,
+                    username: this.state?.sessionUsername || input.username,
                 }),
                 model: earlyModelParam,
                 agent: earlyAgentPreference,
@@ -2869,13 +3013,21 @@ export class ThreadSessionRuntime {
         await this.hydrateSessionEventsFromDatabase({ sessionId: session.id });
         // Store session start source for scheduled tasks
         if (createdNewSession && sessionStartScheduleKind) {
-            await errore.tryAsync(() => {
-                return setSessionStartSource({
-                    sessionId: session.id,
-                    scheduleKind: sessionStartScheduleKind,
-                    scheduledTaskId: sessionStartScheduledTaskId,
-                });
+            const sessionStartSourceResult = await errore.tryAsync({
+                try: () => {
+                    return setSessionStartSource({
+                        sessionId: session.id,
+                        scheduleKind: sessionStartScheduleKind,
+                        scheduledTaskId: sessionStartScheduledTaskId,
+                    });
+                },
+                catch: (e) => new Error('Failed to persist scheduled session start source', {
+                    cause: e,
+                }),
             });
+            if (sessionStartSourceResult instanceof Error) {
+                logger.warn(`[SESSION START SOURCE] ${sessionStartSourceResult.message}`);
+            }
         }
         // Store agent preference if provided
         if (agent && createdNewSession) {

package/dist/session-title-rename.test.js

@@ -0,0 +1,80 @@
+// Unit tests for deriveThreadNameFromSessionTitle — the pure helper that
+// decides whether (and how) to rename a Discord thread based on an
+// OpenCode session title. Kept focused and deterministic; no Discord mocks.
+import { describe, test, expect } from 'vitest';
+import { deriveThreadNameFromSessionTitle } from './session-handler/thread-session-runtime.js';
+describe('deriveThreadNameFromSessionTitle', () => {
+    test('returns trimmed title for plain thread', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '  Fix auth bug  ',
+            currentName: 'fix the auth',
+        })).toMatchInlineSnapshot(`"Fix auth bug"`);
+    });
+    test('preserves worktree prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ refactor queue old',
+        })).toMatchInlineSnapshot(`"⬦ Refactor queue"`);
+    });
+    test('ignores placeholder "New Session -" titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'New Session - 2025-01-02',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('ignores case-insensitive placeholder titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'new session -abc',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate already matches current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Fix auth bug',
+            currentName: 'Fix auth bug',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate (with worktree prefix) already matches', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ Refactor queue',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('truncates to 100 chars including worktree prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'x'.repeat(200),
+            currentName: '⬦ seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+        expect(result?.startsWith('⬦ ')).toMatchInlineSnapshot(`true`);
+    });
+    test('truncates to 100 chars without prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'y'.repeat(200),
+            currentName: 'seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+    });
+    test('returns undefined for empty string', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined for whitespace-only title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '   ',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined for null/undefined title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: null,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: undefined,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+});

package/dist/store.js

@@ -1,7 +1,7 @@
 // Centralized zustand/vanilla store for global bot state.
 // Replaces scattered module-level `let` variables, process.env mutations,
 // and mutable arrays with a single immutable state atom.
-// See discord/skills/zustand-centralized-state/SKILL.md for the pattern.
+// See cli/skills/zustand-centralized-state/SKILL.md for the pattern.
 import { createStore } from 'zustand/vanilla';
 export const store = createStore(() => ({
     dataDir: null,
@@ -9,7 +9,6 @@ export const store = createStore(() => ({
     defaultVerbosity: 'text_and_essential_tools',
     defaultMentionMode: false,
     critiqueEnabled: true,
-    verboseOpencodeServer: false,
     discordBaseUrl: 'https://discord.com',
     gatewayToken: null,
     registeredUserCommands: [],