kimaki 0.26.0 → 0.28.0

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

@@ -6,6 +6,7 @@
 // call runtime APIs (enqueueIncoming, abortActiveRun, etc.) without inspecting
 // run internals.
 import crypto from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { ChannelType } from 'discord.js';
 import path from 'node:path';
 import prettyMilliseconds from 'pretty-ms';
@@ -15,22 +16,24 @@ import { getOpencodeClient, initializeOpencodeForDirectory, buildSessionPermissi
 import { isAbortError } from '../utils.js';
 import { registerEventListener, unregisterEventListener, waitForGlobalEventListener, } from './global-event-listener.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import { sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
-import { formatPart, formatTaskToolTitle } from '../message-formatting.js';
-import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, clearSessionModel, getVariantCascade, setSessionStartSource, completeScheduledTaskRunsForSession, failScheduledTaskRunsForSession, startScheduledTaskRunSession, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, } from '../database.js';
+import { sendThreadMessage, sendSessionPartMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, raceDiscordRename, DISCORD_THREAD_RENAME_TIMEOUT_MS, resolveThreadFooterMentionUserId, } from '../discord-utils.js';
+import { asDiscordQuote, formatPart, formatTaskToolTitle, planAssistantTurnFlush, QUEUE_PREFIX, sessionPartKind, shouldLeadWithBlankLine, shouldQuoteIntermediateTextPart, STATUS_PREFIX, WORKTREE_PREFIX, } from '../message-formatting.js';
+import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, setSessionModel, clearSessionModel, getVariantCascade, setSessionStartSource, getSessionStartSource, getScheduledTask, completeScheduledTaskRunsForSession, failScheduledTaskRunsForSession, startScheduledTaskRunSession, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, cancelSessionSleepForThread, } from '../database.js';
 import * as orm from 'drizzle-orm';
 import * as schema from '../schema.js';
 import { showPermissionButtons, addPermissionRequestToContext, arePatternsCoveredBy, pendingPermissionContexts, } from '../commands/permissions.js';
-import { showAskUserQuestionDropdowns, pendingQuestionContexts, cancelPendingQuestion, } from '../commands/ask-question.js';
+import { showAskUserQuestionDropdowns, pendingQuestionContexts, cancelPendingQuestion, findPendingQuestionContextForRequest, } from '../commands/ask-question.js';
 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 { displayedModelLabel, resolveDisplayedModelName, validateModelId, } from './model-utils.js';
 import { getOpencodePromptContext, getOpencodeSystemMessage, writeSessionSystemPrompt, } from '../system-message.js';
 import { getDataDir } from '../config.js';
+import { store } from '../store.js';
 import { trackEvent, } from '../analytics.js';
 import { resolveValidatedAgentPreference } from './agent-utils.js';
 import { appendOpencodeSessionEventLog, getOpencodeEventSessionId, isOpencodeSessionEventLogEnabled, } from './opencode-session-event-log.js';
-import { doesLatestUserTurnHaveNaturalCompletion, didQuestionQueueHandoffSinceLatestQuestionAsked, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getIdleTokenUsageDelta, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getLatestAssistantMessageIdForLatestUserTurn, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, } from './event-stream-state.js';
+import { doesLatestUserTurnHaveNaturalCompletion, didLatestUserTurnUseSleepTool, didQuestionQueueHandoffSinceLatestQuestionAsked, deriveLatestUnansweredQuestion, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getIdleTokenUsageDelta, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getTokenUsageSessionIdsForIdle, isDerivedChildSession, getLatestAssistantMessageIdForLatestUserTurn, getAssistantMessageKind, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, shouldBufferSessionEvent, } from './event-stream-state.js';
 // Track multiple pending permissions per thread (keyed by permission ID).
 // OpenCode handles blocking/sequencing — we just need to track all pending
 // permissions to avoid duplicates and properly clean up on reply/teardown.
@@ -61,6 +64,48 @@ const shouldLogSessionEvents = process.env['KIMAKI_LOG_SESSION_EVENTS'] === '1'
 // Runtime instances are kept in a plain Map (not Zustand — the Map
 // is not reactive state, just a lookup for resource handles).
 const runtimes = new Map();
+// Per-thread FIFO for Discord arrival order of one-shot slash calls vs messages.
+// Covers /plan-agent (no prompt) and /foo-cmd /foo-skill. OpenCode already
+// queues promptAsync. /model, /agent, and /compact are not on this queue.
+const threadIngressChains = new Map();
+const threadIngressSlotAls = new AsyncLocalStorage();
+export function reserveThreadIngress(threadId) {
+    const previous = threadIngressChains.get(threadId) ?? Promise.resolve();
+    let released = false;
+    let releaseHeld = () => { };
+    const held = new Promise((resolve) => {
+        releaseHeld = resolve;
+    });
+    threadIngressChains.set(threadId, previous.then(() => held));
+    return {
+        wait: previous,
+        release: () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            releaseHeld();
+        },
+    };
+}
+export async function runInThreadIngressSlot(slot, run) {
+    try {
+        return await threadIngressSlotAls.run(slot, run);
+    }
+    finally {
+        slot?.release();
+    }
+}
+export async function waitForCurrentThreadIngress() {
+    const slot = threadIngressSlotAls.getStore();
+    if (!slot) {
+        return;
+    }
+    await slot.wait;
+}
+export function releaseCurrentThreadIngress() {
+    threadIngressSlotAls.getStore()?.release();
+}
 export function getRuntime(threadId) {
     return runtimes.get(threadId);
 }
@@ -70,9 +115,15 @@ export function getOrCreateRuntime(opts) {
         if (existing.sdkDirectory !== opts.sdkDirectory) {
             logger.warn(`[RUNTIME] Ignoring sdkDirectory change for existing thread ${opts.threadId}: ${existing.sdkDirectory} → ${opts.sdkDirectory}`);
         }
+        if (opts.sessionId && !existing.state?.sessionId) {
+            threadState.setSessionId(opts.threadId, opts.sessionId);
+        }
         return existing;
     }
     threadState.ensureThread(opts.threadId); // add to global store
+    if (opts.sessionId) {
+        threadState.setSessionId(opts.threadId, opts.sessionId);
+    }
     const runtime = new ThreadSessionRuntime(opts);
     runtimes.set(opts.threadId, runtime);
     return runtime;
@@ -85,6 +136,7 @@ export function disposeRuntime(threadId) {
     runtime.dispose();
     runtimes.delete(threadId);
     threadState.removeThread(threadId); // remove from global store
+    threadIngressChains.delete(threadId);
 }
 export function disposeRuntimesForDirectory({ directory, channelId, }) {
     let count = 0;
@@ -98,6 +150,7 @@ export function disposeRuntimesForDirectory({ directory, channelId, }) {
         runtime.dispose();
         runtimes.delete(threadId);
         threadState.removeThread(threadId);
+        threadIngressChains.delete(threadId);
         count++;
     }
     return count;
@@ -116,6 +169,7 @@ export function disposeInactiveRuntimes({ idleMs, nowMs = Date.now(), }) {
         runtime.dispose();
         runtimes.delete(threadId);
         threadState.removeThread(threadId);
+        threadIngressChains.delete(threadId);
         disposedThreadIds.push(threadId);
         disposedDirectories.add(runtime.projectDirectory);
     }
@@ -227,26 +281,37 @@ export function isEssentialToolPart(part) {
 }
 // ── Thread title derivation ──────────────────────────────────────
 const DISCORD_THREAD_NAME_MAX = 100;
-const WORKTREE_THREAD_PREFIX = '⬦ ';
-// Prefixes that should survive OpenCode session title renames.
-// When a thread starts with one of these, the rename preserves it.
 const PRESERVED_THREAD_PREFIXES = [
-    WORKTREE_THREAD_PREFIX,
+    WORKTREE_PREFIX,
     'btw: ',
     'Fork: ',
 ];
+function stripPreservedThreadPrefix(name) {
+    const matchedPrefix = PRESERVED_THREAD_PREFIXES.find((prefix) => {
+        return name.startsWith(prefix);
+    });
+    if (!matchedPrefix)
+        return name;
+    return name.slice(matchedPrefix.length).trim();
+}
 function getThreadNameCandidateFromSessionTitle({ sessionTitle, currentName, }) {
-    const trimmed = sessionTitle?.trim();
+    const trimmed = sessionTitle
+        ?.replace(/<\/?callout\b[^>]*>/gi, '')
+        .trim();
     if (!trimmed) {
         return null;
     }
-    if (/^new session\s*-/i.test(trimmed)) {
+    const withoutCopiedPrefix = stripPreservedThreadPrefix(trimmed);
+    if (!withoutCopiedPrefix) {
+        return null;
+    }
+    if (/^new session\s*-/i.test(withoutCopiedPrefix)) {
         return null;
     }
     const matchedPrefix = PRESERVED_THREAD_PREFIXES.find((p) => {
         return currentName.startsWith(p);
     }) ?? '';
-    return `${matchedPrefix}${trimmed}`.slice(0, DISCORD_THREAD_NAME_MAX);
+    return `${matchedPrefix}${withoutCopiedPrefix}`.slice(0, DISCORD_THREAD_NAME_MAX);
 }
 export function deriveThreadNameFromSessionTitle({ sessionTitle, currentName, }) {
     const candidate = getThreadNameCandidateFromSessionTitle({
@@ -261,34 +326,6 @@ export function deriveThreadNameFromSessionTitle({ sessionTitle, currentName, })
     }
     return candidate;
 }
-export function deriveThreadRenameFromSessionUpdate({ sessionTitle, currentName, lastSyncedName, }) {
-    if (lastSyncedName !== null && currentName !== lastSyncedName) {
-        return {
-            desiredName: null,
-            nextSyncedName: lastSyncedName,
-        };
-    }
-    const candidate = getThreadNameCandidateFromSessionTitle({
-        sessionTitle,
-        currentName,
-    });
-    if (candidate === null) {
-        return {
-            desiredName: null,
-            nextSyncedName: lastSyncedName,
-        };
-    }
-    if (candidate === currentName) {
-        return {
-            desiredName: null,
-            nextSyncedName: currentName,
-        };
-    }
-    return {
-        desiredName: candidate,
-        nextSyncedName: candidate,
-    };
-}
 function resolveTurnSource(input) {
     if (input.analyticsSource)
         return input.analyticsSource;
@@ -351,26 +388,23 @@ export class ThreadSessionRuntime {
     // message and showing multiple back-to-back POSTs is wasteful.
     typingKeepaliveTimeout = null;
     typingRepulseDebounce;
+    deferredQuestionShow;
     static TYPING_REPULSE_DEBOUNCE_MS = 500;
+    static DEFERRED_QUESTION_SHOW_MS = 1000;
     // 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).
+    // Last OpenCode session title we applied to Discord. Dedupes session.updated
+    // so we only call setName once per distinct title. Not persisted.
     appliedOpencodeTitle;
-    // Last Discord thread name known to match the OpenCode title. Persisted so a
-    // user rename is still respected after Kimaki restarts.
-    lastSyncedThreadName;
     // Part output buffering (write-side cache, not domain state)
     partBuffer = new Map();
+    shownQuestionRequestIds = new Set();
     // Derivable cache (perf optimization for provider.list API call)
     modelContextLimit;
     modelContextLimitKey;
     lastPromptWorktreeKey;
+    lastSentPartKind;
     // 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).
@@ -432,6 +466,17 @@ export class ThreadSessionRuntime {
                 this.restartTypingKeepalive({ sendNow: true });
             },
         });
+        this.deferredQuestionShow = createDebouncedTimeout({
+            delayMs: ThreadSessionRuntime.DEFERRED_QUESTION_SHOW_MS,
+            callback: () => {
+                if (this.disposed) {
+                    return;
+                }
+                void this.dispatchAction(async () => {
+                    await this.tryShowPendingQuestion({ ignoreUnfinishedText: true });
+                });
+            },
+        });
     }
     consumeWorktreePromptChange(worktree) {
         const nextKey = getWorktreePromptKey(worktree);
@@ -579,6 +624,42 @@ export class ThreadSessionRuntime {
         }
         return isSessionBusy({ events: this.eventBuffer, sessionId });
     }
+    async persistIngressVariant({ sessionId, channelId, appId, agentPreference, getClient, variant, }) {
+        if (!variant)
+            return;
+        if (getClient instanceof Error)
+            return;
+        const variantModelInfo = await getCurrentModelInfo({
+            sessionId,
+            channelId,
+            appId,
+            agentPreference,
+            getClient,
+            directory: this.sdkDirectory,
+        });
+        if (variantModelInfo.type === 'none')
+            return;
+        const providersResponse = await getClient()
+            .provider.list({ directory: this.sdkDirectory })
+            .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }));
+        if (providersResponse instanceof Error || !providersResponse.data)
+            return;
+        const matchedVariant = matchThinkingValue({
+            requestedValue: variant,
+            availableValues: getThinkingValuesForModel({
+                providers: providersResponse.data.all,
+                providerId: variantModelInfo.providerID,
+                modelId: variantModelInfo.modelID,
+            }),
+        });
+        if (!matchedVariant)
+            return;
+        await setSessionModel({
+            sessionId,
+            modelId: variantModelInfo.model,
+            variant: matchedVariant,
+        });
+    }
     getAssistantMessageIdsForCurrentTurn({ sessionId, upToIndex, }) {
         const normalizedIndex = upToIndex === undefined ? undefined : upToIndex - 1;
         return getAssistantMessageIdsForLatestUserTurn({
@@ -600,20 +681,24 @@ export class ThreadSessionRuntime {
         if (!mainSessionId || candidateSessionId === mainSessionId) {
             return undefined;
         }
-        const subtaskIndex = getDerivedSubtaskIndex({
+        if (!isDerivedChildSession({
             events: this.eventBuffer,
             mainSessionId,
             candidateSessionId,
-        });
-        if (!subtaskIndex) {
+        })) {
             return undefined;
         }
+        const subtaskIndex = getDerivedSubtaskIndex({
+            events: this.eventBuffer,
+            mainSessionId,
+            candidateSessionId,
+        });
         const agentType = getDerivedSubtaskAgentType({
             events: this.eventBuffer,
             mainSessionId,
             candidateSessionId,
         });
-        const label = `${agentType || 'task'}-${subtaskIndex}`;
+        const label = `${agentType || 'task'}-${subtaskIndex || 1}`;
         const assistantMessageId = this.getLatestAssistantMessageIdForCurrentTurn({
             sessionId: candidateSessionId,
         });
@@ -624,12 +709,14 @@ export class ThreadSessionRuntime {
         this.disposed = true;
         unregisterEventListener(this.threadId);
         void this.persistEventBufferDebounced.dispose();
+        this.deferredQuestionShow.clear();
         this.stopTyping();
         // Release large internal buffers so GC can reclaim memory immediately
         // instead of waiting for the runtime object itself to become unreachable.
         this.eventBuffer = [];
         this.nextEventIndex = 0;
         this.partBuffer.clear();
+        this.shownQuestionRequestIds.clear();
         this.preprocessChain = Promise.resolve();
         // Don't clear actionQueue here — queued closures own resolve/reject for
         // dispatchAction() promises. Dropping them would leave awaiting callers
@@ -719,7 +806,6 @@ export class ThreadSessionRuntime {
                 })
                 : [];
             delete info.system;
-            delete info.summary;
             delete info.tools;
             delete info.parts;
             if (partsSummary.length > 0) {
@@ -870,10 +956,14 @@ export class ThreadSessionRuntime {
     // Global events (tui.toast.show) bypass the guard.
     // Subtask sessions also bypass — they're tracked in subtaskSessions.
     async handleEvent(event) {
-        // session.diff can carry repeated full-file before/after snapshots and is
-        // not used by event-derived runtime state, queueing, typing, or UI routing.
-        // Drop it at ingress so large diff payloads never hit memory buffers.
-        if (event.type === 'session.diff') {
+        const sessionId = this.state?.sessionId;
+        if (!shouldBufferSessionEvent({
+            event,
+            mainSessionId: sessionId,
+            isKnownChildSession: (candidateSessionId) => {
+                return Boolean(this.getSubtaskInfoForSession(candidateSessionId));
+            },
+        })) {
             return;
         }
         // Skip message.part.delta from the event buffer — no derivation function
@@ -886,7 +976,6 @@ export class ThreadSessionRuntime {
         if (event.type !== 'message.part.delta') {
             this.appendEventToBuffer(event);
         }
-        const sessionId = this.state?.sessionId;
         const eventSessionId = getOpencodeEventSessionId(event);
         const toastSessionId = event.type === 'tui.toast.show'
             ? extractToastSessionId({ message: event.properties.message })
@@ -1180,22 +1269,58 @@ export class ThreadSessionRuntime {
             return part.type === 'step-finish';
         });
     }
-    shouldSendPart({ part, force, }) {
+    shouldSendPlannedPart({ part, mode, }) {
         if (part.type === 'step-start' || part.type === 'step-finish') {
             return false;
         }
         if (part.type === 'tool' && part.state.status === 'pending') {
             return false;
         }
-        if (!force && part.type === 'text' && !part.time?.end) {
-            return false;
-        }
-        if (!force && part.type === 'tool' && part.state.status === 'completed') {
+        if (part.type === 'text' && !part.time?.end && mode === 'progress') {
             return false;
         }
         return true;
     }
-    async sendPartMessage({ part, repulseTyping = true, }) {
+    getCurrentTurnParts() {
+        const sessionId = this.state?.sessionId;
+        const messageIds = sessionId
+            ? [...this.getAssistantMessageIdsForCurrentTurn({ sessionId })]
+            : [];
+        if (messageIds.length > 0) {
+            return messageIds.flatMap((id) => this.getBufferedParts(id));
+        }
+        return [...this.partBuffer.keys()].flatMap((id) => this.getBufferedParts(id));
+    }
+    async flushCurrentTurnParts({ mode, throughPartId, skipPartId, repulseTyping = true, }) {
+        const parts = this.getCurrentTurnParts().filter((part) => {
+            return !this.state?.sentPartIds.has(part.id);
+        });
+        const planned = planAssistantTurnFlush({
+            parts,
+            mode,
+            throughPartId,
+        });
+        for (const { part, quoteText } of planned.sendParts) {
+            if (skipPartId && part.id === skipPartId) {
+                continue;
+            }
+            if (!this.shouldSendPlannedPart({ part, mode })) {
+                continue;
+            }
+            if (part.type === 'tool' && part.tool === 'task') {
+                continue;
+            }
+            const pulseTyping = part.type === 'text' && part.ignored === true
+                ? false
+                : repulseTyping;
+            await this.sendPartMessage({
+                part,
+                quoteText,
+                repulseTyping: pulseTyping,
+            });
+        }
+    }
+    async sendPartMessage({ part, repulseTyping = true, quoteText = false, }) {
         const verbosity = await this.getVerbosity();
         if (verbosity === 'text_only' && part.type !== 'text') {
             return;
@@ -1205,7 +1330,13 @@ export class ThreadSessionRuntime {
                 return;
             }
         }
-        const content = formatPart(part);
+        const formatted = formatPart(part);
+        const quote = quoteText
+            && shouldQuoteIntermediateTextPart({
+                part,
+                isLastInTurn: false,
+            });
+        const content = quote ? asDiscordQuote(formatted) : formatted;
         if (!content.trim() || content.length === 0) {
             return;
         }
@@ -1219,7 +1350,13 @@ export class ThreadSessionRuntime {
             newIds.add(part.id);
             return { ...t, sentPartIds: newIds };
         });
-        const sendResult = await sendThreadMessage(this.thread, content)
+        const kind = sessionPartKind(part);
+        const sendResult = await sendSessionPartMessage(this.thread, content, {
+            leadWithBlankLine: shouldLeadWithBlankLine({
+                previousKind: this.lastSentPartKind,
+                nextKind: kind,
+            }),
+        })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {
             threadState.updateThread(this.threadId, (t) => {
@@ -1230,66 +1367,19 @@ export class ThreadSessionRuntime {
             discordLogger.error(`ERROR: Failed to send part ${part.id}:`, sendResult);
             return;
         }
+        this.lastSentPartKind = kind;
         await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
         if (repulseTyping) {
             this.requestTypingRepulse();
         }
     }
-    async flushBufferedParts({ messageID, force, skipPartId, repulseTyping = true, }) {
-        if (!messageID) {
-            return;
-        }
-        const parts = this.getBufferedParts(messageID);
-        for (const part of parts) {
-            if (skipPartId && part.id === skipPartId) {
-                continue;
-            }
-            if (!this.shouldSendPart({ part, force })) {
-                continue;
-            }
-            await this.sendPartMessage({ part, repulseTyping });
-        }
-    }
-    async flushBufferedPartsForMessages({ messageIDs, force, skipPartId, repulseTyping = true, }) {
-        const uniqueMessageIDs = [...new Set(messageIDs)];
-        for (const messageID of uniqueMessageIDs) {
-            await this.flushBufferedParts({
-                messageID,
-                force,
-                skipPartId,
-                repulseTyping,
-            });
-        }
-    }
-    async showInteractiveUi({ skipPartId, flushMessageId, show, }) {
+    async showInteractiveUi({ skipPartId, show, }) {
         this.stopTyping();
-        const sessionId = this.state?.sessionId;
-        const targetMessageId = (() => {
-            if (flushMessageId) {
-                return flushMessageId;
-            }
-            if (!sessionId) {
-                return undefined;
-            }
-            return this.getLatestAssistantMessageIdForCurrentTurn({ sessionId });
-        })();
-        if (targetMessageId) {
-            await this.flushBufferedParts({
-                messageID: targetMessageId,
-                force: true,
-                skipPartId,
-            });
-        }
-        else {
-            const assistantMessageIds = sessionId
-                ? [...this.getAssistantMessageIdsForCurrentTurn({ sessionId })]
-                : [];
-            await this.flushBufferedPartsForMessages({
-                messageIDs: assistantMessageIds,
-                force: true,
-                skipPartId,
-            });
-        }
+        await this.flushCurrentTurnParts({
+            mode: 'interactive',
+            throughPartId: skipPartId,
+            skipPartId,
+        });
         await show();
     }
     async ensureModelContextLimit({ providerID, modelID, }) {
@@ -1325,10 +1415,21 @@ export class ThreadSessionRuntime {
     // These operate on runtime instance state + global store transitions.
     async handleMessageUpdated(msg) {
         const sessionId = this.state?.sessionId;
-        if (msg.sessionID !== sessionId) {
+        if (msg.role !== 'assistant') {
             return;
         }
-        if (msg.role !== 'assistant') {
+        if (msg.summary === true) {
+            this.clearBufferedPartsForMessages([msg.id]);
+            logger.info(`[SKIP] message.updated for compaction summary ${msg.id}`);
+            return;
+        }
+        if (msg.sessionID !== sessionId) {
+            const subtaskInfo = this.getSubtaskInfoForSession(msg.sessionID);
+            if (subtaskInfo) {
+                for (const part of this.getBufferedParts(msg.id)) {
+                    await this.handleSubtaskPart(part, subtaskInfo);
+                }
+            }
             return;
         }
         if (!sessionId) {
@@ -1339,6 +1440,7 @@ export class ThreadSessionRuntime {
             sessionId,
             messageId: msg.id,
         })) {
+            this.clearBufferedPartsForMessages([msg.id]);
             logger.info(`[SKIP] message.updated for old assistant message ${msg.id}, not in latest user turn`);
             return;
         }
@@ -1366,9 +1468,8 @@ export class ThreadSessionRuntime {
                 this.storePart(part);
             });
         }
-        await this.flushBufferedParts({
-            messageID: msg.id,
-            force: false,
+        await this.flushCurrentTurnParts({
+            mode: 'progress',
         });
         const wasAlreadyCompleted = hasAssistantMessageCompletedBefore({
             events: this.eventBuffer,
@@ -1417,7 +1518,7 @@ export class ThreadSessionRuntime {
             return;
         }
         this.lastDisplayedContextPercentage = thresholdCrossed;
-        const chunk = `⬦ context usage ${currentPercentage}%`;
+        const chunk = `${STATUS_PREFIX}context usage ${currentPercentage}%`;
         const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {
@@ -1425,8 +1526,21 @@ export class ThreadSessionRuntime {
         }
     }
     async handlePartUpdated(part) {
-        this.storePart(part);
         const sessionId = this.state?.sessionId;
+        const messageKind = getAssistantMessageKind({
+            events: this.eventBuffer,
+            sessionId: part.sessionID,
+            messageId: part.messageID,
+        });
+        if (messageKind === 'summary') {
+            this.clearBufferedPartsForMessages([part.messageID]);
+            logger.info(`[SKIP] message.part.updated for compaction summary ${part.messageID}`);
+            return;
+        }
+        this.storePart(part);
+        if (messageKind === 'unknown') {
+            return;
+        }
         const subtaskInfo = this.getSubtaskInfoForSession(part.sessionID);
         const isSubtaskEvent = Boolean(subtaskInfo);
         if (part.sessionID !== sessionId && !isSubtaskEvent) {
@@ -1444,42 +1558,51 @@ export class ThreadSessionRuntime {
             this.ensureTypingNow();
             return;
         }
-        if (part.type === 'tool' &&
-            part.tool === 'task' &&
-            !this.state?.sentPartIds.has(part.id)) {
-            const taskDisplay = formatTaskToolTitle(part);
-            if (taskDisplay && (await this.getVerbosity()) !== 'text_only') {
-                await this.flushBufferedParts({
-                    messageID: part.messageID,
-                    force: true,
-                    skipPartId: part.id,
-                });
-                threadState.updateThread(this.threadId, (t) => {
-                    const newIds = new Set(t.sentPartIds);
-                    newIds.add(part.id);
-                    return { ...t, sentPartIds: newIds };
-                });
-                const sendResult = await sendThreadMessage(this.thread, taskDisplay + '\n\n')
-                    .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
-                if (sendResult instanceof Error) {
+        if (part.type === 'tool' && part.state.status === 'running') {
+            await this.flushCurrentTurnParts({
+                mode: 'progress',
+            });
+            const unsent = this.getCurrentTurnParts().filter((candidate) => {
+                return !this.state?.sentPartIds.has(candidate.id);
+            });
+            const held = planAssistantTurnFlush({
+                parts: unsent,
+                mode: 'progress',
+            }).hold.some((entry) => entry.id === part.id);
+            if (held) {
+                return;
+            }
+            if (!this.state?.sentPartIds.has(part.id) && part.tool !== 'task') {
+                await this.sendPartMessage({ part });
+            }
+            if (part.tool === 'task' && !this.state?.sentPartIds.has(part.id)) {
+                const taskDisplay = formatTaskToolTitle(part);
+                if (taskDisplay && (await this.getVerbosity()) !== 'text_only') {
                     threadState.updateThread(this.threadId, (t) => {
                         const newIds = new Set(t.sentPartIds);
-                        newIds.delete(part.id);
+                        newIds.add(part.id);
                         return { ...t, sentPartIds: newIds };
                     });
-                    discordLogger.error(`ERROR: Failed to send task part ${part.id}:`, sendResult);
-                    return;
+                    const sendResult = await sendSessionPartMessage(this.thread, taskDisplay, {
+                        leadWithBlankLine: shouldLeadWithBlankLine({
+                            previousKind: this.lastSentPartKind,
+                            nextKind: 'tool',
+                        }),
+                    })
+                        .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+                    if (sendResult instanceof Error) {
+                        threadState.updateThread(this.threadId, (t) => {
+                            const newIds = new Set(t.sentPartIds);
+                            newIds.delete(part.id);
+                            return { ...t, sentPartIds: newIds };
+                        });
+                        discordLogger.error(`ERROR: Failed to send task part ${part.id}:`, sendResult);
+                        return;
+                    }
+                    this.lastSentPartKind = 'tool';
+                    await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
                 }
-                await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
             }
-        }
-        if (part.type === 'tool' && part.state.status === 'running') {
-            await this.flushBufferedParts({
-                messageID: part.messageID,
-                force: true,
-                skipPartId: part.id,
-            });
-            await this.sendPartMessage({ part });
             return;
         }
         // Action buttons tool handler
@@ -1575,7 +1698,7 @@ export class ThreadSessionRuntime {
                         }
                         return ` (${pct.toFixed(1)}%)`;
                     })();
-                    const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
+                    const chunk = `${STATUS_PREFIX}${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
                     const largeOutputResult = await this.thread.send({
                         content: chunk,
                         flags: SILENT_MESSAGE_FLAGS,
@@ -1587,18 +1710,17 @@ export class ThreadSessionRuntime {
             }
         }
         if (part.type === 'reasoning') {
-            await this.sendPartMessage({ part });
+            await this.flushCurrentTurnParts({ mode: 'progress' });
             return;
         }
-        if (part.type === 'text' && part.time?.end) {
-            await this.sendPartMessage({ part });
+        if (part.type === 'text') {
+            await this.flushCurrentTurnParts({ mode: 'progress' });
+            if (part.time?.end) {
+                await this.tryShowPendingQuestion();
+            }
             return;
         }
         if (part.type === 'step-finish') {
-            await this.flushBufferedParts({
-                messageID: part.messageID,
-                force: true,
-            });
             this.ensureTypingKeepalive();
         }
     }
@@ -1629,12 +1751,19 @@ export class ThreadSessionRuntime {
         if (!content.trim() || this.state?.sentPartIds.has(part.id)) {
             return;
         }
-        const sendResult = await sendThreadMessage(this.thread, content + '\n\n')
+        const kind = sessionPartKind(part);
+        const sendResult = await sendSessionPartMessage(this.thread, content, {
+            leadWithBlankLine: shouldLeadWithBlankLine({
+                previousKind: this.lastSentPartKind,
+                nextKind: kind,
+            }),
+        })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {
             discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, sendResult);
             return;
         }
+        this.lastSentPartKind = kind;
         threadState.updateThread(this.threadId, (t) => {
             const newIds = new Set(t.sentPartIds);
             newIds.add(part.id);
@@ -1643,21 +1772,10 @@ export class ThreadSessionRuntime {
         await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
         this.requestTypingRepulse();
     }
-    trackIdleTokenUsage(idleSessionId) {
-        let idleEventIndex;
-        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
-            const event = this.eventBuffer[i]?.event;
-            if (event?.type === 'session.idle' && event.properties.sessionID === idleSessionId) {
-                idleEventIndex = i;
-                break;
-            }
-        }
-        if (idleEventIndex === undefined) {
-            return;
-        }
+    trackIdleTokenUsage({ sessionId, idleEventIndex, }) {
         const usage = getIdleTokenUsageDelta({
             events: this.eventBuffer,
-            sessionId: idleSessionId,
+            sessionId,
             idleEventIndex,
         });
         if (!usage) {
@@ -1672,7 +1790,7 @@ export class ThreadSessionRuntime {
             tokens_total: usage.total,
             cost: usage.cost,
             assistant_message_count: usage.assistantMessageCount,
-            is_subagent: Boolean(this.getSubtaskInfoForSession(idleSessionId)),
+            is_subagent: Boolean(this.getSubtaskInfoForSession(sessionId)),
         };
         if (usage.model) {
             properties.model = usage.model;
@@ -1682,8 +1800,36 @@ export class ThreadSessionRuntime {
         }
         trackEvent('tokens_used', properties);
     }
+    trackIdleTokenUsageForSessionTree(idleSessionId) {
+        let idleEventIndex;
+        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
+            const event = this.eventBuffer[i]?.event;
+            if (event?.type === 'session.idle' && event.properties.sessionID === idleSessionId) {
+                idleEventIndex = i;
+                break;
+            }
+        }
+        if (idleEventIndex === undefined) {
+            return;
+        }
+        const mainSessionId = this.state?.sessionId;
+        const sessionIds = mainSessionId
+            ? getTokenUsageSessionIdsForIdle({
+                events: this.eventBuffer,
+                mainSessionId,
+                idleSessionId,
+                upToIndex: idleEventIndex,
+            })
+            : [idleSessionId];
+        for (const sessionId of sessionIds) {
+            this.trackIdleTokenUsage({
+                sessionId,
+                idleEventIndex,
+            });
+        }
+    }
     async handleSessionIdle(idleSessionId) {
-        this.trackIdleTokenUsage(idleSessionId);
+        this.trackIdleTokenUsageForSessionTree(idleSessionId);
         const sessionId = this.state?.sessionId;
         // ── Subtask idle ──────────────────────────────────────────
         const subtask = this.getSubtaskInfoForSession(idleSessionId);
@@ -1722,9 +1868,8 @@ export class ThreadSessionRuntime {
         if (assistantMessageIds.length === 0) {
             return;
         }
-        await this.flushBufferedPartsForMessages({
-            messageIDs: assistantMessageIds,
-            force: true,
+        await this.flushCurrentTurnParts({
+            mode: 'final',
             repulseTyping: false,
         });
         // Skip footer if model produced no visible output (no text, no tool calls,
@@ -1882,38 +2027,79 @@ export class ThreadSessionRuntime {
         }
         this.onInteractiveUiStateChanged();
     }
-    async handleQuestionAsked(questionRequest) {
+    hasUnfinishedTextPart(messageID) {
+        return this.getBufferedParts(messageID).some((part) => {
+            return part.type === 'text' && !part.time?.end;
+        });
+    }
+    // OpenCode emits question.asked when the tool starts, often before the
+    // preceding text part gets time.end. Showing the dropdown on that event
+    // holds the action queue while Discord posts, so the later text-end cannot
+    // send and dumps after the queued » user: indicator. Wait for text-end.
+    async tryShowPendingQuestion({ ignoreUnfinishedText = false, } = {}) {
         const sessionId = this.state?.sessionId;
-        if (questionRequest.sessionID !== sessionId) {
-            logger.log(`[QUESTION IGNORED] Question for different session (expected: ${sessionId}, got: ${questionRequest.sessionID})`);
-            return;
+        if (!sessionId) {
+            return false;
         }
-        logger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+        const request = deriveLatestUnansweredQuestion({
+            events: this.eventBuffer,
+            sessionId,
+        });
+        if (!request) {
+            this.deferredQuestionShow.clear();
+            return false;
+        }
+        if (this.shownQuestionRequestIds.has(request.id)
+            || findPendingQuestionContextForRequest({
+                threadId: this.thread.id,
+                requestId: request.id,
+            })) {
+            this.deferredQuestionShow.clear();
+            return true;
+        }
+        const messageId = request.tool?.messageID;
+        if (!ignoreUnfinishedText && messageId && this.hasUnfinishedTextPart(messageId)) {
+            return false;
+        }
+        this.shownQuestionRequestIds.add(request.id);
         await this.showInteractiveUi({
+            flushMessageId: messageId,
             show: async () => {
-                if (!sessionId) {
-                    return;
-                }
                 await showAskUserQuestionDropdowns({
                     thread: this.thread,
                     sessionId,
                     directory: this.sdkDirectory,
-                    requestId: questionRequest.id,
-                    input: { questions: questionRequest.questions },
+                    requestId: request.id,
+                    input: { questions: request.questions },
                     silent: this.getQueueLength() > 0,
                 });
             },
         });
+        this.deferredQuestionShow.clear();
         this.maybeHandoffQueuedItemForPendingQuestion({
             sessionId,
             reason: 'question-shown',
         });
+        return true;
+    }
+    async handleQuestionAsked(questionRequest) {
+        const sessionId = this.state?.sessionId;
+        if (questionRequest.sessionID !== sessionId) {
+            logger.log(`[QUESTION IGNORED] Question for different session (expected: ${sessionId}, got: ${questionRequest.sessionID})`);
+            return;
+        }
+        logger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+        const shown = await this.tryShowPendingQuestion();
+        if (!shown) {
+            this.deferredQuestionShow.trigger();
+        }
     }
     handleQuestionReplied(properties) {
         const sessionId = this.state?.sessionId;
         if (properties.sessionID !== sessionId) {
             return;
         }
+        this.deferredQuestionShow.clear();
         this.onInteractiveUiStateChanged();
         // When a question is answered and the local queue has items, the model may
         // continue the same run without ever reaching the local-queue idle gate.
@@ -1973,7 +2159,7 @@ export class ThreadSessionRuntime {
             ? `/${next.command.name}`
             : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
         if (displayText.trim()) {
-            await sendThreadMessage(this.thread, `» **${next.username}:** ${displayText}`);
+            await sendThreadMessage(this.thread, `${QUEUE_PREFIX}**${next.username}:** ${displayText}`);
         }
         this.markQuestionQueueHandoffStarted(sessionId);
         await this.submitViaOpencodeQueue(next);
@@ -2011,7 +2197,7 @@ export class ThreadSessionRuntime {
             const secs = remainingSec % 60;
             return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
         })();
-        const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`;
+        const chunk = `${STATUS_PREFIX}${message} - retrying in ${duration} (attempt #${attempt})`;
         const retryResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (retryResult instanceof Error) {
@@ -2032,80 +2218,36 @@ export class ThreadSessionRuntime {
         if (info.id !== this.state?.sessionId) {
             return;
         }
-        if (this.lastSyncedThreadName === undefined) {
-            const persistedName = await this.loadLastSyncedThreadName().catch((e) => new Error('Failed to read persisted thread rename state', { cause: e }));
-            if (persistedName instanceof Error) {
-                logger.warn(`[TITLE] ${persistedName.message} for thread ${this.threadId}`);
-                return;
-            }
-            this.lastSyncedThreadName = persistedName;
+        const normalizedTitle = info.title.trim();
+        if (this.appliedOpencodeTitle === normalizedTitle) {
+            return;
         }
-        const renameDecision = deriveThreadRenameFromSessionUpdate({
+        const desiredName = deriveThreadNameFromSessionTitle({
             sessionTitle: info.title,
             currentName: this.thread.name,
-            lastSyncedName: this.lastSyncedThreadName,
         });
-        if (renameDecision.desiredName === null) {
-            if (renameDecision.nextSyncedName !== null &&
-                renameDecision.nextSyncedName !== this.lastSyncedThreadName) {
-                await this.persistLastSyncedThreadName(renameDecision.nextSyncedName);
-            }
-            return;
-        }
-        const { desiredName } = renameDecision;
-        const normalizedTitle = info.title.trim();
-        if (this.appliedOpencodeTitle === normalizedTitle) {
+        // Mark before setName so concurrent session.updated events don't stack
+        // renames. Keep the mark on failure — retry is almost always a rate limit.
+        this.appliedOpencodeTitle = normalizedTitle;
+        if (!desiredName) {
             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([
-            this.thread.setName(desiredName)
+        const renameResult = await raceDiscordRename({
+            rename: 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)`);
+            logger.warn(`[TITLE] setName timed out after ${DISCORD_THREAD_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;
         }
-        await this.persistLastSyncedThreadName(desiredName);
         logger.log(`[TITLE] Renamed thread ${this.threadId} to "${desiredName}" from OpenCode session title`);
     }
-    async loadLastSyncedThreadName() {
-        const db = await getDb();
-        const row = await db.query.thread_sessions.findFirst({
-            where: { thread_id: this.threadId },
-            columns: { last_synced_name: true },
-        });
-        return row?.last_synced_name ?? null;
-    }
-    async persistLastSyncedThreadName(name) {
-        this.lastSyncedThreadName = name;
-        const db = await getDb();
-        const result = await db.update(schema.thread_sessions)
-            .set({ last_synced_name: name })
-            .where(orm.eq(schema.thread_sessions.thread_id, this.threadId))
-            .catch((e) => new Error('Failed to persist thread rename state', {
-            cause: e,
-        }));
-        if (result instanceof Error) {
-            logger.warn(`[TITLE] ${result.message} for thread ${this.threadId}`);
-        }
-    }
     async handleTuiToast(properties) {
         if (properties.variant === 'warning') {
             return;
@@ -2121,7 +2263,7 @@ export class ThreadSessionRuntime {
         const titlePrefix = properties.title
             ? `${properties.title.trim()}: `
             : '';
-        const chunk = `⬦ ${properties.variant}: ${titlePrefix}${toastMessage}`;
+        const chunk = `${STATUS_PREFIX}${properties.variant}: ${titlePrefix}${toastMessage}`;
         const toastResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (toastResult instanceof Error) {
@@ -2138,6 +2280,7 @@ export class ThreadSessionRuntime {
      * fields that the local-queue path provides.
      */
     async submitViaOpencodeQueue(input) {
+        await this.supersedePendingSleep(input);
         let skippedBySessionGuard = false;
         await this.dispatchAction(async () => {
             if (input.expectedSessionId &&
@@ -2197,6 +2340,17 @@ export class ThreadSessionRuntime {
                 await setSessionAgent(session.id, input.agent);
                 await clearSessionModel(session.id);
             }
+            if (input.model) {
+                const validatedModel = await validateModelId({
+                    model: input.model,
+                    getClient,
+                    directory: this.sdkDirectory,
+                });
+                if (validatedModel instanceof Error) {
+                    await cleanupOnError(`Failed to resolve model: ${validatedModel.message}`);
+                    return;
+                }
+            }
             await ensureSessionPreferencesSnapshot({
                 sessionId: session.id,
                 channelId,
@@ -2220,14 +2374,23 @@ export class ThreadSessionRuntime {
             }
             const resolvedAgent = agentResult.agentPreference;
             const availableAgents = agentResult.agents;
+            releaseCurrentThreadIngress();
+            await this.persistIngressVariant({
+                sessionId: session.id,
+                channelId,
+                appId: resolvedAppId,
+                agentPreference: resolvedAgent,
+                getClient,
+                variant: input.variant,
+            });
             const [modelResult, preferredVariant] = await Promise.all([
                 (async () => {
                     if (input.model) {
-                        const [providerID, ...modelParts] = input.model.split('/');
-                        const modelID = modelParts.join('/');
-                        if (providerID && modelID) {
-                            return { providerID, modelID };
-                        }
+                        return validateModelId({
+                            model: input.model,
+                            getClient,
+                            directory: this.sdkDirectory,
+                        });
                     }
                     const modelInfo = await getCurrentModelInfo({
                         sessionId: session.id,
@@ -2333,6 +2496,7 @@ export class ThreadSessionRuntime {
                 userId: input.userId,
                 sourceMessageId: input.sourceMessageId,
                 sourceThreadId: input.sourceThreadId,
+                threadName: this.thread.name || undefined,
                 repliedMessage: input.repliedMessage,
                 worktree,
                 currentAgent: resolvedAgent,
@@ -2357,6 +2521,7 @@ export class ThreadSessionRuntime {
                     username: this.state?.sessionUsername || input.username,
                     userId: this.state?.sessionUserId || input.userId,
                     parentSessionId: this.state?.parentSessionId || input.parentSessionId,
+                    scheduledTask: await this.resolveScheduledTaskContext(session.id),
                 }),
                 ...(resolvedAgent ? { agent: resolvedAgent } : {}),
                 ...(modelField ? { model: modelField } : {}),
@@ -2407,7 +2572,26 @@ export class ThreadSessionRuntime {
      * Enqueue in kimaki's local per-thread queue.
      * Used for explicit queue workflows (/queue, queueMessage=true).
      */
+    /**
+     * A new turn supersedes a pending sleep.
+     *
+     * Called from the two terminal routers rather than from the top of
+     * enqueueIncoming: arrival order is only fixed once a message reaches the
+     * preprocessChain link, so awaiting anything before that lets two rapid
+     * messages swap places. By here the order is already committed.
+     *
+     * Awaited rather than fire-and-forget so it cannot race the task runner and
+     * let a stale wake land after the user took the conversation back.
+     */
+    async supersedePendingSleep(input) {
+        if (input.isSleepWake)
+            return;
+        await cancelSessionSleepForThread({ threadId: this.threadId }).catch((error) => {
+            logger.error('[SLEEP] failed to cancel pending sleep:', error);
+        });
+    }
     async enqueueViaLocalQueue(input) {
+        await this.supersedePendingSleep(input);
         const queueId = crypto.randomBytes(8).toString('hex');
         const queuedMessage = {
             queueId,
@@ -2419,6 +2603,7 @@ export class ThreadSessionRuntime {
             command: input.command,
             agent: input.agent,
             model: input.model,
+            variant: input.variant,
             permissions: input.permissions,
             injectionGuardPatterns: input.injectionGuardPatterns,
             parentSessionId: input.parentSessionId,
@@ -2463,8 +2648,12 @@ export class ThreadSessionRuntime {
      * discord-bot.ts.
      */
     async enqueueIncoming(input) {
+        await waitForCurrentThreadIngress();
         threadState.setSessionUsername(this.threadId, input.username);
-        threadState.setSessionUserId(this.threadId, input.userId);
+        const botUserId = this.thread.client.user?.id;
+        if (input.userId && input.userId !== botUserId) {
+            threadState.setSessionUserId(this.threadId, input.userId);
+        }
         await this.ensureParentSessionId({
             parentSessionId: input.parentSessionId,
         });
@@ -2623,6 +2812,10 @@ export class ThreadSessionRuntime {
         const sessionIsBusy = this.isMainSessionBusy();
         logger.log(`[ABORT] id=${abortId} reason=${reason} threadId=${this.threadId} sessionId=${sessionId || 'none'} queueLength=${state.queueItems.length} ${this.formatRunStateForLog()} sessionBusy=${sessionIsBusy}`);
         this.stopTyping();
+        this.deferredQuestionShow.clear();
+        // The aborted run owns the question request, so the dropdown dies with it.
+        // Questions have no TTL, so this is the only thing that clears them here.
+        void cancelPendingQuestion(this.threadId);
         const apiAbortPromise = sessionId
             ? this.abortSessionViaApi({ abortId, reason, sessionId })
             : undefined;
@@ -2680,13 +2873,6 @@ export class ThreadSessionRuntime {
     getQueueLength() {
         return this.state?.queueItems.length ?? 0;
     }
-    /** NOTIFY_MESSAGE_FLAGS unless queue has a next item, then SILENT.
-     * Permissions should NOT use this — they always notify. */
-    getNotifyFlags() {
-        return this.getQueueLength() > 0
-            ? SILENT_MESSAGE_FLAGS
-            : NOTIFY_MESSAGE_FLAGS;
-    }
     /** Clear all queued messages. Returns the removed items. */
     clearQueue() {
         return threadState.clearQueueItems(this.threadId);
@@ -2763,7 +2949,7 @@ export class ThreadSessionRuntime {
                 ? `/${next.command.name}`
                 : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
             if (displayText.trim()) {
-                await sendThreadMessage(this.thread, `» **${next.username}:** ${displayText}`);
+                await sendThreadMessage(this.thread, `${QUEUE_PREFIX}**${next.username}:** ${displayText}`);
             }
         }
         // Start dispatch (detached — does not block the action queue).
@@ -2794,6 +2980,7 @@ export class ThreadSessionRuntime {
     async dispatchPrompt(input) {
         this.lastDisplayedContextPercentage = 0;
         this.lastRateLimitDisplayTime = 0;
+        this.lastSentPartKind = undefined;
         // ── Ensure session ────────────────────────────────────────
         const sessionResult = await this.ensureSession({
             prompt: input.prompt,
@@ -2834,6 +3021,19 @@ export class ThreadSessionRuntime {
             await setSessionAgent(session.id, input.agent);
             await clearSessionModel(session.id);
         }
+        if (input.model) {
+            const validatedModel = await validateModelId({
+                model: input.model,
+                getClient,
+                directory: this.sdkDirectory,
+            });
+            if (validatedModel instanceof Error) {
+                this.stopTyping();
+                await sendThreadMessage(this.thread, `Failed to resolve model: ${validatedModel.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
+                await this.tryDrainQueue({ showIndicator: true });
+                return;
+            }
+        }
         await ensureSessionPreferencesSnapshot({
             sessionId: session.id,
             channelId,
@@ -2860,14 +3060,22 @@ export class ThreadSessionRuntime {
         }
         const earlyAgentPreference = earlyAgentResult.agentPreference;
         const earlyAvailableAgents = earlyAgentResult.agents;
+        await this.persistIngressVariant({
+            sessionId: session.id,
+            channelId,
+            appId: resolvedAppId,
+            agentPreference: earlyAgentPreference,
+            getClient,
+            variant: input.variant,
+        });
         const [earlyModelResult, preferredVariant] = await Promise.all([
             (async () => {
                 if (input.model) {
-                    const [providerID, ...modelParts] = input.model.split('/');
-                    const modelID = modelParts.join('/');
-                    if (providerID && modelID) {
-                        return { providerID, modelID };
-                    }
+                    return validateModelId({
+                        model: input.model,
+                        getClient,
+                        directory: this.sdkDirectory,
+                    });
                 }
                 const modelInfo = await getCurrentModelInfo({
                     sessionId: session.id,
@@ -2980,6 +3188,7 @@ export class ThreadSessionRuntime {
             userId: input.userId,
             sourceMessageId: input.sourceMessageId,
             sourceThreadId: input.sourceThreadId,
+            threadName: this.thread.name || undefined,
             repliedMessage: input.repliedMessage,
             worktree,
             currentAgent: earlyAgentPreference,
@@ -3023,6 +3232,7 @@ export class ThreadSessionRuntime {
                 userId: input.userId,
                 sourceMessageId: input.sourceMessageId,
                 sourceThreadId: input.sourceThreadId,
+                threadName: this.thread.name || undefined,
                 repliedMessage: input.repliedMessage,
             });
             // OpenCode's session.command API has no `system` field. Persist the
@@ -3040,6 +3250,7 @@ export class ThreadSessionRuntime {
                 username: this.state?.sessionUsername || input.username,
                 userId: this.state?.sessionUserId || input.userId,
                 parentSessionId: this.state?.parentSessionId || input.parentSessionId,
+                scheduledTask: await this.resolveScheduledTaskContext(session.id),
             });
             const systemWriteResult = await writeSessionSystemPrompt({
                 sessionId: session.id,
@@ -3141,6 +3352,7 @@ export class ThreadSessionRuntime {
                 username: this.state?.sessionUsername || input.username,
                 userId: this.state?.sessionUserId || input.userId,
                 parentSessionId: this.state?.parentSessionId || input.parentSessionId,
+                scheduledTask: await this.resolveScheduledTaskContext(session.id),
             }),
             model: earlyModelParam,
             agent: earlyAgentPreference,
@@ -3176,6 +3388,41 @@ export class ThreadSessionRuntime {
     }
     // ── Session Ensure ──────────────────────────────────────────
     // Creates or reuses the OpenCode session for this thread.
+    /** Cached per-session scheduled task info for the system message. */
+    scheduledTaskContextCache = new Map();
+    /**
+     * Resolve the scheduled-task context for the system message, once per
+     * session. The row in session_start_sources is immutable, so caching the
+     * result keeps the system prompt identical across turns (prompt-cache safe).
+     * One-shot 'at' tasks are deleted after their run, so only schedule_kind
+     * survives for them.
+     */
+    async resolveScheduledTaskContext(sessionId) {
+        const cache = this.scheduledTaskContextCache;
+        if (cache.has(sessionId)) {
+            return cache.get(sessionId);
+        }
+        const context = await (async () => {
+            const source = await getSessionStartSource({ sessionId });
+            if (!source) {
+                return undefined;
+            }
+            const task = source.scheduled_task_id
+                ? await getScheduledTask(source.scheduled_task_id)
+                : null;
+            return {
+                taskId: source.scheduled_task_id ?? undefined,
+                scheduleKind: source.schedule_kind,
+                cronExpr: task?.cron_expr,
+                timezone: task?.timezone,
+            };
+        })().catch((error) => {
+            logger.warn(`[SCHEDULED TASK CONTEXT] Failed to resolve for session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        });
+        cache.set(sessionId, context);
+        return context;
+    }
     async updateExistingSessionPermissions({ client, sessionId, createdNewSession, permissions, }) {
         if (createdNewSession) {
             return null;
@@ -3232,7 +3479,8 @@ export class ThreadSessionRuntime {
                 session = sessionResponse.data;
             }
             else {
-                logger.warn(`[ENSURE SESSION] session.get returned no data for ${sessionId}, response=${JSON.stringify(sessionResponse)}`);
+                const sdkMessage = extractSdkErrorMessage(sessionResponse.error);
+                logger.warn(`[ENSURE SESSION] session.get returned no data for ${sessionId}: ${sdkMessage}, response=${JSON.stringify(sessionResponse)}`);
             }
         }
         if (!session) {
@@ -3256,31 +3504,31 @@ export class ThreadSessionRuntime {
                 logger.error(`[ENSURE SESSION] session.create failed: ${createResult.message}`);
                 return new Error(`Failed to create session: ${createResult.message}, threadId=${this.thread.id}, directory=${this.sdkDirectory}`, { cause: createResult });
             }
-            session = createResult.data;
-            if (!session) {
-                logger.warn(`[ENSURE SESSION] session.create returned no data, threadId=${this.thread.id}, directory=${this.sdkDirectory}, response=${JSON.stringify(createResult)}`);
+            if (createResult.error || !createResult.data) {
+                const errorMessage = extractSdkErrorMessage(createResult.error);
+                logger.error(`[ENSURE SESSION] session.create failed: ${errorMessage}, threadId=${this.thread.id}, directory=${this.sdkDirectory}, response=${JSON.stringify(createResult)}`);
+                return new Error(`Failed to create session: ${errorMessage}, threadId=${this.thread.id}, directory=${this.sdkDirectory}`);
             }
+            session = createResult.data;
             // Insert DB row immediately so the external-sync poller sees
             // source='kimaki' before the next poll tick and skips this session.
             // The upsert at the end of ensureSession is kept for the reuse path.
-            if (session) {
-                await setThreadSession(this.thread.id, session.id);
-                if (injectionGuardPatterns?.length) {
-                    writeInjectionGuardConfig({
-                        sessionId: session.id,
-                        scanPatterns: injectionGuardPatterns,
-                    });
-                }
-                const worktree = await getThreadWorktreeOrWorkspace(this.thread.id);
-                trackEvent('session_created', {
-                    has_worktree: Boolean(worktree),
-                    source: sessionStartScheduleKind ? 'scheduled' : 'discord',
+            await setThreadSession(this.thread.id, session.id);
+            if (injectionGuardPatterns?.length) {
+                writeInjectionGuardConfig({
+                    sessionId: session.id,
+                    scanPatterns: injectionGuardPatterns,
                 });
             }
+            const worktree = await getThreadWorktreeOrWorkspace(this.thread.id);
+            trackEvent('session_created', {
+                has_worktree: Boolean(worktree),
+                source: sessionStartScheduleKind ? 'scheduled' : 'discord',
+            });
             createdNewSession = true;
         }
         if (!session) {
-            return new Error(`Failed to create or get session: threadId=${this.thread.id}, channelId=${this.channelId}, directory=${directory}, sdkDirectory=${this.sdkDirectory}, existingSessionId=${sessionId ?? 'none'}, createdNewSession=${createdNewSession}. session.create returned empty data, check the [ENSURE SESSION] warn log above for the full response body`);
+            return new Error(`Failed to create or get session: threadId=${this.thread.id}, channelId=${this.channelId}, directory=${directory}, sdkDirectory=${this.sdkDirectory}, existingSessionId=${sessionId ?? 'none'}, createdNewSession=${createdNewSession}`);
         }
         // Store session in DB and thread state
         await setThreadSession(this.thread.id, session.id);
@@ -3326,7 +3574,7 @@ export class ThreadSessionRuntime {
         const agentLabel = agent && agent.toLowerCase() !== 'build'
             ? ` ⋅ ${agent}`
             : '';
-        const result = await sendThreadMessage(this.thread, `*using ${modelLabel}${agentLabel}*`, { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+        const result = await sendThreadMessage(this.thread, asDiscordQuote(`*using ${modelLabel}${agentLabel}*`), { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (result instanceof Error) {
             logger.warn(`[SESSION INFO] Failed to send model info: ${result.message}`);
         }
@@ -3350,7 +3598,6 @@ export class ThreadSessionRuntime {
         const sessionDuration = elapsedMs < 1000
             ? '<1s'
             : prettyMilliseconds(elapsedMs, { secondsDecimalDigits: 0 });
-        const modelInfo = runInfo.model ? ` ⋅ ${runInfo.model}` : '';
         const agentInfo = runInfo.agent && runInfo.agent.toLowerCase() !== 'build'
             ? ` ⋅ **${runInfo.agent}**`
             : '';
@@ -3364,7 +3611,7 @@ export class ThreadSessionRuntime {
             }).catch((e) => new FilesystemOperationError({ operation: 'gitBranch', cause: e })),
             (async () => {
                 if (!client || !sessionId) {
-                    return;
+                    return [];
                 }
                 let tokensUsed = runInfo.tokensUsed;
                 // Fetch final token count from API
@@ -3401,9 +3648,12 @@ export class ThreadSessionRuntime {
                         providerID: runInfo.providerID,
                     })
                     : undefined;
+                const providers = providersResult && !(providersResult instanceof Error)
+                    ? providersResult.data?.all ?? []
+                    : [];
                 let contextLimit = fallbackLimit;
-                if (providersResult && !(providersResult instanceof Error)) {
-                    const provider = providersResult.data?.all?.find((p) => {
+                if (providers.length > 0) {
+                    const provider = providers.find((p) => {
                         return p.id === runInfo.providerID;
                     });
                     const model = provider?.models?.[runInfo.model || ''];
@@ -3413,12 +3663,26 @@ export class ThreadSessionRuntime {
                     const percentage = Math.round((tokensUsed / contextLimit) * 100);
                     contextInfo = ` ⋅ ${percentage}%`;
                 }
+                return providers;
             })().catch((e) => new OpenCodeSdkError({ operation: 'resolveModelPreference', cause: e })),
         ]);
         const branchName = branchResult instanceof Error ? '' : branchResult.stdout.trim();
         if (contextResult instanceof Error) {
             logger.error('Failed to fetch provider info for context percentage:', contextResult);
         }
+        const providers = contextResult instanceof Error ? [] : (contextResult ?? []);
+        const modelLabel = runInfo.model
+            ? displayedModelLabel({
+                modelID: runInfo.model,
+                name: await resolveDisplayedModelName({
+                    providers,
+                    providerID: runInfo.providerID,
+                    modelID: runInfo.model,
+                    sessionID: sessionId,
+                }),
+            })
+            : undefined;
+        const modelInfo = modelLabel ? ` ⋅ ${modelLabel}` : '';
         const truncate = (s, max) => {
             return s.length > max ? s.slice(0, max - 1) + '\u2026' : s;
         };
@@ -3427,12 +3691,22 @@ export class ThreadSessionRuntime {
         const projectInfo = truncatedBranch
             ? `${truncatedFolder} ⋅ ${truncatedBranch} ⋅ `
             : `${truncatedFolder} ⋅ `;
-        const footerText = `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*`;
+        const hasQueuedMessage = this.getQueueLength() > 0;
+        const didUseSleepTool = sessionId
+            ? didLatestUserTurnUseSleepTool({ events: this.eventBuffer, sessionId })
+            : false;
+        const shouldNotifyUser = !hasQueuedMessage && !didUseSleepTool;
+        const mentionUserId = store.getState().footerMentionsEnabled && shouldNotifyUser
+            ? await resolveThreadFooterMentionUserId({
+                sessionUserId: this.state?.sessionUserId,
+                thread: this.thread,
+            })
+            : undefined;
+        const mention = mentionUserId ? ` <@${mentionUserId}>` : '';
+        const footerText = asDiscordQuote(`*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`);
         this.stopTyping();
-        // Skip notification if there's a queued message next — the user only
-        // needs to be notified when the entire queue finishes.
         await sendThreadMessage(this.thread, footerText, {
-            flags: this.getNotifyFlags(),
+            flags: shouldNotifyUser ? NOTIFY_MESSAGE_FLAGS : SILENT_MESSAGE_FLAGS,
         });
         logger.log(`DURATION: Session completed in ${sessionDuration}, model ${runInfo.model}, tokens ${runInfo.tokensUsed}`);
     }
@@ -3442,6 +3716,7 @@ export class ThreadSessionRuntime {
         this.modelContextLimitKey = undefined;
         this.lastDisplayedContextPercentage = 0;
         this.lastRateLimitDisplayTime = 0;
+        this.lastSentPartKind = undefined;
     }
     // ── Retry Last User Prompt (for model-change flow) ──────────
     /**