kimaki 0.28.0 → 0.30.0

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

@@ -8,7 +8,7 @@
 
 import crypto from 'node:crypto'
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { ChannelType, type ThreadChannel } from 'discord.js'
+import { ChannelType, type Client, type ThreadChannel } from 'discord.js'
 import type {
   Event as OpenCodeEvent,
   Part,
@@ -45,14 +45,17 @@ import {
   raceDiscordRename,
   DISCORD_THREAD_RENAME_TIMEOUT_MS,
   resolveThreadFooterMentionUserId,
+  resolveWorkingDirectory,
 } from '../discord-utils.js'
 import type { DiscordFileAttachment, SessionPartKind } from '../message-formatting.js'
 import {
   asDiscordQuote,
+  asSystemLine,
   formatPart,
   formatTaskToolTitle,
   planAssistantTurnFlush,
   QUEUE_PREFIX,
+  sessionPartContent,
   sessionPartKind,
   shouldLeadWithBlankLine,
   shouldQuoteIntermediateTextPart,
@@ -83,6 +86,11 @@ import {
   appendSessionEventsSinceLastTimestamp,
   getSessionEventSnapshot,
   cancelSessionSleepForThread,
+  insertThreadQueueItem,
+  listAllThreadQueueItems,
+  deleteThreadQueueItem,
+  deleteThreadQueueItems,
+  updateThreadQueueItemPayload,
 } from '../database.js'
 import * as orm from 'drizzle-orm'
 import * as schema from '../schema.js'
@@ -127,6 +135,7 @@ import {
   type ScheduledTaskSystemContext,
 } from '../system-message.js'
 import { getDataDir } from '../config.js'
+import { countSystemPromptDiffLines } from '../cache-rewrite.js'
 import { store } from '../store.js'
 import {
   trackEvent,
@@ -150,6 +159,8 @@ import {
   getCurrentTurnStartTime,
   isSessionBusy,
   getLatestRunInfo,
+  getPromptCacheClear,
+  formatPromptCacheClearMessage,
   getIdleTokenUsageDelta,
   getDerivedSubtaskIndex,
   getDerivedSubtaskAgentType,
@@ -161,6 +172,8 @@ import {
   isAssistantMessageInLatestUserTurn,
   isAssistantMessageNaturalCompletion,
   shouldBufferSessionEvent,
+  shouldRetainSessionEvent,
+  trimEventBuffer,
   type EventBufferEvent,
   type EventBufferEntry,
 } from './event-stream-state.js'
@@ -320,11 +333,92 @@ export function getOrCreateRuntime(
   return runtime
 }
 
-export function disposeRuntime(threadId: string): void {
+function groupQueueRowsByThread(
+  rows: Array<{ thread_id: string; queue_id: string; payload_json: string }>,
+): Map<string, QueuedMessage[]> {
+  const byThread = new Map<string, QueuedMessage[]>()
+  for (const row of rows) {
+    const parsed = parseQueuedMessagePayload({
+      queueId: row.queue_id,
+      payloadJson: row.payload_json,
+    })
+    if (parsed instanceof Error) {
+      logger.warn(
+        `[QUEUE] Skipping invalid queue row ${row.queue_id} in thread ${row.thread_id}: ${parsed.message}`,
+      )
+      continue
+    }
+    const items = byThread.get(row.thread_id) ?? []
+    items.push(parsed)
+    byThread.set(row.thread_id, items)
+  }
+  return byThread
+}
+
+export async function restorePersistedLocalQueues({
+  discordClient,
+  appId,
+}: {
+  discordClient: Client
+  appId?: string
+}): Promise<void> {
+  const rows = await listAllThreadQueueItems()
+  if (rows.length === 0) {
+    return
+  }
+
+  const byThread = groupQueueRowsByThread(rows)
+  for (const [threadId, items] of byThread) {
+    if (items.length === 0) {
+      continue
+    }
+    let runtime = runtimes.get(threadId)
+    if (!runtime) {
+      const fetched = await discordClient.channels.fetch(threadId).catch((error) => {
+        logger.warn(
+          `[QUEUE] Failed to fetch thread ${threadId} for restored queue: ${error instanceof Error ? error.message : String(error)}`,
+        )
+        return null
+      })
+      if (!fetched?.isThread()) {
+        logger.warn(`[QUEUE] Skipping restored queue for missing thread ${threadId}`)
+        continue
+      }
+
+      const resolved = await resolveWorkingDirectory({ channel: fetched })
+      if (!resolved) {
+        logger.warn(`[QUEUE] Skipping restored queue for thread ${threadId}: no project directory`)
+        continue
+      }
+
+      const sessionId = await getThreadSession(threadId)
+      runtime = getOrCreateRuntime({
+        threadId,
+        thread: fetched,
+        projectDirectory: resolved.projectDirectory,
+        sdkDirectory: resolved.workingDirectory,
+        channelId: fetched.parentId || fetched.id,
+        appId,
+        sessionId,
+      })
+    }
+    await runtime.dispatchAction(() => {
+      return runtime.mergeRestoredQueueAndDrain(items)
+    })
+  }
+}
+
+export function disposeRuntime(
+  threadId: string,
+  { abortActiveRun = false }: { abortActiveRun?: boolean } = {},
+): void {
   const runtime = runtimes.get(threadId)
   if (!runtime) {
     return
   }
+  if (abortActiveRun) {
+    runtime.abortDeletedDiscordResource()
+  }
   runtime.dispose()
   runtimes.delete(threadId)
   threadState.removeThread(threadId) // remove from global store
@@ -355,6 +449,12 @@ export function disposeRuntimesForDirectory({
   return count
 }
 
+export function getRuntimeThreadIdsForChannel(channelId: string): string[] {
+  return Array.from(runtimes.entries())
+    .filter(([, runtime]) => runtime.channelId === channelId)
+    .map(([threadId]) => threadId)
+}
+
 /** Returns number of active runtimes (useful for diagnostics). */
 export function getRuntimeCount(): number {
   return runtimes.size
@@ -722,6 +822,36 @@ function trackTurnStarted({
   })
 }
 
+function parseQueuedMessagePayload({
+  queueId,
+  payloadJson,
+}: {
+  queueId: string
+  payloadJson: string
+}): QueuedMessage | Error {
+  return errore.try(
+    () => {
+      const parsed = JSON.parse(payloadJson) as QueuedMessage
+      if (!parsed || typeof parsed !== 'object') {
+        return new Error('Queued message payload is not an object')
+      }
+      if (typeof parsed.prompt !== 'string') {
+        return new Error('Queued message payload is missing prompt')
+      }
+      if (typeof parsed.userId !== 'string') {
+        return new Error('Queued message payload is missing userId')
+      }
+      if (typeof parsed.username !== 'string') {
+        return new Error('Queued message payload is missing username')
+      }
+      return { ...parsed, queueId }
+    },
+    (error) => {
+      return new Error('Failed to parse queued message payload', { cause: error })
+    },
+  )
+}
+
 // Rewrite `{ prompt: "/build foo" }` → `{ prompt: "", command: { name, arguments }, mode: "local-queue" }`
 // when the prompt's leading token matches a registered opencode command.
 // Skip if a command is already set or there's no prompt to inspect.
@@ -770,6 +900,7 @@ export class ThreadSessionRuntime {
 
   // Set to true by dispose(). Guards against queued work running after cleanup.
   private disposed = false
+  private dispatchingQueueId: string | undefined
 
   // Typing indicator scheduler handles.
   // `typingKeepaliveTimeout` is the 7s keepalive loop while a run stays busy.
@@ -786,6 +917,7 @@ export class ThreadSessionRuntime {
   // Notification throttles for retry/context notices.
   private lastDisplayedContextPercentage = 0
   private lastRateLimitDisplayTime = 0
+  private userSystemByMessageId = new Map<string, string>()
 
   // Last OpenCode session title we applied to Discord. Dedupes session.updated
   // so we only call setName once per distinct title. Not persisted.
@@ -900,7 +1032,7 @@ export class ThreadSessionRuntime {
   }
 
   getDerivedPhase(): 'idle' | 'running' {
-    return this.isMainSessionBusy() ? 'running' : 'idle'
+    return this.isBusy() ? 'running' : 'idle'
   }
 
   private getLastRuntimeActivityTimestamp({
@@ -929,7 +1061,7 @@ export class ThreadSessionRuntime {
   }
 
   private isIdleCandidateForInactivityCheck(): boolean {
-    if (this.isMainSessionBusy()) {
+    if (this.isBusy()) {
       return false
     }
     if ((this.state?.queueItems.length ?? 0) > 0) {
@@ -1013,7 +1145,18 @@ export class ThreadSessionRuntime {
       ]
     })
 
-    this.eventBuffer = hydratedEvents.slice(-ThreadSessionRuntime.EVENT_BUFFER_MAX)
+    this.eventBuffer = trimEventBuffer({
+      events: hydratedEvents,
+      mainSessionId: sessionId,
+      max: ThreadSessionRuntime.EVENT_BUFFER_MAX,
+      isKnownChildSession: (candidateSessionId) => {
+        return isDerivedChildSession({
+          events: hydratedEvents,
+          mainSessionId: sessionId,
+          candidateSessionId,
+        })
+      },
+    })
     const lastHydratedEvent = this.eventBuffer[this.eventBuffer.length - 1]
     this.nextEventIndex = lastHydratedEvent
       ? Number(lastHydratedEvent.eventIndex || 0) + 1
@@ -1072,7 +1215,8 @@ export class ThreadSessionRuntime {
     return `phase=${phase},assistant=${latestAssistant},assistantCount=${assistantCount}`
   }
 
-  private isMainSessionBusy(): boolean {
+  /** Whether the main session currently has an active run (derived from events). */
+  isBusy(): boolean {
     const sessionId = this.state?.sessionId
     if (!sessionId) {
       return false
@@ -1190,6 +1334,14 @@ export class ThreadSessionRuntime {
 
   // ── Lifecycle ────────────────────────────────────────────────
 
+  abortDeletedDiscordResource(): void {
+    if (this.getDerivedPhase() === 'running') {
+      void this.abortActiveRunInternal({
+        reason: 'discord-resource-deleted',
+      }).apiAbortPromise
+    }
+  }
+
   dispose(): void {
     this.disposed = true
     unregisterEventListener(this.threadId)
@@ -1312,6 +1464,9 @@ export class ThreadSessionRuntime {
             return [{ id: candidate.id, type: candidate.type }]
           })
         : []
+      if (info.role === 'user' && typeof info.id === 'string' && typeof info.system === 'string') {
+        this.userSystemByMessageId.set(info.id, info.system)
+      }
       delete info.system
       delete info.tools
       delete info.parts
@@ -1389,6 +1544,15 @@ export class ThreadSessionRuntime {
     if (!compactedEvent) {
       return
     }
+    if (!shouldRetainSessionEvent({
+      event: compactedEvent,
+      mainSessionId: this.state?.sessionId,
+      isKnownChildSession: (candidateSessionId) => {
+        return Boolean(this.getSubtaskInfoForSession(candidateSessionId))
+      },
+    })) {
+      return
+    }
 
     const timestamp = Date.now()
     const eventIndex = this.nextEventIndex
@@ -1398,9 +1562,14 @@ export class ThreadSessionRuntime {
       timestamp,
       eventIndex,
     })
-    if (this.eventBuffer.length > ThreadSessionRuntime.EVENT_BUFFER_MAX) {
-      this.eventBuffer.splice(0, this.eventBuffer.length - ThreadSessionRuntime.EVENT_BUFFER_MAX)
-    }
+    this.eventBuffer = trimEventBuffer({
+      events: this.eventBuffer,
+      mainSessionId: this.state?.sessionId,
+      max: ThreadSessionRuntime.EVENT_BUFFER_MAX,
+      isKnownChildSession: (candidateSessionId) => {
+        return Boolean(this.getSubtaskInfoForSession(candidateSessionId))
+      },
+    })
     this.persistEventBufferDebounced.trigger()
   }
 
@@ -1513,6 +1682,7 @@ export class ThreadSessionRuntime {
     // causing tryDrainQueue to drain the local queue while the session is
     // actually still busy. This was the root cause of "? queue" messages
     // interrupting instead of queuing.
+    // Child task part floods are also dropped at retain time for the same reason.
     if (event.type !== 'message.part.delta') {
       this.appendEventToBuffer(event)
     }
@@ -1872,6 +2042,9 @@ export class ThreadSessionRuntime {
     if (part.type === 'text' && !part.time?.end && mode === 'progress') {
       return false
     }
+    if (part.type === 'text' && part.synthetic === true) {
+      return false
+    }
     return true
   }
 
@@ -1883,7 +2056,50 @@ export class ThreadSessionRuntime {
     if (messageIds.length > 0) {
       return messageIds.flatMap((id) => this.getBufferedParts(id))
     }
-    return [...this.partBuffer.keys()].flatMap((id) => this.getBufferedParts(id))
+    return []
+  }
+
+  private async unquoteFinalTextPart(): Promise<void> {
+    const parts = this.getCurrentTurnParts()
+    const finalPart = planAssistantTurnFlush({
+      parts,
+      mode: 'final',
+    }).sendParts.at(-1)
+    if (!finalPart || finalPart.quoteText || finalPart.part.type !== 'text') return
+    const last = finalPart.part
+    const db = await getDb()
+    const row = await db.query.part_messages.findFirst({
+      where: { part_id: last.id },
+      columns: { message_id: true },
+    }).catch((e) => new DiscordOperationError({ operation: 'getPartMessage', cause: e }))
+    if (row instanceof Error) {
+      discordLogger.error(`Failed to find Discord message for ${last.id}:`, row)
+      return
+    }
+    const messageId = row?.message_id
+    if (!messageId) return
+    const message = await this.thread.messages.fetch(messageId)
+      .catch((e) => new DiscordOperationError({ operation: 'fetchMessage', cause: e }))
+    if (message instanceof Error) {
+      discordLogger.error(`Failed to fetch Discord message for ${last.id}:`, message)
+      return
+    }
+    const formatted = formatPart(last)
+    const leadWithBlankLine = message.content.startsWith('\n')
+    const quoted = sessionPartContent({
+      content: asDiscordQuote(formatted),
+      leadWithBlankLine,
+    })
+    if (message.content !== quoted) return
+    const plain = sessionPartContent({
+      content: formatted,
+      leadWithBlankLine,
+    })
+    const edited = await message.edit({ content: plain })
+      .catch((e) => new DiscordOperationError({ operation: 'editMessage', cause: e }))
+    if (edited instanceof Error) {
+      discordLogger.error(`ERROR: Failed to unquote final text ${last.id}:`, edited)
+    }
   }
 
   private async flushCurrentTurnParts({
@@ -1897,15 +2113,16 @@ export class ThreadSessionRuntime {
     skipPartId?: string
     repulseTyping?: boolean
   }): Promise<void> {
-    const parts = this.getCurrentTurnParts().filter((part) => {
-      return !this.state?.sentPartIds.has(part.id)
-    })
+    const parts = this.getCurrentTurnParts()
     const planned = planAssistantTurnFlush({
       parts,
       mode,
       throughPartId,
     })
     for (const { part, quoteText } of planned.sendParts) {
+      if (this.state?.sentPartIds.has(part.id)) {
+        continue
+      }
       if (skipPartId && part.id === skipPartId) {
         continue
       }
@@ -2203,6 +2420,15 @@ export class ThreadSessionRuntime {
       return
     }
 
+    if (part.type === 'text' && part.synthetic === true) {
+      return
+    }
+
+    if (part.type === 'text' && part.ignored === true) {
+      await this.sendPartMessage({ part, repulseTyping: false })
+      return
+    }
+
     this.storePart(part)
 
     if (messageKind === 'unknown') {
@@ -2236,11 +2462,8 @@ export class ThreadSessionRuntime {
       await this.flushCurrentTurnParts({
         mode: 'progress',
       })
-      const unsent = this.getCurrentTurnParts().filter((candidate) => {
-        return !this.state?.sentPartIds.has(candidate.id)
-      })
       const held = planAssistantTurnFlush({
-        parts: unsent,
+        parts: this.getCurrentTurnParts(),
         mode: 'progress',
       }).hold.some((entry) => entry.id === part.id)
       if (held) {
@@ -2607,6 +2830,12 @@ export class ThreadSessionRuntime {
       mode: 'final',
       repulseTyping: false,
     })
+    await this.unquoteFinalTextPart()
+
+    await this.maybeNotifyPromptCacheClear({
+      sessionId,
+      messageId: completedMessageId,
+    })
 
     // Skip footer if model produced no visible output (no text, no tool calls,
     // just step-start/step-finish lifecycle parts). This happens when the model
@@ -3401,10 +3630,12 @@ export class ThreadSessionRuntime {
       })()
       const worktreeChanged = this.consumeWorktreePromptChange(worktree)
       const syntheticContext = getOpencodePromptContext({
+        sessionId: session.id,
+        threadId: this.thread.id,
         username: input.username,
         userId: input.userId,
         sourceMessageId: input.sourceMessageId,
-        sourceThreadId: input.sourceThreadId,
+        sourceThreadId: input.sourceThreadId || this.thread.id,
         threadName: this.thread.name || undefined,
         repliedMessage: input.repliedMessage,
         worktree,
@@ -3538,7 +3769,19 @@ export class ThreadSessionRuntime {
     let result: EnqueueResult = { queued: false, queueId }
 
     await this.dispatchAction(async () => {
-      // Enqueue the message
+      const persistResult = await insertThreadQueueItem({
+        queueId,
+        threadId: this.threadId,
+        payloadJson: JSON.stringify(queuedMessage),
+      }).catch((error) => {
+        return new Error('Failed to persist queued message', { cause: error })
+      })
+      if (persistResult instanceof Error) {
+        logger.error(
+          `[QUEUE] Failed to persist queued message ${queueId} in thread ${this.threadId}: ${persistResult.message}`,
+        )
+        throw persistResult
+      }
       threadState.enqueueItem(this.threadId, queuedMessage)
 
       // Determine if the message is genuinely waiting in queue
@@ -3547,7 +3790,7 @@ export class ThreadSessionRuntime {
       const willDrainNow = stateAfterEnqueue
         ? (
           stateAfterEnqueue.queueItems.length > 0
-          && !this.isMainSessionBusy()
+          && !this.isBusy()
         )
         : false
       result = !willDrainNow && position > 0
@@ -3780,7 +4023,7 @@ export class ThreadSessionRuntime {
     }
 
     const sessionId = state.sessionId
-    const sessionIsBusy = this.isMainSessionBusy()
+    const sessionIsBusy = this.isBusy()
 
     logger.log(
       `[ABORT] id=${abortId} reason=${reason} threadId=${this.threadId} sessionId=${sessionId || 'none'} queueLength=${state.queueItems.length} ${this.formatRunStateForLog()} sessionBusy=${sessionIsBusy}`,
@@ -3837,7 +4080,7 @@ export class ThreadSessionRuntime {
     let needsIdleWait = false
     const waitSinceTimestamp = Date.now()
     const abortResult = await this.dispatchAction(async () => {
-      needsIdleWait = this.isMainSessionBusy()
+      needsIdleWait = this.isBusy()
       const outcome = this.abortActiveRunInternal({ reason })
       if (outcome.apiAbortPromise) {
         void outcome.apiAbortPromise
@@ -3866,18 +4109,72 @@ export class ThreadSessionRuntime {
   }
 
   /** Clear all queued messages. Returns the removed items. */
-  clearQueue(): threadState.QueuedMessage[] {
-    return threadState.clearQueueItems(this.threadId)
+  async clearQueue(): Promise<threadState.QueuedMessage[]> {
+    let cleared: threadState.QueuedMessage[] = []
+    await this.dispatchAction(async () => {
+      const persistResult = await deleteThreadQueueItems(this.threadId).catch((error) => {
+        return new Error('Failed to clear persisted queue', { cause: error })
+      })
+      if (persistResult instanceof Error) {
+        logger.error(
+          `[QUEUE] Failed to clear persisted queue for thread ${this.threadId}: ${persistResult.message}`,
+        )
+        return
+      }
+      cleared = threadState.clearQueueItems(this.threadId)
+    })
+    return cleared
   }
 
   /** Remove a queued message by its 1-based position. */
-  removeQueuePosition(position: number): threadState.QueuedMessage | undefined {
-    return threadState.removeQueueItemAtPosition(this.threadId, position)
+  async removeQueuePosition(position: number): Promise<threadState.QueuedMessage | undefined> {
+    let removed: threadState.QueuedMessage | undefined
+    await this.dispatchAction(async () => {
+      const current = this.state?.queueItems[position - 1]
+      if (!current) {
+        return
+      }
+      if (current.queueId) {
+        const persistResult = await deleteThreadQueueItem(current.queueId).catch((error) => {
+          return new Error('Failed to delete persisted queue item', { cause: error })
+        })
+        if (persistResult instanceof Error) {
+          logger.error(
+            `[QUEUE] Failed to delete persisted queue item ${current.queueId}: ${persistResult.message}`,
+          )
+          return
+        }
+      }
+      removed = threadState.removeQueueItemAtPosition(this.threadId, position)
+    })
+    return removed
   }
 
   /** Remove a queued message by stable queue id. */
-  removeQueueItemById(queueId: string): threadState.QueuedMessage | undefined {
-    return threadState.removeQueueItemById(this.threadId, queueId)
+  async removeQueueItemById(queueId: string): Promise<threadState.QueuedMessage | undefined> {
+    let removed: threadState.QueuedMessage | undefined
+    await this.dispatchAction(async () => {
+      const persistResult = await deleteThreadQueueItem(queueId).catch((error) => {
+        return new Error('Failed to delete persisted queue item', { cause: error })
+      })
+      if (persistResult instanceof Error) {
+        logger.error(
+          `[QUEUE] Failed to delete persisted queue item ${queueId}: ${persistResult.message}`,
+        )
+        return
+      }
+      removed = threadState.removeQueueItemById(this.threadId, queueId)
+      if (!removed && persistResult) {
+        const parsed = parseQueuedMessagePayload({
+          queueId: persistResult.queue_id,
+          payloadJson: persistResult.payload_json,
+        })
+        if (!(parsed instanceof Error)) {
+          removed = parsed
+        }
+      }
+    })
+    return removed
   }
 
   /**
@@ -3886,33 +4183,150 @@ export class ThreadSessionRuntime {
    * Returns { found: true, removed } if the item was in the queue,
    * or { found: false } if it was already dispatched or never queued.
    */
-  updateQueuedMessage(
+  async updateQueuedMessage(
     sourceMessageId: string,
     newPrompt: string,
-  ): { found: boolean; removed: boolean } {
-    const trimmed = newPrompt.trim()
-    const original = threadState.updateQueueItemBySourceMessageId(
-      this.threadId,
-      sourceMessageId,
-      (item) => {
-        if (!trimmed) return null
-        return { ...item, prompt: trimmed }
-      },
-    )
-    if (!original) return { found: false, removed: false }
-    if (!trimmed) return { found: true, removed: true }
-    return { found: true, removed: false }
+  ): Promise<{ found: boolean; removed: boolean }> {
+    let result: { found: boolean; removed: boolean } = { found: false, removed: false }
+    await this.dispatchAction(async () => {
+      const trimmed = newPrompt.trim()
+      const original = this.state?.queueItems.find((item) => {
+        return item.sourceMessageId === sourceMessageId
+      })
+      if (!original) {
+        result = { found: false, removed: false }
+        return
+      }
+      const queueId = original.queueId
+      if (queueId) {
+        const persistResult = trimmed
+          ? await updateThreadQueueItemPayload({
+            queueId,
+            payloadJson: JSON.stringify({ ...original, prompt: trimmed }),
+          }).catch((error) => {
+            return new Error('Failed to update persisted queue item', { cause: error })
+          })
+          : await deleteThreadQueueItem(queueId).catch((error) => {
+            return new Error('Failed to delete persisted queue item', { cause: error })
+          })
+        if (persistResult instanceof Error) {
+          logger.error(
+            `[QUEUE] Failed to persist queue update for ${queueId}: ${persistResult.message}`,
+          )
+          result = { found: true, removed: false }
+          return
+        }
+      }
+      threadState.updateQueueItemBySourceMessageId(
+        this.threadId,
+        sourceMessageId,
+        (item) => {
+          if (!trimmed) return null
+          return { ...item, prompt: trimmed }
+        },
+      )
+      result = trimmed
+        ? { found: true, removed: false }
+        : { found: true, removed: true }
+    })
+    return result
   }
 
   /** Remove a queued message identified by its Discord source message ID. */
-  removeQueuedMessage(
+  async removeQueuedMessage(
     sourceMessageId: string,
-  ): threadState.QueuedMessage | undefined {
-    return threadState.updateQueueItemBySourceMessageId(
-      this.threadId,
-      sourceMessageId,
-      () => null,
-    )
+  ): Promise<threadState.QueuedMessage | undefined> {
+    let removed: threadState.QueuedMessage | undefined
+    await this.dispatchAction(async () => {
+      const current = this.state?.queueItems.find((item) => {
+        return item.sourceMessageId === sourceMessageId
+      })
+      if (!current) {
+        return
+      }
+      if (current.queueId) {
+        const persistResult = await deleteThreadQueueItem(current.queueId).catch((error) => {
+          return new Error('Failed to delete persisted queue item', { cause: error })
+        })
+        if (persistResult instanceof Error) {
+          logger.error(
+            `[QUEUE] Failed to delete persisted queue item ${current.queueId}: ${persistResult.message}`,
+          )
+          return
+        }
+      }
+      removed = threadState.updateQueueItemBySourceMessageId(
+        this.threadId,
+        sourceMessageId,
+        () => null,
+      )
+    })
+    return removed
+  }
+
+  async mergeRestoredQueueAndDrain(items: QueuedMessage[]): Promise<void> {
+    const current = this.state?.queueItems ?? []
+    const currentIds = new Set(current.flatMap((item) => item.queueId ? [item.queueId] : []))
+    threadState.replaceQueueItems(this.threadId, [
+      ...items.filter((item) => item.queueId && !currentIds.has(item.queueId)),
+      ...current,
+    ])
+    const liveStatus = await this.hydrateLiveSessionStatus()
+    if (liveStatus === 'unavailable') {
+      return
+    }
+    await this.tryDrainQueue({ showIndicator: true })
+  }
+
+  private async hydrateLiveSessionStatus(): Promise<'idle' | 'busy' | 'unavailable'> {
+    const sessionId = this.state?.sessionId
+    if (!sessionId) {
+      return 'idle'
+    }
+    await this.hydrateSessionEventsFromDatabase({ sessionId })
+    const getClient = await initializeOpencodeForDirectory(this.sdkDirectory)
+    if (getClient instanceof Error) {
+      logger.warn(
+        `[QUEUE] OpenCode unavailable while restoring queue for ${this.threadId}: ${getClient.message}`,
+      )
+      return 'unavailable'
+    }
+    const statusResponse = await getClient().session.status({
+      directory: this.sdkDirectory,
+    }).catch((error) => {
+      logger.warn(
+        `[QUEUE] Failed to read session status while restoring queue for ${this.threadId}: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      return undefined
+    })
+    if (!statusResponse || statusResponse.error) {
+      return 'unavailable'
+    }
+    const sessionStatus = statusResponse.data?.[sessionId]
+    if (!sessionStatus || sessionStatus.type === 'idle') {
+      this.markQueueDispatchIdle(sessionId)
+      return 'idle'
+    }
+    this.markQueueDispatchBusy(sessionId)
+    return 'busy'
+  }
+
+  private async acknowledgeAcceptedQueueItem(item: QueuedMessage): Promise<void> {
+    if (!item.queueId) {
+      return
+    }
+    await this.dispatchAction(async () => {
+      const persistResult = await deleteThreadQueueItem(item.queueId!).catch((error) => {
+        return new Error('Failed to delete persisted queue item', { cause: error })
+      })
+      if (persistResult instanceof Error) {
+        logger.error(
+          `[QUEUE] Failed to persist accept of ${item.queueId}: ${persistResult.message}`,
+        )
+        return
+      }
+      threadState.removeQueueItemById(this.threadId, item.queueId!)
+    })
   }
 
   // ── Queue Drain ─────────────────────────────────────────────
@@ -3947,10 +4361,11 @@ export class ThreadSessionRuntime {
       return
     }
 
-    const next = threadState.dequeueItem(this.threadId)
+    const next = thread.queueItems.find((item) => item.queueId !== this.dispatchingQueueId)
     if (!next) {
       return
     }
+    this.dispatchingQueueId = next.queueId
 
     logger.log(
       `[QUEUE DRAIN] Processing queued message from ${next.username}`,
@@ -3979,13 +4394,23 @@ export class ThreadSessionRuntime {
     if (dispatchSessionId) {
       this.markQueueDispatchBusy(dispatchSessionId)
     }
-    void this.dispatchPrompt(next).catch(async (err) => {
+    let accepted = false
+    void this.dispatchPrompt(next).then(async (ok) => {
+      accepted = ok
+      if (ok) {
+        await this.acknowledgeAcceptedQueueItem(next)
+      }
+    }).catch(async (err) => {
       logger.error('[DISPATCH] Prompt dispatch failed:', err)
       void notifyError(err, 'Runtime prompt dispatch failed')
       if (dispatchSessionId) {
         this.markQueueDispatchIdle(dispatchSessionId)
       }
     }).finally(() => {
+      this.dispatchingQueueId = undefined
+      if (!accepted) {
+        return
+      }
       void this.dispatchAction(() => {
         return this.tryDrainQueue({ showIndicator: true })
       })
@@ -3997,7 +4422,7 @@ export class ThreadSessionRuntime {
   // The listener is already running, so this only handles
   // session ensure + model/agent + SDK call + state.
 
-  private async dispatchPrompt(input: QueuedMessage): Promise<void> {
+  private async dispatchPrompt(input: QueuedMessage): Promise<boolean> {
     this.lastDisplayedContextPercentage = 0
     this.lastRateLimitDisplayTime = 0
     this.lastSentPartKind = undefined
@@ -4020,8 +4445,7 @@ export class ThreadSessionRuntime {
       )
       // Show indicator: this dispatch failed, so the next queued message
       // has been waiting — the user needs to see which one is starting.
-      await this.tryDrainQueue({ showIndicator: true })
-      return
+      return false
     }
     const { session, getClient, createdNewSession } = sessionResult
 
@@ -4038,8 +4462,7 @@ export class ThreadSessionRuntime {
         `Failed to update session permissions: ${updatePermissionsResult.message}`,
         { flags: NOTIFY_MESSAGE_FLAGS },
       )
-      await this.tryDrainQueue({ showIndicator: true })
-      return
+      return false
     }
 
     // ── Resolve model + agent preferences ─────────────────────
@@ -4067,8 +4490,7 @@ export class ThreadSessionRuntime {
           `Failed to resolve model: ${validatedModel.message}`,
           { flags: NOTIFY_MESSAGE_FLAGS },
         )
-        await this.tryDrainQueue({ showIndicator: true })
-        return
+        return false
       }
     }
 
@@ -4097,9 +4519,7 @@ export class ThreadSessionRuntime {
         `Failed to resolve agent: ${earlyAgentResult.message}`,
         { flags: NOTIFY_MESSAGE_FLAGS },
       )
-      // Show indicator: dispatch failed mid-setup, next queued message was waiting.
-      await this.tryDrainQueue({ showIndicator: true })
-      return
+      return false
     }
     const earlyAgentPreference = earlyAgentResult.agentPreference
     const earlyAvailableAgents = earlyAgentResult.agents
@@ -4148,9 +4568,7 @@ export class ThreadSessionRuntime {
         `Failed to resolve model: ${earlyModelResult.message}`,
         { flags: NOTIFY_MESSAGE_FLAGS },
       )
-      // Show indicator: dispatch failed mid-setup, next queued message was waiting.
-      await this.tryDrainQueue({ showIndicator: true })
-      return
+      return false
     }
     const earlyModelParam = earlyModelResult
     if (!earlyModelParam) {
@@ -4159,9 +4577,7 @@ export class ThreadSessionRuntime {
         this.thread,
         'No AI provider connected. Configure a provider in OpenCode with `/connect` command.',
       )
-      // Show indicator: dispatch failed, next queued message was waiting.
-      await this.tryDrainQueue({ showIndicator: true })
-      return
+      return false
     }
 
     // Resolve thinking variant
@@ -4243,10 +4659,12 @@ export class ThreadSessionRuntime {
     })()
     const worktreeChanged = this.consumeWorktreePromptChange(worktree)
     const syntheticContext = getOpencodePromptContext({
+      sessionId: session.id,
+      threadId: this.thread.id,
       username: input.username,
       userId: input.userId,
       sourceMessageId: input.sourceMessageId,
-      sourceThreadId: input.sourceThreadId,
+      sourceThreadId: input.sourceThreadId || this.thread.id,
       threadName: this.thread.name || undefined,
       repliedMessage: input.repliedMessage,
       worktree,
@@ -4294,10 +4712,12 @@ export class ThreadSessionRuntime {
       // Append <discord-user /> tag to arguments so external sync can
       // detect this message came from Discord (same tag as promptAsync).
       const discordTag = getOpencodePromptContext({
+        sessionId: session.id,
+        threadId: this.thread.id,
         username: input.username,
         userId: input.userId,
         sourceMessageId: input.sourceMessageId,
-        sourceThreadId: input.sourceThreadId,
+        sourceThreadId: input.sourceThreadId || this.thread.id,
         threadName: this.thread.name || undefined,
         repliedMessage: input.repliedMessage,
       })
@@ -4341,10 +4761,7 @@ export class ThreadSessionRuntime {
           `✗ Failed to prepare command system prompt: ${systemWriteResult.message}`,
           { flags: NOTIFY_MESSAGE_FLAGS },
         )
-        await this.dispatchAction(() => {
-          return this.tryDrainQueue({ showIndicator: true })
-        })
-        return
+        return false
       }
       const commandResponse = await getClient().session.command(
         {
@@ -4376,10 +4793,7 @@ export class ThreadSessionRuntime {
             '✗ Command timed out after 30 seconds. Try a shorter command or run it with /run-shell-command.',
             { flags: NOTIFY_MESSAGE_FLAGS },
           )
-          await this.dispatchAction(() => {
-            return this.tryDrainQueue({ showIndicator: true })
-          })
-          return
+          return false
         }
 
         const commandErrorForAbortCheck: unknown = commandResponse
@@ -4388,7 +4802,7 @@ export class ThreadSessionRuntime {
             `[DISPATCH] Command aborted (expected) sessionId=${session.id}`,
           )
           this.stopTyping()
-          return
+          return true
         }
 
         logger.error(
@@ -4401,10 +4815,7 @@ export class ThreadSessionRuntime {
           `✗ Unexpected bot Error: ${commandResponse.message}`,
           { flags: NOTIFY_MESSAGE_FLAGS },
         )
-        await this.dispatchAction(() => {
-          return this.tryDrainQueue({ showIndicator: true })
-        })
-        return
+        return false
       }
 
       if (commandResponse.error) {
@@ -4414,7 +4825,7 @@ export class ThreadSessionRuntime {
             `[DISPATCH] Command aborted (expected) sessionId=${session.id}`,
           )
           this.stopTyping()
-          return
+          return true
         }
         const apiError = new Error(`OpenCode API error: ${errorMessage}`)
         logger.error(`[DISPATCH] ${apiError.message}`)
@@ -4423,10 +4834,7 @@ export class ThreadSessionRuntime {
         await sendThreadMessage(this.thread, `✗ ${apiError.message}`, {
           flags: NOTIFY_MESSAGE_FLAGS,
         })
-        await this.dispatchAction(() => {
-          return this.tryDrainQueue({ showIndicator: true })
-        })
-        return
+        return false
       }
 
       logger.log(`[DISPATCH] Successfully ran command for session ${session.id}`)
@@ -4436,7 +4844,7 @@ export class ThreadSessionRuntime {
         source: resolveTurnSource(input),
         agent: earlyAgentPreference,
       })
-      return
+      return true
     }
 
     await waitForGlobalEventListener()
@@ -4475,10 +4883,7 @@ export class ThreadSessionRuntime {
       await sendThreadMessage(this.thread, `✗ OpenCode API error: ${errorMessage}`, {
         flags: NOTIFY_MESSAGE_FLAGS,
       })
-      await this.dispatchAction(() => {
-        return this.tryDrainQueue({ showIndicator: true })
-      })
-      return
+      return false
     }
 
     logger.log(
@@ -4490,6 +4895,7 @@ export class ThreadSessionRuntime {
       source: resolveTurnSource(input),
       agent: earlyAgentPreference,
     })
+    return true
   }
 
   // ── Session Ensure ──────────────────────────────────────────
@@ -4768,7 +5174,7 @@ export class ThreadSessionRuntime {
       : ''
     const result = await sendThreadMessage(
       this.thread,
-      asDiscordQuote(`*using ${modelLabel}${agentLabel}*`),
+      asSystemLine(`*using ${modelLabel}${agentLabel}*`),
       { flags: SILENT_MESSAGE_FLAGS },
     ).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }))
     if (result instanceof Error) {
@@ -4921,7 +5327,7 @@ export class ThreadSessionRuntime {
         })
       : undefined
     const mention = mentionUserId ? ` <@${mentionUserId}>` : ''
-    const footerText = asDiscordQuote(
+    const footerText = asSystemLine(
       `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`,
     )
     this.stopTyping()
@@ -4943,6 +5349,77 @@ export class ThreadSessionRuntime {
     this.lastSentPartKind = undefined
   }
 
+  private async maybeNotifyPromptCacheClear({
+    sessionId,
+    messageId,
+  }: {
+    sessionId: string
+    messageId: string
+  }): Promise<void> {
+    const cacheClear = getPromptCacheClear({
+      events: this.eventBuffer,
+      sessionId,
+      currentMessageId: messageId,
+    })
+    if (!cacheClear) {
+      return
+    }
+    const systemDiff = await this.getSystemPromptDiffForCacheClear({
+      sessionId,
+      previousMessageId: cacheClear.previousMessageId,
+      currentMessageId: cacheClear.currentMessageId,
+    })
+    const chunk = `${STATUS_PREFIX}${formatPromptCacheClearMessage(cacheClear, systemDiff)}`
+    const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+      .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }))
+    if (sendResult instanceof Error) {
+      discordLogger.error('Failed to send prompt cache notice:', sendResult)
+    }
+  }
+
+  private async getSystemPromptDiffForCacheClear({
+    sessionId,
+    previousMessageId,
+    currentMessageId,
+  }: {
+    sessionId: string
+    previousMessageId: string
+    currentMessageId: string
+  }): Promise<{ additions: number; deletions: number } | undefined> {
+    const previousParentId = this.getAssistantParentId({ sessionId, messageId: previousMessageId })
+    const currentParentId = this.getAssistantParentId({ sessionId, messageId: currentMessageId })
+    if (!previousParentId || !currentParentId) {
+      return undefined
+    }
+    const beforeText = this.userSystemByMessageId.get(previousParentId)
+    const afterText = this.userSystemByMessageId.get(currentParentId)
+    if (beforeText === undefined || afterText === undefined || beforeText === afterText) {
+      return undefined
+    }
+    return countSystemPromptDiffLines({ beforeText, afterText })
+  }
+
+  private getAssistantParentId({
+    sessionId,
+    messageId,
+  }: {
+    sessionId: string
+    messageId: string
+  }): string | undefined {
+    for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
+      const event = this.eventBuffer[i]?.event
+      if (event?.type !== 'message.updated') {
+        continue
+      }
+      const info = event.properties.info
+      if (info.sessionID !== sessionId || info.role !== 'assistant' || info.id !== messageId) {
+        continue
+      }
+      return info.parentID
+    }
+    return undefined
+  }
+
   // ── Retry Last User Prompt (for model-change flow) ──────────
 
   /**
@@ -4965,7 +5442,7 @@ export class ThreadSessionRuntime {
     let needsIdleWait = false
     const waitSinceTimestamp = Date.now()
     const abortResult = await this.dispatchAction(async () => {
-      needsIdleWait = this.isMainSessionBusy()
+      needsIdleWait = this.isBusy()
       const outcome = this.abortActiveRunInternal({
         reason: 'model-change',
       })
@@ -5026,6 +5503,31 @@ export class ThreadSessionRuntime {
 
     return true
   }
+
+  /**
+   * Resume an idle session by sending `text` as a new user turn.
+   *
+   * Used when a question is answered after its run was aborted elsewhere:
+   * the original run is dead, so question.reply is a no-op. We instead feed
+   * the answer back as a fresh prompt so opencode continues from history.
+   */
+  async resumeWithText({ text }: { text: string }): Promise<boolean> {
+    const sessionId = this.state?.sessionId
+    if (!sessionId || this.disposed) {
+      logger.log(`[RESUME] No session for thread ${this.threadId}`)
+      return false
+    }
+    await this.enqueueIncoming({
+      prompt: text,
+      userId: '',
+      username: '',
+      appId: this.appId,
+      mode: 'opencode',
+      resetAssistantForNewRun: true,
+      expectedSessionId: sessionId,
+    })
+    return true
+  }
 }
 
 // ── Module-level helpers ──────────────────────────────────────────