kimaki 0.26.0 → 0.27.0

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

@@ -40,6 +40,8 @@ import {
   sendThreadMessage,
   SILENT_MESSAGE_FLAGS,
   NOTIFY_MESSAGE_FLAGS,
+  raceDiscordRename,
+  DISCORD_THREAD_RENAME_TIMEOUT_MS,
 } from '../discord-utils.js'
 import type { DiscordFileAttachment } from '../message-formatting.js'
 import { formatPart, formatTaskToolTitle } from '../message-formatting.js'
@@ -62,6 +64,7 @@ import {
   startScheduledTaskRunSession,
   appendSessionEventsSinceLastTimestamp,
   getSessionEventSnapshot,
+  cancelSessionSleepForThread,
 } from '../database.js'
 import * as orm from 'drizzle-orm'
 import * as schema from '../schema.js'
@@ -75,6 +78,7 @@ import {
   showAskUserQuestionDropdowns,
   pendingQuestionContexts,
   cancelPendingQuestion,
+  findPendingQuestionContextForRequest,
 } from '../commands/ask-question.js'
 import {
   showActionButtons,
@@ -90,6 +94,11 @@ import {
   getCurrentModelInfo,
   ensureSessionPreferencesSnapshot,
 } from '../commands/model.js'
+import {
+  displayedModelLabel,
+  getProviderModelName,
+  validateModelId,
+} from './model-utils.js'
 import {
   getOpencodePromptContext,
   getOpencodeSystemMessage,
@@ -99,6 +108,7 @@ import {
   type WorktreeInfo,
 } from '../system-message.js'
 import { getDataDir } from '../config.js'
+import { store } from '../store.js'
 import {
   trackEvent,
   type AnalyticsIngressMode,
@@ -115,6 +125,7 @@ import {
 import {
   doesLatestUserTurnHaveNaturalCompletion,
   didQuestionQueueHandoffSinceLatestQuestionAsked,
+  deriveLatestUnansweredQuestion,
   getAssistantMessageIdsForLatestUserTurn,
   getCurrentTurnStartTime,
   isSessionBusy,
@@ -122,6 +133,8 @@ import {
   getIdleTokenUsageDelta,
   getDerivedSubtaskIndex,
   getDerivedSubtaskAgentType,
+  getTokenUsageSessionIdsForIdle,
+  isDerivedChildSession,
   getLatestAssistantMessageIdForLatestUserTurn,
   hasAssistantMessageCompletedBefore,
   isAssistantMessageInLatestUserTurn,
@@ -429,6 +442,14 @@ const PRESERVED_THREAD_PREFIXES: string[] = [
   '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,
@@ -440,14 +461,18 @@ function getThreadNameCandidateFromSessionTitle({
   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 +495,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 = {
@@ -588,6 +574,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,27 +686,22 @@ 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
@@ -792,6 +779,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(
@@ -1026,21 +1024,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 +1055,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 +1063,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
@@ -2066,41 +2070,6 @@ 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) {
-          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
-        }
-        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,
@@ -2108,6 +2077,32 @@ export class ThreadSessionRuntime {
         skipPartId: part.id,
       })
       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.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) {
+            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
+          }
+          await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id })
+        }
+      }
       return
     }
 
@@ -2238,6 +2233,7 @@ export class ThreadSessionRuntime {
 
     if (part.type === 'text' && part.time?.end) {
       await this.sendPartMessage({ part })
+      await this.tryShowPendingQuestion()
       return
     }
 
@@ -2301,21 +2297,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 +2322,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 +2333,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
 
@@ -2629,41 +2649,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 +2739,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
@@ -2830,61 +2899,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 +2935,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
@@ -2965,6 +2979,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 +3054,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,
@@ -3067,11 +3094,11 @@ export class ThreadSessionRuntime {
       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 +3213,7 @@ export class ThreadSessionRuntime {
         userId: input.userId,
         sourceMessageId: input.sourceMessageId,
         sourceThreadId: input.sourceThreadId,
+        threadName: this.thread.name || undefined,
         repliedMessage: input.repliedMessage,
         worktree,
         currentAgent: resolvedAgent,
@@ -3269,7 +3297,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,
@@ -3540,6 +3589,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 +3667,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)
@@ -3809,6 +3855,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,
@@ -3844,11 +3908,11 @@ export class ThreadSessionRuntime {
     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 +4039,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 +4090,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
@@ -4477,7 +4543,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 +4559,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 +4599,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 +4617,7 @@ export class ThreadSessionRuntime {
           )
           contextInfo = ` ⋅ ${percentage}%`
         }
+        return providers
       })().catch((e) => new OpenCodeSdkError({ operation: 'resolveModelPreference', cause: e })),
     ])
     const branchName =
@@ -4559,6 +4628,18 @@ export class ThreadSessionRuntime {
         contextResult,
       )
     }
+    const providers = contextResult instanceof Error ? [] : (contextResult ?? [])
+    const modelLabel = runInfo.model
+      ? displayedModelLabel({
+          modelID: runInfo.model,
+          name: getProviderModelName({
+            providers,
+            providerID: runInfo.providerID,
+            modelID: runInfo.model,
+          }),
+        })
+      : undefined
+    const modelInfo = modelLabel ? ` ⋅ ${modelLabel}` : ''
 
     const truncate = (s: string, max: number) => {
       return s.length > max ? s.slice(0, max - 1) + '\u2026' : s
@@ -4568,13 +4649,17 @@ export class ThreadSessionRuntime {
     const projectInfo = truncatedBranch
       ? `${truncatedFolder} ⋅ ${truncatedBranch} ⋅ `
       : `${truncatedFolder} ⋅ `
-    const footerText = `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*`
+    const hasQueuedMessage = this.getQueueLength() > 0
+    const mention = store.getState().footerMentionsEnabled
+      && !hasQueuedMessage
+      && this.state?.sessionUserId
+      ? ` <@${this.state.sessionUserId}>`
+      : ''
+    const footerText = `*${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: hasQueuedMessage ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
     })
     logger.log(
       `DURATION: Session completed in ${sessionDuration}, model ${runInfo.model}, tokens ${runInfo.tokensUsed}`,