kimaki 0.26.0 → 0.28.0

package/src/session-handler/thread-session-runtime.ts

@@ -7,6 +7,7 @@
 // run internals.
 
 import crypto from 'node:crypto'
+import { AsyncLocalStorage } from 'node:async_hooks'
 import { ChannelType, type ThreadChannel } from 'discord.js'
 import type {
   Event as OpenCodeEvent,
@@ -38,11 +39,27 @@ import {
 import { createLogger, LogPrefix } from '../logger.js'
 import {
   sendThreadMessage,
+  sendSessionPartMessage,
   SILENT_MESSAGE_FLAGS,
   NOTIFY_MESSAGE_FLAGS,
+  raceDiscordRename,
+  DISCORD_THREAD_RENAME_TIMEOUT_MS,
+  resolveThreadFooterMentionUserId,
 } from '../discord-utils.js'
-import type { DiscordFileAttachment } from '../message-formatting.js'
-import { formatPart, formatTaskToolTitle } from '../message-formatting.js'
+import type { DiscordFileAttachment, SessionPartKind } from '../message-formatting.js'
+import {
+  asDiscordQuote,
+  formatPart,
+  formatTaskToolTitle,
+  planAssistantTurnFlush,
+  QUEUE_PREFIX,
+  sessionPartKind,
+  shouldLeadWithBlankLine,
+  shouldQuoteIntermediateTextPart,
+  STATUS_PREFIX,
+  WORKTREE_PREFIX,
+  type AssistantTurnFlushMode,
+} from '../message-formatting.js'
 import {
   getChannelVerbosity,
   getPartMessageIds,
@@ -54,14 +71,18 @@ import {
   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'
@@ -75,6 +96,7 @@ import {
   showAskUserQuestionDropdowns,
   pendingQuestionContexts,
   cancelPendingQuestion,
+  findPendingQuestionContextForRequest,
 } from '../commands/ask-question.js'
 import {
   showActionButtons,
@@ -90,6 +112,11 @@ import {
   getCurrentModelInfo,
   ensureSessionPreferencesSnapshot,
 } from '../commands/model.js'
+import {
+  displayedModelLabel,
+  resolveDisplayedModelName,
+  validateModelId,
+} from './model-utils.js'
 import {
   getOpencodePromptContext,
   getOpencodeSystemMessage,
@@ -97,8 +124,10 @@ import {
   type AgentInfo,
   type RepliedMessageContext,
   type WorktreeInfo,
+  type ScheduledTaskSystemContext,
 } from '../system-message.js'
 import { getDataDir } from '../config.js'
+import { store } from '../store.js'
 import {
   trackEvent,
   type AnalyticsIngressMode,
@@ -114,7 +143,9 @@ import {
 } from './opencode-session-event-log.js'
 import {
   doesLatestUserTurnHaveNaturalCompletion,
+  didLatestUserTurnUseSleepTool,
   didQuestionQueueHandoffSinceLatestQuestionAsked,
+  deriveLatestUnansweredQuestion,
   getAssistantMessageIdsForLatestUserTurn,
   getCurrentTurnStartTime,
   isSessionBusy,
@@ -122,10 +153,14 @@ import {
   getIdleTokenUsageDelta,
   getDerivedSubtaskIndex,
   getDerivedSubtaskAgentType,
+  getTokenUsageSessionIdsForIdle,
+  isDerivedChildSession,
   getLatestAssistantMessageIdForLatestUserTurn,
+  getAssistantMessageKind,
   hasAssistantMessageCompletedBefore,
   isAssistantMessageInLatestUserTurn,
   isAssistantMessageNaturalCompletion,
+  shouldBufferSessionEvent,
   type EventBufferEvent,
   type EventBufferEntry,
 } from './event-stream-state.js'
@@ -188,6 +223,63 @@ const shouldLogSessionEvents =
 
 const runtimes = new Map<string, ThreadSessionRuntime>()
 
+// 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<string, Promise<void>>()
+const threadIngressSlotAls = new AsyncLocalStorage<ThreadIngressSlot | undefined>()
+
+export type ThreadIngressSlot = {
+  wait: Promise<void>
+  release: () => void
+}
+
+export function reserveThreadIngress(threadId: string): ThreadIngressSlot {
+  const previous = threadIngressChains.get(threadId) ?? Promise.resolve()
+  let released = false
+  let releaseHeld = () => {}
+  const held = new Promise<void>((resolve) => {
+    releaseHeld = resolve
+  })
+  threadIngressChains.set(
+    threadId,
+    previous.then(() => held),
+  )
+  return {
+    wait: previous,
+    release: () => {
+      if (released) {
+        return
+      }
+      released = true
+      releaseHeld()
+    },
+  }
+}
+
+export async function runInThreadIngressSlot<T>(
+  slot: ThreadIngressSlot | undefined,
+  run: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await threadIngressSlotAls.run(slot, run)
+  } finally {
+    slot?.release()
+  }
+}
+
+export async function waitForCurrentThreadIngress(): Promise<void> {
+  const slot = threadIngressSlotAls.getStore()
+  if (!slot) {
+    return
+  }
+  await slot.wait
+}
+
+export function releaseCurrentThreadIngress(): void {
+  threadIngressSlotAls.getStore()?.release()
+}
+
 export function getRuntime(
   threadId: string,
 ): ThreadSessionRuntime | undefined {
@@ -201,6 +293,7 @@ export type RuntimeOptions = {
   sdkDirectory: string
   channelId?: string
   appId?: string
+  sessionId?: string
 }
 
 export function getOrCreateRuntime(
@@ -213,9 +306,15 @@ export function getOrCreateRuntime(
         `[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
@@ -229,6 +328,7 @@ export function disposeRuntime(threadId: string): void {
   runtime.dispose()
   runtimes.delete(threadId)
   threadState.removeThread(threadId) // remove from global store
+  threadIngressChains.delete(threadId)
 }
 
 export function disposeRuntimesForDirectory({
@@ -249,6 +349,7 @@ export function disposeRuntimesForDirectory({
     runtime.dispose()
     runtimes.delete(threadId)
     threadState.removeThread(threadId)
+    threadIngressChains.delete(threadId)
     count++
   }
   return count
@@ -279,6 +380,7 @@ export function disposeInactiveRuntimes({
     runtime.dispose()
     runtimes.delete(threadId)
     threadState.removeThread(threadId)
+    threadIngressChains.delete(threadId)
     disposedThreadIds.push(threadId)
     disposedDirectories.add(runtime.projectDirectory)
   }
@@ -419,16 +521,20 @@ export function isEssentialToolPart(part: Part): boolean {
 // ── 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: string[] = [
-  WORKTREE_THREAD_PREFIX,
+  WORKTREE_PREFIX,
   'btw: ',
   'Fork: ',
 ]
 
+function stripPreservedThreadPrefix(name: string) {
+  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,
@@ -436,18 +542,24 @@ function getThreadNameCandidateFromSessionTitle({
   sessionTitle: string | undefined | null
   currentName: string
 }) {
-  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({
@@ -470,45 +582,6 @@ export function deriveThreadNameFromSessionTitle({
   return candidate
 }
 
-export function deriveThreadRenameFromSessionUpdate({
-  sessionTitle,
-  currentName,
-  lastSyncedName,
-}: {
-  sessionTitle: string | undefined | null
-  currentName: string
-  lastSyncedName: string | null
-}) {
-  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,
-  }
-}
-
 // ── Ingress input type ───────────────────────────────────────────
 
 export type EnqueueResult = {
@@ -563,6 +636,11 @@ export type IngressInput = {
   // First-dispatch-only overrides (used when creating a new session)
   agent?: string
   model?: string
+  /**
+   * Thinking-level variant from `/xxx-agent variant:`. Applied after
+   * agent/model snapshot so it wins over cascade for this turn.
+   */
+  variant?: string
   /**
    * Raw permission rule strings from --permission flag ("tool:action" or
    * "tool:pattern:action"). Parsed into PermissionRuleset entries by
@@ -588,6 +666,12 @@ export type IngressInput = {
    * (e.g. user-to-user replies in a thread).
    */
   noReply?: boolean
+  /**
+   * True only for the wake prompt posted by the kimaki_sleep task runner.
+   * Every other ingress cancels a pending sleep; this one must not, because it
+   * is delivering that sleep rather than superseding it.
+   */
+  isSleepWake?: boolean
   /**
    * Product-analytics turn source. Defaults to discord. Set retry/cli/scheduled
    * at the ingress site so DAU queries can exclude non-user activity.
@@ -694,32 +778,28 @@ export class ThreadSessionRuntime {
   // message and showing multiple back-to-back POSTs is wasteful.
   private typingKeepaliveTimeout: ReturnType<typeof setTimeout> | null = null
   private readonly typingRepulseDebounce: ReturnType<typeof createDebouncedTimeout>
+  private readonly deferredQuestionShow: ReturnType<typeof createDebouncedTimeout>
 
   private static TYPING_REPULSE_DEBOUNCE_MS = 500
+  private static DEFERRED_QUESTION_SHOW_MS = 1000
 
   // Notification throttles for retry/context notices.
   private lastDisplayedContextPercentage = 0
   private 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.
   private appliedOpencodeTitle: string | undefined
 
-  // Last Discord thread name known to match the OpenCode title. Persisted so a
-  // user rename is still respected after Kimaki restarts.
-  private lastSyncedThreadName: string | null | undefined
-
   // Part output buffering (write-side cache, not domain state)
   private partBuffer = new Map<string, Map<string, Part>>()
+  private shownQuestionRequestIds = new Set<string>()
 
   // Derivable cache (perf optimization for provider.list API call)
   private modelContextLimit: number | undefined
   private modelContextLimitKey: string | undefined
   private lastPromptWorktreeKey: string | null | undefined
+  private lastSentPartKind: SessionPartKind | undefined
 
   // Bounded buffer of recent SSE events with timestamps.
   // Used by waitForEvent() to scan for specific events that arrived
@@ -792,6 +872,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 })
+        })
+      },
+    })
   }
 
   private consumeWorktreePromptChange(
@@ -989,6 +1080,52 @@ export class ThreadSessionRuntime {
     return isSessionBusy({ events: this.eventBuffer, sessionId })
   }
 
+  private async persistIngressVariant({
+    sessionId,
+    channelId,
+    appId,
+    agentPreference,
+    getClient,
+    variant,
+  }: {
+    sessionId: string
+    channelId?: string
+    appId?: string
+    agentPreference?: string
+    getClient: Awaited<ReturnType<typeof initializeOpencodeForDirectory>>
+    variant?: string
+  }) {
+    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,
+    })
+  }
+
   private getAssistantMessageIdsForCurrentTurn({
     sessionId,
     upToIndex,
@@ -1026,21 +1163,25 @@ 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,
     })
@@ -1053,6 +1194,7 @@ 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
@@ -1060,6 +1202,7 @@ export class ThreadSessionRuntime {
     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
@@ -1170,7 +1313,6 @@ export class ThreadSessionRuntime {
           })
         : []
       delete info.system
-      delete info.summary
       delete info.tools
       delete info.parts
       if (partsSummary.length > 0) {
@@ -1353,10 +1495,14 @@ export class ThreadSessionRuntime {
   // Subtask sessions also bypass — they're tracked in subtaskSessions.
 
   private async handleEvent(event: OpenCodeEvent): Promise<void> {
-    // 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
     }
 
@@ -1371,8 +1517,6 @@ export class ThreadSessionRuntime {
       this.appendEventToBuffer(event)
     }
 
-    const sessionId = this.state?.sessionId
-
     const eventSessionId = getOpencodeEventSessionId(event)
     const toastSessionId = event.type === 'tui.toast.show'
       ? extractToastSessionId({ message: event.properties.message })
@@ -1712,12 +1856,12 @@ export class ThreadSessionRuntime {
     })
   }
 
-  private shouldSendPart({
+  private shouldSendPlannedPart({
     part,
-    force,
+    mode,
   }: {
     part: Part
-    force: boolean
+    mode: AssistantTurnFlushMode
   }): boolean {
     if (part.type === 'step-start' || part.type === 'step-finish') {
       return false
@@ -1725,21 +1869,72 @@ export class ThreadSessionRuntime {
     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
   }
 
+  private getCurrentTurnParts(): Part[] {
+    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))
+  }
+
+  private async flushCurrentTurnParts({
+    mode,
+    throughPartId,
+    skipPartId,
+    repulseTyping = true,
+  }: {
+    mode: AssistantTurnFlushMode
+    throughPartId?: string
+    skipPartId?: string
+    repulseTyping?: boolean
+  }): Promise<void> {
+    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,
+      })
+    }
+  }
+
   private async sendPartMessage({
     part,
     repulseTyping = true,
+    quoteText = false,
   }: {
     part: Part
     repulseTyping?: boolean
+    quoteText?: boolean
   }): Promise<void> {
     const verbosity = await this.getVerbosity()
     if (verbosity === 'text_only' && part.type !== 'text') {
@@ -1751,7 +1946,14 @@ export class ThreadSessionRuntime {
       }
     }
 
-    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
     }
@@ -1766,7 +1968,13 @@ export class ThreadSessionRuntime {
       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) => {
@@ -1780,63 +1988,15 @@ export class ThreadSessionRuntime {
       )
       return
     }
+    this.lastSentPartKind = kind
     await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id })
     if (repulseTyping) {
       this.requestTypingRepulse()
     }
   }
 
-  private async flushBufferedParts({
-    messageID,
-    force,
-    skipPartId,
-    repulseTyping = true,
-  }: {
-    messageID: string | undefined
-    force: boolean
-    skipPartId?: string
-    repulseTyping?: boolean
-  }): Promise<void> {
-    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 })
-    }
-  }
-
-  private async flushBufferedPartsForMessages({
-    messageIDs,
-    force,
-    skipPartId,
-    repulseTyping = true,
-  }: {
-    messageIDs: ReadonlyArray<string>
-    force: boolean
-    skipPartId?: string
-    repulseTyping?: boolean
-  }): Promise<void> {
-    const uniqueMessageIDs = [...new Set(messageIDs)]
-    for (const messageID of uniqueMessageIDs) {
-      await this.flushBufferedParts({
-        messageID,
-        force,
-        skipPartId,
-        repulseTyping,
-      })
-    }
-  }
-
   private async showInteractiveUi({
     skipPartId,
-    flushMessageId,
     show,
   }: {
     skipPartId?: string
@@ -1844,32 +2004,11 @@ export class ThreadSessionRuntime {
     show: () => Promise<void>
   }): Promise<void> {
     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()
   }
 
@@ -1920,10 +2059,21 @@ export class ThreadSessionRuntime {
   private async handleMessageUpdated(msg: OpenCodeMessage): Promise<void> {
     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) {
@@ -1934,6 +2084,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
     }
@@ -1970,9 +2121,8 @@ export class ThreadSessionRuntime {
       })
     }
 
-    await this.flushBufferedParts({
-      messageID: msg.id,
-      force: false,
+    await this.flushCurrentTurnParts({
+      mode: 'progress',
     })
 
     const wasAlreadyCompleted = hasAssistantMessageCompletedBefore({
@@ -2031,7 +2181,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) {
@@ -2040,8 +2190,24 @@ export class ThreadSessionRuntime {
   }
 
   private async handlePartUpdated(part: Part): Promise<void> {
-    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)
@@ -2066,48 +2232,55 @@ export class ThreadSessionRuntime {
       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
     }
 
@@ -2219,7 +2392,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,
@@ -2232,20 +2405,19 @@ 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()
     }
   }
@@ -2283,7 +2455,13 @@ 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(
@@ -2292,6 +2470,7 @@ export class ThreadSessionRuntime {
       )
       return
     }
+    this.lastSentPartKind = kind
     threadState.updateThread(this.threadId, (t) => {
       const newIds = new Set(t.sentPartIds)
       newIds.add(part.id)
@@ -2301,21 +2480,16 @@ export class ThreadSessionRuntime {
     this.requestTypingRepulse()
   }
 
-  private trackIdleTokenUsage(idleSessionId: string): void {
-    let idleEventIndex: number | undefined
-    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
-    }
+  private trackIdleTokenUsage({
+    sessionId,
+    idleEventIndex,
+  }: {
+    sessionId: string
+    idleEventIndex: number
+  }): void {
     const usage = getIdleTokenUsageDelta({
       events: this.eventBuffer,
-      sessionId: idleSessionId,
+      sessionId,
       idleEventIndex,
     })
     if (!usage) {
@@ -2331,7 +2505,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
@@ -2342,8 +2516,37 @@ export class ThreadSessionRuntime {
     trackEvent('tokens_used', properties)
   }
 
+  private trackIdleTokenUsageForSessionTree(idleSessionId: string): void {
+    let idleEventIndex: number | undefined
+    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,
+      })
+    }
+  }
+
   private async handleSessionIdle(idleSessionId: string): Promise<void> {
-    this.trackIdleTokenUsage(idleSessionId)
+    this.trackIdleTokenUsageForSessionTree(idleSessionId)
 
     const sessionId = this.state?.sessionId
 
@@ -2400,9 +2603,8 @@ export class ThreadSessionRuntime {
       return
     }
 
-    await this.flushBufferedPartsForMessages({
-      messageIDs: assistantMessageIds,
-      force: true,
+    await this.flushCurrentTurnParts({
+      mode: 'final',
       repulseTyping: false,
     })
 
@@ -2629,41 +2831,89 @@ export class ThreadSessionRuntime {
     this.onInteractiveUiStateChanged()
   }
 
-  private async handleQuestionAsked(
-    questionRequest: QuestionRequest,
-  ): Promise<void> {
+  private hasUnfinishedTextPart(messageID: string): boolean {
+    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.
+  private async tryShowPendingQuestion({
+    ignoreUnfinishedText = false,
+  } = {}): Promise<boolean> {
     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
+  }
+
+  private async handleQuestionAsked(
+    questionRequest: QuestionRequest,
+  ): Promise<void> {
+    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()
+    }
   }
 
   private handleQuestionReplied(properties: { sessionID: string }): void {
@@ -2671,6 +2921,7 @@ export class ThreadSessionRuntime {
     if (properties.sessionID !== sessionId) {
       return
     }
+    this.deferredQuestionShow.clear()
     this.onInteractiveUiStateChanged()
 
     // When a question is answered and the local queue has items, the model may
@@ -2752,7 +3003,7 @@ export class ThreadSessionRuntime {
     if (displayText.trim()) {
       await sendThreadMessage(
         this.thread,
-        `» **${next.username}:** ${displayText}`,
+        `${QUEUE_PREFIX}**${next.username}:** ${displayText}`,
       )
     }
 
@@ -2805,7 +3056,7 @@ export class ThreadSessionRuntime {
       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) {
@@ -2830,61 +3081,33 @@ 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<'timeout'>((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)`,
+        `[TITLE] setName timed out after ${DISCORD_THREAD_RENAME_TIMEOUT_MS}ms for thread ${this.threadId} (likely rate-limited)`,
       )
       return
     }
@@ -2894,38 +3117,11 @@ export class ThreadSessionRuntime {
       )
       return
     }
-    await this.persistLastSyncedThreadName(desiredName)
     logger.log(
       `[TITLE] Renamed thread ${this.threadId} to "${desiredName}" from OpenCode session title`,
     )
   }
 
-  private 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
-  }
-
-  private async persistLastSyncedThreadName(name: string): Promise<void> {
-    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}`)
-    }
-  }
-
   private async handleTuiToast(properties: {
     title?: string
     message: string
@@ -2946,7 +3142,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) {
@@ -2965,6 +3161,7 @@ export class ThreadSessionRuntime {
    * fields that the local-queue path provides.
    */
   private async submitViaOpencodeQueue(input: IngressInput): Promise<EnqueueResult> {
+    await this.supersedePendingSleep(input)
     let skippedBySessionGuard = false
 
     await this.dispatchAction(async () => {
@@ -3039,6 +3236,18 @@ export class ThreadSessionRuntime {
         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,
@@ -3063,15 +3272,25 @@ 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,
@@ -3186,6 +3405,7 @@ export class ThreadSessionRuntime {
         userId: input.userId,
         sourceMessageId: input.sourceMessageId,
         sourceThreadId: input.sourceThreadId,
+        threadName: this.thread.name || undefined,
         repliedMessage: input.repliedMessage,
         worktree,
         currentAgent: resolvedAgent,
@@ -3211,6 +3431,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 } : {}),
@@ -3269,7 +3490,28 @@ 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.
+   */
+  private async supersedePendingSleep(input: IngressInput): Promise<void> {
+    if (input.isSleepWake) return
+    await cancelSessionSleepForThread({ threadId: this.threadId }).catch(
+      (error) => {
+        logger.error('[SLEEP] failed to cancel pending sleep:', error)
+      },
+    )
+  }
+
   private async enqueueViaLocalQueue(input: IngressInput): Promise<EnqueueResult> {
+    await this.supersedePendingSleep(input)
     const queueId = crypto.randomBytes(8).toString('hex')
     const queuedMessage: QueuedMessage = {
       queueId,
@@ -3281,6 +3523,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,
@@ -3333,8 +3576,12 @@ export class ThreadSessionRuntime {
    * discord-bot.ts.
    */
   async enqueueIncoming(input: IngressInput): Promise<EnqueueResult> {
+    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,
     })
@@ -3540,6 +3787,11 @@ export class ThreadSessionRuntime {
     )
 
     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 })
@@ -3613,14 +3865,6 @@ export class ThreadSessionRuntime {
     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. */
-  private getNotifyFlags(): number {
-    return this.getQueueLength() > 0
-      ? SILENT_MESSAGE_FLAGS
-      : NOTIFY_MESSAGE_FLAGS
-  }
-
   /** Clear all queued messages. Returns the removed items. */
   clearQueue(): threadState.QueuedMessage[] {
     return threadState.clearQueueItems(this.threadId)
@@ -3721,7 +3965,7 @@ export class ThreadSessionRuntime {
       if (displayText.trim()) {
         await sendThreadMessage(
           this.thread,
-          `» **${next.username}:** ${displayText}`,
+          `${QUEUE_PREFIX}**${next.username}:** ${displayText}`,
         )
       }
     }
@@ -3756,6 +4000,7 @@ export class ThreadSessionRuntime {
   private async dispatchPrompt(input: QueuedMessage): Promise<void> {
     this.lastDisplayedContextPercentage = 0
     this.lastRateLimitDisplayTime = 0
+    this.lastSentPartKind = undefined
 
     // ── Ensure session ────────────────────────────────────────
     const sessionResult = await this.ensureSession({
@@ -3809,6 +4054,24 @@ export class ThreadSessionRuntime {
       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,
@@ -3841,14 +4104,23 @@ 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,
@@ -3975,6 +4247,7 @@ export class ThreadSessionRuntime {
       userId: input.userId,
       sourceMessageId: input.sourceMessageId,
       sourceThreadId: input.sourceThreadId,
+      threadName: this.thread.name || undefined,
       repliedMessage: input.repliedMessage,
       worktree,
       currentAgent: earlyAgentPreference,
@@ -4025,6 +4298,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
@@ -4042,6 +4316,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,
@@ -4179,6 +4454,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,
@@ -4219,6 +4495,52 @@ export class ThreadSessionRuntime {
   // ── Session Ensure ──────────────────────────────────────────
   // Creates or reuses the OpenCode session for this thread.
 
+  /** Cached per-session scheduled task info for the system message. */
+  private scheduledTaskContextCache = new Map<
+    string,
+    ScheduledTaskSystemContext | undefined
+  >()
+
+  /**
+   * 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.
+   */
+  private async resolveScheduledTaskContext(
+    sessionId: string,
+  ): Promise<ScheduledTaskSystemContext | undefined> {
+    const cache = this.scheduledTaskContextCache
+    if (cache.has(sessionId)) {
+      return cache.get(sessionId)
+    }
+    const context = await (async (): Promise<
+      ScheduledTaskSystemContext | undefined
+    > => {
+      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
+  }
+
   private async updateExistingSessionPermissions({
     client,
     sessionId,
@@ -4314,8 +4636,9 @@ export class ThreadSessionRuntime {
       } else if (sessionResponse.data) {
         session = sessionResponse.data
       } else {
+        const sdkMessage = extractSdkErrorMessage(sessionResponse.error)
         logger.warn(
-          `[ENSURE SESSION] session.get returned no data for ${sessionId}, response=${JSON.stringify(sessionResponse)}`,
+          `[ENSURE SESSION] session.get returned no data for ${sessionId}: ${sdkMessage}, response=${JSON.stringify(sessionResponse)}`,
         )
       }
     }
@@ -4346,35 +4669,37 @@ export class ThreadSessionRuntime {
           { 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`,
+        `Failed to create or get session: threadId=${this.thread.id}, channelId=${this.channelId}, directory=${directory}, sdkDirectory=${this.sdkDirectory}, existingSessionId=${sessionId ?? 'none'}, createdNewSession=${createdNewSession}`,
       )
     }
 
@@ -4443,7 +4768,7 @@ export class ThreadSessionRuntime {
       : ''
     const result = await sendThreadMessage(
       this.thread,
-      `*using ${modelLabel}${agentLabel}*`,
+      asDiscordQuote(`*using ${modelLabel}${agentLabel}*`),
       { flags: SILENT_MESSAGE_FLAGS },
     ).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }))
     if (result instanceof Error) {
@@ -4477,7 +4802,6 @@ export class ThreadSessionRuntime {
       elapsedMs < 1000
         ? '<1s'
         : prettyMilliseconds(elapsedMs, { secondsDecimalDigits: 0 })
-    const modelInfo = runInfo.model ? ` ⋅ ${runInfo.model}` : ''
     const agentInfo =
       runInfo.agent && runInfo.agent.toLowerCase() !== 'build'
         ? ` ⋅ **${runInfo.agent}**`
@@ -4494,7 +4818,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
@@ -4534,9 +4858,12 @@ export class ThreadSessionRuntime {
             })
           : 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 || '']
@@ -4549,6 +4876,7 @@ export class ThreadSessionRuntime {
           )
           contextInfo = ` ⋅ ${percentage}%`
         }
+        return providers
       })().catch((e) => new OpenCodeSdkError({ operation: 'resolveModelPreference', cause: e })),
     ])
     const branchName =
@@ -4559,6 +4887,19 @@ export class ThreadSessionRuntime {
         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: string, max: number) => {
       return s.length > max ? s.slice(0, max - 1) + '\u2026' : s
@@ -4568,13 +4909,25 @@ 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}`,
@@ -4587,6 +4940,7 @@ export class ThreadSessionRuntime {
     this.modelContextLimitKey = undefined
     this.lastDisplayedContextPercentage = 0
     this.lastRateLimitDisplayTime = 0
+    this.lastSentPartKind = undefined
   }
 
   // ── Retry Last User Prompt (for model-change flow) ──────────