From 692cf5a3bd64b7bdbf3021469aa65c1a6fc31431 Mon Sep 17 00:00:00 2001
From: shaowei <466995322@qq.com>
Date: Mon, 3 Aug 2026 02:08:20 +0800
Subject: [PATCH 1/4] feat: add persistent plan and thread goals

---
 scripts/verify-frontend-normalizers.mjs       |  76 +-
 src/App.vue                                   |  93 ++-
 src/api/codexGateway.ts                       |  26 +
 src/api/normalizers/v2.ts                     |  24 +-
 .../content/ComposerRegressionFixture.vue     |  81 ++-
 .../content/ConversationRegressionFixture.vue |  80 ++-
 src/components/content/ThreadComposer.vue     |  39 +-
 src/components/content/ThreadConversation.vue | 433 ++++++++++++
 src/components/content/ThreadGoalBar.vue      | 650 ++++++++++++++++++
 src/composables/conversationProjection.ts     |  41 ++
 src/composables/threadGoal.ts                 |  35 +
 src/composables/useDesktopState.ts            | 442 +++++++++++-
 src/types/codex.ts                            |  35 +
 tests.md                                      |  45 +-
 14 files changed, 2056 insertions(+), 44 deletions(-)
 create mode 100644 src/components/content/ThreadGoalBar.vue
 create mode 100644 src/composables/threadGoal.ts

diff --git a/scripts/verify-frontend-normalizers.mjs b/scripts/verify-frontend-normalizers.mjs
index 6e8ae2c..79429fd 100644
--- a/scripts/verify-frontend-normalizers.mjs
+++ b/scripts/verify-frontend-normalizers.mjs
@@ -31,6 +31,7 @@ const latestReplyImport = toImportPath(relative(outputRoot, join(repoRoot, 'src'
 const taskPetReadPolicyImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'mobile', 'taskPetReadPolicy.ts')))
 const sessionFileChangeImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'sessionFileChange.ts')))
 const composerEnterBehaviorImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'composerEnterBehavior.ts')))
+const threadGoalImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'threadGoal.ts')))
 
 try {
   writeFileSync(entryPath, `
@@ -64,7 +65,9 @@ import {
 } from '${messageOutboxPersistenceImport}'
 import {
   areMessageFieldsEqual,
+  hasPlanImplementationConfirmation,
   mergeMessages,
+  PLAN_IMPLEMENTATION_CONFIRMATION,
   removeRedundantLiveAgentMessages,
   removeStaleHistoryNoticeAfterOlderMerge,
   sortMessagesByTurnIndex,
@@ -105,6 +108,7 @@ import {
   readCxSessionFileChangeSource,
 } from '${sessionFileChangeImport}'
 import { resolveSendWithEnterPreference } from '${composerEnterBehaviorImport}'
+import { normalizeThreadGoal } from '${threadGoalImport}'
 
 assert.equal(CONVERSATION_BOTTOM_THRESHOLD_PX, 24)
 assert.equal(CX_SESSION_FILES_CHANGED_METHOD, 'cx/session-files/changed')
@@ -131,6 +135,27 @@ assert.equal(resolveSendWithEnterPreference(null, true), false)
 assert.equal(resolveSendWithEnterPreference('1', true), true)
 assert.equal(resolveSendWithEnterPreference('0', false), false)
 assert.equal(resolveSendWithEnterPreference('invalid', true), false)
+assert.deepEqual(normalizeThreadGoal({
+  threadId: 'thread-goal',
+  objective: 'Keep improving',
+  status: 'active',
+  tokenBudget: 1000,
+  tokensUsed: 120,
+  timeUsedSeconds: 30,
+  createdAt: 1,
+  updatedAt: 2,
+}), {
+  threadId: 'thread-goal',
+  objective: 'Keep improving',
+  status: 'active',
+  tokenBudget: 1000,
+  tokensUsed: 120,
+  timeUsedSeconds: 30,
+  createdAt: 1,
+  updatedAt: 2,
+})
+assert.equal(normalizeThreadGoal({ threadId: 'thread-goal', objective: 'x', status: 'unknown' }), null)
+assert.equal(normalizeThreadGoal({ threadId: '', objective: 'x', status: 'active' }), null)
 assert.equal(conversationDistanceFromBottom({ scrollHeight: 1000, scrollTop: 676, clientHeight: 300 }), 24)
 assert.equal(isConversationViewportAtBottom({ scrollHeight: 1000, scrollTop: 676, clientHeight: 300 }), true)
 assert.equal(isConversationViewportAtBottom({ scrollHeight: 1000, scrollTop: 675, clientHeight: 300 }), false)
@@ -562,6 +587,37 @@ assert.equal(areMessageFieldsEqual(projectedCommand, {
   ...projectedCommand,
   commandExecution: { ...projectedCommand.commandExecution, command: 'npm run test' },
 }), false)
+const projectedPlan = {
+  id: 'plan:turn-projection',
+  role: 'system',
+  text: '',
+  messageType: 'plan',
+  plan: {
+    turnId: 'turn-projection',
+    explanation: 'Plan safely',
+    steps: [{ step: 'Inspect', status: 'pending' }],
+    rawText: '',
+    isStreaming: false,
+  },
+}
+assert.equal(areMessageFieldsEqual(projectedPlan, { ...projectedPlan, plan: { ...projectedPlan.plan } }), true)
+assert.equal(areMessageFieldsEqual(projectedPlan, {
+  ...projectedPlan,
+  plan: { ...projectedPlan.plan, steps: [{ step: 'Inspect', status: 'completed' }] },
+}), false)
+assert.equal(hasPlanImplementationConfirmation([
+  projectedPlan,
+  { id: 'plan-confirmation', role: 'user', text: PLAN_IMPLEMENTATION_CONFIRMATION },
+], projectedPlan.id), true)
+assert.equal(hasPlanImplementationConfirmation([
+  projectedPlan,
+  { id: 'ordinary-follow-up', role: 'user', text: '继续检查，但先不要执行' },
+], projectedPlan.id), false)
+assert.equal(hasPlanImplementationConfirmation([
+  projectedPlan,
+  { ...projectedPlan, id: 'plan:newer-turn' },
+  { id: 'late-confirmation', role: 'user', text: PLAN_IMPLEMENTATION_CONFIRMATION },
+], projectedPlan.id), false)
 assert.equal(areMessageFieldsEqual(projectedCommand, {
   ...projectedCommand,
   commandExecution: { ...projectedCommand.commandExecution, cwd: 'E:/other' },
@@ -717,6 +773,7 @@ const messages = normalizeThreadMessagesV2({
         status: 'completed',
         items: [
           { id: 'item-known', type: 'agentMessage', text: 'Known message' },
+          { id: 'item-plan', type: 'plan', text: '1. Inspect\\n2. Implement' },
           {
             id: 'item-mcp',
             type: 'mcpToolCall',
@@ -756,16 +813,21 @@ const messages = normalizeThreadMessagesV2({
   },
 })
 
-assert.equal(messages.length, 3)
+assert.equal(messages.length, 4)
 assert.equal(messages[0]?.messageType, 'agentMessage')
 assert.equal(messages[1]?.role, 'system')
-assert.equal(messages[1]?.messageType, 'unhandled.threadShellCommandOutput')
-assert.equal(messages[1]?.text, 'Unhandled App Server item: threadShellCommandOutput')
-assert.equal(messages[1]?.isUnhandled, true)
-assert.equal(messages[1]?.turnIndex, 0)
-assert.equal(messages[1]?.rawPayload?.includes('secret command'), true)
-assert.equal(messages[2]?.messageType, 'unhandled.invalidItem')
+assert.equal(messages[1]?.id, 'plan:turn-a')
+assert.equal(messages[1]?.messageType, 'plan')
+assert.equal(messages[1]?.plan?.turnId, 'turn-a')
+assert.equal(messages[1]?.plan?.rawText, '1. Inspect\\n2. Implement')
+assert.equal(messages[1]?.plan?.isStreaming, false)
+assert.equal(messages[2]?.messageType, 'unhandled.threadShellCommandOutput')
+assert.equal(messages[2]?.text, 'Unhandled App Server item: threadShellCommandOutput')
 assert.equal(messages[2]?.isUnhandled, true)
+assert.equal(messages[2]?.turnIndex, 0)
+assert.equal(messages[2]?.rawPayload?.includes('secret command'), true)
+assert.equal(messages[3]?.messageType, 'unhandled.invalidItem')
+assert.equal(messages[3]?.isUnhandled, true)
 assert.equal(messages.some((message) => message.messageType === 'unhandled.fileChange'), false)
 assert.equal(messages.some((message) => message.messageType === 'unhandled.webSearch'), false)
 assert.equal(messages.some((message) => message.rawPayload?.includes('large internal patch details')), false)
diff --git a/src/App.vue b/src/App.vue
index fedda60..dcc6f46 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -813,6 +813,8 @@
                   :show-empty-thread-actions="isRouteOnlyEmptyThread"
                   :is-turn-in-progress="isSelectedThreadInProgress"
                   :is-rolling-back="isRollingBack"
+                  :implementing-plan-id="implementingPlanId"
+                  :implemented-plan-ids="implementedPlanIds"
                   @update-scroll-state="onUpdateThreadScrollState"
                   @respond-server-request="onRespondServerRequest"
                   @toggle-favorite="onToggleFavoriteMessage"
@@ -823,6 +825,7 @@
                   @dismiss-empty-thread="onDismissEmptyThread"
                   @copy-status="onConversationCopyStatus"
                   @retry-failed-message="retryFailedUserMessage"
+                  @implement-plan="onImplementPlan"
                   @rollback="onRollback" />
               </div>
 
@@ -846,6 +849,20 @@
                   @retry="retryQueuedMessage"
                   @delete="deleteQueuedMessage"
                 />
+                <ThreadGoalBar
+                  :key="selectedThreadId"
+                  :goal="selectedThreadGoal"
+                  :is-loading="isSelectedThreadGoalLoading"
+                  :is-updating="isSelectedThreadGoalUpdating"
+                  :error="selectedThreadGoalError"
+                  :execution-hint="selectedThreadGoalExecutionHint"
+                  :plan-mode-active="selectedCollaborationMode === 'plan'"
+                  :disabled="isThreadContentSwitching"
+                  @set-goal="onSaveThreadGoal"
+                  @set-status="onSetThreadGoalStatus"
+                  @clear-goal="onClearThreadGoal"
+                  @retry="refreshSelectedThreadGoal"
+                />
                 <ThreadComposer ref="threadComposerRef" :active-thread-id="composerThreadContextId"
                   :cwd="composerCwd"
                   :models="availableModelIds"
@@ -861,7 +878,6 @@
                   :is-loading-plugins="isLoadingComposerPlugins"
                   :has-loaded-plugins="hasLoadedComposerPlugins"
                   :is-turn-in-progress="isSelectedThreadInterruptible" :is-interrupting-turn="isInterruptingTurn"
-                  :has-queue-above="selectedThreadQueuedMessages.length > 0"
                   :send-with-enter="sendWithEnter"
                   :dictation-click-to-toggle="dictationClickToToggle" :dictation-auto-send="dictationAutoSend"
                   :show-dictation-button="dictationButtonVisible"
@@ -1091,6 +1107,7 @@ import { chatFeedbackNow } from './composables/chatFeedbackMetrics'
 import { useFavorites, type FavoriteRecord } from './composables/useFavorites'
 import { useMobile } from './composables/useMobile'
 import { resolveSendWithEnterPreference } from './composables/composerEnterBehavior'
+import { PLAN_IMPLEMENTATION_CONFIRMATION } from './composables/conversationProjection'
 import { useLazyModalEnvironment } from './composables/useLazyModalEnvironment'
 import {
   createWorktree,
@@ -1183,6 +1200,7 @@ const ThreadConversation = defineAsyncComponent({
   loadingComponent: ConversationLoadingSkeleton,
   delay: 0,
 })
+const ThreadGoalBar = defineAsyncComponent(() => import('./components/content/ThreadGoalBar.vue'))
 const QueuedMessages = defineAsyncComponent(() => import('./components/content/QueuedMessages.vue'))
 const RateLimitStatus = defineAsyncComponent(() => import('./components/content/RateLimitStatus.vue'))
 const FavoritesModal = defineAsyncComponent(() => import('./components/content/FavoritesModal.vue'))
@@ -1442,6 +1460,10 @@ const {
   selectedLiveOverlay,
   selectedThreadRuntimeStatus,
   selectedThreadTokenUsage,
+  selectedThreadGoal,
+  isSelectedThreadGoalLoading,
+  isSelectedThreadGoalUpdating,
+  selectedThreadGoalError,
   selectedThreadLoadError,
   selectedThreadId,
   availableModels,
@@ -1508,6 +1530,10 @@ const {
   setWorktreeGitAutomationEnabled,
   setSelectedReasoningEffort,
   setSelectedCollaborationMode,
+  refreshSelectedThreadGoal,
+  saveSelectedThreadGoal,
+  updateSelectedThreadGoalStatus,
+  clearSelectedThreadGoal,
   updateSelectedSpeedMode,
   respondToPendingServerRequest,
   renameProject,
@@ -1530,6 +1556,8 @@ const isSettingsSheetMode = computed(() => isMobile.value || isDualPaneMobile.va
 const { favorites, toggleFavorite, removeFavorite, refreshFavorites } = useFavorites()
 const homeThreadComposerRef = ref<ThreadComposerExposed | null>(null)
 const threadComposerRef = ref<ThreadComposerExposed | null>(null)
+const implementingPlanId = ref('')
+const implementedPlanIds = ref<string[]>([])
 const threadConversationRef = ref<ThreadConversationExposed | null>(null)
 const sidebarThreadTreeRef = ref<{ revealSelectedThread: () => Promise<boolean> } | null>(null)
 const sidebarScrollableRef = ref<HTMLElement | null>(null)
@@ -2333,6 +2361,13 @@ const displayFavorites = computed<FavoriteRecord[]>(() => (
 ))
 const isSelectedThreadInProgress = computed(() => !isHomeRoute.value && selectedThreadExecutionActive.value)
 const isSelectedThreadInterruptible = computed(() => !isHomeRoute.value && selectedThreadCanStop.value)
+const selectedThreadGoalExecutionHint = computed(() => {
+  if (selectedThreadGoal.value?.status !== 'active') return ''
+  if (selectedThreadServerRequests.value.length > 0) return '等待确认'
+  if (selectedThreadQueuedMessages.value.length > 0) return '等待消息队列'
+  if (isSelectedThreadInProgress.value) return '正在推进'
+  return '等待继续'
+})
 const shouldShowSelectedThreadProcessing = computed(() => (
   selectedThreadServerRequests.value.length > 0 ||
   selectedLiveOverlay.value !== null ||
@@ -4581,8 +4616,62 @@ function onSelectCollaborationMode(mode: CollaborationMode): void {
   setSelectedCollaborationMode(mode)
 }
 
+function onSaveThreadGoal(objective: string): void {
+  void saveSelectedThreadGoal(objective).catch(() => {
+    // The desktop state exposes the actionable RPC error in the shared error banner.
+  })
+}
+
+function onSetThreadGoalStatus(status: 'active' | 'paused'): void {
+  void updateSelectedThreadGoalStatus(status).catch(() => {
+    // Keep the existing goal visible so the user can retry without re-entering it.
+  })
+}
+
+function onClearThreadGoal(): void {
+  void clearSelectedThreadGoal().catch(() => {
+    // The goal remains visible when the authoritative clear fails.
+  })
+}
+
+async function onImplementPlan(message: UiMessage): Promise<void> {
+  const threadId = selectedThreadId.value
+  if (
+    !threadId
+    || isSelectedThreadInProgress.value
+    || implementingPlanId.value
+    || implementedPlanIds.value.includes(message.id)
+  ) return
+  const previousMode = selectedCollaborationMode.value
+  implementingPlanId.value = message.id
+  setSelectedCollaborationMode('execute')
+  try {
+    await sendMessageToSelectedThread(
+      PLAN_IMPLEMENTATION_CONFIRMATION,
+      [],
+      [],
+      'steer',
+      [],
+      undefined,
+      'execute',
+    )
+    implementedPlanIds.value = [...implementedPlanIds.value, message.id].slice(-12)
+    markDesktopSyncPending(threadId)
+  } catch {
+    if (selectedThreadId.value === threadId) setSelectedCollaborationMode(previousMode)
+    showProductToast('计划提交失败，计划卡已保留，可直接重试。', 'danger')
+  } finally {
+    if (implementingPlanId.value === message.id) implementingPlanId.value = ''
+  }
+}
+
 function onInterruptTurn(source: 'composer-stop' | 'runtime-status-stop' | 'unknown' = 'unknown'): void {
-  showProductToast('已请求停止，正在确认任务状态。', 'warning')
+  showProductToast(
+    selectedThreadGoal.value?.status === 'active'
+      ? '已请求停止，持续目标已同时暂停。'
+      : '已请求停止，正在确认任务状态。',
+    'warning',
+  )
   void interruptSelectedThreadTurn(source)
 }
 
diff --git a/src/api/codexGateway.ts b/src/api/codexGateway.ts
index c312020..9746cbf 100644
--- a/src/api/codexGateway.ts
+++ b/src/api/codexGateway.ts
@@ -35,11 +35,14 @@ import type {
   SpeedMode,
   UiMessage,
   UiProjectGroup,
+  UiThreadGoal,
+  UiThreadGoalStatus,
   UiThreadTokenUsage,
   UiTokenUsageBreakdown,
 } from '../types/codex'
 import { normalizePathForUi } from '../pathUtils.js'
 import { shouldAutoLoginForResponse, tryMobileShellAutoLogin } from '../mobile/mobileAuth'
+import { normalizeThreadGoal } from '../composables/threadGoal'
 
 type CurrentModelConfig = {
   model: string
@@ -1038,6 +1041,29 @@ export async function renameThread(threadId: string, threadName: string): Promis
   await callRpc('thread/name/set', { threadId, name: threadName })
 }
 
+export async function getThreadGoal(threadId: string, options: RpcCallOptions = {}): Promise<UiThreadGoal | null> {
+  const payload = await callRpc<{ goal?: unknown }>('thread/goal/get', { threadId }, options)
+  return normalizeThreadGoal(payload?.goal)
+}
+
+export async function setThreadGoal(
+  threadId: string,
+  input: { objective?: string; status?: Extract<UiThreadGoalStatus, 'active' | 'paused'> },
+): Promise<UiThreadGoal> {
+  const params: Record<string, unknown> = { threadId }
+  const objective = input.objective?.trim()
+  if (objective) params.objective = objective
+  if (input.status) params.status = input.status
+  const payload = await callRpc<{ goal?: unknown }>('thread/goal/set', params)
+  const goal = normalizeThreadGoal(payload?.goal)
+  if (!goal) throw new Error('thread/goal/set did not return a valid goal')
+  return goal
+}
+
+export async function clearThreadGoal(threadId: string): Promise<void> {
+  await callRpc('thread/goal/clear', { threadId })
+}
+
 export async function rollbackThread(threadId: string, numTurns: number): Promise<UiMessage[]> {
   const payload = await callRpc<ThreadReadResponse>('thread/rollback', { threadId, numTurns })
   return normalizeThreadMessagesV2(payload)
diff --git a/src/api/normalizers/v2.ts b/src/api/normalizers/v2.ts
index 7c5c360..d306a4b 100644
--- a/src/api/normalizers/v2.ts
+++ b/src/api/normalizers/v2.ts
@@ -223,7 +223,7 @@ function extractAssistantImages(item: ThreadItem): string[] {
   return images
 }
 
-function toUiMessages(item: ThreadItem): UiMessage[] {
+function toUiMessages(item: ThreadItem, turnId = ''): UiMessage[] {
   const rawItem = item as Record<string, unknown>
   const itemId = readTrimmedString(rawItem.id) || `unhandled:${readTrimmedString(rawItem.type) || 'item'}`
   const itemType = readTrimmedString(rawItem.type)
@@ -254,6 +254,26 @@ function toUiMessages(item: ThreadItem): UiMessage[] {
     ]
   }
 
+  if (item.type === 'plan') {
+    const text = typeof item.text === 'string' ? item.text : ''
+    const normalizedTurnId = turnId.trim()
+    return [
+      {
+        id: normalizedTurnId ? `plan:${normalizedTurnId}` : item.id,
+        role: 'system',
+        text,
+        messageType: 'plan',
+        plan: {
+          turnId: normalizedTurnId,
+          explanation: '',
+          steps: [],
+          rawText: text,
+          isStreaming: false,
+        },
+      },
+    ]
+  }
+
   if (item.type === 'imageView') {
     const images: string[] = []
     pushImageCandidate(images, rawItem.path)
@@ -507,7 +527,7 @@ export function normalizeThreadMessagesV2(payload: ThreadReadResponse): UiMessag
           ? item
           : { id: `turn-${String(turnIndex)}:item-${String(messages.length)}`, type: 'invalidItem', content: item }
       ) as ThreadItem
-      for (const msg of toUiMessages(threadItem)) {
+      for (const msg of toUiMessages(threadItem, readTrimmedString(rawTurn.id))) {
         messages.push({ ...msg, turnIndex: absoluteTurnIndex })
       }
     }
diff --git a/src/components/content/ComposerRegressionFixture.vue b/src/components/content/ComposerRegressionFixture.vue
index 95f58f9..f179cfc 100644
--- a/src/components/content/ComposerRegressionFixture.vue
+++ b/src/components/content/ComposerRegressionFixture.vue
@@ -14,8 +14,30 @@
         >
           模拟语音转文字
         </button>
+        <button
+          v-if="isGoalSwitchFixture"
+          class="composer-regression-dictation-insert"
+          data-testid="switch-goal-thread"
+          type="button"
+          @click="switchFixtureGoalThread"
+        >切换目标会话</button>
+        <span v-if="isGoalSwitchFixture" data-testid="active-goal-thread">{{ fixtureThreadId }}</span>
         <span class="composer-regression-submit-count">{{ submitCount }}</span>
       </div>
+      <ThreadGoalBar
+        v-if="showGoalFixture"
+        :key="fixtureThreadId"
+        :goal="fixtureGoal"
+        :is-loading="false"
+        :is-updating="false"
+        :error="fixtureGoalError"
+        :plan-mode-active="selectedCollaborationMode === 'plan'"
+        execution-hint="等待消息队列"
+        @set-goal="updateFixtureGoal"
+        @set-status="updateFixtureGoalStatus"
+        @clear-goal="fixtureGoal = null"
+        @retry="fixtureGoalError = ''"
+      />
       <ThreadComposer
         ref="composerRef"
         active-thread-id="fixture-thread-composer"
@@ -25,7 +47,7 @@
         selected-model="gpt-5.5"
         selected-reasoning-effort="high"
         selected-speed-mode="fast"
-        selected-collaboration-mode="execute"
+        :selected-collaboration-mode="selectedCollaborationMode"
         :skills="skills"
         :plugins="plugins"
         :is-loading-plugins="false"
@@ -41,7 +63,7 @@
         @update:selected-model="noop"
         @update:selected-reasoning-effort="noop"
         @update:selected-speed-mode="noop"
-        @update:selected-collaboration-mode="noop"
+        @update:selected-collaboration-mode="selectedCollaborationMode = $event"
         @refresh-plugins="noop"
         @reload-plugins="noop"
         @login-plugin="noop"
@@ -54,7 +76,8 @@
 <script setup lang="ts">
 import { computed, onBeforeUnmount, ref } from 'vue'
 import ThreadComposer, { type SubmitPayload, type ThreadComposerExposed } from './ThreadComposer.vue'
-import type { ComposerModelInfo, ComposerPluginInfo, ReasoningEffort } from '../../types/codex'
+import ThreadGoalBar from './ThreadGoalBar.vue'
+import type { CollaborationMode, ComposerModelInfo, ComposerPluginInfo, ReasoningEffort, UiThreadGoal } from '../../types/codex'
 import { useMobile } from '../../composables/useMobile'
 import { resolveSendWithEnterPreference } from '../../composables/composerEnterBehavior'
 
@@ -94,6 +117,24 @@ const availableModels: ComposerModelInfo[] = [
 ]
 const composerRef = ref<ThreadComposerExposed | null>(null)
 const submitCount = ref(0)
+const fixtureParams = typeof window !== 'undefined'
+  ? new URLSearchParams(window.location.hash.split('?')[1] ?? '')
+  : new URLSearchParams()
+const showGoalFixture = fixtureParams.get('goal') === '1'
+const isGoalSwitchFixture = fixtureParams.get('goalSwitch') === '1'
+const fixtureThreadId = ref(isGoalSwitchFixture ? 'fixture-thread-a' : 'fixture-thread-composer')
+const selectedCollaborationMode = ref<CollaborationMode>(fixtureParams.get('planMode') === '1' ? 'plan' : 'execute')
+const fixtureGoalError = ref(fixtureParams.get('goalError') === '1' ? '持续目标同步失败，请重试。' : '')
+const fixtureGoal = ref<UiThreadGoal | null>(fixtureParams.get('goalEmpty') === '1' ? null : {
+  threadId: fixtureThreadId.value,
+  objective: '持续完善 7420 的稳定性与细节体验，并以可复现回归作为完成标准。',
+  status: 'active',
+  tokenBudget: 120_000,
+  tokensUsed: 36_800,
+  timeUsedSeconds: 4_260,
+  createdAt: Date.now() - 4_260_000,
+  updatedAt: Date.now(),
+})
 const { isMobile } = useMobile()
 const sendWithEnter = computed(() => resolveSendWithEnterPreference(null, isMobile.value))
 const originalFetch = window.fetch
@@ -154,6 +195,40 @@ function noop(): void {
   // Fixture route only needs rendered output for browser assertions.
 }
 
+function updateFixtureGoal(objective: string): void {
+  fixtureGoal.value = fixtureGoal.value
+    ? { ...fixtureGoal.value, objective, updatedAt: Date.now() }
+    : {
+        threadId: fixtureThreadId.value,
+        objective,
+        status: 'active',
+        tokenBudget: null,
+        tokensUsed: 0,
+        timeUsedSeconds: 0,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      }
+}
+
+function updateFixtureGoalStatus(status: 'active' | 'paused'): void {
+  if (!fixtureGoal.value) return
+  fixtureGoal.value = { ...fixtureGoal.value, status, updatedAt: Date.now() }
+}
+
+function switchFixtureGoalThread(): void {
+  fixtureThreadId.value = fixtureThreadId.value === 'fixture-thread-a' ? 'fixture-thread-b' : 'fixture-thread-a'
+  fixtureGoal.value = {
+    threadId: fixtureThreadId.value,
+    objective: `持续目标：${fixtureThreadId.value}`,
+    status: 'active',
+    tokenBudget: 120_000,
+    tokensUsed: 36_800,
+    timeUsedSeconds: 4_260,
+    createdAt: Date.now() - 4_260_000,
+    updatedAt: Date.now(),
+  }
+}
+
 function onSubmit(_payload: SubmitPayload): void {
   submitCount.value += 1
 }
diff --git a/src/components/content/ConversationRegressionFixture.vue b/src/components/content/ConversationRegressionFixture.vue
index bba1462..68194b8 100644
--- a/src/components/content/ConversationRegressionFixture.vue
+++ b/src/components/content/ConversationRegressionFixture.vue
@@ -53,7 +53,7 @@
         :pending-requests="pendingRequests"
         :live-overlay="liveOverlay"
         :is-loading="false"
-        :is-turn-in-progress="!isLoadFailureFixture && !isScrollSwitchRaceFixture"
+        :is-turn-in-progress="!isLoadFailureFixture && !isScrollSwitchRaceFixture && !isPlanFixture"
         :load-error="isLoadFailureFixture ? '连接不到桌面端，会话内容暂时未加载。页面会自动重试，也可以检查或修改连接地址。' : ''"
         :show-connection-settings-action="isLoadFailureFixture"
         compact-runtime-chrome
@@ -61,6 +61,8 @@
         cwd="E:/javaword/CXCodex/codexui"
         :scroll-state="activeScrollState"
         :favorite-message-ids="favoriteMessageIds"
+        :implementing-plan-id="fixtureImplementingPlanId"
+        :implemented-plan-ids="fixtureImplementedPlanIds"
         @update-scroll-state="onUpdateScrollState"
         @respond-server-request="noop"
         @rollback="noop"
@@ -71,6 +73,7 @@
         @return-to-new-thread="noop"
         @dismiss-empty-thread="noop"
         @retry-failed-message="noop"
+        @implement-plan="implementFixturePlan"
         @copy-status="copyStatus = $event"
       />
       <p
@@ -103,6 +106,7 @@ import { computed, ref } from 'vue'
 import ThreadConversation from './ThreadConversation.vue'
 import RuntimeStatusBar from './RuntimeStatusBar.vue'
 import QueuedMessages from './QueuedMessages.vue'
+import { PLAN_IMPLEMENTATION_CONFIRMATION } from '../../composables/conversationProjection'
 import type {
   ThreadScrollState,
   UiLiveOverlay,
@@ -366,6 +370,11 @@ const isForegroundResumeScrollFixture = fixtureParams.get('foregroundResumeScrol
 const isImagePreviewFixture = fixtureParams.get('imagePreview') === '1'
 const isMarkdownImageFixture = fixtureParams.get('markdownImage') === '1'
 const isMessageActionHitFixture = fixtureParams.get('messageActionHit') === '1'
+const isPlanFixture = fixtureParams.get('plan') === '1'
+const isPlanSubmittedFixture = fixtureParams.get('planSubmitted') === '1'
+const isPlanHistoryImplementedFixture = fixtureParams.get('planHistoryImplemented') === '1'
+const fixtureImplementingPlanId = ref(fixtureParams.get('planSubmitting') === '1' ? 'plan:fixture-plan-turn' : '')
+const fixtureImplementedPlanIds = ref<string[]>(isPlanSubmittedFixture ? ['plan:fixture-plan-turn'] : [])
 const activeThreadId = ref(isScrollSwitchRaceFixture ? 'regression-scroll-a' : 'regression-conversation-blocks')
 const scrollStateByThreadId = ref<Record<string, ThreadScrollState>>({})
 const activeScrollState = computed(() => scrollStateByThreadId.value[activeThreadId.value] ?? null)
@@ -393,6 +402,54 @@ const markdownImageMessages: UiMessage[] = [
     turnIndex: 9,
   },
 ]
+const planMessages: UiMessage[] = [
+  {
+    id: 'plan:fixture-older-plan-turn',
+    role: 'system',
+    text: '',
+    messageType: 'plan',
+    plan: {
+      turnId: 'fixture-older-plan-turn',
+      explanation: '这是较早的计划，默认应收起以降低长会话噪声。',
+      steps: [
+        { step: '读取现有实现', status: 'completed' },
+        { step: '列出体验问题', status: 'completed' },
+      ],
+      rawText: '',
+      isStreaming: false,
+    },
+    turnIndex: 9,
+  },
+  {
+    id: 'fixture-plan-request',
+    role: 'user',
+    text: '请先规划如何稳定实现持续目标，不要修改文件。',
+    turnIndex: 10,
+  },
+  {
+    id: 'plan:fixture-plan-turn',
+    role: 'system',
+    text: '',
+    messageType: 'plan',
+    plan: {
+      turnId: 'fixture-plan-turn',
+      explanation: '先确认桌面端协议，再以最小改动补齐状态、交互和验证闭环。',
+      steps: [
+        { step: '核对 thread/goal 与 turn/plan 事件结构', status: 'completed' },
+        { step: '接入线程级目标生命周期和持续计划模式', status: 'completed' },
+        { step: '补充计划增量合并，避免频繁重绘', status: 'completed' },
+        { step: '为目标读取增加请求去重与旧响应保护', status: 'completed' },
+        { step: '优化移动端目标操作区', status: 'inProgress' },
+        { step: '验证清除确认和错误重试', status: 'pending' },
+        { step: '完成浏览器回归并记录兼容边界', status: 'pending' },
+        { step: '整理发布前验收结论', status: 'pending' },
+      ],
+      rawText: '',
+      isStreaming: false,
+    },
+    turnIndex: 10,
+  },
+]
 const scrollRaceMessagesByThreadId = ref<Record<string, UiMessage[]>>(Object.fromEntries(
   ['regression-scroll-a', 'regression-scroll-b'].map((threadId) => [
     threadId,
@@ -411,6 +468,16 @@ const fixtureMessages = computed(() => {
   }
   if (isImagePreviewFixture) return [...messages, imagePreviewMessage]
   if (isMarkdownImageFixture) return [...messages, ...markdownImageMessages]
+  if (isPlanFixture) {
+    return isPlanHistoryImplementedFixture
+      ? [...planMessages, {
+          id: 'fixture-plan-implementation-confirmation',
+          role: 'user' as const,
+          text: PLAN_IMPLEMENTATION_CONFIRMATION,
+          turnIndex: 11,
+        }]
+      : planMessages
+  }
   return messages
 })
 const pendingRequests: UiServerRequest[] = isTailStatusFixture || isLoadFailureFixture ? [] : allPendingRequests
@@ -428,7 +495,7 @@ const liveOverlay = ref<UiLiveOverlay | null>({
   errorText: '',
 })
 
-if (isLoadFailureFixture || isScrollSwitchRaceFixture) {
+if (isLoadFailureFixture || isScrollSwitchRaceFixture || isPlanFixture) {
   liveOverlay.value = null
 }
 
@@ -498,6 +565,15 @@ function noop(): void {
   // Fixture route only needs rendered output for browser assertions.
 }
 
+function implementFixturePlan(message: UiMessage): void {
+  if (fixtureImplementingPlanId.value || fixtureImplementedPlanIds.value.includes(message.id)) return
+  fixtureImplementingPlanId.value = message.id
+  window.setTimeout(() => {
+    fixtureImplementedPlanIds.value = [...fixtureImplementedPlanIds.value, message.id]
+    fixtureImplementingPlanId.value = ''
+  }, 400)
+}
+
 function appendResumeOutput(): void {
   const threadId = activeThreadId.value
   const currentMessages = scrollRaceMessagesByThreadId.value[threadId] ?? []
diff --git a/src/components/content/ThreadComposer.vue b/src/components/content/ThreadComposer.vue
index 373a580..15c8cd6 100644
--- a/src/components/content/ThreadComposer.vue
+++ b/src/components/content/ThreadComposer.vue
@@ -221,7 +221,10 @@
         </span>
       </div>
 
-      <div v-if="selectedPlugins.length > 0 || goalModeEnabled || pendingCapabilityCount > 0" class="thread-composer-option-chips">
+      <div
+        v-if="selectedPlugins.length > 0 || goalModeEnabled || selectedCollaborationMode === 'plan' || pendingCapabilityCount > 0"
+        class="thread-composer-option-chips"
+      >
         <span
           v-if="pendingCapabilityCount > 0"
           class="thread-composer-option-chip"
@@ -248,10 +251,26 @@
           <button
             class="thread-composer-option-chip-remove"
             type="button"
-            aria-label="移除本轮要求"
+            aria-label="移除一次性本轮要求"
             @click="disableGoalMode"
           >×</button>
         </span>
+        <span
+          v-if="selectedCollaborationMode === 'plan'"
+          class="thread-composer-option-chip thread-composer-option-chip--plan"
+          role="status"
+          title="计划模式会持续开启，发送消息只生成计划"
+        >
+          <span class="thread-composer-option-chip-dot" aria-hidden="true" />
+          <span class="thread-composer-option-chip-name">计划模式 · 持续开启</span>
+          <button
+            class="thread-composer-option-chip-remove"
+            type="button"
+            aria-label="退出计划模式"
+            title="退出计划模式"
+            @click="togglePlanMode"
+          >×</button>
+        </span>
       </div>
 
       <div class="thread-composer-input-wrap">
@@ -409,9 +428,9 @@
             >
               <span class="thread-composer-attach-item-icon thread-composer-attach-item-icon--text">✓</span>
               <span class="thread-composer-attach-item-body">
-                <span class="thread-composer-attach-item-title">仅生成计划</span>
+                <span class="thread-composer-attach-item-title">计划模式</span>
                 <span class="thread-composer-attach-item-subtitle">
-                  {{ selectedCollaborationMode === 'plan' ? '本次只生成计划，发送后回到执行' : '仅规划一次，不执行文件和命令' }}
+                  {{ selectedCollaborationMode === 'plan' ? '持续开启，仅规划，不执行修改' : '开启后持续使用计划模式' }}
                 </span>
               </span>
               <span class="thread-composer-switch" :class="{ 'is-on': selectedCollaborationMode === 'plan' }" aria-hidden="true" />
@@ -425,7 +444,7 @@
             >
               <span class="thread-composer-attach-item-icon thread-composer-attach-item-icon--text">◎</span>
               <span class="thread-composer-attach-item-body">
-                <span class="thread-composer-attach-item-title">本轮要求</span>
+                <span class="thread-composer-attach-item-title">本轮要求（一次性）</span>
                 <span class="thread-composer-attach-item-subtitle">{{ activeGoalLabel }}</span>
               </span>
               <span class="thread-composer-switch" :class="{ 'is-on': goalModeEnabled }" aria-hidden="true" />
@@ -434,7 +453,7 @@
               <textarea
                 v-model="goalText"
                 class="thread-composer-goal-input"
-                aria-label="本轮要求内容"
+                aria-label="一次性本轮要求内容"
                 placeholder="输入本次消息的额外要求，例如：给出可执行方案并主动补齐风险"
                 :disabled="isInteractionDisabled"
                 rows="2"
@@ -1209,7 +1228,7 @@ const isSpeedToggleDisabled = computed(() =>
 const collaborationModeHintText = computed(() => {
   if (props.isTurnInProgress) return ''
   return props.selectedCollaborationMode === 'plan'
-    ? '只制定计划，发送后自动回到执行'
+    ? '计划模式会保持开启，直到你主动关闭'
     : ''
 })
 const submitActionLabel = computed(() => {
@@ -2947,6 +2966,12 @@ watch(
   @apply border-amber-200 bg-amber-50 text-amber-800;
 }
 
+.thread-composer-option-chip--plan {
+  border-color: color-mix(in srgb, var(--ui-accent) 28%, var(--ui-border-subtle));
+  background: color-mix(in srgb, var(--ui-accent) 7%, var(--ui-bg-surface));
+  color: var(--ui-accent);
+}
+
 .thread-composer-option-chip-dot {
   @apply h-1.5 w-1.5 shrink-0 rounded-full bg-[#0d9488];
 }
diff --git a/src/components/content/ThreadConversation.vue b/src/components/content/ThreadConversation.vue
index 8aa6114..f1c4a50 100644
--- a/src/components/content/ThreadConversation.vue
+++ b/src/components/content/ThreadConversation.vue
@@ -542,6 +542,68 @@
           </div>
         </div>
 
+        <div v-else-if="isPlanMessage(entry.message)" class="message-row" data-role="system" data-message-type="plan">
+          <div class="message-stack" data-role="system">
+            <section class="plan-card" :class="{ 'is-streaming': entry.message.plan?.isStreaming }">
+              <button
+                type="button"
+                class="plan-card-header"
+                :aria-expanded="isPlanExpanded(entry.message)"
+                @click="togglePlanExpanded(entry.message)"
+              >
+                <span class="plan-card-title-wrap">
+                  <span class="plan-card-icon" aria-hidden="true">✓</span>
+                  <span class="plan-card-title">计划</span>
+                </span>
+                <span class="plan-card-meta">{{ planProgressLabel(entry.message) }}</span>
+                <span class="plan-card-chevron" :class="{ 'is-open': isPlanExpanded(entry.message) }" aria-hidden="true">›</span>
+              </button>
+              <div v-if="isPlanExpanded(entry.message)" class="plan-card-body">
+                <p v-if="entry.message.plan?.explanation" class="plan-card-explanation">
+                  {{ entry.message.plan.explanation }}
+                </p>
+                <ol v-if="entry.message.plan?.steps.length" class="plan-step-list">
+                  <template
+                    v-for="stepEntry in visiblePlanStepEntries(entry.message)"
+                    :key="`${entry.message.id}:${stepEntry.index}`"
+                  >
+                    <li v-if="stepEntry.hiddenBefore > 0" class="plan-step-gap">
+                      已隐藏 {{ stepEntry.hiddenBefore }} 步
+                    </li>
+                    <li class="plan-step" :data-status="stepEntry.step.status">
+                      <span class="plan-step-marker" aria-hidden="true">{{ planStepMarker(stepEntry.step.status) }}</span>
+                      <span class="plan-step-copy">{{ stepEntry.step.step }}</span>
+                      <span class="plan-step-status">{{ planStepStatusLabel(stepEntry.step.status) }}</span>
+                    </li>
+                  </template>
+                </ol>
+                <button
+                  v-if="shouldShowPlanStepToggle(entry.message)"
+                  type="button"
+                  class="plan-steps-toggle"
+                  @click.stop="togglePlanSteps(entry.message)"
+                >
+                  {{ isPlanStepListExpanded(entry.message) ? '收起步骤' : `显示全部 ${entry.message.plan?.steps.length ?? 0} 步` }}
+                </button>
+                <p
+                  v-if="!entry.message.plan?.steps.length && entry.message.plan?.rawText"
+                  class="plan-card-raw"
+                >{{ entry.message.plan.rawText }}</p>
+                <p v-else-if="!entry.message.plan?.steps.length" class="plan-card-raw">正在整理计划…</p>
+                <div v-if="shouldShowPlanImplementationAction(entry.message)" class="plan-card-actions">
+                  <span>{{ isPlanImplemented(entry.message) ? '计划已交给执行模式' : '实施此计划？' }}</span>
+                  <button
+                    type="button"
+                    :class="{ 'is-submitted': isPlanImplemented(entry.message) }"
+                    :disabled="isPlanImplementing(entry.message) || isPlanImplemented(entry.message)"
+                    @click.stop="onImplementPlan(entry.message)"
+                  >{{ planImplementationActionLabel(entry.message) }}</button>
+                </div>
+              </div>
+            </section>
+          </div>
+        </div>
+
         <div v-else-if="isCommandMessage(entry.message)" class="message-row" data-role="system">
           <div class="message-stack" data-role="system">
             <button
@@ -1267,6 +1329,7 @@ import {
   CONVERSATION_BOTTOM_THRESHOLD_PX,
   isConversationViewportAtBottom,
 } from '../../composables/conversationViewport'
+import { hasPlanImplementationConfirmation } from '../../composables/conversationProjection'
 import { copyTextToClipboard } from '../../utils/clipboard'
 
 export type ThreadConversationExposed = {
@@ -1329,6 +1392,143 @@ function isCommandMessage(message: UiMessage): boolean {
   return message.messageType === 'commandExecution' && !!message.commandExecution
 }
 
+function isPlanMessage(message: UiMessage): boolean {
+  return message.messageType === 'plan' && !!message.plan
+}
+
+const collapsedLatestPlanIds = ref<Set<string>>(new Set())
+const expandedOlderPlanIds = ref<Set<string>>(new Set())
+const expandedPlanStepIds = ref<Set<string>>(new Set())
+
+const latestPlanMessageId = computed(() => {
+  for (let index = props.messages.length - 1; index >= 0; index -= 1) {
+    const message = props.messages[index]
+    if (message && isPlanMessage(message)) return message.id
+  }
+  return ''
+})
+
+function isPlanExpanded(message: UiMessage): boolean {
+  if (message.id === latestPlanMessageId.value) {
+    return !collapsedLatestPlanIds.value.has(message.id)
+  }
+  return expandedOlderPlanIds.value.has(message.id)
+}
+
+function togglePlanExpanded(message: UiMessage): void {
+  if (message.id === latestPlanMessageId.value) {
+    const next = new Set(collapsedLatestPlanIds.value)
+    if (next.has(message.id)) next.delete(message.id)
+    else next.add(message.id)
+    collapsedLatestPlanIds.value = next
+    return
+  }
+  const next = new Set(expandedOlderPlanIds.value)
+  if (next.has(message.id)) next.delete(message.id)
+  else next.add(message.id)
+  expandedOlderPlanIds.value = next
+}
+
+function planProgressLabel(message: UiMessage): string {
+  const plan = message.plan
+  if (!plan) return ''
+  if (plan.isStreaming) return '生成中'
+  if (isPlanImplemented(message)) return '已提交执行'
+  if (plan.steps.length > 0 && plan.steps.every((step) => step.status === 'completed')) return '已完成'
+  return '已生成'
+}
+
+function planStepMarker(status: NonNullable<UiMessage['plan']>['steps'][number]['status']): string {
+  if (status === 'completed') return '✓'
+  if (status === 'inProgress') return '→'
+  return '·'
+}
+
+function planStepStatusLabel(status: NonNullable<UiMessage['plan']>['steps'][number]['status']): string {
+  if (status === 'completed') return '已完成'
+  if (status === 'inProgress') return '执行中'
+  return '待处理'
+}
+
+function isPlanStepListExpanded(message: UiMessage): boolean {
+  return expandedPlanStepIds.value.has(message.id)
+}
+
+function shouldShowPlanStepToggle(message: UiMessage): boolean {
+  return (message.plan?.steps.length ?? 0) > 6
+}
+
+function togglePlanSteps(message: UiMessage): void {
+  const next = new Set(expandedPlanStepIds.value)
+  if (next.has(message.id)) next.delete(message.id)
+  else next.add(message.id)
+  expandedPlanStepIds.value = next
+}
+
+function visiblePlanStepEntries(message: UiMessage): Array<{
+  index: number
+  step: NonNullable<UiMessage['plan']>['steps'][number]
+  hiddenBefore: number
+}> {
+  const steps = message.plan?.steps ?? []
+  if (steps.length <= 6 || isPlanStepListExpanded(message)) {
+    return steps.map((step, index) => ({ index, step, hiddenBefore: 0 }))
+  }
+  const currentIndex = steps.findIndex((step) => step.status === 'inProgress')
+  const visibleIndexes = new Set([0, 1, currentIndex >= 0 ? currentIndex : 2])
+  const sortedIndexes = [...visibleIndexes]
+    .filter((index) => index >= 0 && index < steps.length)
+    .sort((left, right) => left - right)
+  return sortedIndexes.map((index, position) => ({
+    index,
+    step: steps[index]!,
+    hiddenBefore: position > 0 ? Math.max(0, index - sortedIndexes[position - 1]! - 1) : 0,
+  }))
+}
+
+const latestImplementablePlanMessageId = computed(() => {
+  let hasLaterUserMessage = false
+  for (let index = props.messages.length - 1; index >= 0; index -= 1) {
+    const message = props.messages[index]
+    if (!message) continue
+    if (message.role === 'user') hasLaterUserMessage = true
+    if (isPlanMessage(message)) return hasLaterUserMessage ? '' : message.id
+  }
+  return ''
+})
+
+function canImplementPlan(message: UiMessage): boolean {
+  return latestImplementablePlanMessageId.value === message.id
+    && message.plan?.isStreaming !== true
+    && !props.isTurnInProgress
+    && !isPlanImplementing(message)
+    && !isPlanImplemented(message)
+}
+
+function isPlanImplementing(message: UiMessage): boolean {
+  return props.implementingPlanId === message.id
+}
+
+function isPlanImplemented(message: UiMessage): boolean {
+  return props.implementedPlanIds?.includes(message.id) === true
+    || hasPlanImplementationConfirmation(props.messages, message.id)
+}
+
+function shouldShowPlanImplementationAction(message: UiMessage): boolean {
+  return canImplementPlan(message) || isPlanImplementing(message) || isPlanImplemented(message)
+}
+
+function planImplementationActionLabel(message: UiMessage): string {
+  if (isPlanImplementing(message)) return '正在提交…'
+  if (isPlanImplemented(message)) return '已提交执行'
+  return '是，实施此计划'
+}
+
+function onImplementPlan(message: UiMessage): void {
+  if (!canImplementPlan(message)) return
+  emit('implementPlan', message)
+}
+
 function isInterruptedTurnMessage(message: UiMessage): boolean {
   return message.messageType === 'turn.interrupted'
 }
@@ -1536,6 +1736,8 @@ const props = defineProps<{
   showConnectionSettingsAction?: boolean
   favoriteMessageIds?: string[]
   allowFailedMessageEdit?: boolean
+  implementingPlanId?: string
+  implementedPlanIds?: string[]
 }>()
 
 const retainedLiveOverlay = ref<UiLiveOverlay | null>(null)
@@ -2002,6 +2204,7 @@ const emit = defineEmits<{
   retryFailedMessage: [messageId: string]
   editFailedMessage: [messageId: string]
   copyStatus: [payload: { message: string; tone: 'success' | 'info' | 'warning' | 'danger' }]
+  implementPlan: [message: UiMessage]
 }>()
 
 const conversationListRef = ref<HTMLElement | null>(null)
@@ -7923,6 +8126,211 @@ onBeforeUnmount(() => {
   @apply sr-only;
 }
 
+.plan-card {
+  box-sizing: border-box;
+  width: min(42rem, 100%);
+  max-width: 100%;
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid color-mix(in srgb, var(--ui-accent) 22%, var(--ui-border-subtle));
+  border-radius: var(--ui-radius-card);
+  background: color-mix(in srgb, var(--ui-accent) 4%, var(--ui-bg-surface));
+}
+
+.plan-card.is-streaming {
+  border-color: color-mix(in srgb, var(--ui-accent) 34%, var(--ui-border-subtle));
+}
+
+.plan-card-header {
+  box-sizing: border-box;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto auto;
+  align-items: center;
+  gap: .65rem;
+  width: 100%;
+  min-height: 42px;
+  padding: .55rem .7rem;
+  border: 0;
+  background: transparent;
+  color: var(--ui-text-primary);
+  text-align: left;
+  cursor: pointer;
+}
+
+.plan-card-header:hover,
+.plan-card-header:focus-visible {
+  background: color-mix(in srgb, var(--ui-accent) 6%, transparent);
+}
+
+.plan-card-title-wrap {
+  display: inline-flex;
+  min-width: 0;
+  align-items: center;
+  gap: .5rem;
+}
+
+.plan-card-icon {
+  display: inline-grid;
+  width: 20px;
+  height: 20px;
+  flex: 0 0 auto;
+  place-items: center;
+  border-radius: 6px;
+  background: color-mix(in srgb, var(--ui-accent) 12%, transparent);
+  color: var(--ui-accent);
+  font-size: 11px;
+  font-weight: 700;
+}
+
+.plan-card-title {
+  overflow: hidden;
+  font-size: 12px;
+  font-weight: 650;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.plan-card-meta,
+.plan-step-status {
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+  white-space: nowrap;
+}
+
+.plan-card-chevron {
+  color: var(--ui-text-tertiary);
+  font-size: 18px;
+  line-height: 1;
+  transform: rotate(90deg);
+  transition: transform var(--motion-duration-fast) var(--motion-ease-standard);
+}
+
+.plan-card-chevron.is-open {
+  transform: rotate(-90deg);
+}
+
+.plan-card-body {
+  padding: 0 .75rem .75rem 2.95rem;
+}
+
+.plan-card-explanation,
+.plan-card-raw {
+  margin: 0 0 .6rem;
+  color: var(--ui-text-secondary);
+  font-size: 12px;
+  line-height: 1.55;
+  white-space: pre-wrap;
+}
+
+.plan-step-list {
+  display: grid;
+  gap: .42rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.plan-step {
+  display: grid;
+  grid-template-columns: 18px minmax(0, 1fr) auto;
+  align-items: start;
+  gap: .35rem;
+  color: var(--ui-text-secondary);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.plan-step-gap {
+  padding-left: 1.45rem;
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+  line-height: 1.35;
+  list-style: none;
+}
+
+.plan-step-marker {
+  display: inline-grid;
+  width: 16px;
+  height: 16px;
+  place-items: center;
+  margin-top: 1px;
+  border: 1px solid var(--ui-border-subtle);
+  border-radius: 50%;
+  color: var(--ui-text-tertiary);
+  font-size: 10px;
+}
+
+.plan-step[data-status='completed'] .plan-step-marker {
+  border-color: color-mix(in srgb, var(--ui-success) 38%, var(--ui-border-subtle));
+  background: color-mix(in srgb, var(--ui-success) 9%, transparent);
+  color: var(--ui-success);
+}
+
+.plan-step[data-status='inProgress'] .plan-step-marker,
+.plan-step[data-status='inProgress'] .plan-step-status {
+  border-color: color-mix(in srgb, var(--ui-accent) 42%, var(--ui-border-subtle));
+  color: var(--ui-accent);
+}
+
+.plan-steps-toggle {
+  min-height: 28px;
+  margin-top: .55rem;
+  padding: 0 .45rem;
+  border: 0;
+  border-radius: var(--ui-radius-control);
+  background: transparent;
+  color: var(--ui-text-secondary);
+  font: inherit;
+  font-size: 11px;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.plan-steps-toggle:hover,
+.plan-steps-toggle:focus-visible {
+  background: var(--ui-bg-row-hover);
+  color: var(--ui-text-primary);
+}
+
+.plan-card-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: .55rem;
+  margin-top: .75rem;
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+}
+
+.plan-card-actions button {
+  min-height: 30px;
+  padding: 0 .7rem;
+  border: 1px solid color-mix(in srgb, var(--ui-accent) 38%, var(--ui-border-subtle));
+  border-radius: var(--ui-radius-control);
+  background: var(--ui-accent);
+  color: #fff;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.plan-card-actions button:hover,
+.plan-card-actions button:focus-visible {
+  filter: brightness(.96);
+}
+
+.plan-card-actions button:disabled {
+  cursor: wait;
+  opacity: .72;
+}
+
+.plan-card-actions button.is-submitted {
+  border-color: color-mix(in srgb, var(--ui-success) 36%, var(--ui-border-subtle));
+  background: color-mix(in srgb, var(--ui-success) 10%, var(--ui-bg-surface));
+  color: var(--ui-success);
+  cursor: default;
+  opacity: 1;
+}
+
 .interrupted-turn-card {
   @apply flex w-full items-center gap-2 border px-3 py-2;
   max-width: min(38rem, 100%);
@@ -7931,6 +8339,31 @@ onBeforeUnmount(() => {
   background: color-mix(in srgb, var(--ui-warning) 6%, var(--ui-bg-surface));
 }
 
+@media (max-width: 640px) {
+  .plan-card-body {
+    padding: 0 .65rem .65rem;
+  }
+
+  .plan-step-status {
+    display: none;
+  }
+
+  .plan-step {
+    grid-template-columns: 18px minmax(0, 1fr);
+  }
+
+  .plan-card-actions {
+    align-items: stretch;
+    flex-direction: column;
+    gap: .4rem;
+  }
+
+  .plan-card-actions button {
+    width: 100%;
+    min-height: 44px;
+  }
+}
+
 .interrupted-turn-dot {
   @apply h-2 w-2 shrink-0 rounded-full;
   background: var(--ui-warning);
diff --git a/src/components/content/ThreadGoalBar.vue b/src/components/content/ThreadGoalBar.vue
new file mode 100644
index 0000000..074e7b1
--- /dev/null
+++ b/src/components/content/ThreadGoalBar.vue
@@ -0,0 +1,650 @@
+<template>
+  <section class="thread-goal" :data-state="goal?.status || 'empty'" aria-label="持续目标">
+    <div v-if="isLoading && !goal" class="thread-goal-loading" role="status">
+      <span class="thread-goal-spinner" aria-hidden="true" />
+      正在读取持续目标…
+    </div>
+
+    <div v-if="error" class="thread-goal-error" role="alert">
+      <span>{{ error }}</span>
+      <button type="button" :disabled="isLoading || isUpdating" @click="$emit('retry')">重试</button>
+    </div>
+
+    <template v-if="goal">
+      <div class="thread-goal-summary">
+        <span class="thread-goal-status-dot" aria-hidden="true" />
+        <button
+          class="thread-goal-objective"
+          type="button"
+          :aria-expanded="isEditing"
+          :title="goal.objective"
+          @click="openEditor"
+        >
+          <span class="thread-goal-kicker">
+            持续目标 · {{ statusLabel }}<template v-if="executionHint"> · {{ executionHint }}</template>
+          </span>
+          <span class="thread-goal-text">{{ goal.objective }}</span>
+          <span v-if="usageLabel" class="thread-goal-usage-mobile">{{ usageLabel }}</span>
+        </button>
+        <span v-if="usageLabel" class="thread-goal-usage">{{ usageLabel }}</span>
+        <div class="thread-goal-actions">
+          <button
+            v-if="goal.status === 'active'"
+            type="button"
+            class="thread-goal-action thread-goal-action-primary"
+            :disabled="isUpdating || disabled"
+            aria-label="暂停持续目标"
+            title="暂停持续目标"
+            @click="requestStatus('paused')"
+          >{{ isUpdating && pendingAction === 'pause' ? '暂停中…' : '暂停' }}</button>
+          <button
+            v-else-if="goal.status === 'paused' || goal.status === 'blocked' || goal.status === 'usageLimited'"
+            type="button"
+            class="thread-goal-action thread-goal-action-primary"
+            :disabled="isUpdating || disabled"
+            aria-label="继续持续目标"
+            title="继续持续目标"
+            @click="requestStatus('active')"
+          >{{ isUpdating && pendingAction === 'resume' ? '继续中…' : '继续' }}</button>
+          <button
+            type="button"
+            class="thread-goal-action thread-goal-action-secondary"
+            :disabled="isUpdating || disabled"
+            @click="openEditor"
+          >编辑</button>
+          <button
+            type="button"
+            class="thread-goal-action thread-goal-action-secondary thread-goal-action-danger"
+            :disabled="isUpdating || disabled"
+            @click="requestClear"
+          >清除</button>
+          <div ref="moreRootRef" class="thread-goal-more">
+            <button
+              ref="moreTriggerRef"
+              type="button"
+              class="thread-goal-action thread-goal-more-trigger"
+              :aria-expanded="isMoreOpen"
+              aria-haspopup="menu"
+              aria-label="更多持续目标操作"
+              :disabled="isUpdating || disabled"
+              @click="toggleMoreMenu"
+              @keydown.arrow-down.prevent="openMoreMenu(false)"
+              @keydown.arrow-up.prevent="openMoreMenu(true)"
+            >•••</button>
+            <div
+              v-if="isMoreOpen"
+              ref="moreMenuRef"
+              class="thread-goal-more-menu"
+              role="menu"
+              @keydown="onMoreMenuKeydown"
+            >
+              <button type="button" role="menuitem" @click="openEditor">编辑目标</button>
+              <button type="button" role="menuitem" class="is-danger" @click="requestClear">清除目标</button>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <p v-if="planModeActive && goal.status === 'active'" class="thread-goal-scope-note" role="status">
+        计划模式只影响新消息；持续目标仍会推进，可随时暂停。
+      </p>
+
+      <div v-if="isConfirmingClear" class="thread-goal-confirm" role="alert">
+        <span>确定清除“{{ objectivePreview }}”？清除后不会自动继续。</span>
+        <div>
+          <button type="button" :disabled="isUpdating" @click="cancelClear">取消</button>
+          <button type="button" class="is-danger" :disabled="isUpdating" @click="confirmClear">
+            {{ isUpdating ? '清除中…' : '确认清除' }}
+          </button>
+        </div>
+      </div>
+    </template>
+
+    <button
+      v-else-if="!isLoading && !isEditing"
+      type="button"
+      class="thread-goal-create"
+      :disabled="isUpdating || disabled"
+      @click="openEditor"
+    >
+      <span aria-hidden="true">◎</span>
+      设置持续目标
+    </button>
+
+    <form v-if="isEditing" class="thread-goal-editor" @submit.prevent="save">
+      <label class="thread-goal-editor-label" for="thread-goal-objective">
+        {{ goal ? '编辑持续目标' : '设置要持续追求的目标' }}
+      </label>
+      <textarea
+        id="thread-goal-objective"
+        ref="editorRef"
+        v-model="draft"
+        rows="2"
+        maxlength="2000"
+        :disabled="isUpdating || disabled"
+        placeholder="描述目标和可衡量的成果"
+        @keydown.escape.prevent="cancelEditor"
+      />
+      <p class="thread-goal-help">任务空闲时，CX-Codex 将继续推进；暂停后不会自动恢复。</p>
+      <div class="thread-goal-editor-actions">
+        <button type="button" :disabled="isUpdating" @click="cancelEditor">取消</button>
+        <button type="submit" class="is-primary" :disabled="!canSave">
+          {{ saveButtonLabel }}
+        </button>
+      </div>
+    </form>
+  </section>
+</template>
+
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import type { UiThreadGoal, UiThreadGoalStatus } from '../../types/codex'
+
+const props = withDefaults(defineProps<{
+  goal: UiThreadGoal | null
+  isLoading?: boolean
+  isUpdating?: boolean
+  disabled?: boolean
+  error?: string
+  executionHint?: string
+  planModeActive?: boolean
+}>(), {
+  isLoading: false,
+  isUpdating: false,
+  disabled: false,
+  error: '',
+  executionHint: '',
+  planModeActive: false,
+})
+
+const emit = defineEmits<{
+  setGoal: [objective: string]
+  setStatus: [status: Extract<UiThreadGoalStatus, 'active' | 'paused'>]
+  clearGoal: []
+  retry: []
+}>()
+
+const editorRef = ref<HTMLTextAreaElement | null>(null)
+const moreRootRef = ref<HTMLElement | null>(null)
+const moreTriggerRef = ref<HTMLButtonElement | null>(null)
+const moreMenuRef = ref<HTMLElement | null>(null)
+const isEditing = ref(false)
+const isMoreOpen = ref(false)
+const isConfirmingClear = ref(false)
+const draft = ref('')
+const pendingAction = ref<'pause' | 'resume' | 'save' | 'clear' | ''>('')
+
+const statusLabel = computed(() => {
+  switch (props.goal?.status) {
+    case 'active': return '进行中'
+    case 'paused': return '已暂停'
+    case 'budgetLimited': return '预算已用完'
+    case 'usageLimited': return '用量受限'
+    case 'blocked': return '已阻塞'
+    case 'complete': return '已完成'
+    default: return ''
+  }
+})
+
+const usageLabel = computed(() => {
+  const goal = props.goal
+  if (!goal) return ''
+  const tokens = goal.tokenBudget && goal.tokenBudget > 0
+    ? `预算已用 ${Math.min(100, Math.round((goal.tokensUsed / goal.tokenBudget) * 100))}%`
+    : goal.tokensUsed > 0
+      ? `已用 ${formatCount(goal.tokensUsed)} tokens`
+      : ''
+  const time = goal.timeUsedSeconds > 0 ? formatDuration(goal.timeUsedSeconds) : ''
+  return [tokens, time].filter(Boolean).join(' · ')
+})
+
+const objectivePreview = computed(() => {
+  const objective = props.goal?.objective.trim() ?? ''
+  return objective.length > 42 ? `${objective.slice(0, 42)}…` : objective
+})
+
+const canSave = computed(() => (
+  draft.value.trim().length > 0
+  && draft.value.trim() !== (props.goal?.objective ?? '')
+  && !props.isUpdating
+  && !props.disabled
+))
+
+const saveButtonLabel = computed(() => {
+  if (props.isUpdating) return props.goal ? '保存中…' : '启动中…'
+  return props.goal ? '保存' : '保存并开始'
+})
+
+function formatCount(value: number): string {
+  return new Intl.NumberFormat('zh-CN', { notation: value >= 10_000 ? 'compact' : 'standard' }).format(value)
+}
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${Math.max(1, Math.round(seconds))}秒`
+  if (seconds < 3600) return `${Math.round(seconds / 60)}分钟`
+  return `${Math.round(seconds / 360) / 10}小时`
+}
+
+function openEditor(): void {
+  if (props.disabled) return
+  closeMoreMenu()
+  cancelClear()
+  draft.value = props.goal?.objective ?? ''
+  isEditing.value = true
+  void nextTick(() => editorRef.value?.focus())
+}
+
+function cancelEditor(): void {
+  draft.value = props.goal?.objective ?? ''
+  isEditing.value = false
+}
+
+function save(): void {
+  if (!canSave.value) return
+  pendingAction.value = 'save'
+  emit('setGoal', draft.value.trim())
+}
+
+function cancelClear(): void {
+  isConfirmingClear.value = false
+}
+
+function requestClear(): void {
+  closeMoreMenu()
+  isEditing.value = false
+  isConfirmingClear.value = true
+}
+
+function confirmClear(): void {
+  if (props.isUpdating) return
+  pendingAction.value = 'clear'
+  emit('clearGoal')
+}
+
+function requestStatus(status: Extract<UiThreadGoalStatus, 'active' | 'paused'>): void {
+  if (props.isUpdating || props.disabled) return
+  pendingAction.value = status === 'active' ? 'resume' : 'pause'
+  emit('setStatus', status)
+}
+
+function menuItems(): HTMLButtonElement[] {
+  return moreMenuRef.value
+    ? Array.from(moreMenuRef.value.querySelectorAll<HTMLButtonElement>('[role="menuitem"]'))
+    : []
+}
+
+function focusMoreMenuItem(focusLast = false): void {
+  const items = menuItems()
+  const target = focusLast ? items[items.length - 1] : items[0]
+  target?.focus()
+}
+
+function openMoreMenu(focusLast = false): void {
+  if (props.isUpdating || props.disabled) return
+  isMoreOpen.value = true
+  void nextTick(() => focusMoreMenuItem(focusLast))
+}
+
+function closeMoreMenu(restoreFocus = false): void {
+  if (!isMoreOpen.value) return
+  isMoreOpen.value = false
+  if (restoreFocus) void nextTick(() => moreTriggerRef.value?.focus())
+}
+
+function toggleMoreMenu(): void {
+  if (isMoreOpen.value) closeMoreMenu(true)
+  else openMoreMenu()
+}
+
+function onMoreMenuKeydown(event: KeyboardEvent): void {
+  if (event.key === 'Escape') {
+    event.preventDefault()
+    closeMoreMenu(true)
+    return
+  }
+  if (event.key === 'Tab') {
+    closeMoreMenu()
+    return
+  }
+  if (!['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) return
+  event.preventDefault()
+  const items = menuItems()
+  if (items.length === 0) return
+  if (event.key === 'Home') {
+    items[0]?.focus()
+    return
+  }
+  if (event.key === 'End') {
+    items[items.length - 1]?.focus()
+    return
+  }
+  const currentIndex = Math.max(0, items.indexOf(document.activeElement as HTMLButtonElement))
+  const offset = event.key === 'ArrowDown' ? 1 : -1
+  items[(currentIndex + offset + items.length) % items.length]?.focus()
+}
+
+function onDocumentPointerDown(event: PointerEvent): void {
+  if (!isMoreOpen.value || moreRootRef.value?.contains(event.target as Node)) return
+  closeMoreMenu()
+}
+
+function resetTransientState(): void {
+  closeMoreMenu()
+  cancelClear()
+  isEditing.value = false
+  pendingAction.value = ''
+  draft.value = props.goal?.objective ?? ''
+}
+
+watch(() => props.goal?.objective, (objective) => {
+  if (!isEditing.value) draft.value = objective ?? ''
+})
+
+watch(() => props.goal?.threadId, (threadId, previousThreadId) => {
+  if (threadId !== previousThreadId) resetTransientState()
+})
+
+watch(() => props.goal, (goal, previous) => {
+  if (previous && !goal) cancelClear()
+})
+
+watch(() => props.isUpdating, (updating, previous) => {
+  if (previous && !updating && props.goal?.objective === draft.value.trim()) {
+    isEditing.value = false
+  }
+  if (previous && !updating) pendingAction.value = ''
+})
+
+onMounted(() => document.addEventListener('pointerdown', onDocumentPointerDown, true))
+onBeforeUnmount(() => {
+  document.removeEventListener('pointerdown', onDocumentPointerDown, true)
+  cancelClear()
+})
+</script>
+
+<style scoped>
+.thread-goal {
+  box-sizing: border-box;
+  width: min(100%, 860px);
+  max-width: 100%;
+  min-width: 0;
+  margin: 0 auto 6px;
+  color: var(--ui-text-primary);
+}
+
+.thread-goal-loading,
+.thread-goal-create,
+.thread-goal-summary,
+.thread-goal-editor,
+.thread-goal-error,
+.thread-goal-confirm {
+  box-sizing: border-box;
+  max-width: 100%;
+  border: 1px solid var(--ui-border-subtle);
+  background: color-mix(in srgb, var(--ui-bg-surface) 92%, transparent);
+}
+
+.thread-goal-loading,
+.thread-goal-create {
+  display: inline-flex;
+  min-height: 32px;
+  align-items: center;
+  gap: 7px;
+  padding: 0 10px;
+  border-radius: 8px;
+  color: var(--ui-text-secondary);
+  font: inherit;
+  font-size: 12px;
+}
+
+.thread-goal-create { cursor: pointer; }
+
+.thread-goal-create:hover,
+.thread-goal-create:focus-visible,
+.thread-goal-action:hover,
+.thread-goal-action:focus-visible {
+  border-color: var(--ui-border-strong);
+  color: var(--ui-text-primary);
+}
+
+.thread-goal-error,
+.thread-goal-confirm {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  margin-bottom: 5px;
+  padding: 7px 9px;
+  border-radius: 8px;
+  font-size: 11px;
+}
+
+.thread-goal-scope-note {
+  margin: 4px 4px 0;
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+  line-height: 1.4;
+}
+
+.thread-goal-error {
+  border-color: color-mix(in srgb, var(--ui-danger) 30%, var(--ui-border-subtle));
+  color: var(--ui-danger);
+}
+
+.thread-goal-error button,
+.thread-goal-confirm button {
+  min-height: 28px;
+  padding: 0 8px;
+  border: 1px solid var(--ui-border-subtle);
+  border-radius: 7px;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.thread-goal-confirm > div { display: flex; flex: 0 0 auto; gap: 4px; }
+.thread-goal-confirm .is-danger { border-color: var(--ui-danger); color: var(--ui-danger); }
+
+.thread-goal-summary {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto auto;
+  width: 100%;
+  min-width: 0;
+  min-height: 42px;
+  align-items: center;
+  gap: 9px;
+  padding: 5px 7px 5px 11px;
+  border-radius: 10px;
+}
+
+.thread-goal-status-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--ui-text-tertiary);
+}
+
+.thread-goal[data-state='active'] .thread-goal-status-dot { background: var(--ui-accent); }
+.thread-goal[data-state='complete'] .thread-goal-status-dot { background: var(--ui-success); }
+.thread-goal[data-state='blocked'] .thread-goal-status-dot,
+.thread-goal[data-state='budgetLimited'] .thread-goal-status-dot,
+.thread-goal[data-state='usageLimited'] .thread-goal-status-dot { background: var(--ui-warning); }
+
+.thread-goal-objective {
+  min-width: 0;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.thread-goal-kicker,
+.thread-goal-text { display: block; }
+
+.thread-goal-kicker {
+  margin-bottom: 1px;
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+  line-height: 1.2;
+}
+
+.thread-goal-text {
+  display: -webkit-box;
+  overflow: hidden;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.thread-goal-usage {
+  color: var(--ui-text-secondary);
+  font-size: 11px;
+  white-space: nowrap;
+}
+
+.thread-goal-usage-mobile { display: none; }
+
+.thread-goal-actions,
+.thread-goal-editor-actions {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  gap: 4px;
+}
+
+.thread-goal-action,
+.thread-goal-editor-actions button {
+  min-height: 28px;
+  padding: 0 8px;
+  border: 1px solid transparent;
+  border-radius: 7px;
+  background: transparent;
+  color: var(--ui-text-secondary);
+  font: inherit;
+  font-size: 11px;
+  cursor: pointer;
+}
+
+.thread-goal-action-primary { border-color: var(--ui-border-subtle); }
+.thread-goal-action-danger:hover,
+.thread-goal-action-danger:focus-visible { color: var(--ui-danger); }
+
+.thread-goal-more { position: relative; display: none; flex: 0 0 auto; }
+.thread-goal-more-trigger { letter-spacing: 1px; }
+.thread-goal-more-menu {
+  box-sizing: border-box;
+  position: absolute;
+  right: 0;
+  bottom: calc(100% + 6px);
+  z-index: var(--ui-z-popover, 70);
+  width: 132px;
+  max-width: calc(100vw - 24px);
+  padding: 4px;
+  border: 1px solid var(--ui-border-subtle);
+  border-radius: 9px;
+  background: var(--ui-bg-surface);
+  box-shadow: 0 6px 8px rgb(0 0 0 / .08);
+}
+
+.thread-goal-more-menu button {
+  display: block;
+  width: 100%;
+  min-height: 44px;
+  padding: 0 9px;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: var(--ui-text-primary);
+  text-align: left;
+  font: inherit;
+  font-size: 12px;
+}
+
+.thread-goal-more-menu button:hover,
+.thread-goal-more-menu button:focus-visible { background: var(--ui-bg-row-hover); }
+.thread-goal-more-menu button.is-danger { color: var(--ui-danger); }
+
+.thread-goal-editor {
+  padding: 10px;
+  border-radius: 10px;
+}
+
+.thread-goal-editor-label {
+  display: block;
+  margin-bottom: 6px;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.thread-goal-editor textarea {
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 58px;
+  resize: vertical;
+  padding: 8px 9px;
+  border: 1px solid var(--ui-border-subtle);
+  border-radius: 8px;
+  outline: none;
+  background: var(--ui-bg-surface-muted);
+  color: var(--ui-text-primary);
+  font: inherit;
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.thread-goal-editor textarea:focus { border-color: var(--ui-accent); }
+.thread-goal-help { margin: 6px 0 8px; color: var(--ui-text-secondary); font-size: 11px; }
+.thread-goal-editor-actions { justify-content: flex-end; }
+.thread-goal-editor-actions button { border-color: var(--ui-border-subtle); }
+.thread-goal-editor-actions .is-primary { border-color: var(--ui-accent); background: var(--ui-accent); color: #fff; }
+
+button:disabled,
+textarea:disabled { cursor: not-allowed; opacity: .55; }
+
+.thread-goal-spinner {
+  width: 10px;
+  height: 10px;
+  border: 1px solid var(--ui-border-strong);
+  border-top-color: var(--ui-accent);
+  border-radius: 50%;
+  animation: thread-goal-spin .8s linear infinite;
+}
+
+@keyframes thread-goal-spin { to { transform: rotate(360deg); } }
+
+@media (max-width: 640px) {
+  .thread-goal-summary {
+    grid-template-columns: auto minmax(0, 1fr) auto;
+    min-height: 52px;
+    gap: 7px;
+    padding: 5px 5px 5px 9px;
+  }
+
+  .thread-goal-usage { display: none; }
+  .thread-goal-usage-mobile {
+    display: block;
+    margin-top: 2px;
+    color: var(--ui-text-secondary);
+    font-size: 11px;
+    line-height: 1.3;
+  }
+  .thread-goal-action-secondary { display: none; }
+  .thread-goal-more { display: block; }
+  .thread-goal-action { min-width: 44px; min-height: 44px; padding-inline: 7px; }
+  .thread-goal-create,
+  .thread-goal-error button,
+  .thread-goal-editor-actions button { min-height: 44px; }
+  .thread-goal-confirm { align-items: flex-start; flex-direction: column; }
+  .thread-goal-confirm > div { align-self: flex-end; }
+  .thread-goal-confirm button { min-height: 44px; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .thread-goal-spinner { animation: none; }
+}
+</style>
diff --git a/src/composables/conversationProjection.ts b/src/composables/conversationProjection.ts
index 6147750..7a21bbd 100644
--- a/src/composables/conversationProjection.ts
+++ b/src/composables/conversationProjection.ts
@@ -1,6 +1,23 @@
 import type { CommandExecutionData, UiMessage } from '../types/codex'
 import { normalizeMessageText } from './messageIdentity'
 
+export const PLAN_IMPLEMENTATION_CONFIRMATION = '是的，执行此计划'
+
+export function hasPlanImplementationConfirmation(messages: UiMessage[], planMessageId: string): boolean {
+  const planIndex = messages.findIndex((message) => message.id === planMessageId)
+  if (planIndex < 0) return false
+
+  for (let index = planIndex + 1; index < messages.length; index += 1) {
+    const message = messages[index]
+    if (!message) continue
+    if (message.messageType === 'plan') return false
+    if (message.role !== 'user') continue
+    return normalizeMessageText(message.text) === PLAN_IMPLEMENTATION_CONFIRMATION
+  }
+
+  return false
+}
+
 export function areStringArraysEqual(first?: string[], second?: string[]): boolean {
   const left = Array.isArray(first) ? first : []
   const right = Array.isArray(second) ? second : []
@@ -40,6 +57,29 @@ function areFileAttachmentsEqual(
   return true
 }
 
+function arePlansEqual(first?: UiMessage['plan'], second?: UiMessage['plan']): boolean {
+  if (!first && !second) return true
+  if (!first || !second) return false
+  if (
+    first.turnId !== second.turnId
+    || first.explanation !== second.explanation
+    || first.rawText !== second.rawText
+    || first.isStreaming !== second.isStreaming
+    || first.steps.length !== second.steps.length
+  ) {
+    return false
+  }
+  for (let index = 0; index < first.steps.length; index += 1) {
+    if (
+      first.steps[index]?.step !== second.steps[index]?.step
+      || first.steps[index]?.status !== second.steps[index]?.status
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
 export function areMessageFieldsEqual(first: UiMessage, second: UiMessage): boolean {
   return (
     first.id === second.id &&
@@ -51,6 +91,7 @@ export function areMessageFieldsEqual(first: UiMessage, second: UiMessage): bool
     first.rawPayload === second.rawPayload &&
     first.isUnhandled === second.isUnhandled &&
     areCommandExecutionsEqual(first.commandExecution, second.commandExecution) &&
+    arePlansEqual(first.plan, second.plan) &&
     first.turnIndex === second.turnIndex &&
     first.deliveryState === second.deliveryState &&
     first.deliveryError === second.deliveryError &&
diff --git a/src/composables/threadGoal.ts b/src/composables/threadGoal.ts
new file mode 100644
index 0000000..9571552
--- /dev/null
+++ b/src/composables/threadGoal.ts
@@ -0,0 +1,35 @@
+import type { UiThreadGoal, UiThreadGoalStatus } from '../types/codex'
+
+const THREAD_GOAL_STATUSES = new Set<UiThreadGoalStatus>([
+  'active',
+  'paused',
+  'budgetLimited',
+  'usageLimited',
+  'blocked',
+  'complete',
+])
+
+function readFiniteNumber(value: unknown, fallback = 0): number {
+  return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : fallback
+}
+export function normalizeThreadGoal(value: unknown): UiThreadGoal | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const record = value as Record<string, unknown>
+  const threadId = typeof record.threadId === 'string' ? record.threadId.trim() : ''
+  const objective = typeof record.objective === 'string' ? record.objective.trim() : ''
+  const rawStatus = typeof record.status === 'string' ? record.status.trim() : ''
+  if (!threadId || !objective || !THREAD_GOAL_STATUSES.has(rawStatus as UiThreadGoalStatus)) return null
+
+  return {
+    threadId,
+    objective,
+    status: rawStatus as UiThreadGoalStatus,
+    tokenBudget: typeof record.tokenBudget === 'number' && Number.isFinite(record.tokenBudget)
+      ? Math.max(0, record.tokenBudget)
+      : null,
+    tokensUsed: readFiniteNumber(record.tokensUsed),
+    timeUsedSeconds: readFiniteNumber(record.timeUsedSeconds),
+    createdAt: readFiniteNumber(record.createdAt),
+    updatedAt: readFiniteNumber(record.updatedAt),
+  }
+}
diff --git a/src/composables/useDesktopState.ts b/src/composables/useDesktopState.ts
index e3f8bf4..0de3810 100644
--- a/src/composables/useDesktopState.ts
+++ b/src/composables/useDesktopState.ts
@@ -37,6 +37,7 @@ import {
   getPendingServerRequests,
   getSkillsList,
   getThreadDetail,
+  getThreadGoal,
   getThreadRuntimeSnapshot,
   getThreadRuntimeStatusSnapshot,
   getThreadTokenUsage,
@@ -48,6 +49,7 @@ import {
   getWorkspaceRootsState,
   setCodexSpeedMode,
   setDefaultModel,
+  setThreadGoal,
   setWorkspaceRootsState,
   startComposerPluginOauthLogin,
   reloadComposerPlugins,
@@ -60,6 +62,7 @@ import {
   rollbackWorktreeToMessage,
   startRuntimeThreadTurn,
   subscribeCodexNotifications,
+  clearThreadGoal,
   unarchiveThread,
   type RuntimeInterruptSource,
   type RpcConnectionState,
@@ -80,15 +83,19 @@ import type {
   ThreadScrollState,
   UiLiveOverlay,
   UiMessage,
+  UiPlanStep,
   UiProjectGroup,
   UiRateLimitSnapshot,
   UiRuntimeStatusSummary,
   UiServerRequest,
   UiServerRequestReply,
   UiTaskPetItem,
+  UiThreadGoal,
+  UiThreadGoalStatus,
   UiThreadTokenUsage,
   UiThread,
 } from '../types/codex'
+import { normalizeThreadGoal } from './threadGoal'
 import { isAbortLikeError } from '../api/codexErrors'
 import { normalizePathForUi, toProjectName } from '../pathUtils.js'
 import { getCxSessionFileChangeSyncPolicy } from '../sessionFileChange'
@@ -257,6 +264,7 @@ const NEW_THREAD_ACCEPTED_RECONCILE_DELAYS_MS = [150, 500, 1000, 2000, 3000]
 const LIVE_OVERLAY_ACTIVITY_GRACE_MS = 4500
 const UNKNOWN_ACTIVE_TURN_ID = '__unknown_active_turn__'
 const LIVE_DELTA_BATCH_MS = 48
+const THREAD_GOAL_CONTINUATION_DELAY_MS = 750
 const NOTIFICATION_STALE_MS = 30000
 const THREAD_LIST_REFRESH_INTERVAL_MS = 300000
 const THREAD_TOKEN_USAGE_REFRESH_RETRY_MS = 5 * 60 * 1000
@@ -1480,9 +1488,18 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   const persistedMessagesByThreadId = ref<Record<string, UiMessage[]>>({})
   const optimisticUserMessagesByThreadId = ref<Record<string, UiMessage[]>>({})
   const liveAgentMessagesByThreadId = ref<Record<string, UiMessage[]>>({})
+  const livePlanMessagesByThreadId = ref<Record<string, UiMessage[]>>({})
   const liveReasoningTextByThreadId = ref<Record<string, string>>({})
   const liveCommandsByThreadId = ref<Record<string, UiMessage[]>>({})
   const threadTokenUsageByThreadId = ref<Record<string, UiThreadTokenUsage>>({})
+  const threadGoalByThreadId = ref<Record<string, UiThreadGoal | null>>({})
+  const threadGoalLoadingByThreadId = ref<Record<string, boolean>>({})
+  const threadGoalUpdatingByThreadId = ref<Record<string, boolean>>({})
+  const threadGoalErrorByThreadId = ref<Record<string, string>>({})
+  const threadGoalContinuationTimerByThreadId = new Map<string, number>()
+  const threadGoalContinuationInFlight = new Set<string>()
+  const threadGoalRefreshInFlightByThreadId = new Map<string, Promise<void>>()
+  const threadGoalStateGenerationByThreadId = new Map<string, number>()
   const tokenUsageRefreshInFlightByThreadId = new Map<string, Promise<void>>()
   const tokenUsageRefreshAttemptedAtByThreadId = new Map<string, number>()
   const tokenUsageRefreshTimerByThreadId = new Map<string, number>()
@@ -1523,6 +1540,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   const failedMessageRetryInFlightIds = new Set<string>()
   type BufferedAgentDelta = { threadId: string; messageId: string; delta: string }
   type BufferedCommandDelta = { threadId: string; itemId: string; delta: string }
+  type BufferedPlanDelta = { threadId: string; turnId: string; delta: string }
   const queuedMessagesByThreadId = ref<Record<string, QueuedMessage[]>>(loadQueuedMessagesMap())
   const queueProcessingByThreadId = ref<Record<string, boolean>>({})
   const eventUnreadByThreadId = ref<Record<string, boolean>>(loadUnreadStateMap())
@@ -1634,6 +1652,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   const bufferedAgentDeltaByKey = new Map<string, BufferedAgentDelta>()
   const bufferedCommandDeltaByKey = new Map<string, BufferedCommandDelta>()
   const bufferedReasoningDeltaByThreadId = new Map<string, string>()
+  const bufferedPlanDeltaByKey = new Map<string, BufferedPlanDelta>()
   const initialNotificationCursor = loadLastNotificationCursor()
   const notificationReplayCoordinator = createNotificationReplayCoordinator({
     initialCursor: initialNotificationCursor.cursor,
@@ -2027,6 +2046,20 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (!threadId) return null
     return threadTokenUsageByThreadId.value[threadId] ?? null
   })
+  const selectedThreadGoal = computed<UiThreadGoal | null>(() => {
+    const threadId = selectedThreadId.value
+    if (!threadId) return null
+    return threadGoalByThreadId.value[threadId] ?? null
+  })
+  const isSelectedThreadGoalLoading = computed(() => (
+    selectedThreadId.value ? threadGoalLoadingByThreadId.value[selectedThreadId.value] === true : false
+  ))
+  const isSelectedThreadGoalUpdating = computed(() => (
+    selectedThreadId.value ? threadGoalUpdatingByThreadId.value[selectedThreadId.value] === true : false
+  ))
+  const selectedThreadGoalError = computed(() => (
+    selectedThreadId.value ? threadGoalErrorByThreadId.value[selectedThreadId.value] ?? '' : ''
+  ))
   const notificationStale = computed(() => {
     notificationHealthTick.value
     return Date.now() - lastNotificationAtMs >= NOTIFICATION_STALE_MS
@@ -2120,19 +2153,25 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       optimisticUserMessageMetaById,
     )
     const liveAgent = liveAgentMessagesByThreadId.value[threadId] ?? []
+    const livePlans = livePlanMessagesByThreadId.value[threadId] ?? []
     const liveCommands = liveCommandsByThreadId.value[threadId] ?? []
     const combined = [...persisted, ...optimisticUser]
-    for (const liveMessage of [...liveCommands, ...liveAgent]) {
+    for (const liveMessage of [...livePlans, ...liveCommands, ...liveAgent]) {
       const existingIndex = combined.findIndex((message) => message.id === liveMessage.id)
       if (existingIndex < 0) {
         combined.push(liveMessage)
         continue
       }
       const existing = combined[existingIndex]
-      const shouldPreferLive = liveMessage.commandExecution?.status === 'inProgress'
+      const shouldPreferLive = Boolean(liveMessage.plan)
+        || liveMessage.commandExecution?.status === 'inProgress'
         || liveMessage.text.length >= (existing?.text.length ?? 0)
       if (shouldPreferLive) {
-        combined[existingIndex] = liveMessage
+        combined[existingIndex] = {
+          ...existing,
+          ...liveMessage,
+          turnIndex: existing?.turnIndex ?? liveMessage.turnIndex,
+        }
       }
     }
 
@@ -2340,12 +2379,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     saveSelectedCollaborationMode(nextMode)
   }
 
-  function consumePlanModeAfterSubmit(mode: CollaborationMode): void {
-    if (mode !== 'plan') return
-    if (selectedCollaborationMode.value !== 'plan') return
-    setSelectedCollaborationMode('execute')
-  }
-
   async function updateSelectedSpeedMode(mode: SpeedMode): Promise<void> {
     const nextMode: SpeedMode = mode === 'fast' ? 'fast' : 'standard'
     if (isUpdatingSpeedMode.value || selectedSpeedMode.value === nextMode) {
@@ -2614,9 +2647,14 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     persistedMessagesByThreadId.value = pruneThreadStateMap(persistedMessagesByThreadId.value, activeThreadIds)
     optimisticUserMessagesByThreadId.value = pruneThreadStateMap(optimisticUserMessagesByThreadId.value, activeThreadIds)
     liveAgentMessagesByThreadId.value = pruneThreadStateMap(liveAgentMessagesByThreadId.value, activeThreadIds)
+    livePlanMessagesByThreadId.value = pruneThreadStateMap(livePlanMessagesByThreadId.value, activeThreadIds)
     liveReasoningTextByThreadId.value = pruneThreadStateMap(liveReasoningTextByThreadId.value, activeThreadIds)
     liveCommandsByThreadId.value = pruneThreadStateMap(liveCommandsByThreadId.value, activeThreadIds)
     threadTokenUsageByThreadId.value = pruneThreadStateMap(threadTokenUsageByThreadId.value, activeThreadIds)
+    threadGoalByThreadId.value = pruneThreadStateMap(threadGoalByThreadId.value, activeThreadIds)
+    threadGoalLoadingByThreadId.value = pruneThreadStateMap(threadGoalLoadingByThreadId.value, activeThreadIds)
+    threadGoalUpdatingByThreadId.value = pruneThreadStateMap(threadGoalUpdatingByThreadId.value, activeThreadIds)
+    threadGoalErrorByThreadId.value = pruneThreadStateMap(threadGoalErrorByThreadId.value, activeThreadIds)
     turnSummaryByThreadId.value = pruneThreadStateMap(turnSummaryByThreadId.value, activeThreadIds)
     turnActivityByThreadId.value = pruneThreadStateMap(turnActivityByThreadId.value, activeThreadIds)
     turnErrorByThreadId.value = pruneThreadStateMap(turnErrorByThreadId.value, activeThreadIds)
@@ -3975,6 +4013,193 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     return (queuedMessagesByThreadId.value[threadId] ?? []).length > 0
   }
 
+  function setThreadGoalState(threadId: string, goal: UiThreadGoal | null): void {
+    if (!threadId) return
+    const previous = threadGoalByThreadId.value[threadId] ?? null
+    if (JSON.stringify(previous) === JSON.stringify(goal)) return
+    threadGoalStateGenerationByThreadId.set(
+      threadId,
+      (threadGoalStateGenerationByThreadId.get(threadId) ?? 0) + 1,
+    )
+    threadGoalByThreadId.value = {
+      ...threadGoalByThreadId.value,
+      [threadId]: goal,
+    }
+  }
+
+  function invalidateThreadGoalRefresh(threadId: string): void {
+    if (!threadId) return
+    threadGoalStateGenerationByThreadId.set(
+      threadId,
+      (threadGoalStateGenerationByThreadId.get(threadId) ?? 0) + 1,
+    )
+  }
+
+  function setThreadGoalError(threadId: string, message: string): void {
+    if (!threadId) return
+    const normalized = message.trim()
+    threadGoalErrorByThreadId.value = normalized
+      ? { ...threadGoalErrorByThreadId.value, [threadId]: normalized }
+      : omitKey(threadGoalErrorByThreadId.value, threadId)
+  }
+
+  function readThreadGoalError(unknownError: unknown, fallback: string): string {
+    return unknownError instanceof Error && unknownError.message.trim()
+      ? unknownError.message
+      : fallback
+  }
+
+  function setThreadGoalLoading(threadId: string, loading: boolean): void {
+    if (!threadId) return
+    threadGoalLoadingByThreadId.value = loading
+      ? { ...threadGoalLoadingByThreadId.value, [threadId]: true }
+      : omitKey(threadGoalLoadingByThreadId.value, threadId)
+  }
+
+  function setThreadGoalUpdating(threadId: string, updating: boolean): void {
+    if (!threadId) return
+    threadGoalUpdatingByThreadId.value = updating
+      ? { ...threadGoalUpdatingByThreadId.value, [threadId]: true }
+      : omitKey(threadGoalUpdatingByThreadId.value, threadId)
+  }
+
+  function cancelThreadGoalContinuation(threadId: string): void {
+    const timer = threadGoalContinuationTimerByThreadId.get(threadId)
+    if (timer !== undefined && typeof window !== 'undefined') {
+      window.clearTimeout(timer)
+    }
+    threadGoalContinuationTimerByThreadId.delete(threadId)
+  }
+
+  function canContinueThreadGoal(threadId: string): boolean {
+    const goal = threadGoalByThreadId.value[threadId]
+    if (!goal || goal.status !== 'active') return false
+    if (loadedMessagesByThreadId.value[threadId] !== true || messageLoadInFlightByThreadId.has(threadId)) return false
+    if (isThreadExecutionActive(threadId) || hasQueuedThreadWork(threadId)) return false
+    if ((pendingServerRequestsByThreadId.value[threadId] ?? []).length > 0) return false
+    if ((pendingServerRequestsByThreadId.value[GLOBAL_SERVER_REQUEST_SCOPE] ?? []).length > 0) return false
+    return !threadGoalContinuationInFlight.has(threadId)
+  }
+
+  function scheduleThreadGoalContinuation(threadId: string): void {
+    if (!threadId || typeof window === 'undefined') return
+    cancelThreadGoalContinuation(threadId)
+    if (!canContinueThreadGoal(threadId)) return
+    const timer = window.setTimeout(() => {
+      threadGoalContinuationTimerByThreadId.delete(threadId)
+      if (!canContinueThreadGoal(threadId)) return
+      threadGoalContinuationInFlight.add(threadId)
+      void setThreadGoal(threadId, { status: 'active' })
+        .then((goal) => setThreadGoalState(threadId, goal))
+        .catch(() => {
+          // The next authoritative goal refresh or notification can recover this continuation.
+        })
+        .finally(() => threadGoalContinuationInFlight.delete(threadId))
+    }, THREAD_GOAL_CONTINUATION_DELAY_MS)
+    threadGoalContinuationTimerByThreadId.set(threadId, timer)
+  }
+
+  function refreshThreadGoal(threadId: string, continueIfActive = true): Promise<void> {
+    if (!threadId) return Promise.resolve()
+    const existingRequest = threadGoalRefreshInFlightByThreadId.get(threadId)
+    if (existingRequest) return existingRequest
+    const stateGeneration = threadGoalStateGenerationByThreadId.get(threadId) ?? 0
+    setThreadGoalLoading(threadId, true)
+    setThreadGoalError(threadId, '')
+    const request = (async () => {
+      try {
+        const goal = await getThreadGoal(threadId)
+        if ((threadGoalStateGenerationByThreadId.get(threadId) ?? 0) !== stateGeneration) return
+        setThreadGoalState(threadId, goal)
+        if (goal?.status === 'active' && continueIfActive) {
+          scheduleThreadGoalContinuation(threadId)
+        } else {
+          cancelThreadGoalContinuation(threadId)
+        }
+      } catch (unknownError) {
+        if ((threadGoalStateGenerationByThreadId.get(threadId) ?? 0) === stateGeneration) {
+          setThreadGoalError(threadId, readThreadGoalError(unknownError, '读取持续目标失败'))
+        }
+      } finally {
+        threadGoalRefreshInFlightByThreadId.delete(threadId)
+        setThreadGoalLoading(threadId, false)
+      }
+    })()
+    threadGoalRefreshInFlightByThreadId.set(threadId, request)
+    return request
+  }
+
+  async function refreshSelectedThreadGoal(): Promise<void> {
+    const threadId = selectedThreadId.value.trim()
+    if (!threadId) return
+    await refreshThreadGoal(threadId)
+  }
+
+  async function saveSelectedThreadGoal(objective: string): Promise<void> {
+    const threadId = selectedThreadId.value
+    const normalizedObjective = objective.trim()
+    if (!threadId || !normalizedObjective || threadGoalUpdatingByThreadId.value[threadId]) return
+    setThreadGoalUpdating(threadId, true)
+    invalidateThreadGoalRefresh(threadId)
+    setThreadGoalError(threadId, '')
+    error.value = ''
+    try {
+      const current = threadGoalByThreadId.value[threadId]
+      const goal = await setThreadGoal(threadId, current
+        ? { objective: normalizedObjective }
+        : { objective: normalizedObjective, status: 'active' })
+      setThreadGoalState(threadId, goal)
+      if (goal.status === 'active') scheduleThreadGoalContinuation(threadId)
+    } catch (unknownError) {
+      error.value = readThreadGoalError(unknownError, '保存持续目标失败')
+      setThreadGoalError(threadId, error.value)
+      throw unknownError
+    } finally {
+      setThreadGoalUpdating(threadId, false)
+    }
+  }
+
+  async function updateSelectedThreadGoalStatus(status: Extract<UiThreadGoalStatus, 'active' | 'paused'>): Promise<void> {
+    const threadId = selectedThreadId.value
+    if (!threadId || !threadGoalByThreadId.value[threadId] || threadGoalUpdatingByThreadId.value[threadId]) return
+    setThreadGoalUpdating(threadId, true)
+    invalidateThreadGoalRefresh(threadId)
+    setThreadGoalError(threadId, '')
+    error.value = ''
+    if (status === 'paused') cancelThreadGoalContinuation(threadId)
+    try {
+      const goal = await setThreadGoal(threadId, { status })
+      setThreadGoalState(threadId, goal)
+      if (status === 'active') scheduleThreadGoalContinuation(threadId)
+    } catch (unknownError) {
+      error.value = readThreadGoalError(unknownError, '更新持续目标失败')
+      setThreadGoalError(threadId, error.value)
+      throw unknownError
+    } finally {
+      setThreadGoalUpdating(threadId, false)
+    }
+  }
+
+  async function clearSelectedThreadGoal(): Promise<void> {
+    const threadId = selectedThreadId.value
+    if (!threadId || threadGoalUpdatingByThreadId.value[threadId]) return
+    setThreadGoalUpdating(threadId, true)
+    invalidateThreadGoalRefresh(threadId)
+    setThreadGoalError(threadId, '')
+    error.value = ''
+    cancelThreadGoalContinuation(threadId)
+    try {
+      await clearThreadGoal(threadId)
+      setThreadGoalState(threadId, null)
+    } catch (unknownError) {
+      error.value = readThreadGoalError(unknownError, '清除持续目标失败')
+      setThreadGoalError(threadId, error.value)
+      throw unknownError
+    } finally {
+      setThreadGoalUpdating(threadId, false)
+    }
+  }
+
   function hasPendingLocalTurnFeedback(threadId: string): boolean {
     if (!threadId) return false
     const runtimeSummary = runtimeStatusSummaryByThreadId.value[threadId]
@@ -4334,6 +4559,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     bufferedAgentDeltaByKey.clear()
     bufferedCommandDeltaByKey.clear()
     bufferedReasoningDeltaByThreadId.clear()
+    bufferedPlanDeltaByKey.clear()
   }
 
   function flushBufferedLiveDeltas(): void {
@@ -4345,7 +4571,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (
       bufferedAgentDeltaByKey.size === 0 &&
       bufferedCommandDeltaByKey.size === 0 &&
-      bufferedReasoningDeltaByThreadId.size === 0
+      bufferedReasoningDeltaByThreadId.size === 0 &&
+      bufferedPlanDeltaByKey.size === 0
     ) {
       return
     }
@@ -4353,9 +4580,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     const agentEntries = Array.from(bufferedAgentDeltaByKey.values())
     const commandEntries = Array.from(bufferedCommandDeltaByKey.values())
     const reasoningEntries = Array.from(bufferedReasoningDeltaByThreadId.entries())
+    const planEntries = Array.from(bufferedPlanDeltaByKey.values())
     bufferedAgentDeltaByKey.clear()
     bufferedCommandDeltaByKey.clear()
     bufferedReasoningDeltaByThreadId.clear()
+    bufferedPlanDeltaByKey.clear()
     const activeThreadIds = new Set<string>()
 
     for (const [threadId, delta] of reasoningEntries) {
@@ -4364,6 +4593,16 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       setLiveReasoningText(threadId, `${previous}${delta}`)
     }
 
+    for (const entry of planEntries) {
+      activeThreadIds.add(entry.threadId)
+      const id = `plan:${entry.turnId}`
+      const existing = (livePlanMessagesByThreadId.value[entry.threadId] ?? [])
+        .find((message) => message.id === id)
+      upsertLivePlan(entry.threadId, entry.turnId, {
+        rawText: `${existing?.plan?.rawText ?? existing?.text ?? ''}${entry.delta}`,
+      })
+    }
+
     const agentEntriesByThread = new Map<string, BufferedAgentDelta[]>()
     for (const entry of agentEntries) {
       activeThreadIds.add(entry.threadId)
@@ -4463,6 +4702,22 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     scheduleLiveDeltaFlush()
   }
 
+  function bufferLivePlanDelta(threadId: string, turnId: string, delta: string): void {
+    if (!threadId || !turnId || !delta) return
+    const key = `${threadId}:${turnId}`
+    const current = bufferedPlanDeltaByKey.get(key)
+    const id = `plan:${turnId}`
+    const isFirstVisibleDelta = !current && !(livePlanMessagesByThreadId.value[threadId] ?? [])
+      .some((message) => message.id === id && Boolean(message.plan?.rawText || message.text))
+    if (current) current.delta += delta
+    else bufferedPlanDeltaByKey.set(key, { threadId, turnId, delta })
+    if (isFirstVisibleDelta) {
+      flushBufferedLiveDeltas()
+      return
+    }
+    scheduleLiveDeltaFlush()
+  }
+
   function setThreadScrollState(threadId: string, nextState: ThreadScrollState): void {
     if (!threadId) return
 
@@ -5474,6 +5729,104 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     setLiveAgentMessagesForThread(threadId, next)
   }
 
+  function setLivePlanMessagesForThread(threadId: string, nextMessages: UiMessage[]): void {
+    const previous = livePlanMessagesByThreadId.value[threadId] ?? []
+    if (areMessageArraysEqual(previous, nextMessages)) return
+    livePlanMessagesByThreadId.value = nextMessages.length > 0
+      ? { ...livePlanMessagesByThreadId.value, [threadId]: nextMessages }
+      : omitKey(livePlanMessagesByThreadId.value, threadId)
+  }
+
+  function normalizePlanSteps(value: unknown): UiPlanStep[] {
+    if (!Array.isArray(value)) return []
+    const steps: UiPlanStep[] = []
+    for (const entry of value) {
+      const row = asRecord(entry)
+      const step = readString(row?.step).trim()
+      const rawStatus = readString(row?.status).trim()
+      if (!step || (rawStatus !== 'pending' && rawStatus !== 'inProgress' && rawStatus !== 'completed')) continue
+      steps.push({ step, status: rawStatus })
+    }
+    return steps
+  }
+
+  function upsertLivePlan(
+    threadId: string,
+    turnId: string,
+    patch: Partial<NonNullable<UiMessage['plan']>>,
+  ): void {
+    if (!threadId || !turnId) return
+    const id = `plan:${turnId}`
+    const previousLive = livePlanMessagesByThreadId.value[threadId] ?? []
+    const existing = previousLive.find((message) => message.id === id)
+      ?? (persistedMessagesByThreadId.value[threadId] ?? []).find((message) => message.id === id)
+    const previousPlan = existing?.plan
+    const nextPlan = {
+      turnId,
+      explanation: patch.explanation ?? previousPlan?.explanation ?? '',
+      steps: patch.steps ?? previousPlan?.steps ?? [],
+      rawText: patch.rawText ?? previousPlan?.rawText ?? existing?.text ?? '',
+      isStreaming: patch.isStreaming ?? previousPlan?.isStreaming ?? true,
+    }
+    const nextMessage: UiMessage = {
+      id,
+      role: 'system',
+      text: nextPlan.rawText,
+      messageType: 'plan',
+      plan: nextPlan,
+      turnIndex: existing?.turnIndex,
+    }
+    setLivePlanMessagesForThread(threadId, upsertMessage(previousLive, nextMessage))
+  }
+
+  function readPlanTurnId(notification: RpcNotification): string {
+    const params = asRecord(notification.params)
+    return readString(params?.turnId)
+      || readString(asRecord(params?.turn)?.id)
+  }
+
+  function applyPlanNotification(notification: RpcNotification, threadId: string): void {
+    const params = asRecord(notification.params)
+    if (!params) return
+    const turnId = readPlanTurnId(notification)
+    if (!turnId) return
+
+    if (notification.method === 'turn/plan/updated') {
+      upsertLivePlan(threadId, turnId, {
+        explanation: readString(params.explanation).trim(),
+        steps: normalizePlanSteps(params.plan),
+        isStreaming: true,
+      })
+      return
+    }
+
+    if (notification.method === 'item/plan/delta') {
+      const delta = readString(params.delta)
+      if (!delta) return
+      bufferLivePlanDelta(threadId, turnId, delta)
+      return
+    }
+
+    if (notification.method !== 'item/started' && notification.method !== 'item/completed') return
+    const item = asRecord(params.item)
+    if (item?.type !== 'plan') return
+    if (notification.method === 'item/completed') flushBufferedLiveDeltas()
+    upsertLivePlan(threadId, turnId, {
+      rawText: readString(item.text),
+      isStreaming: notification.method !== 'item/completed',
+    })
+  }
+
+  function finishLivePlansForThread(threadId: string): void {
+    flushBufferedLiveDeltas()
+    const previous = livePlanMessagesByThreadId.value[threadId] ?? []
+    if (previous.length === 0) return
+    setLivePlanMessagesForThread(threadId, previous.map((message) => ({
+      ...message,
+      plan: message.plan ? { ...message.plan, isStreaming: false } : message.plan,
+    })))
+  }
+
   function setLiveReasoningText(threadId: string, text: string): void {
     if (!threadId) return
     const normalized = text.trim()
@@ -6289,6 +6642,23 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       setThreadTokenUsage(threadTokenUsageUpdate.threadId, threadTokenUsageUpdate.tokenUsage)
     }
 
+    if (notification.method === 'thread/goal/updated') {
+      const params = asRecord(notification.params)
+      const goal = normalizeThreadGoal(params?.goal)
+      if (goal) {
+        setThreadGoalError(goal.threadId, '')
+        setThreadGoalState(goal.threadId, goal)
+        if (goal.status !== 'active') cancelThreadGoalContinuation(goal.threadId)
+      }
+    } else if (notification.method === 'thread/goal/cleared') {
+      const goalThreadId = extractThreadIdFromNotification(notification)
+      if (goalThreadId) {
+        cancelThreadGoalContinuation(goalThreadId)
+        setThreadGoalError(goalThreadId, '')
+        setThreadGoalState(goalThreadId, null)
+      }
+    }
+
     if (shouldBoostSyncForNotification(notification.method)) {
       markActiveSyncBoost()
       const notificationThreadId = extractThreadIdFromNotification(notification)
@@ -6371,6 +6741,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       if (!shouldRetryWithFallback) {
         clearPendingTurnRequest(completedTurn.threadId)
         void processQueuedMessages(completedTurn.threadId)
+        if (!turnErrorMessage) scheduleThreadGoalContinuation(completedTurn.threadId)
       }
       if (!turnErrorMessage && !shouldRetryWithFallback) {
         const commitMessage = pendingTurnRequest?.text?.trim() || AUTO_COMMIT_MESSAGE_FALLBACK
@@ -6454,6 +6825,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     const notificationThreadId = extractThreadIdFromNotification(notification)
     if (!notificationThreadId || notificationThreadId !== selectedThreadId.value) return
 
+    applyPlanNotification(notification, notificationThreadId)
+    if (notification.method === 'turn/completed') {
+      finishLivePlansForThread(notificationThreadId)
+    }
+
     const startedAgentMessageId = readAgentMessageStartedId(notification)
     if (startedAgentMessageId) {
       markThreadLiveExecutionSignal(notificationThreadId)
@@ -7424,6 +7800,9 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       if (options.loadMessages !== false) {
         await loadMessages(selectedThreadId.value)
       }
+      if (selectedThreadId.value) {
+        await refreshThreadGoal(selectedThreadId.value)
+      }
     } catch (unknownError) {
       error.value = unknownError instanceof Error ? unknownError.message : 'Unknown application error'
     }
@@ -7458,6 +7837,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
       await loadPendingServerRequestsFromBridge()
       await loadThreads({ preserveMissingSelected: true })
+      await refreshThreadGoal(threadId)
 
       if (selectedThreadId.value === threadId) {
         const resolvedExecutionState = resolveThreadReadExecutionState(
@@ -7527,6 +7907,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       return
     }
 
+    void refreshThreadGoal(normalizedThreadId)
+
     const abortController = new AbortController()
     threadSelectionAbortController = abortController
 
@@ -7536,6 +7918,9 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       if (normalizedThreadId && isThreadExecutionActive(normalizedThreadId)) {
         markActiveSyncBoost()
       }
+      if (threadGoalByThreadId.value[normalizedThreadId]?.status === 'active') {
+        scheduleThreadGoalContinuation(normalizedThreadId)
+      }
     }
 
     const runThreadLoad = async (silent: boolean): Promise<void> => {
@@ -7756,7 +8141,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       notifyDeliveryPersisted(internalOptions.onDeliveryPersisted)
 
       await recoverThreadExecutionState(threadId)
-      consumePlanModeAfterSubmit(collaborationMode)
       if (inProgressById.value[threadId] !== true) {
         void processQueuedMessages(threadId)
       }
@@ -7833,7 +8217,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
           clientMessageId,
           onRequestDispatched: requestDispatchedCallback(internalOptions.onRequestDispatched),
         })
-        consumePlanModeAfterSubmit(collaborationMode)
       } catch (unknownError) {
         if (isRetryableRuntimeSendError(unknownError)) {
           markOptimisticUserMessageWaiting(threadId, optimisticMessageId)
@@ -7855,7 +8238,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         clientMessageId,
         onRequestDispatched: requestDispatchedCallback(internalOptions.onRequestDispatched),
       })
-      consumePlanModeAfterSubmit(collaborationMode)
     } catch (unknownError) {
       shouldAutoScrollOnNextAgentEvent = false
       if (isRetryableRuntimeSendError(unknownError)) {
@@ -8207,7 +8589,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         if (runtimeResult && isRuntimeRequestAwaitingDeliveryConfirmation(runtimeResult.status)) {
           markPendingNewThreadPreviewConfirming(clientMessageId, optimisticMessageId)
           isSendingMessage.value = false
-          consumePlanModeAfterSubmit(collaborationMode)
           void reconcileAcceptedNewThreadInBackground()
           return ''
         }
@@ -8261,7 +8642,6 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       const capturedCwd = targetCwd || null
       const capturedPrompt = nextText
       isSendingMessage.value = false
-      consumePlanModeAfterSubmit(collaborationMode)
       void requestThreadTitleGeneration(capturedThreadId, capturedPrompt, capturedCwd)
       return threadId
     } catch (unknownError) {
@@ -8560,6 +8940,15 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       throw new Error('Could not determine active turn id for interrupt')
     }
 
+    const activeGoal = threadGoalByThreadId.value[threadId]
+    if (activeGoal?.status === 'active') {
+      cancelThreadGoalContinuation(threadId)
+      setThreadGoalState(threadId, { ...activeGoal, status: 'paused' })
+      void setThreadGoal(threadId, { status: 'paused' })
+        .then((goal) => setThreadGoalState(threadId, goal))
+        .catch(() => void refreshThreadGoal(threadId, false))
+    }
+
     triggerAndroidHaptic('warning')
     isInterruptingTurn.value = true
     error.value = ''
@@ -8649,6 +9038,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       const nextMessages = await rollbackThread(threadId, numTurns)
       setPersistedMessagesForThread(threadId, nextMessages)
       setLiveAgentMessagesForThread(threadId, [])
+      setLivePlanMessagesForThread(threadId, [])
       clearLiveReasoningForThread(threadId)
       if (liveCommandsByThreadId.value[threadId]) {
         liveCommandsByThreadId.value = omitKey(liveCommandsByThreadId.value, threadId)
@@ -9571,9 +9961,23 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     failedUserMessageRequestById.clear()
     failedMessageRetryInFlightIds.clear()
     liveAgentMessagesByThreadId.value = {}
+    livePlanMessagesByThreadId.value = {}
     liveReasoningTextByThreadId.value = {}
     liveCommandsByThreadId.value = {}
     threadTokenUsageByThreadId.value = {}
+    threadGoalByThreadId.value = {}
+    threadGoalLoadingByThreadId.value = {}
+    threadGoalUpdatingByThreadId.value = {}
+    threadGoalErrorByThreadId.value = {}
+    if (typeof window !== 'undefined') {
+      for (const timer of threadGoalContinuationTimerByThreadId.values()) {
+        window.clearTimeout(timer)
+      }
+    }
+    threadGoalContinuationTimerByThreadId.clear()
+    threadGoalContinuationInFlight.clear()
+    threadGoalRefreshInFlightByThreadId.clear()
+    threadGoalStateGenerationByThreadId.clear()
     if (typeof window !== 'undefined') {
       for (const timer of tokenUsageRefreshTimerByThreadId.values()) {
         window.clearTimeout(timer)
@@ -9676,6 +10080,10 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     selectedThreadCanStop,
     selectedThreadRuntimeStatus,
     selectedThreadTokenUsage,
+    selectedThreadGoal,
+    isSelectedThreadGoalLoading,
+    isSelectedThreadGoalUpdating,
+    selectedThreadGoalError,
     selectedThreadLoadError,
     selectedThreadId,
     availableModels,
@@ -9740,6 +10148,10 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     setSelectedModelId,
     setWorktreeGitAutomationEnabled,
     setSelectedCollaborationMode,
+    refreshSelectedThreadGoal,
+    saveSelectedThreadGoal,
+    updateSelectedThreadGoalStatus,
+    clearSelectedThreadGoal,
     setSelectedReasoningEffort,
     updateSelectedSpeedMode,
     respondToPendingServerRequest,
diff --git a/src/types/codex.ts b/src/types/codex.ts
index 8aee4ef..894ccd5 100644
--- a/src/types/codex.ts
+++ b/src/types/codex.ts
@@ -39,6 +39,40 @@ export type ComposerTurnOptions = {
   goal?: TurnGoalSelection
 }
 
+export type UiThreadGoalStatus =
+  | 'active'
+  | 'paused'
+  | 'budgetLimited'
+  | 'usageLimited'
+  | 'blocked'
+  | 'complete'
+
+export type UiThreadGoal = {
+  threadId: string
+  objective: string
+  status: UiThreadGoalStatus
+  tokenBudget: number | null
+  tokensUsed: number
+  timeUsedSeconds: number
+  createdAt: number
+  updatedAt: number
+}
+
+export type UiPlanStepStatus = 'pending' | 'inProgress' | 'completed'
+
+export type UiPlanStep = {
+  step: string
+  status: UiPlanStepStatus
+}
+
+export type UiPlan = {
+  turnId: string
+  explanation: string
+  steps: UiPlanStep[]
+  rawText: string
+  isStreaming: boolean
+}
+
 export type ComposerPluginInfo = {
   id: string
   name: string
@@ -176,6 +210,7 @@ export type UiMessage = {
   rawPayload?: string
   isUnhandled?: boolean
   commandExecution?: CommandExecutionData
+  plan?: UiPlan
   turnIndex?: number
   deliveryState?: 'sending' | 'retrying' | 'waiting' | 'confirming' | 'sent' | 'failed'
   deliveryError?: string
diff --git a/tests.md b/tests.md
index 000031f..ba1d11e 100644
--- a/tests.md
+++ b/tests.md
@@ -1476,7 +1476,7 @@ The pending home conversation must derive `is-turn-in-progress` from its current
 4. Confirm internal `<recommended_plugins>` / Codex context messages, trailing `<oai-mem-citation>` blocks, and supported `::git-*` / task directives do not appear as chat content.
 5. Reload the thread and confirm the existing conversation is readable before deferred capability metadata completes; after the background refresh, open the model control.
 6. Confirm the model list matches visible `model/list` entries, uses server display names/descriptions/default markers, and only offers reasoning levels supported by the selected model. If the runtime later exposes GPT-5.6 variants, confirm they appear without a frontend code change.
-7. Open `+`, verify `添加照片和文件`, `添加文件夹`, `拍照`, `仅生成计划`, `本轮要求`, `插件`, and enabled skills remain available with concise one-shot descriptions.
+7. Open `+`, verify `添加照片和文件`, `添加文件夹`, `拍照`, persistent `计划模式`, `本轮要求（一次性）`, `插件`, and enabled skills remain available with concise descriptions.
 8. Open the plugin subview and confirm installed/enabled native plugins appear as soon as `plugin/list` returns without waiting for the slower MCP scan; after background completion, search by name and confirm only usable ready/login-required MCP servers are merged. Use Tab/Shift+Tab to confirm focus stays inside the mobile sheet, then close it with Escape or the close control and confirm focus returns to `+`.
 9. Save a draft with one skill/plugin selected and reload. Before capability metadata completes, confirm a compact `正在恢复 N 项能力` state is shown and Send is disabled; after loading, confirm valid selections are restored, unavailable selections are removed, and the draft text is preserved.
 10. Start a reply from the second client. Confirm the first assistant text appears immediately, subsequent text remains smooth, only one copy of the live answer is visible, and the compact activity overlay yields to the answer text.
@@ -4394,7 +4394,7 @@ The pending home conversation must derive `is-turn-in-progress` from its current
 
 ---
 
-### Feature: 计划模式接近桌面端行为
+### Feature: 持续计划模式、结构化计划与实施动作
 
 #### Prerequisites
 - `7420` 服务运行中，当前构建已包含计划模式优化。
@@ -4402,17 +4402,20 @@ The pending home conversation must derive `is-turn-in-progress` from its current
 
 #### Steps
 1. 打开新会话或任意已有会话。
-2. 点击输入区的 `计划`。
+2. 打开 `+`，启用 `计划模式`。
 3. 输入一个只需要制定计划的任务并发送。
 4. 观察回复内容是否只给计划，不执行命令、不读写文件。
-5. 等待回复完成后查看输入区模式。
+5. 等待回复完成，确认输入框上方持续显示 `计划模式 · 持续开启`，可直接点 `×` 退出；刷新页面后再次确认该模式保持。
 6. 打开 `/codex-api/health`，确认 `activePlanModeTurnCount` 回到 `0`。
-7. 再输入 `开始执行`，确认默认已处于 `执行`，不会继续被计划模式拦截。
+7. 确认 `turn/plan/updated` 对应的计划以可折叠步骤卡展示：最新计划默认展开、旧计划默认收起，超过 6 步时先展示前两步和当前步骤，并用 `已隐藏 N 步` 解释中间跳步，可手动显示全部；增量阶段不出现重复计划卡或逐字重绘抖动。
+8. 点击最新计划上的 `是，实施此计划`，确认按钮立即变为 `正在提交…` 且不能重复点击；提交成功后保留 `已提交执行`，模式切换到执行并发送 `是的，执行此计划`；刷新页面后仍从会话历史恢复 `已提交执行`；提交失败时保留计划卡并允许重试。
+9. 再次手动关闭计划模式，确认后续普通消息使用执行模式。
 
 #### Expected Results
 - 前端发送计划时使用原生 `mode: plan`，不再把整段 Plan Mode 规则注入用户消息。
 - 如果后端不支持原生 `mode: plan`，才降级注入只读计划提示。
-- 计划消息发送后输入区自动切回 `执行`。
+- 计划模式持续生效，直到用户主动关闭或点击实施计划。
+- 计划卡使用 `生成中`、`已生成`、`已提交执行`、`执行中`、`已完成` 等明确状态；结构化步骤随 `turn/plan/updated` 更新，`item/plan/delta` 以约 48ms 合并刷新，完成项覆盖临时内容。
 - 计划完成后不残留停止按钮、思考中状态或 `activePlanModeTurnCount`。
 
 #### Rollback/Cleanup
@@ -4420,6 +4423,36 @@ The pending home conversation must derive `is-turn-in-progress` from its current
 
 ---
 
+### Feature: 线程级持续目标完整生命周期
+
+#### Prerequisites
+- 当前 App Server 支持 `thread/goal/get`、`thread/goal/set`、`thread/goal/clear`。
+- 准备一个当前无运行任务的已有会话。
+
+#### Steps
+1. 打开会话，点击输入区上方的 `设置持续目标`，输入可衡量目标并点击 `保存并开始`。
+2. 确认目标条显示目标、运行提示、预算使用百分比和耗时；刷新页面并重新进入会话。
+3. 在目标运行时点击 `暂停`，确认任务完成后不会自动继续；再点击 `继续`，确认空闲时继续推进。
+4. 点击 `编辑` 修改目标，确认状态和已用量保持为服务端返回值。
+5. 在目标活跃且任务运行时点击停止，确认目标同步变为暂停，不会立即重新启动。
+6. 点击 `清除`，确认界面先展示目标摘要和 `确认清除`，取消一次后重新确认清除，刷新页面确认目标不再出现。
+7. 在移动宽度确认只保留 `暂停/继续` 主操作，`编辑/清除` 收入更多菜单，所有直接操作目标至少为 44px；目标正文最多显示两行且页面无横向溢出。
+8. 模拟 `thread/goal/get` 失败，确认错误显示在目标栏附近、草稿不丢失且 `重试` 可恢复；快速重复触发刷新时只保留一个读取请求，较旧响应不会覆盖更新后的目标。
+9. 打开目标编辑器并输入未保存内容，切换到另一个会话，确认编辑器、更多菜单和清除确认全部关闭，新会话不会继承上一会话草稿。
+10. 同时开启计划模式与活跃持续目标，确认目标栏明确提示 `计划模式只影响新消息；持续目标仍会推进`，暂停目标仍是直接操作。
+11. 在手机宽度用键盘打开目标更多菜单，确认焦点进入第一个菜单项，方向键可移动，Escape 关闭并回到触发按钮；点击菜单外部也会关闭。打开清除确认后等待超过 6 秒，确认操作不会自行消失。
+
+#### Expected Results
+- 目标状态以 App Server 为唯一事实来源，通过 `thread/goal/updated` / `thread/goal/cleared` 实时同步。
+- 活跃目标仅在会话空闲、无排队消息且无待处理授权时继续，不与用户消息抢占执行。
+- 目标读取失败不阻塞会话加载；读取请求按会话去重并以状态代次阻止旧响应回写；保存、状态切换或清除失败会保留当前草稿和可重试界面并显示就近错误。
+- 目标用量在移动端仍可见，计划模式与持续目标并存时不隐藏执行边界；切换会话不会携带任何目标栏临时交互状态。
+
+#### Rollback/Cleanup
+- 清除回归目标；若需回退，恢复 `threadGoal.ts`、`useDesktopState.ts`、`ThreadGoalBar.vue` 及 App 接线改动。
+
+---
+
 ### Feature: 会话列表排除归档线程，搜索仍覆盖历史线程
 
 #### Prerequisites

From 8416dfb58e0c6fd4ed91a54265ada0c52f3cd015 Mon Sep 17 00:00:00 2001
From: shaowei <466995322@qq.com>
Date: Mon, 3 Aug 2026 15:28:04 +0800
Subject: [PATCH 2/4] fix: make mobile message delivery durable

---
 .agents/skills/codex-app-parity/SKILL.md      |  31 ++
 scripts/server-module-smoke.ts                | 236 +++++++++-
 scripts/verify-frontend-normalizers.mjs       |  70 +++
 src/api/codexGateway.ts                       |  26 +-
 src/api/normalizers/v2.ts                     |  38 ++
 src/api/runtimeMessageQueue.ts                | 414 ++++++++++++++++++
 src/components/content/QueuedMessages.vue     |   9 +-
 src/components/content/ThreadConversation.vue | 149 +++----
 src/composables/messageIdentity.ts            |  37 ++
 src/composables/messageOutboxPersistence.ts   |   8 +
 src/composables/useDesktopState.ts            | 379 ++++++++--------
 .../appServerNotificationDiagnostics.ts       |   1 +
 src/server/codexAppServerBridge.ts            |  16 +
 src/server/codexBridgeMiddlewareDispose.ts    |   4 +
 src/server/codexBridgeRouteHandlers.ts        |   8 +
 src/server/runtimeActionRoutes.ts             |  38 ++
 src/server/runtimeMessageQueue.ts             | 258 +++++++++++
 src/server/runtimeStore.ts                    |  33 ++
 src/server/threadRoutes.ts                    |   3 +-
 src/server/threadTitleCache.ts                |  53 ++-
 tests.md                                      |  29 +-
 21 files changed, 1543 insertions(+), 297 deletions(-)
 create mode 100644 src/api/runtimeMessageQueue.ts
 create mode 100644 src/server/runtimeMessageQueue.ts

diff --git a/.agents/skills/codex-app-parity/SKILL.md b/.agents/skills/codex-app-parity/SKILL.md
index ef229b7..91e0444 100644
--- a/.agents/skills/codex-app-parity/SKILL.md
+++ b/.agents/skills/codex-app-parity/SKILL.md
@@ -1225,3 +1225,34 @@ After each feature implementation session that uses this skill:
 - CX-Codex previously combined a running shortcut, pinned shortcut, optional chronological mode, project grouping, pinned-project priority, and manual project reordering. On the real 7420 sidebar this placed stale pinned projects above the active `codexui` directory and made one conversation appear in several navigation collections.
 - The user explicitly chose a simpler fixed model, so CX-Codex intentionally narrows rather than copies the full Codex option set: `置顶` conversations, then `目录`, then directory conversations. All three levels use the latest conversation timestamp; running, waiting, and unread remain row state rather than sorting priority or a separate collection.
 - Pinned conversations remain discoverable inside their owning directory, preserving project context. Directory collapse, search, current-thread reveal, thread menus, synchronization, routes, persistence, Runtime Store, and Android lifecycle ownership are unchanged; stored project pin/order metadata is retained for compatibility but no longer affects or advertises the fixed recent presentation.
+
+## Findings: Persistent Plan and Thread-goal Parity (2026-08-02)
+
+- Installed Windows Codex `26.721.4979` treats Plan as a persistent collaboration mode, consumes `turn/plan/updated` plus `item/plan/delta`, and offers `是，实施此计划`; it owns long-running work through `thread/goal/get`, `thread/goal/set`, `thread/goal/clear`, `thread/goal/updated`, and `thread/goal/cleared` rather than by injecting ordinary user text.
+- CX-Codex previously reset Plan to execute after every submission and only exposed an unrelated one-turn requirement. Plan output was flattened or hidden, and no frontend owner hydrated or controlled the App Server's thread-goal state.
+- CX-Codex now preserves Plan until the user disables it, merges structured plan events into one expandable step card, and switches to execute only when the latest eligible plan is explicitly implemented. Historical plan items remain readable through the same card fallback.
+- A compact thread-goal bar now hydrates authoritative state per conversation and supports create, edit, pause, resume, clear, token/time progress, refresh recovery, and idle continuation. Continuation waits for message hydration and yields to running turns, queued work, and pending requests; a user stop pauses the active goal to prevent immediate restart.
+- Follow-up UX hardening keeps Plan visibly dismissible above the composer, coalesces plan text deltas on the existing 48 ms live-update cadence, preserves an explicit submitted state after implementation, defaults older plans closed, and previews long plans around the active step.
+- Thread-goal reads are deduplicated per thread and guarded by a state generation so a late read cannot overwrite a notification or edit. Mobile keeps pause/resume direct, moves edit/clear behind a compact menu, confirms clear inline with the objective, and exposes local retry without dropping the editor draft.
+- Headless Playwright verified one plan card, three structured steps, the implementation action, active-goal controls, and zero horizontal overflow at phone and desktop sizes. The full 34-surface 7420 frontend regression, frontend normalizer smoke, server-module smoke, and production frontend build passed. The existing one-turn requirement remains separate and is now labeled explicitly as one-time.
+
+## Findings: Plan and Goal Interaction Hardening (2026-08-03)
+
+- Installed Windows Codex `26.721.4979` keeps Plan as a collaboration mode while long-running work remains thread-owned goal state. CX-Codex now states that coexistence directly: Plan changes how the next message is handled, while the active goal continues independently and can still be paused.
+- Plan implementation state now survives refresh and cross-client synchronization by deriving `已提交执行` from the exact first implementation-confirmation message after that plan, while a newer plan closes the eligibility window. Long cards disclose collapsed context as `已隐藏 N 步` instead of silently omitting steps.
+- Thread switches now reset goal-editor drafts, overflow menus, pending clear confirmations, and focus ownership. Goal-menu arrow/Home/End/Escape behavior, durable destructive confirmation, 44 px phone actions, visible mobile usage, and explicit pending labels match the shared Codex interaction boundaries while adapting them to the narrower 7420 surface.
+- Headless Playwright at 393 x 852 and 1280 x 800 verified coexistence copy, cross-thread isolation, keyboard focus restoration, clear confirmation after 6.2 seconds, history-derived implementation state, visible hidden-step count, 44 px actions, and zero horizontal overflow.
+
+## Findings: Durable Mobile Queue and Message Fidelity (2026-08-03)
+
+- Desktop-grade conversation ownership requires queued work to remain thread-owned after the renderer disappears. CX-Codex now adapts that boundary to Android by persisting queue records in the 7420 Runtime Store and advancing them from a server coordinator, independent of the selected route, WebView, or Activity lifecycle.
+- A queued row becomes an optimistic user bubble only when the server announces that it is starting. Its stable client id and pre-send message anchor then remain in the durable outbox until authoritative history contains the matching user item, preventing assistant output from appearing above a missing prompt after refresh.
+- Manual conversation titles now have explicit durable ownership and reject later automatic name notifications. Generated images prefer the saved local path over oversized raw base64 payloads and expose a real remounting retry action on failure.
+- Phone Markdown tables retain the semantic desktop table and use a focusable horizontal scroll owner instead of changing rows into cards. Headless Playwright at 393 x 852 measured 322 px visible width over 620 px content, 13 px cells, zero table-card DOM, and no browser console errors.
+
+## Findings: Restart-safe Queued Speed Handoff (2026-08-03)
+
+- A real failed 7420 queue record showed `queued -> queue_failed` in 53 ms with `Turn start was not confirmed after bridge restart`; its prompt was absent from the full authoritative thread history. The queued coordinator had marked the request `pending_start` before `config/batchWrite`, while that configuration call could restart app-server and trigger pending-start reconciliation.
+- Queue speed configuration now remains preflight work. A row stays `queued` until any required configuration change has completed, so restart reconciliation cannot mistake preflight for a dispatched turn. A deletion during preflight is re-read and cannot be resurrected as `pending_start`.
+- `config/read` suppresses no-op speed writes. Standard speed already represented by `service_tier: null` no longer performs the configuration write that triggered the observed restart; fast mode still enables its feature and changes service tier only when necessary.
+- This preserves the desktop queue contract: genuine first-item failures still pause for retry, edit, or delete, while renderer-independent server ownership and stable `clientMessageId` ordering remain unchanged.
diff --git a/scripts/server-module-smoke.ts b/scripts/server-module-smoke.ts
index ad06869..5c181ef 100644
--- a/scripts/server-module-smoke.ts
+++ b/scripts/server-module-smoke.ts
@@ -315,6 +315,7 @@ import {
   type RuntimeEventRecord,
   type RuntimeRequestRecord,
 } from '../src/server/runtimeStore.js'
+import { RuntimeMessageQueue } from '../src/server/runtimeMessageQueue.js'
 import { handleRpcProxyRoute, type RpcProxyRouteDependencies } from '../src/server/rpcProxyRoute.js'
 import {
   createRuntimePromptHash,
@@ -563,6 +564,7 @@ try {
   smokeAppServerRuntimeSnapshotPersistence()
   smokeAppServerNotificationRuntimeSync()
   await smokeRuntimeActionRoutes()
+  await smokeRuntimeMessageQueue()
   await smokeMobilePush()
   await smokeDiagnosticsRoutes()
   await smokeRuntimeStoreMaintenance()
@@ -6377,24 +6379,28 @@ async function smokeThreadTokenUsage(): Promise<void> {
 }
 
 async function smokeThreadTitleCache(): Promise<void> {
-  assert.deepEqual(normalizeThreadTitleCache(null), { titles: {}, order: [] })
+  assert.deepEqual(normalizeThreadTitleCache(null), { titles: {}, order: [], manualTitleIds: [] })
   assert.deepEqual(normalizeThreadTitleCache({
     titles: { a: 'Alpha', b: '', c: 7 },
     order: ['a', 'missing', 'a', '', 9],
   }), {
     titles: { a: 'Alpha' },
     order: ['a', 'missing'],
+    manualTitleIds: [],
   })
 
-  const updated = updateThreadTitleCache({ titles: { a: 'Alpha' }, order: ['a'] }, 'b', 'Beta')
-  assert.deepEqual(updated, { titles: { a: 'Alpha', b: 'Beta' }, order: ['b', 'a'] })
-  assert.deepEqual(removeFromThreadTitleCache(updated, 'a'), { titles: { b: 'Beta' }, order: ['b'] })
+  const updated = updateThreadTitleCache({ titles: { a: 'Alpha' }, order: ['a'], manualTitleIds: [] }, 'b', 'Beta')
+  assert.deepEqual(updated, { titles: { a: 'Alpha', b: 'Beta' }, order: ['b', 'a'], manualTitleIds: [] })
+  assert.deepEqual(removeFromThreadTitleCache(updated, 'a'), { titles: { b: 'Beta' }, order: ['b'], manualTitleIds: [] })
+  const manuallyUpdated = updateThreadTitleCache(updated, 'b', 'Manual Beta', { manual: true })
+  assert.equal(updateThreadTitleCache(manuallyUpdated, 'b', 'Automatic Beta'), manuallyUpdated)
   assert.deepEqual(mergeThreadTitleCaches(
-    { titles: { a: 'Alpha', b: 'Base Beta' }, order: ['a', 'b'] },
-    { titles: { b: 'Session Beta', c: 'Gamma' }, order: ['c', 'b'] },
+    { titles: { a: 'Alpha', b: 'Base Beta' }, order: ['a', 'b'], manualTitleIds: ['b'] },
+    { titles: { b: 'Session Beta', c: 'Gamma' }, order: ['c', 'b'], manualTitleIds: [] },
   ), {
-    titles: { a: 'Alpha', b: 'Session Beta', c: 'Gamma' },
+    titles: { a: 'Alpha', b: 'Base Beta', c: 'Gamma' },
     order: ['c', 'b', 'a'],
+    manualTitleIds: ['b'],
   })
 
   const tempDir = await mkdtemp(join(tmpdir(), 'cx-codex-thread-title-'))
@@ -6402,12 +6408,13 @@ async function smokeThreadTitleCache(): Promise<void> {
     const statePath = join(tempDir, 'global-state.json')
     const sessionIndexPath = join(tempDir, 'session_index.jsonl')
 
-    assert.deepEqual(await readThreadTitleCache(statePath), { titles: {}, order: [] })
+    assert.deepEqual(await readThreadTitleCache(statePath), { titles: {}, order: [], manualTitleIds: [] })
     await writeFile(statePath, JSON.stringify({ existing: true }), 'utf8')
-    await writeThreadTitleCache(statePath, { titles: { manual: 'Manual title' }, order: ['manual'] })
+    await writeThreadTitleCache(statePath, { titles: { manual: 'Manual title' }, order: ['manual'], manualTitleIds: ['manual'] })
     assert.deepEqual(await readThreadTitleCache(statePath), {
       titles: { manual: 'Manual title' },
       order: ['manual'],
+      manualTitleIds: ['manual'],
     })
 
     await writeFile(sessionIndexPath, [
@@ -6421,15 +6428,18 @@ async function smokeThreadTitleCache(): Promise<void> {
     assert.deepEqual(await parseThreadTitlesFromSessionIndex(sessionIndexPath), {
       titles: { 'thread-a': 'New A', 'thread-b': 'Beta' },
       order: ['thread-a', 'thread-b'],
+      manualTitleIds: [],
     })
     assert.deepEqual(await readThreadTitlesFromSessionIndex(sessionIndexPath), {
       titles: { 'thread-a': 'New A', 'thread-b': 'Beta' },
       order: ['thread-a', 'thread-b'],
+      manualTitleIds: [],
     })
-    assert.deepEqual(await readThreadTitlesFromSessionIndex(join(tempDir, 'missing.jsonl')), { titles: {}, order: [] })
+    assert.deepEqual(await readThreadTitlesFromSessionIndex(join(tempDir, 'missing.jsonl')), { titles: {}, order: [], manualTitleIds: [] })
     assert.deepEqual(await readMergedThreadTitleCache(statePath, sessionIndexPath), {
       titles: { manual: 'Manual title', 'thread-a': 'New A', 'thread-b': 'Beta' },
       order: ['thread-a', 'thread-b', 'manual'],
+      manualTitleIds: ['manual'],
     })
   } finally {
     await rm(tempDir, { recursive: true, force: true })
@@ -6715,7 +6725,7 @@ async function smokeThreadSearchIndex(): Promise<void> {
           : { data: [{ id: 'hydrated-thread', name: 'Hydrated needle' }] }
       },
       getSessionIndexPath: () => 'cached-factory-session-index.jsonl',
-      readThreadTitlesFromSessionIndex: async () => ({ titles: {}, order: [] }),
+      readThreadTitlesFromSessionIndex: async () => ({ titles: {}, order: [], manualTitleIds: [] }),
     })
     assert.deepEqual(await cachedFactoryStore.search('cached', 10), {
       threadIds: ['cached-thread'],
@@ -6742,7 +6752,7 @@ async function smokeThreadRoutes(): Promise<void> {
   const bodies: unknown[] = [
     { query: ' alpha ', limit: 2.8 },
     { query: '   ', limit: 10 },
-    { id: 'thread-a', title: 'Alpha title' },
+    { id: 'thread-a', title: 'Alpha title', manual: true },
     { id: 'thread-a', title: '' },
     { title: 'Missing id' },
   ]
@@ -6765,7 +6775,7 @@ async function smokeThreadRoutes(): Promise<void> {
     }),
     readThreadTitleCache: async (path: string) => {
       readTitlePaths.push(path)
-      return { titles: { 'thread-a': 'Old title' }, order: ['thread-a'] }
+      return { titles: { 'thread-a': 'Old title' }, order: ['thread-a'], manualTitleIds: [] }
     },
     writeThreadTitleCache: async (path: string, cache: unknown) => {
       writeTitleCalls.push({ path, cache })
@@ -6819,6 +6829,7 @@ async function smokeThreadRoutes(): Promise<void> {
     cache: {
       titles: { 'thread-a': 'Alpha title' },
       order: ['thread-a'],
+      manualTitleIds: ['thread-a'],
     },
   })
   assert.deepEqual(JSON.parse(updateTitle.body), { ok: true })
@@ -6835,6 +6846,7 @@ async function smokeThreadRoutes(): Promise<void> {
     cache: {
       titles: {},
       order: [],
+      manualTitleIds: [],
     },
   })
   assert.deepEqual(JSON.parse(removeTitle.body), { ok: true })
@@ -9783,6 +9795,76 @@ async function smokeRuntimeActionRoutes(): Promise<void> {
   ])
   assert.deepEqual(JSON.parse(stopUncertain.body), { data: { status: 'stop_uncertain', requestId: 'stop-2' } })
 
+  const queueEntry = {
+    requestId: 'queue-request-a',
+    clientMessageId: 'queue-client-a',
+    threadId: 'thread-queue',
+    status: 'queued' as const,
+    createdAtIso: '2026-01-01T00:00:00.000Z',
+    updatedAtIso: '2026-01-01T00:00:00.000Z',
+    lastError: null,
+    payload: { input: 'queue route' },
+  }
+  const listedQueueThreadIds: string[] = []
+  const cancelledQueueRequestIds: string[] = []
+  const retriedQueueRequestIds: string[] = []
+  const queueDependencies = {
+    ...dependencies,
+    readJsonBody: async () => ({ input: 'queue route' }),
+    enqueueRuntimeTurn: () => queueEntry,
+    listRuntimeQueue: (threadId = '') => {
+      listedQueueThreadIds.push(threadId)
+      return [queueEntry]
+    },
+    cancelQueuedRuntimeTurn: (requestId: string) => {
+      cancelledQueueRequestIds.push(requestId)
+      return true
+    },
+    retryQueuedRuntimeTurn: (requestId: string) => {
+      retriedQueueRequestIds.push(requestId)
+      return true
+    },
+  }
+  const queued = createRouteTestResponse()
+  assert.equal(await handleRuntimeActionRoutes(
+    { method: 'POST' } as never,
+    queued.response as never,
+    new URL('http://127.0.0.1/codex-api/runtime/queue'),
+    queueDependencies,
+  ), true)
+  assert.equal(queued.response.statusCode, 202)
+  assert.deepEqual(JSON.parse(queued.body), { data: queueEntry })
+
+  const listed = createRouteTestResponse()
+  assert.equal(await handleRuntimeActionRoutes(
+    { method: 'GET' } as never,
+    listed.response as never,
+    new URL('http://127.0.0.1/codex-api/runtime/queue?threadId=thread-queue'),
+    queueDependencies,
+  ), true)
+  assert.deepEqual(JSON.parse(listed.body), { data: [queueEntry] })
+  assert.deepEqual(listedQueueThreadIds, ['thread-queue'])
+
+  const removed = createRouteTestResponse()
+  assert.equal(await handleRuntimeActionRoutes(
+    { method: 'DELETE' } as never,
+    removed.response as never,
+    new URL('http://127.0.0.1/codex-api/runtime/queue/queue-request-a'),
+    queueDependencies,
+  ), true)
+  assert.equal(removed.response.statusCode, 200)
+  assert.deepEqual(cancelledQueueRequestIds, ['queue-request-a'])
+
+  const retried = createRouteTestResponse()
+  assert.equal(await handleRuntimeActionRoutes(
+    { method: 'POST' } as never,
+    retried.response as never,
+    new URL('http://127.0.0.1/codex-api/runtime/queue/queue-request-a/retry'),
+    queueDependencies,
+  ), true)
+  assert.equal(retried.response.statusCode, 202)
+  assert.deepEqual(retriedQueueRequestIds, ['queue-request-a'])
+
   assert.equal(await handleRuntimeActionRoutes(
     { method: 'GET' } as never,
     createRouteTestResponse().response as never,
@@ -11194,6 +11276,134 @@ function smokeAppServerNotificationReplay(): void {
   }])
 }
 
+async function smokeRuntimeMessageQueue(): Promise<void> {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cx-codex-runtime-queue-'))
+  const dbPath = join(tempDir, 'runtime.sqlite')
+  const store = new RuntimeStore(dbPath)
+  const notifications: Array<{ method: string; params: unknown }> = []
+  const startedClientMessageIds: string[] = []
+  const rpcMethods: string[] = []
+  const queueStatusAtRpc: Array<{ method: string; status: string }> = []
+  let currentServiceTier: 'fast' | null = null
+  let expectedConfigClientMessageId = 'queued-client-1'
+  let queue: RuntimeMessageQueue | null = null
+  try {
+    store.createRequest({
+      requestId: 'active-request',
+      clientMessageId: 'active-client',
+      threadId: 'thread-queue',
+      status: 'running',
+      promptHash: 'active-hash',
+      mode: 'execute',
+      payload: {},
+    })
+    queue = new RuntimeMessageQueue({
+      store,
+      rpc: async (method, params) => {
+        rpcMethods.push(method)
+        const queuedRequest = store.getLatestRequestByClientMessageId(expectedConfigClientMessageId)
+        if (queuedRequest) {
+          queueStatusAtRpc.push({ method, status: queuedRequest.status })
+        }
+        if (method === 'config/read') {
+          return { config: { service_tier: currentServiceTier, features: { fast_mode: true } } }
+        }
+        if (method === 'config/batchWrite') {
+          updateRuntimeRequestsFromSnapshot('thread-queue', createThreadRuntimeSnapshot({
+            executionState: 'idle',
+            inProgress: false,
+          }), store)
+          const edits = params && typeof params === 'object' && !Array.isArray(params)
+            && Array.isArray((params as Record<string, unknown>).edits)
+            ? (params as Record<string, unknown>).edits as unknown[]
+            : []
+          const serviceTierEdit = edits.find((edit) => readStringProperty(edit, 'keyPath') === 'service_tier')
+          currentServiceTier = readStringProperty(serviceTierEdit, 'value') === 'fast' ? 'fast' : null
+        }
+        return {}
+      },
+      startRuntimeTurn: async (payload) => {
+        const clientMessageId = readStringProperty(payload, 'clientMessageId')
+        startedClientMessageIds.push(clientMessageId)
+        const request = store.getLatestRequestByClientMessageId(clientMessageId)
+        assert.ok(request)
+        store.updateRequest(request.requestId, { status: 'running', turnId: `turn-${clientMessageId}` })
+        return {}
+      },
+      publishNotification: (notification) => { notifications.push(notification) },
+      getErrorMessage: (error, fallback) => error instanceof Error ? error.message : fallback,
+    })
+    queue.start()
+
+    const first = queue.enqueue({
+      threadId: 'thread-queue',
+      clientMessageId: 'queued-client-1',
+      input: [{ type: 'text', text: 'First queued prompt' }],
+      collaborationMode: 'execute',
+      queueMetadata: { speedMode: 'standard', text: 'First queued prompt' },
+    })
+    assert.equal(first.status, 'queued')
+    await new Promise((resolve) => setTimeout(resolve, 30))
+    assert.deepEqual(startedClientMessageIds, [])
+    assert.equal(queue.list('thread-queue').length, 1)
+
+    store.updateRequest('active-request', { status: 'completed' })
+    queue.handleRuntimeEvent('turn/completed', 'thread-queue')
+    await waitForCondition(() => startedClientMessageIds.length === 1)
+    assert.deepEqual(startedClientMessageIds, ['queued-client-1'])
+    assert.equal(queue.list('thread-queue').length, 0)
+    assert.deepEqual(rpcMethods, ['config/read'])
+    assert.deepEqual(queueStatusAtRpc, [{ method: 'config/read', status: 'queued' }])
+    assert.equal(notifications.some((notification) => readStringProperty(notification.params, 'action') === 'starting'), true)
+
+    store.updateRequest(first.requestId, { status: 'completed' })
+    expectedConfigClientMessageId = 'queued-client-fast'
+    const fast = queue.enqueue({
+      threadId: 'thread-queue',
+      clientMessageId: 'queued-client-fast',
+      input: [{ type: 'text', text: 'Fast queued prompt' }],
+      collaborationMode: 'execute',
+      queueMetadata: { speedMode: 'fast', text: 'Fast queued prompt' },
+    })
+    await waitForCondition(() => startedClientMessageIds.length === 2)
+    assert.deepEqual(startedClientMessageIds, ['queued-client-1', 'queued-client-fast'])
+    assert.equal(rpcMethods.includes('config/batchWrite'), true)
+    assert.equal(store.getRequest(fast.requestId)?.status, 'running')
+    assert.equal(
+      queueStatusAtRpc.every((entry) => entry.status === 'queued'),
+      true,
+      'queued speed configuration must finish before claiming pending_start',
+    )
+    store.updateRequest(fast.requestId, { status: 'completed' })
+    queue.dispose()
+    queue = null
+    const failedQueue = new RuntimeMessageQueue({
+      store,
+      rpc: async () => ({}),
+      startRuntimeTurn: async () => { throw new Error('background start failed') },
+      publishNotification: (notification) => { notifications.push(notification) },
+      getErrorMessage: (error, fallback) => error instanceof Error ? error.message : fallback,
+    })
+    const failed = failedQueue.enqueue({
+      threadId: 'thread-queue',
+      clientMessageId: 'queued-client-failed',
+      input: [{ type: 'text', text: 'Failed queued prompt' }],
+      queueMetadata: { speedMode: 'standard', text: 'Failed queued prompt' },
+    })
+    await waitForCondition(() => store.getRequest(failed.requestId)?.status === 'queue_failed')
+    assert.equal(failedQueue.list('thread-queue')[0]?.lastError, 'background start failed')
+    assert.equal(failedQueue.retry(failed.requestId), true)
+    assert.equal(store.getRequest(failed.requestId)?.status, 'queued')
+    assert.equal(failedQueue.cancel(failed.requestId), true)
+    assert.equal(failedQueue.list('thread-queue').length, 0)
+    failedQueue.dispose()
+  } finally {
+    queue?.dispose()
+    store.close()
+    await rm(tempDir, { recursive: true, force: true })
+  }
+}
+
 async function smokeRuntimeStoreMaintenance(): Promise<void> {
   const root = await mkdtemp(join(tmpdir(), 'cx-codex-runtime-store-'))
   const dbPath = join(root, 'runtime.sqlite')
diff --git a/scripts/verify-frontend-normalizers.mjs b/scripts/verify-frontend-normalizers.mjs
index 79429fd..f11da4a 100644
--- a/scripts/verify-frontend-normalizers.mjs
+++ b/scripts/verify-frontend-normalizers.mjs
@@ -53,6 +53,7 @@ import { mergeMessageOutboxEntries, mergeMessageOutboxState } from '${messageOut
 import {
   createClientMessageId,
   filterVisibleOptimisticUserMessages,
+  mergeVisibleOptimisticUserMessages,
   userMessageSignature,
 } from '${messageIdentityImport}'
 import {
@@ -526,6 +527,8 @@ const rememberedIdentityMeta = new Map([[optimisticIdentityMessage.id, {
   kind: 'optimisticUserMessage',
   signature: identitySignature,
   baselineMatchCount: 1,
+  baselineMessageCount: 2,
+  baselineTailMessageId: 'baseline-assistant',
   createdAtMs: 1,
 }]])
 assert.deepEqual(
@@ -544,6 +547,73 @@ assert.deepEqual(
   ),
   [],
 )
+assert.deepEqual(
+  mergeVisibleOptimisticUserMessages(
+    [
+      persistedIdentityMessage,
+      { id: 'baseline-assistant', role: 'assistant', text: 'Previous answer' },
+      { id: 'new-assistant', role: 'assistant', text: 'Reply arrived before history acknowledgement' },
+    ],
+    [optimisticIdentityMessage],
+    rememberedIdentityMeta,
+  ).map((message) => message.id),
+  ['persisted-identity-1', 'baseline-assistant', 'optimistic-user:identity-1', 'new-assistant'],
+)
+const optimisticAfterFirst = { id: 'optimistic-user:after-first', role: 'user', text: 'First queued prompt' }
+const optimisticAfterLast = { id: 'optimistic-user:after-last', role: 'user', text: 'Second queued prompt' }
+assert.deepEqual(
+  mergeVisibleOptimisticUserMessages(
+    [
+      { id: 'persisted-a', role: 'assistant', text: 'A' },
+      { id: 'persisted-b', role: 'assistant', text: 'B' },
+      { id: 'persisted-c', role: 'assistant', text: 'C' },
+    ],
+    [optimisticAfterFirst, optimisticAfterLast],
+    new Map([
+      [optimisticAfterFirst.id, {
+        kind: 'optimisticUserMessage',
+        signature: userMessageSignature(optimisticAfterFirst),
+        baselineMatchCount: 0,
+        baselineMessageCount: 1,
+        baselineTailMessageId: 'persisted-a',
+        createdAtMs: 2,
+      }],
+      [optimisticAfterLast.id, {
+        kind: 'optimisticUserMessage',
+        signature: userMessageSignature(optimisticAfterLast),
+        baselineMatchCount: 0,
+        baselineMessageCount: 3,
+        baselineTailMessageId: 'persisted-c',
+        createdAtMs: 3,
+      }],
+    ]),
+  ).map((message) => message.id),
+  ['persisted-a', 'optimistic-user:after-first', 'persisted-b', 'persisted-c', 'optimistic-user:after-last'],
+)
+
+const generatedImageMessages = normalizeThreadMessagesV2({
+  thread: {
+    id: 'thread-generated-image',
+    cwd: 'E:\\repo',
+    preview: '',
+    updatedAt: 1,
+    createdAt: 1,
+    turns: [{
+      id: 'turn-generated-image',
+      status: 'completed',
+      items: [{
+        id: 'generated-image-1',
+        type: 'imageGeneration',
+        status: 'completed',
+        savedPath: 'C:\\work\\generated.png',
+        result: 'a'.repeat(512),
+      }],
+    }],
+  },
+})
+assert.equal(generatedImageMessages.length, 1)
+assert.equal(generatedImageMessages[0]?.messageType, 'imageGeneration')
+assert.deepEqual(generatedImageMessages[0]?.images, ['C:\\work\\generated.png'])
 
 const historyNoticeMessage = {
   id: 'history-notice',
diff --git a/src/api/codexGateway.ts b/src/api/codexGateway.ts
index 9746cbf..42d9b4d 100644
--- a/src/api/codexGateway.ts
+++ b/src/api/codexGateway.ts
@@ -173,6 +173,8 @@ function throwIfSignalAborted(signal: AbortSignal | undefined): void {
 }
 
 export type RuntimeRequestStatus =
+  | 'queued'
+  | 'queue_failed'
   | 'pending_start'
   | 'starting'
   | 'running'
@@ -631,6 +633,8 @@ function normalizeThreadTokenUsage(value: unknown): UiThreadTokenUsage | null {
   }
 }
 
+const rejectedThreadListCursorsByArchiveState = new Map<boolean, Set<string>>()
+
 async function listThreadsByArchiveState(
   archived: boolean,
   options: ThreadListOptions = {},
@@ -643,6 +647,7 @@ async function listThreadsByArchiveState(
   let pageCount = 0
 
   do {
+    if (cursor && rejectedThreadListCursorsByArchiveState.get(archived)?.has(cursor)) break
     pageCount += 1
     let payload: ThreadListResponse
     try {
@@ -654,6 +659,9 @@ async function listThreadsByArchiveState(
       }, options)
     } catch (error) {
       if (cursor && data.length > 0 && !isAbortLikeError(error)) {
+        const rejected = rejectedThreadListCursorsByArchiveState.get(archived) ?? new Set<string>()
+        rejected.add(cursor)
+        rejectedThreadListCursorsByArchiveState.set(archived, rejected)
         console.warn('Stopped thread/list pagination after a cursor error', error)
         break
       }
@@ -1086,6 +1094,8 @@ function normalizeThreadIdFromPayload(payload: unknown): string {
 function normalizeRuntimeRequestStatus(value: unknown): RuntimeRequestStatus {
   const normalized = typeof value === 'string' ? value.trim() : ''
   if (
+    normalized === 'queued' ||
+    normalized === 'queue_failed' ||
     normalized === 'pending_start' ||
     normalized === 'starting' ||
     normalized === 'running' ||
@@ -2464,7 +2474,7 @@ function getErrorMessageFromPayload(payload: unknown, fallback: string): string
   return typeof error === 'string' && error.trim().length > 0 ? error : fallback
 }
 
-export type ThreadTitleCache = { titles: Record<string, string>; order: string[] }
+export type ThreadTitleCache = { titles: Record<string, string>; order: string[]; manualTitleIds: string[] }
 let supportsThreadTitleGeneration: boolean | null = null
 
 export async function getThreadTitleCache(): Promise<ThreadTitleCache> {
@@ -2473,20 +2483,24 @@ export async function getThreadTitleCache(): Promise<ThreadTitleCache> {
       timeoutMs: GATEWAY_BACKGROUND_FETCH_TIMEOUT_MS,
       label: 'Thread title cache request',
     })
-    if (!response.ok) return { titles: {}, order: [] }
+    if (!response.ok) return { titles: {}, order: [], manualTitleIds: [] }
     const envelope = (await response.json()) as { data?: ThreadTitleCache }
-    return envelope.data ?? { titles: {}, order: [] }
+    return envelope.data ?? { titles: {}, order: [], manualTitleIds: [] }
   } catch {
-    return { titles: {}, order: [] }
+    return { titles: {}, order: [], manualTitleIds: [] }
   }
 }
 
-export async function persistThreadTitle(id: string, title: string): Promise<void> {
+export async function persistThreadTitle(
+  id: string,
+  title: string,
+  options: { manual?: boolean } = {},
+): Promise<void> {
   try {
     await fetchWithTimeout('/codex-api/thread-titles', {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ id, title }),
+      body: JSON.stringify({ id, title, manual: options.manual === true }),
     }, {
       timeoutMs: GATEWAY_BACKGROUND_FETCH_TIMEOUT_MS,
       label: 'Thread title save request',
diff --git a/src/api/normalizers/v2.ts b/src/api/normalizers/v2.ts
index d306a4b..433e479 100644
--- a/src/api/normalizers/v2.ts
+++ b/src/api/normalizers/v2.ts
@@ -223,6 +223,25 @@ function extractAssistantImages(item: ThreadItem): string[] {
   return images
 }
 
+function normalizeGeneratedImageResult(value: unknown): string {
+  const result = readTrimmedString(value)
+  if (!result) return ''
+  if (
+    result.startsWith('data:image/')
+    || result.startsWith('http://')
+    || result.startsWith('https://')
+    || result.startsWith('blob:')
+    || result.startsWith('/')
+    || /^[A-Za-z]:[\\/]/u.test(result)
+  ) {
+    return result
+  }
+
+  const compact = result.replace(/\s+/gu, '')
+  if (compact.length < 256 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(compact)) return ''
+  return `data:image/png;base64,${compact}`
+}
+
 function toUiMessages(item: ThreadItem, turnId = ''): UiMessage[] {
   const rawItem = item as Record<string, unknown>
   const itemId = readTrimmedString(rawItem.id) || `unhandled:${readTrimmedString(rawItem.type) || 'item'}`
@@ -291,6 +310,25 @@ function toUiMessages(item: ThreadItem, turnId = ''): UiMessage[] {
     ]
   }
 
+  if (itemType === 'imageGeneration') {
+    const images: string[] = []
+    pushImageCandidate(images, rawItem.savedPath)
+    pushImageCandidate(images, rawItem.path)
+    pushImageCandidate(images, rawItem.url)
+    if (images.length === 0) {
+      const generatedResult = normalizeGeneratedImageResult(rawItem.result)
+      if (generatedResult) pushImageCandidate(images, generatedResult)
+    }
+    if (images.length === 0) return []
+    return [{
+      id: itemId,
+      role: 'assistant',
+      text: '',
+      images,
+      messageType: itemType,
+    }]
+  }
+
   if (item.type === 'userMessage') {
     const parsed = parseUserMessageContent(item.id, item.content as UserInput[] | undefined)
     const messages: UiMessage[] = []
diff --git a/src/api/runtimeMessageQueue.ts b/src/api/runtimeMessageQueue.ts
new file mode 100644
index 0000000..1e64595
--- /dev/null
+++ b/src/api/runtimeMessageQueue.ts
@@ -0,0 +1,414 @@
+import type {
+  CollaborationMode,
+  ComposerPluginSelection,
+  ComposerTurnOptions,
+  ReasoningEffort,
+  SpeedMode,
+} from '../types/codex'
+import type { FileAttachmentParam } from './codexGateway'
+import { normalizeComposerTurnOptions } from '../composables/composerTurnOptions'
+
+const QUEUE_REQUEST_TIMEOUT_MS = 15_000
+
+export type RuntimeMessageQueueEntry = {
+  id: string
+  clientMessageId: string
+  threadId: string
+  deliveryState: 'queued' | 'failed'
+  text: string
+  imageUrls: string[]
+  skills: Array<{ name: string; path: string }>
+  fileAttachments: FileAttachmentParam[]
+  modelId: string
+  reasoningEffort: ReasoningEffort | ''
+  speedMode: SpeedMode
+  collaborationMode: CollaborationMode
+  turnOptions?: ComposerTurnOptions
+  createdAtIso: string
+  error: string | null
+}
+
+export type RuntimeMessageQueueEnqueueArgs = {
+  threadId: string
+  text: string
+  imageUrls?: string[]
+  model?: string
+  effort?: ReasoningEffort
+  skills?: Array<{ name: string; path: string }>
+  fileAttachments?: FileAttachmentParam[]
+  collaborationMode?: CollaborationMode
+  turnOptions?: ComposerTurnOptions
+  clientMessageId: string
+  speedMode: SpeedMode
+}
+
+export type RuntimeQueuedMessage = {
+  id: string
+  serverRequestId?: string
+  backgroundPersisted?: boolean
+  clientMessageId: string
+  deliveryState: 'queued' | 'failed'
+  text: string
+  imageUrls: string[]
+  skills: Array<{ name: string; path: string }>
+  fileAttachments: FileAttachmentParam[]
+  modelId: string
+  reasoningEffort: ReasoningEffort | ''
+  speedMode: SpeedMode
+  collaborationMode: CollaborationMode
+  turnOptions?: ComposerTurnOptions
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+}
+
+function errorMessageFromPayload(payload: unknown, fallback: string): string {
+  const error = asRecord(payload)?.error
+  return typeof error === 'string' && error.trim() ? error : fallback
+}
+
+async function queueFetch(url: string, init: RequestInit, label: string): Promise<Response> {
+  const controller = new AbortController()
+  const timeout = window.setTimeout(() => controller.abort(), QUEUE_REQUEST_TIMEOUT_MS)
+  try {
+    return await fetch(url, { ...init, signal: controller.signal })
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      throw new Error(`${label} timed out`)
+    }
+    throw error
+  } finally {
+    window.clearTimeout(timeout)
+  }
+}
+
+function normalizeReasoningEffort(value: unknown): ReasoningEffort | '' {
+  const allowed: ReasoningEffort[] = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']
+  return typeof value === 'string' && allowed.includes(value as ReasoningEffort)
+    ? value as ReasoningEffort
+    : ''
+}
+
+function buildTextWithAttachments(prompt: string, files: FileAttachmentParam[]): string {
+  if (files.length === 0) return prompt
+  const lines = ['# Files mentioned by the user:']
+  for (const file of files) lines.push('', `## ${file.label}: ${file.path}`)
+  lines.push('', '## My request for Codex:', '', prompt, '')
+  return lines.join('\n')
+}
+
+function isLocalImageInput(value: string): boolean {
+  return value.startsWith('file://') || /^[A-Za-z]:[\\/]/u.test(value) || (value.startsWith('/') && !value.startsWith('/codex-local-image?'))
+}
+
+function buildTurnStartInput(
+  text: string,
+  imageUrls: string[],
+  skills: Array<{ name: string; path: string }>,
+  fileAttachments: FileAttachmentParam[],
+  plugins: ComposerPluginSelection[] = [],
+): Array<Record<string, unknown>> {
+  const input: Array<Record<string, unknown>> = [
+    { type: 'text', text: buildTextWithAttachments(text, fileAttachments) },
+  ]
+  for (const rawUrl of imageUrls) {
+    const url = rawUrl.trim()
+    if (!url) continue
+    input.push(isLocalImageInput(url)
+      ? { type: 'localImage', path: url }
+      : { type: 'image', url, image_url: url })
+  }
+  for (const skill of skills) input.push({ type: 'skill', name: skill.name, path: skill.path })
+  for (const plugin of plugins) {
+    const name = plugin.name.trim()
+    const id = plugin.id.trim()
+    const path = plugin.path?.trim() || (plugin.source === 'app' ? `app://${id}` : `plugin://${id}`)
+    if (name && path) input.push({ type: 'mention', name, path })
+  }
+  return input
+}
+
+function normalizeEntry(value: unknown): RuntimeMessageQueueEntry | null {
+  const row = asRecord(value)
+  const requestId = typeof row?.requestId === 'string' ? row.requestId.trim() : ''
+  const threadId = typeof row?.threadId === 'string' ? row.threadId.trim() : ''
+  if (!row || !requestId || !threadId) return null
+  const metadata = asRecord(asRecord(row.payload)?.queueMetadata) ?? {}
+  const skills = Array.isArray(metadata.skills)
+    ? metadata.skills.flatMap((item) => {
+        const skill = asRecord(item)
+        const name = typeof skill?.name === 'string' ? skill.name : ''
+        const path = typeof skill?.path === 'string' ? skill.path : ''
+        return name && path ? [{ name, path }] : []
+      })
+    : []
+  const fileAttachments = Array.isArray(metadata.fileAttachments)
+    ? metadata.fileAttachments.flatMap((item) => {
+        const file = asRecord(item)
+        const label = typeof file?.label === 'string' ? file.label : ''
+        const path = typeof file?.path === 'string' ? file.path : ''
+        const fsPath = typeof file?.fsPath === 'string' ? file.fsPath : ''
+        return label && (path || fsPath) ? [{ label, path, fsPath }] : []
+      })
+    : []
+  const turnOptions = asRecord(metadata.turnOptions)
+  return {
+    id: requestId,
+    clientMessageId: typeof row.clientMessageId === 'string' ? row.clientMessageId.trim() : '',
+    threadId,
+    deliveryState: row.status === 'queue_failed' ? 'failed' : 'queued',
+    text: typeof metadata.text === 'string' ? metadata.text : '',
+    imageUrls: Array.isArray(metadata.imageUrls)
+      ? metadata.imageUrls.filter((item): item is string => typeof item === 'string')
+      : [],
+    skills,
+    fileAttachments,
+    modelId: typeof metadata.modelId === 'string' ? metadata.modelId.trim() : '',
+    reasoningEffort: normalizeReasoningEffort(metadata.reasoningEffort),
+    speedMode: metadata.speedMode === 'fast' ? 'fast' : 'standard',
+    collaborationMode: metadata.collaborationMode === 'plan' ? 'plan' : 'execute',
+    turnOptions: turnOptions ? turnOptions as ComposerTurnOptions : undefined,
+    createdAtIso: typeof row.createdAtIso === 'string' ? row.createdAtIso : '',
+    error: typeof row.lastError === 'string' ? row.lastError : null,
+  }
+}
+
+function queuedMessageFromRuntime(entry: RuntimeMessageQueueEntry): RuntimeQueuedMessage {
+  return {
+    id: entry.id,
+    serverRequestId: entry.id,
+    backgroundPersisted: true,
+    clientMessageId: entry.clientMessageId,
+    deliveryState: entry.deliveryState,
+    text: entry.text,
+    imageUrls: [...entry.imageUrls],
+    skills: entry.skills.map((skill) => ({ ...skill })),
+    fileAttachments: entry.fileAttachments.map((file) => ({ ...file })),
+    modelId: entry.modelId,
+    reasoningEffort: entry.reasoningEffort,
+    speedMode: entry.speedMode,
+    collaborationMode: entry.collaborationMode,
+    turnOptions: normalizeComposerTurnOptions(entry.turnOptions),
+  }
+}
+
+function normalizeQueuedMessage(value: unknown): RuntimeQueuedMessage | null {
+  const row = asRecord(value)
+  const id = typeof row?.id === 'string' ? row.id.trim() : ''
+  if (!row || !id) return null
+  const skills = Array.isArray(row.skills)
+    ? row.skills.flatMap((item) => {
+        const skill = asRecord(item)
+        const name = typeof skill?.name === 'string' ? skill.name : ''
+        const path = typeof skill?.path === 'string' ? skill.path : ''
+        return name && path ? [{ name, path }] : []
+      })
+    : []
+  const fileAttachments = Array.isArray(row.fileAttachments)
+    ? row.fileAttachments.flatMap((item) => {
+        const file = asRecord(item)
+        const label = typeof file?.label === 'string' ? file.label : ''
+        const path = typeof file?.path === 'string' ? file.path : ''
+        const fsPath = typeof file?.fsPath === 'string' ? file.fsPath : ''
+        return label && (path || fsPath) ? [{ label, path, fsPath }] : []
+      })
+    : []
+  return {
+    id,
+    serverRequestId: typeof row.serverRequestId === 'string' && row.serverRequestId.trim()
+      ? row.serverRequestId.trim()
+      : undefined,
+    backgroundPersisted: row.backgroundPersisted === true,
+    clientMessageId: typeof row.clientMessageId === 'string' && row.clientMessageId.trim()
+      ? row.clientMessageId.trim()
+      : `queued-${id}`,
+    deliveryState: row.deliveryState === 'failed' ? 'failed' : 'queued',
+    text: typeof row.text === 'string' ? row.text : '',
+    imageUrls: Array.isArray(row.imageUrls)
+      ? row.imageUrls.filter((item): item is string => typeof item === 'string')
+      : [],
+    skills,
+    fileAttachments,
+    modelId: typeof row.modelId === 'string' ? row.modelId.trim() : '',
+    reasoningEffort: normalizeReasoningEffort(row.reasoningEffort),
+    speedMode: row.speedMode === 'fast' ? 'fast' : 'standard',
+    collaborationMode: row.collaborationMode === 'plan' ? 'plan' : 'execute',
+    turnOptions: normalizeComposerTurnOptions(row.turnOptions),
+  }
+}
+
+export function loadQueuedMessagesMap(storageKey: string): Record<string, RuntimeQueuedMessage[]> {
+  try {
+    const raw = window.localStorage.getItem(storageKey)
+    if (!raw) return {}
+    const parsed = JSON.parse(raw) as unknown
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+    const next: Record<string, RuntimeQueuedMessage[]> = {}
+    for (const [threadId, rows] of Object.entries(parsed as Record<string, unknown>)) {
+      if (!threadId || !Array.isArray(rows)) continue
+      const queue = rows.map(normalizeQueuedMessage).filter((row): row is RuntimeQueuedMessage => row !== null)
+      if (queue.length > 0) next[threadId] = queue
+    }
+    return next
+  } catch {
+    return {}
+  }
+}
+
+export function saveQueuedMessagesMap(
+  storageKey: string,
+  queueByThreadId: Record<string, RuntimeQueuedMessage[]>,
+): void {
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(queueByThreadId))
+  } catch {
+    // Keep the in-memory queue when browser storage is unavailable.
+  }
+}
+
+export async function syncRuntimeMessageQueueState(
+  current: Record<string, RuntimeQueuedMessage[]>,
+  threadId = '',
+): Promise<Record<string, RuntimeQueuedMessage[]>> {
+  const normalizedThreadId = threadId.trim()
+  const entries = await listRuntimeMessageQueue(normalizedThreadId)
+  const serverByThreadId = new Map<string, RuntimeQueuedMessage[]>()
+  for (const entry of entries) {
+    const queue = serverByThreadId.get(entry.threadId) ?? []
+    queue.push(queuedMessageFromRuntime(entry))
+    serverByThreadId.set(entry.threadId, queue)
+  }
+  const merge = (targetThreadId: string): RuntimeQueuedMessage[] => {
+    const serverQueue = serverByThreadId.get(targetThreadId) ?? []
+    const serverClientIds = new Set(serverQueue.map((message) => message.clientMessageId))
+    const localOnly = (current[targetThreadId] ?? [])
+      .filter((message) => !message.serverRequestId && !serverClientIds.has(message.clientMessageId))
+    return [...serverQueue, ...localOnly]
+  }
+  if (normalizedThreadId) {
+    const queue = merge(normalizedThreadId)
+    const next = { ...current }
+    if (queue.length > 0) next[normalizedThreadId] = queue
+    else delete next[normalizedThreadId]
+    return next
+  }
+  const next: Record<string, RuntimeQueuedMessage[]> = {}
+  const threadIds = new Set([...Object.keys(current), ...serverByThreadId.keys()])
+  for (const targetThreadId of threadIds) {
+    const queue = merge(targetThreadId)
+    if (queue.length > 0) next[targetThreadId] = queue
+  }
+  return next
+}
+
+function isRetryableQueueError(error: unknown): boolean {
+  if (error instanceof TypeError || error instanceof SyntaxError) return true
+  if (!(error instanceof Error)) return false
+  const message = error.message.toLowerCase()
+  return ['failed to fetch', 'networkerror', 'network error', 'load failed', 'connection reset', 'connection refused', 'timed out']
+    .some((fragment) => message.includes(fragment))
+}
+
+export async function persistRuntimeQueuedMessages(
+  threadId: string,
+  queue: RuntimeQueuedMessage[],
+): Promise<RuntimeQueuedMessage[]> {
+  let next = [...queue]
+  for (const message of queue) {
+    if (message.serverRequestId || message.deliveryState === 'failed') continue
+    try {
+      const entry = await enqueueRuntimeThreadTurn({
+        threadId,
+        text: message.text,
+        imageUrls: message.imageUrls,
+        model: message.modelId || undefined,
+        effort: message.reasoningEffort || undefined,
+        skills: message.skills,
+        fileAttachments: message.fileAttachments,
+        collaborationMode: message.collaborationMode,
+        turnOptions: message.turnOptions,
+        clientMessageId: message.clientMessageId,
+        speedMode: message.speedMode,
+      })
+      next = next.map((candidate) => candidate.clientMessageId === message.clientMessageId
+        ? queuedMessageFromRuntime(entry)
+        : candidate)
+    } catch (error) {
+      if (!isRetryableQueueError(error)) {
+        next = next.map((candidate) => candidate.id === message.id
+          ? { ...candidate, deliveryState: 'failed' }
+          : candidate)
+      }
+    }
+  }
+  return next
+}
+
+export async function enqueueRuntimeThreadTurn(args: RuntimeMessageQueueEnqueueArgs): Promise<RuntimeMessageQueueEntry> {
+  const fileAttachments = args.fileAttachments ?? []
+  const imageUrls = args.imageUrls ?? []
+  const skills = args.skills ?? []
+  const collaborationMode = args.collaborationMode ?? 'execute'
+  const body: Record<string, unknown> = {
+    threadId: args.threadId.trim(),
+    input: buildTurnStartInput(args.text, imageUrls, skills, fileAttachments, args.turnOptions?.plugins),
+    attachments: fileAttachments.map((file) => ({ ...file })),
+    collaborationMode,
+    turnOptions: args.turnOptions,
+    clientMessageId: args.clientMessageId,
+    queueMetadata: {
+      text: args.text,
+      imageUrls,
+      skills,
+      fileAttachments,
+      modelId: args.model?.trim() ?? '',
+      reasoningEffort: args.effort ?? '',
+      speedMode: args.speedMode,
+      collaborationMode,
+      turnOptions: args.turnOptions,
+    },
+  }
+  if (args.model?.trim()) body.model = args.model.trim()
+  if (args.effort?.trim()) body.effort = args.effort.trim()
+
+  const response = await queueFetch('/codex-api/runtime/queue', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  }, 'Runtime queue request')
+  const payload = (await response.json()) as unknown
+  if (!response.ok && response.status !== 202) {
+    throw new Error(errorMessageFromPayload(payload, 'Failed to queue runtime turn'))
+  }
+  const entry = normalizeEntry(asRecord(payload)?.data)
+  if (!entry) throw new Error('Runtime queue response was invalid')
+  return entry
+}
+
+export async function listRuntimeMessageQueue(threadId = ''): Promise<RuntimeMessageQueueEntry[]> {
+  const query = threadId.trim() ? `?threadId=${encodeURIComponent(threadId.trim())}` : ''
+  const response = await queueFetch(`/codex-api/runtime/queue${query}`, { method: 'GET' }, 'Runtime queue list request')
+  const payload = (await response.json()) as unknown
+  if (!response.ok) throw new Error(errorMessageFromPayload(payload, 'Failed to load runtime queue'))
+  const rows = asRecord(payload)?.data
+  return Array.isArray(rows)
+    ? rows.map(normalizeEntry).filter((entry): entry is RuntimeMessageQueueEntry => entry !== null)
+    : []
+}
+
+export async function removeRuntimeQueuedMessage(requestId: string): Promise<void> {
+  const response = await queueFetch(`/codex-api/runtime/queue/${encodeURIComponent(requestId)}`, { method: 'DELETE' }, 'Runtime queue remove request')
+  if (!response.ok && response.status !== 404) {
+    throw new Error(errorMessageFromPayload(await response.json(), 'Failed to remove queued message'))
+  }
+}
+
+export async function retryRuntimeQueuedMessage(requestId: string): Promise<void> {
+  const response = await queueFetch(`/codex-api/runtime/queue/${encodeURIComponent(requestId)}/retry`, { method: 'POST' }, 'Runtime queue retry request')
+  if (!response.ok && response.status !== 202) {
+    throw new Error(errorMessageFromPayload(await response.json(), 'Failed to retry queued message'))
+  }
+}
diff --git a/src/components/content/QueuedMessages.vue b/src/components/content/QueuedMessages.vue
index 8c3ca36..a9e4170 100644
--- a/src/components/content/QueuedMessages.vue
+++ b/src/components/content/QueuedMessages.vue
@@ -8,14 +8,17 @@
       <LoadingInline
         v-if="isProcessing"
         class="queued-messages-caption queued-messages-caption-loading"
-        label="正在提交队列中的下一条消息"
+        label="正在同步到 7420 后台队列"
         compact
       />
       <p v-else-if="hasPausedFailure" class="queued-messages-caption queued-messages-caption-failed" role="status">
         下一条未能发送，队列已暂停。重试、编辑或删除后继续。
       </p>
+      <p v-else-if="hasLocalPending" class="queued-messages-caption" role="status">
+        已保存在本机，正在等待连接 7420；同步完成后才可脱离移动端执行。
+      </p>
       <p v-else class="queued-messages-caption">
-        当前任务结束后按顺序执行。点正文可继续编辑。
+        已交给 7420 后台；切换会话或关闭移动端后仍会按顺序执行。点正文可编辑。
       </p>
 
       <div
@@ -65,6 +68,7 @@ import LoadingInline from './LoadingInline.vue'
 
 type QueuedMessageRow = {
   id: string
+  backgroundPersisted?: boolean
   deliveryState?: 'queued' | 'failed'
   text: string
   imageUrls?: string[]
@@ -85,6 +89,7 @@ defineEmits<{
 }>()
 
 const hasPausedFailure = computed(() => props.messages[0]?.deliveryState === 'failed')
+const hasLocalPending = computed(() => props.messages.some((message) => message.backgroundPersisted !== true))
 
 function getMessagePreview(message: QueuedMessageRow): string {
   const text = message.text.trim()
diff --git a/src/components/content/ThreadConversation.vue b/src/components/content/ThreadConversation.vue
index f1c4a50..7478512 100644
--- a/src/components/content/ThreadConversation.vue
+++ b/src/components/content/ThreadConversation.vue
@@ -680,9 +680,8 @@
                       'is-failed': isMessageImageFailed(entry.message.id, imageIndex),
                     }"
                     type="button"
-                    aria-label="打开消息图片预览"
-                    :disabled="isMessageImageFailed(entry.message.id, imageIndex)"
-                    @click="openImageModal(imageUrl)"
+                    :aria-label="isMessageImageFailed(entry.message.id, imageIndex) ? '图片加载失败，重新加载' : '打开消息图片预览'"
+                    @click="openOrRetryMessageImage(imageUrl, entry.message.id, imageIndex)"
                   >
                     <span
                       v-if="!isMessageImageLoaded(entry.message.id, imageIndex) && !isMessageImageFailed(entry.message.id, imageIndex)"
@@ -691,9 +690,10 @@
                     />
                     <img
                       v-if="!isMessageImageFailed(entry.message.id, imageIndex)"
+                      :key="messageImageRenderKey(entry.message.id, imageIndex)"
                       class="message-image-preview"
                       :class="{ 'is-loaded': isMessageImageLoaded(entry.message.id, imageIndex) }"
-                      :src="toRenderableImageUrl(imageUrl)"
+                      :src="messageImageRenderUrl(imageUrl, entry.message.id, imageIndex)"
                       alt="消息图片预览"
                       loading="lazy"
                       :ref="(element) => onMessageImageElementRef(element, entry.message.id, imageIndex)"
@@ -701,7 +701,7 @@
                       @error="onMessageImageError(entry.message.id, imageIndex)"
                     />
                     <span v-else class="message-image-failed" role="img" aria-label="图片加载失败">
-                      加载失败
+                      图片加载失败，点此重试
                     </span>
                   </button>
                 </li>
@@ -809,7 +809,12 @@
                         </template>
                       </p>
                       <div v-else-if="block.kind === 'table'" class="message-table-block">
-                        <div v-if="!isCompactTableViewport" class="message-table-scroll" role="region" aria-label="表格内容">
+                        <div
+                          class="message-table-scroll"
+                          role="region"
+                          tabindex="0"
+                          aria-label="表格内容，可横向滚动查看"
+                        >
                           <table class="message-table">
                             <thead>
                               <tr>
@@ -885,45 +890,6 @@
                             </tbody>
                           </table>
                         </div>
-                        <div v-else class="message-table-cards" aria-label="表格内容">
-                          <article v-for="(row, rowIndex) in block.rows" :key="`table-card-${blockIndex}-${rowIndex}`" class="message-table-card">
-                            <div v-for="(cell, cellIndex) in row" :key="`table-card-cell-${blockIndex}-${rowIndex}-${cellIndex}`" class="message-table-card-row">
-                              <span class="message-table-card-label">{{ block.headers[cellIndex]?.value || `列 ${cellIndex + 1}` }}</span>
-                              <span class="message-table-card-value">
-                                <template v-for="(segment, segmentIndex) in cell.segments" :key="`table-card-cell-seg-${blockIndex}-${rowIndex}-${cellIndex}-${segmentIndex}`">
-                                  <span v-if="segment.kind === 'text'">{{ segment.value }}</span>
-                                  <strong v-else-if="segment.kind === 'bold'" class="message-bold-text">{{ segment.value }}</strong>
-                                  <span v-else-if="segment.kind === 'file'" class="message-file-link-wrap">
-                                    <a
-                                      class="message-file-link"
-                                      :href="toBrowseUrl(segment.path)"
-                                      target="_blank"
-                                      rel="noopener noreferrer"
-                                      :title="segment.path"
-                                      @click="onHyperlinkClick($event, toBrowseUrl(segment.path))"
-                                      @contextmenu.prevent="onFileLinkContextMenu($event, segment.path)"
-                                    >
-                                      {{ segment.displayPath }}
-                                    </a>
-                                  </span>
-                                  <a
-                                    v-else-if="segment.kind === 'url'"
-                                    class="message-file-link"
-                                    :href="segment.href"
-                                    target="_blank"
-                                    rel="noopener noreferrer"
-                                    :title="segment.href"
-                                    @click="onHyperlinkClick($event, segment.href)"
-                                    @contextmenu.prevent="onUrlLinkContextMenu($event, segment.href)"
-                                  >
-                                    {{ segment.value }}
-                                  </a>
-                                  <code v-else class="message-inline-code">{{ segment.value }}</code>
-                                </template>
-                              </span>
-                            </div>
-                          </article>
-                        </div>
                       </div>
                       <div
                         v-else-if="block.kind === 'code'"
@@ -1343,9 +1309,6 @@ const commandElapsedNowMs = ref(Date.now())
 const observedCommandStartedAtById = ref<Record<string, number>>({})
 let commandElapsedTimer: number | null = null
 const estimatedMessageHeightById = new Map<string, { sourceText: string; signature: string; height: number }>()
-const COMPACT_TABLE_VIEWPORT_QUERY = '(max-width: 767px)'
-const isCompactTableViewport = ref(false)
-let compactTableViewportMql: MediaQueryList | null = null
 let chatFeedbackMetricFrame = 0
 
 type ThreadFirstScreenReadyMetric = {
@@ -1355,38 +1318,6 @@ type ThreadFirstScreenReadyMetric = {
   assistantCount: number
 }
 
-type LegacyMediaQueryList = MediaQueryList & {
-  addListener?: (listener: () => void) => void
-  removeListener?: (listener: () => void) => void
-}
-
-function updateCompactTableViewport(): void {
-  isCompactTableViewport.value = compactTableViewportMql?.matches === true
-}
-
-function addCompactTableViewportListener(): void {
-  if (!compactTableViewportMql) return
-  if (typeof compactTableViewportMql.addEventListener === 'function') {
-    compactTableViewportMql.addEventListener('change', updateCompactTableViewport)
-    return
-  }
-  ;(compactTableViewportMql as LegacyMediaQueryList).addListener?.(updateCompactTableViewport)
-}
-
-function removeCompactTableViewportListener(): void {
-  if (!compactTableViewportMql) return
-  if (typeof compactTableViewportMql.removeEventListener === 'function') {
-    compactTableViewportMql.removeEventListener('change', updateCompactTableViewport)
-    return
-  }
-  ;(compactTableViewportMql as LegacyMediaQueryList).removeListener?.(updateCompactTableViewport)
-}
-
-if (typeof window !== 'undefined') {
-  compactTableViewportMql = window.matchMedia(COMPACT_TABLE_VIEWPORT_QUERY)
-  updateCompactTableViewport()
-  addCompactTableViewportListener()
-}
 
 function isCommandMessage(message: UiMessage): boolean {
   return message.messageType === 'commandExecution' && !!message.commandExecution
@@ -2221,6 +2152,7 @@ const imageModalStageRef = ref<HTMLElement | null>(null)
 const imageModalImageRef = ref<HTMLImageElement | null>(null)
 const loadedMessageImageKeys = ref<Set<string>>(new Set())
 const failedMessageImageKeys = ref<Set<string>>(new Set())
+const messageImageRetryAttempts = ref<Map<string, number>>(new Map())
 const loadedMarkdownImageKeys = ref<Set<string>>(new Set())
 const markdownImageRetryAttempts = ref<Map<string, number>>(new Map())
 const modalImageScale = ref(1)
@@ -5791,6 +5723,7 @@ watch(
     modalImageUrl.value = ''
     loadedMessageImageKeys.value = new Set()
     failedMessageImageKeys.value = new Set()
+    messageImageRetryAttempts.value = new Map()
     loadedMarkdownImageKeys.value = new Set()
     markdownImageRetryAttempts.value = new Map()
     closeFileLinkContextMenu()
@@ -6224,6 +6157,39 @@ function messageImageKey(messageId: string, imageIndex: number): string {
   return `${messageId}:${imageIndex}`
 }
 
+function messageImageRenderKey(messageId: string, imageIndex: number): string {
+  const key = messageImageKey(messageId, imageIndex)
+  return `${key}:${String(messageImageRetryAttempts.value.get(key) ?? 0)}`
+}
+
+function messageImageRenderUrl(imageUrl: string, messageId: string, imageIndex: number): string {
+  const rendered = toRenderableImageUrl(imageUrl)
+  const attempt = messageImageRetryAttempts.value.get(messageImageKey(messageId, imageIndex)) ?? 0
+  if (attempt <= 0 || rendered.startsWith('data:') || rendered.startsWith('blob:')) return rendered
+  return `${rendered}${rendered.includes('?') ? '&' : '?'}cx_retry=${String(attempt)}`
+}
+
+function retryMessageImage(messageId: string, imageIndex: number): void {
+  const key = messageImageKey(messageId, imageIndex)
+  const nextFailed = new Set(failedMessageImageKeys.value)
+  nextFailed.delete(key)
+  failedMessageImageKeys.value = nextFailed
+  const nextLoaded = new Set(loadedMessageImageKeys.value)
+  nextLoaded.delete(key)
+  loadedMessageImageKeys.value = nextLoaded
+  const nextAttempts = new Map(messageImageRetryAttempts.value)
+  nextAttempts.set(key, (nextAttempts.get(key) ?? 0) + 1)
+  messageImageRetryAttempts.value = nextAttempts
+}
+
+function openOrRetryMessageImage(imageUrl: string, messageId: string, imageIndex: number): void {
+  if (isMessageImageFailed(messageId, imageIndex)) {
+    retryMessageImage(messageId, imageIndex)
+    return
+  }
+  openImageModal(imageUrl)
+}
+
 function onMessageImageElementRef(
   element: MeasureRefTarget,
   messageId: string,
@@ -6483,7 +6449,6 @@ onBeforeUnmount(() => {
   window.removeEventListener('keydown', onWindowKeydownForImageModal)
   window.removeEventListener('resize', onWindowResizeForImageModal)
   window.removeEventListener('keydown', onWindowKeyDownForConversationSurface, { capture: true })
-  removeCompactTableViewportListener()
   if (typeof document !== 'undefined') {
     document.body.style.overflow = previousBodyOverflow
   }
@@ -7564,6 +7529,13 @@ onBeforeUnmount(() => {
   border-color: var(--ui-border-subtle);
   background: var(--ui-bg-surface);
   overscroll-behavior-x: contain;
+  -webkit-overflow-scrolling: touch;
+  scrollbar-gutter: stable;
+}
+
+.message-table-scroll:focus-visible {
+  outline: 2px solid color-mix(in srgb, var(--ui-accent) 55%, transparent);
+  outline-offset: 2px;
 }
 
 .message-table {
@@ -8470,11 +8442,20 @@ onBeforeUnmount(() => {
   }
 
   .message-table-scroll {
-    @apply hidden;
+    @apply block;
+    max-width: 100%;
+  }
+
+  .message-table {
+    min-width: 620px;
+    font-size: 13px;
+    line-height: 1.45;
   }
 
-  .message-table-cards {
-    @apply flex;
+  .message-table th,
+  .message-table td {
+    padding: 0.5rem 0.625rem;
+    font-size: 13px;
   }
 
   .request-card {
diff --git a/src/composables/messageIdentity.ts b/src/composables/messageIdentity.ts
index b38fac8..61dfea6 100644
--- a/src/composables/messageIdentity.ts
+++ b/src/composables/messageIdentity.ts
@@ -6,6 +6,8 @@ export type OptimisticUserMessageMeta = {
   kind: 'optimisticUserMessage'
   signature: string
   baselineMatchCount: number
+  baselineMessageCount: number
+  baselineTailMessageId: string
   createdAtMs: number
 }
 
@@ -57,6 +59,12 @@ function parseOptimisticUserMessageMeta(
       kind: 'optimisticUserMessage',
       signature: record.signature,
       baselineMatchCount: Math.max(0, Math.floor(record.baselineMatchCount)),
+      baselineMessageCount: typeof record.baselineMessageCount === 'number' && Number.isFinite(record.baselineMessageCount)
+        ? Math.max(0, Math.floor(record.baselineMessageCount))
+        : Number.MAX_SAFE_INTEGER,
+      baselineTailMessageId: typeof record.baselineTailMessageId === 'string'
+        ? record.baselineTailMessageId.trim()
+        : '',
       createdAtMs: record.createdAtMs,
     }
   } catch {
@@ -64,6 +72,35 @@ function parseOptimisticUserMessageMeta(
   }
 }
 
+export function mergeVisibleOptimisticUserMessages(
+  persisted: UiMessage[],
+  optimistic: UiMessage[],
+  rememberedMetaById?: ReadonlyMap<string, OptimisticUserMessageMeta>,
+): UiMessage[] {
+  const visible = filterVisibleOptimisticUserMessages(persisted, optimistic, rememberedMetaById)
+  if (visible.length === 0) return persisted
+
+  const insertionsByPersistedIndex = new Map<number, UiMessage[]>()
+  for (const message of visible) {
+    const meta = parseOptimisticUserMessageMeta(message, rememberedMetaById?.get(message.id))
+    const anchorId = meta?.baselineTailMessageId ?? ''
+    const anchorIndex = anchorId ? persisted.findIndex((candidate) => candidate.id === anchorId) : -1
+    const insertIndex = anchorIndex >= 0
+      ? anchorIndex + 1
+      : Math.min(meta?.baselineMessageCount ?? persisted.length, persisted.length)
+    const insertions = insertionsByPersistedIndex.get(insertIndex) ?? []
+    insertions.push(message)
+    insertionsByPersistedIndex.set(insertIndex, insertions)
+  }
+
+  const combined: UiMessage[] = []
+  for (let index = 0; index <= persisted.length; index += 1) {
+    combined.push(...(insertionsByPersistedIndex.get(index) ?? []))
+    if (index < persisted.length) combined.push(persisted[index]!)
+  }
+  return combined
+}
+
 export function countPersistedUserMessageSignatures(messages: UiMessage[]): Map<string, number> {
   const counts = new Map<string, number>()
   for (const message of messages) {
diff --git a/src/composables/messageOutboxPersistence.ts b/src/composables/messageOutboxPersistence.ts
index 009eb6d..637e4bf 100644
--- a/src/composables/messageOutboxPersistence.ts
+++ b/src/composables/messageOutboxPersistence.ts
@@ -35,6 +35,8 @@ export type MessageOutboxEntry = {
   reasoningEffort: ReasoningEffort | ''
   collaborationMode: CollaborationMode
   turnOptions?: ComposerTurnOptions
+  baselineMessageCount?: number
+  baselineTailMessageId?: string
   state: 'sending' | 'waiting' | 'confirming' | 'failed'
   createdAtMs: number
   updatedAtMs: number
@@ -105,6 +107,12 @@ function normalizeMessageOutboxEntry(value: unknown, nowMs: number): MessageOutb
     reasoningEffort,
     collaborationMode: row.collaborationMode === 'plan' ? 'plan' : 'execute',
     turnOptions: normalizeComposerTurnOptions(row.turnOptions),
+    baselineMessageCount: typeof row.baselineMessageCount === 'number' && Number.isFinite(row.baselineMessageCount)
+      ? Math.max(0, Math.floor(row.baselineMessageCount))
+      : undefined,
+    baselineTailMessageId: typeof row.baselineTailMessageId === 'string'
+      ? row.baselineTailMessageId.trim()
+      : undefined,
     state: row.state === 'failed'
       ? 'failed'
       : row.state === 'waiting'
diff --git a/src/composables/useDesktopState.ts b/src/composables/useDesktopState.ts
index 0de3810..ebca7db 100644
--- a/src/composables/useDesktopState.ts
+++ b/src/composables/useDesktopState.ts
@@ -71,6 +71,7 @@ import {
   type ThreadRuntimeSnapshot,
   type WorkspaceRootsState,
 } from '../api/codexGateway'
+import type { RuntimeQueuedMessage as QueuedMessage } from '../api/runtimeMessageQueue'
 import type {
   CollaborationMode,
   ComposerModelInfo,
@@ -139,6 +140,7 @@ import {
   countPersistedUserMessageSignatures,
   createClientMessageId,
   filterVisibleOptimisticUserMessages,
+  mergeVisibleOptimisticUserMessages,
   normalizeMessageText,
   userMessageSignature,
   type OptimisticUserMessageMeta,
@@ -153,6 +155,14 @@ import {
   upsertMessage,
 } from './conversationProjection'
 
+function removeRuntimeQueuedMessage(requestId: string): Promise<void> {
+  return import('../api/runtimeMessageQueue').then((api) => api.removeRuntimeQueuedMessage(requestId))
+}
+
+function retryRuntimeQueuedMessage(requestId: string): Promise<void> {
+  return import('../api/runtimeMessageQueue').then((api) => api.retryRuntimeQueuedMessage(requestId))
+}
+
 function flattenThreads(groups: UiProjectGroup[]): UiThread[] {
   return groups.flatMap((group) => group.threads)
 }
@@ -316,20 +326,6 @@ type DesktopStateSubmitCallbacks = {
 }
 
 type FileAttachment = MessageOutboxFileAttachment
-type QueuedMessage = {
-  id: string
-  clientMessageId: string
-  deliveryState: 'queued' | 'failed'
-  text: string
-  imageUrls: string[]
-  skills: Array<{ name: string; path: string }>
-  fileAttachments: FileAttachment[]
-  modelId: string
-  reasoningEffort: ReasoningEffort | ''
-  speedMode: SpeedMode
-  collaborationMode: CollaborationMode
-  turnOptions?: ComposerTurnOptions
-}
 type RealtimeConnectionState = RpcConnectionState
 type ThreadGroupCachePayload = {
   version: number
@@ -924,93 +920,6 @@ function saveHiddenThreadIds(threadIds: string[]): void {
   window.localStorage.setItem(HIDDEN_THREAD_IDS_STORAGE_KEY, JSON.stringify(threadIds))
 }
 
-function normalizeQueuedMessage(value: unknown): QueuedMessage | null {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
-  const row = value as Record<string, unknown>
-  const id = typeof row.id === 'string' ? row.id.trim() : ''
-  if (!id) return null
-
-  const text = typeof row.text === 'string' ? row.text : ''
-  const imageUrls = Array.isArray(row.imageUrls)
-    ? row.imageUrls.filter((item): item is string => typeof item === 'string')
-    : []
-  const skills = Array.isArray(row.skills)
-    ? row.skills
-      .filter((item): item is { name: string; path: string } => (
-        Boolean(item)
-        && typeof item === 'object'
-        && typeof (item as Record<string, unknown>).name === 'string'
-        && typeof (item as Record<string, unknown>).path === 'string'
-      ))
-      .map((item) => ({ name: item.name, path: item.path }))
-    : []
-  const fileAttachments = Array.isArray(row.fileAttachments)
-    ? row.fileAttachments
-      .filter((item): item is FileAttachment => (
-        Boolean(item)
-        && typeof item === 'object'
-        && typeof (item as Record<string, unknown>).label === 'string'
-        && typeof (item as Record<string, unknown>).path === 'string'
-        && typeof (item as Record<string, unknown>).fsPath === 'string'
-      ))
-      .map((item) => ({ label: item.label, path: item.path, fsPath: item.fsPath }))
-    : []
-
-  return {
-    id,
-    clientMessageId: typeof row.clientMessageId === 'string' && row.clientMessageId.trim()
-      ? row.clientMessageId.trim()
-      : `queued-${id}`,
-    deliveryState: row.deliveryState === 'failed' ? 'failed' : 'queued',
-    text,
-    imageUrls,
-    skills,
-    fileAttachments,
-    modelId: typeof row.modelId === 'string' ? row.modelId.trim() : '',
-    reasoningEffort: typeof row.reasoningEffort === 'string' && REASONING_EFFORT_OPTIONS.includes(row.reasoningEffort as ReasoningEffort)
-      ? row.reasoningEffort as ReasoningEffort
-      : '',
-    speedMode: row.speedMode === 'fast' ? 'fast' : 'standard',
-    collaborationMode: row.collaborationMode === 'plan' ? 'plan' : 'execute',
-    turnOptions: normalizeTurnOptions(row.turnOptions),
-  }
-}
-
-function loadQueuedMessagesMap(): Record<string, QueuedMessage[]> {
-  if (typeof window === 'undefined') return {}
-
-  try {
-    const raw = window.localStorage.getItem(QUEUED_MESSAGES_STORAGE_KEY)
-    if (!raw) return {}
-
-    const parsed = JSON.parse(raw) as unknown
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
-
-    const next: Record<string, QueuedMessage[]> = {}
-    for (const [threadId, rows] of Object.entries(parsed as Record<string, unknown>)) {
-      if (!threadId || !Array.isArray(rows)) continue
-      const normalizedRows = rows
-        .map((row) => normalizeQueuedMessage(row))
-        .filter((row): row is QueuedMessage => row !== null)
-      if (normalizedRows.length > 0) {
-        next[threadId] = normalizedRows
-      }
-    }
-    return next
-  } catch {
-    return {}
-  }
-}
-
-function saveQueuedMessagesMap(queueByThreadId: Record<string, QueuedMessage[]>): void {
-  if (typeof window === 'undefined') return
-  try {
-    window.localStorage.setItem(QUEUED_MESSAGES_STORAGE_KEY, JSON.stringify(queueByThreadId))
-  } catch {
-    // Keep in-memory queue state when storage is unavailable or quota-limited.
-  }
-}
-
 function loadLastNotificationCursor(): { cursor: number; streamId: string } {
   if (typeof window === 'undefined') return { cursor: 0, streamId: '' }
 
@@ -1541,8 +1450,9 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   type BufferedAgentDelta = { threadId: string; messageId: string; delta: string }
   type BufferedCommandDelta = { threadId: string; itemId: string; delta: string }
   type BufferedPlanDelta = { threadId: string; turnId: string; delta: string }
-  const queuedMessagesByThreadId = ref<Record<string, QueuedMessage[]>>(loadQueuedMessagesMap())
+  const queuedMessagesByThreadId = ref<Record<string, QueuedMessage[]>>({})
   const queueProcessingByThreadId = ref<Record<string, boolean>>({})
+  let runtimeMessageQueueSyncTail: Promise<void> = Promise.resolve()
   const eventUnreadByThreadId = ref<Record<string, boolean>>(loadUnreadStateMap())
   const availableModels = ref<ComposerModelInfo[]>([])
   const availableModelIds = ref<string[]>([])
@@ -1574,6 +1484,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   const pendingTurnRequestByThreadId = ref<Record<string, PendingTurnRequest>>({})
 
   const threadTitleById = ref<Record<string, string>>({})
+  const manualThreadTitleIds = new Set<string>()
+  let hasLoadedThreadTitleCache = false
 
   const installedSkills = ref<SkillInfo[]>([])
   const hasLoadedSkills = ref(false)
@@ -2147,15 +2059,15 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (!threadId) return []
 
     const persisted = persistedMessagesByThreadId.value[threadId] ?? []
-    const optimisticUser = filterVisibleOptimisticUserMessages(
+    const optimisticUser = optimisticUserMessagesByThreadId.value[threadId] ?? []
+    const combined = mergeVisibleOptimisticUserMessages(
       persisted,
-      optimisticUserMessagesByThreadId.value[threadId] ?? [],
+      optimisticUser,
       optimisticUserMessageMetaById,
     )
     const liveAgent = liveAgentMessagesByThreadId.value[threadId] ?? []
     const livePlans = livePlanMessagesByThreadId.value[threadId] ?? []
     const liveCommands = liveCommandsByThreadId.value[threadId] ?? []
-    const combined = [...persisted, ...optimisticUser]
     for (const liveMessage of [...livePlans, ...liveCommands, ...liveAgent]) {
       const existingIndex = combined.findIndex((message) => message.id === liveMessage.id)
       if (existingIndex < 0) {
@@ -2690,7 +2602,10 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
   function replaceQueuedMessagesState(nextState: Record<string, QueuedMessage[]>): void {
     queuedMessagesByThreadId.value = nextState
-    saveQueuedMessagesMap(nextState)
+    if (typeof window !== 'undefined') {
+      void import('../api/runtimeMessageQueue')
+        .then((api) => api.saveQueuedMessagesMap(QUEUED_MESSAGES_STORAGE_KEY, nextState))
+    }
   }
 
   function setQueuedMessagesForThread(threadId: string, queue: QueuedMessage[]): void {
@@ -2702,14 +2617,49 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     replaceQueuedMessagesState(nextState)
   }
 
+  function syncRuntimeMessageQueue(threadId = ''): Promise<void> {
+    const normalizedThreadId = threadId.trim()
+    const sync = async (): Promise<void> => {
+      const api = await import('../api/runtimeMessageQueue')
+      const next = await api.syncRuntimeMessageQueueState(queuedMessagesByThreadId.value, normalizedThreadId)
+      replaceQueuedMessagesState(next)
+    }
+
+    const next = runtimeMessageQueueSyncTail.then(sync, sync)
+    runtimeMessageQueueSyncTail = next.catch(() => {})
+    return next
+  }
+
+  async function restoreRuntimeMessageQueue(): Promise<void> {
+    try {
+      const api = await import('../api/runtimeMessageQueue')
+      const stored = api.loadQueuedMessagesMap(QUEUED_MESSAGES_STORAGE_KEY)
+      if (Object.keys(stored).length > 0) {
+        replaceQueuedMessagesState({ ...stored, ...queuedMessagesByThreadId.value })
+      }
+      await syncRuntimeMessageQueue()
+      await Promise.all(Object.keys(queuedMessagesByThreadId.value).map(processQueuedMessages))
+    } catch {
+      // Keep local queued messages usable until this 7420 server supports the durable queue.
+    }
+  }
+
   function removeQueuedMessageByThreadId(threadId: string, messageId: string): void {
     const normalizedThreadId = threadId.trim()
     const normalizedMessageId = messageId.trim()
     if (!normalizedThreadId || !normalizedMessageId) return
     const queue = queuedMessagesByThreadId.value[normalizedThreadId]
     if (!queue) return
+    const target = queue.find((message) => message.id === normalizedMessageId)
     const next = queue.filter((message) => message.id !== normalizedMessageId)
     setQueuedMessagesForThread(normalizedThreadId, next)
+    if (target?.serverRequestId) {
+      void removeRuntimeQueuedMessage(target.serverRequestId)
+        .then(
+          () => syncRuntimeMessageQueue(normalizedThreadId),
+          () => syncRuntimeMessageQueue(normalizedThreadId),
+        )
+    }
   }
 
   function setQueuedMessageDeliveryState(
@@ -4527,7 +4477,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       const optimisticOnly = hasOptimisticOnlyExecutionState(activeThreadId)
       const shouldRefreshMessages =
         pendingThreadMessageRefresh.has(activeThreadId) ||
-        notificationIsStale ||
+        (notificationIsStale && now - lastDetailSyncAt >= ACTIVE_THREAD_DETAIL_FALLBACK_SYNC_INTERVAL_MS) ||
         optimisticOnly
       const shouldRefreshThreads = shouldRefreshThreadListForActiveBoost(now)
       const shouldRefreshRuntime = isThreadExecutionActive(activeThreadId) || optimisticOnly
@@ -4792,6 +4742,13 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       optimisticUserMessageMetaById,
     )
     if (!areMessageArraysEqual(previousOptimistic, nextOptimistic)) {
+      const visibleIds = new Set(nextOptimistic.map((message) => message.id))
+      for (const message of previousOptimistic) {
+        if (visibleIds.has(message.id)) continue
+        const clientMessageId = outboxClientIdByOptimisticMessageId.get(message.id)
+        if (clientMessageId) removeMessageOutboxEntry(clientMessageId)
+        optimisticUserMessageMetaById.delete(message.id)
+      }
       optimisticUserMessagesByThreadId.value = {
         ...optimisticUserMessagesByThreadId.value,
         [threadId]: nextOptimistic,
@@ -4929,6 +4886,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     reasoningEffort: ReasoningEffort | ''
     collaborationMode: CollaborationMode
     turnOptions?: ComposerTurnOptions
+    baselineMessageCount?: number
+    baselineTailMessageId?: string
   }): MessageOutboxEntry {
     const nowMs = Date.now()
     return {
@@ -4943,6 +4902,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       reasoningEffort: args.reasoningEffort,
       collaborationMode: args.collaborationMode,
       turnOptions: cloneTurnOptions(args.turnOptions),
+      baselineMessageCount: args.baselineMessageCount,
+      baselineTailMessageId: args.baselineTailMessageId,
       state: 'sending',
       createdAtMs: nowMs,
       updatedAtMs: nowMs,
@@ -4951,7 +4912,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
   function updateMessageOutboxEntry(
     clientMessageId: string,
-    patch: Partial<Pick<MessageOutboxEntry, 'threadId' | 'modelId' | 'state'>>,
+    patch: Partial<Pick<MessageOutboxEntry, 'threadId' | 'modelId' | 'state' | 'baselineMessageCount' | 'baselineTailMessageId'>>,
   ): void {
     mergeMessageOutboxFromStorage()
     const current = messageOutboxByClientId.get(clientMessageId)
@@ -5146,11 +5107,14 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       deliveryState: 'sending',
     }
     const signature = userMessageSignature(optimisticMessage)
-    const persistedCounts = countPersistedUserMessageSignatures(persistedMessagesByThreadId.value[threadId] ?? [])
+    const persistedMessages = persistedMessagesByThreadId.value[threadId] ?? []
+    const persistedCounts = countPersistedUserMessageSignatures(persistedMessages)
     const meta: OptimisticUserMessageMeta = {
       kind: 'optimisticUserMessage',
       signature,
       baselineMatchCount: persistedCounts.get(signature) ?? 0,
+      baselineMessageCount: persistedMessages.length,
+      baselineTailMessageId: persistedMessages.at(-1)?.id ?? '',
       createdAtMs: options.createdAtMs ?? Date.now(),
     }
     optimisticUserMessageMetaById.set(optimisticMessage.id, meta)
@@ -5280,7 +5244,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       deliveryAttemptMax: undefined,
     })
     const clientMessageId = outboxClientIdByOptimisticMessageId.get(messageId)
-    if (clientMessageId) removeMessageOutboxEntry(clientMessageId)
+    if (clientMessageId) updateMessageOutboxEntry(clientMessageId, { state: 'confirming' })
   }
 
   function markOptimisticUserMessageConfirming(threadId: string, messageId: string): void {
@@ -5319,6 +5283,14 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
           createdAtMs: entry.createdAtMs,
         },
       )
+    const restoredMeta = optimisticUserMessageMetaById.get(optimisticMessageId)
+    if (restoredMeta) {
+      optimisticUserMessageMetaById.set(optimisticMessageId, {
+        ...restoredMeta,
+        baselineMessageCount: entry.baselineMessageCount ?? restoredMeta.baselineMessageCount,
+        baselineTailMessageId: entry.baselineTailMessageId ?? restoredMeta.baselineTailMessageId,
+      })
+    }
     attachOutboxEntryToOptimisticMessage(entry.clientMessageId, normalizedThreadId, optimisticMessageId)
     markOptimisticUserMessageConfirming(normalizedThreadId, optimisticMessageId)
   }
@@ -5440,6 +5412,14 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
           createdAtMs: entry.createdAtMs,
         },
       )
+    const restoredMeta = optimisticUserMessageMetaById.get(optimisticMessageId)
+    if (restoredMeta) {
+      optimisticUserMessageMetaById.set(optimisticMessageId, {
+        ...restoredMeta,
+        baselineMessageCount: entry.baselineMessageCount ?? restoredMeta.baselineMessageCount,
+        baselineTailMessageId: entry.baselineTailMessageId ?? restoredMeta.baselineTailMessageId,
+      })
+    }
     attachOutboxEntryToOptimisticMessage(entry.clientMessageId, normalizedThreadId, optimisticMessageId)
     markOptimisticUserMessageFailed(normalizedThreadId, optimisticMessageId, {
       threadId: normalizedThreadId,
@@ -5467,6 +5447,14 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
           createdAtMs: entry.createdAtMs,
         },
       )
+    const restoredMeta = optimisticUserMessageMetaById.get(optimisticMessageId)
+    if (restoredMeta) {
+      optimisticUserMessageMetaById.set(optimisticMessageId, {
+        ...restoredMeta,
+        baselineMessageCount: entry.baselineMessageCount ?? restoredMeta.baselineMessageCount,
+        baselineTailMessageId: entry.baselineTailMessageId ?? restoredMeta.baselineTailMessageId,
+      })
+    }
     attachOutboxEntryToOptimisticMessage(entry.clientMessageId, normalizedThreadId, optimisticMessageId)
     markOptimisticUserMessageWaiting(normalizedThreadId, optimisticMessageId)
   }
@@ -6670,9 +6658,12 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       const threadId = readString(params?.threadId)
       const threadName = readString(params?.threadName)
       if (threadId && threadName) {
+        if (manualThreadTitleIds.has(threadId) && threadTitleById.value[threadId] !== threadName) {
+          return
+        }
         threadTitleById.value = { ...threadTitleById.value, [threadId]: threadName }
         applyThreadFlags()
-        void persistThreadTitle(threadId, threadName)
+        void persistThreadTitle(threadId, threadName, { manual: false })
       }
     }
 
@@ -7034,13 +7025,24 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   }
 
   async function loadThreadTitleCacheIfNeeded(signal?: AbortSignal): Promise<void> {
-    if (Object.keys(threadTitleById.value).length > 0) return
+    if (hasLoadedThreadTitleCache) return
     try {
       const cache = await getThreadTitleCache()
       if (signal?.aborted) return
+      const locallyLockedTitleIds = new Set(manualThreadTitleIds)
       if (Object.keys(cache.titles).length > 0) {
-        threadTitleById.value = cache.titles
+        const mergedTitles = { ...cache.titles, ...threadTitleById.value }
+        for (const threadId of cache.manualTitleIds ?? []) {
+          if (!locallyLockedTitleIds.has(threadId) && cache.titles[threadId]) {
+            mergedTitles[threadId] = cache.titles[threadId]
+          }
+        }
+        threadTitleById.value = mergedTitles
       }
+      manualThreadTitleIds.clear()
+      for (const threadId of cache.manualTitleIds ?? []) manualThreadTitleIds.add(threadId)
+      for (const threadId of locallyLockedTitleIds) manualThreadTitleIds.add(threadId)
+      hasLoadedThreadTitleCache = true
     } catch {
       // Title cache is optional; keep UI functional.
     }
@@ -7056,7 +7058,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       if (!title || threadTitleById.value[threadId]) return
       threadTitleById.value = { ...threadTitleById.value, [threadId]: title }
       applyThreadFlags()
-      void persistThreadTitle(threadId, title)
+      void persistThreadTitle(threadId, title, { manual: false })
     } catch {
       // Title generation is best-effort.
     }
@@ -8046,12 +8048,19 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     const normalizedName = threadName.trim()
     if (!threadId || !normalizedName) return
 
+    const previousTitle = threadTitleById.value[threadId]
+    const wasManual = manualThreadTitleIds.has(threadId)
+    manualThreadTitleIds.add(threadId)
     try {
       await renameThread(threadId, normalizedName)
       threadTitleById.value = { ...threadTitleById.value, [threadId]: normalizedName }
       applyThreadFlags()
-      void persistThreadTitle(threadId, normalizedName)
+      void persistThreadTitle(threadId, normalizedName, { manual: true })
     } catch (unknownError) {
+      if (!wasManual) manualThreadTitleIds.delete(threadId)
+      if (previousTitle) {
+        threadTitleById.value = { ...threadTitleById.value, [threadId]: previousTitle }
+      }
       error.value = unknownError instanceof Error ? unknownError.message : 'Unknown application error'
     }
   }
@@ -8125,6 +8134,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         : nextQueue.length
       nextQueue.splice(insertIndex, 0, {
         id,
+        backgroundPersisted: false,
         clientMessageId: createClientMessageId(),
         deliveryState: 'queued',
         text: nextText,
@@ -8139,11 +8149,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       })
       setQueuedMessagesForThread(threadId, nextQueue)
       notifyDeliveryPersisted(internalOptions.onDeliveryPersisted)
-
-      await recoverThreadExecutionState(threadId)
-      if (inProgressById.value[threadId] !== true) {
-        void processQueuedMessages(threadId)
-      }
+      await processQueuedMessages(threadId)
       return
     }
 
@@ -8170,6 +8176,13 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       messageId: reusedOptimisticMessageId || undefined,
     })
     attachOutboxEntryToOptimisticMessage(clientMessageId, threadId, optimisticMessageId)
+    const optimisticMeta = optimisticUserMessageMetaById.get(optimisticMessageId)
+    if (optimisticMeta) {
+      updateMessageOutboxEntry(clientMessageId, {
+        baselineMessageCount: optimisticMeta.baselineMessageCount,
+        baselineTailMessageId: optimisticMeta.baselineTailMessageId,
+      })
+    }
     updateOptimisticUserMessageDelivery(threadId, optimisticMessageId, {
       deliveryState: 'sending',
       deliveryError: undefined,
@@ -8853,74 +8866,64 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
   async function processQueuedMessages(threadId: string): Promise<void> {
     if (queueProcessingByThreadId.value[threadId] === true) return
-    if (inProgressById.value[threadId] === true) return
-    if (pendingTurnRequestByThreadId.value[threadId]) return
-    if (hasPendingServerRequestSignal(threadId)) return
     const queue = queuedMessagesByThreadId.value[threadId]
     if (!queue || queue.length === 0) return
-    if (queue[0]?.deliveryState === 'failed') return
     queueProcessingByThreadId.value = {
       ...queueProcessingByThreadId.value,
       [threadId]: true,
     }
-    const [next] = queue
-    isSendingMessage.value = true
-    error.value = ''
-    shouldAutoScrollOnNextAgentEvent = true
-    const queuedModelId = next.modelId.trim() || selectedModelId.value.trim()
-    const queuedReasoningEffort = next.reasoningEffort || selectedReasoningEffort.value
-    const queuedSpeedMode: SpeedMode = next.speedMode === 'fast' ? 'fast' : 'standard'
-    setTurnSummaryForThread(threadId, null)
-    setTurnActivityForThread(threadId, {
-      label: next.collaborationMode === 'plan' ? 'Planning' : 'Thinking',
-      details: buildPendingTurnDetails(queuedModelId, queuedReasoningEffort, next.collaborationMode),
-    })
-    setTurnErrorForThread(threadId, null)
-    setThreadInProgress(threadId, true)
-    markThreadLiveExecutionSignal(threadId)
-    markActiveSyncBoost()
-    const optimisticMessageId = addOptimisticUserMessage(threadId, next.text, next.imageUrls, next.fileAttachments)
-    notifyPendingRequestCreated(undefined, next.clientMessageId)
     try {
-      if (selectedSpeedMode.value !== queuedSpeedMode) {
-        await updateSelectedSpeedMode(queuedSpeedMode)
-        if (selectedSpeedMode.value !== queuedSpeedMode) {
-          throw new Error('Failed to apply queued speed mode before sending')
-        }
-      }
-      await startTurnForThread(
-        threadId,
-        next.text,
-        next.imageUrls,
-        next.skills,
-        next.fileAttachments,
-        next.collaborationMode,
-        next.turnOptions,
-        {
-          modelId: queuedModelId,
-          reasoningEffort: queuedReasoningEffort,
-          optimisticMessageId,
-          clientMessageId: next.clientMessageId,
-          onRequestDispatched: submitCallbacks.onRequestDispatched,
-        },
-      )
-      removeQueuedMessageByThreadId(threadId, next.id)
-    } catch (unknownError) {
-      removeOptimisticUserMessage(threadId, optimisticMessageId)
-      setThreadInProgress(threadId, false)
-      setTurnActivityForThread(threadId, null)
-      setQueuedMessageDeliveryState(
-        threadId,
-        next.id,
-        'failed',
-        isRetryableRuntimeSendError(unknownError) ? next.clientMessageId : createClientMessageId(),
-      )
+      const api = await import('../api/runtimeMessageQueue')
+      setQueuedMessagesForThread(threadId, await api.persistRuntimeQueuedMessages(threadId, queue))
+      await syncRuntimeMessageQueue(threadId)
+    } catch {
+      // The local queue remains durable and will migrate when 7420 reconnects.
     } finally {
       queueProcessingByThreadId.value = omitKey(queueProcessingByThreadId.value, threadId)
-      isSendingMessage.value = false
     }
   }
 
+  function promoteQueuedMessageToOptimistic(threadId: string, requestId: string): void {
+    const queue = queuedMessagesByThreadId.value[threadId] ?? []
+    const queued = queue.find((message) => message.serverRequestId === requestId || message.id === requestId)
+    if (!queued) return
+
+    if (!messageOutboxByClientId.has(queued.clientMessageId)) {
+      putMessageOutboxEntry(createMessageOutboxEntry({
+        clientMessageId: queued.clientMessageId,
+        threadId,
+        text: queued.text,
+        imageUrls: queued.imageUrls,
+        skills: queued.skills,
+        fileAttachments: queued.fileAttachments,
+        modelId: queued.modelId,
+        reasoningEffort: queued.reasoningEffort,
+        collaborationMode: queued.collaborationMode,
+        turnOptions: queued.turnOptions,
+      }))
+    }
+    const optimisticMessageId = addOptimisticUserMessage(
+      threadId,
+      queued.text,
+      queued.imageUrls,
+      queued.fileAttachments,
+      { messageId: `${OPTIMISTIC_USER_MESSAGE_PREFIX}${threadId}:queue:${queued.clientMessageId}` },
+    )
+    attachOutboxEntryToOptimisticMessage(queued.clientMessageId, threadId, optimisticMessageId)
+    const optimisticMeta = optimisticUserMessageMetaById.get(optimisticMessageId)
+    if (optimisticMeta) {
+      updateMessageOutboxEntry(queued.clientMessageId, {
+        baselineMessageCount: optimisticMeta.baselineMessageCount,
+        baselineTailMessageId: optimisticMeta.baselineTailMessageId,
+      })
+    }
+    markOptimisticUserMessageSent(threadId, optimisticMessageId)
+    setQueuedMessagesForThread(
+      threadId,
+      queue.filter((message) => message.id !== queued.id),
+    )
+  }
+
   async function interruptSelectedThreadTurn(source: RuntimeInterruptSource = 'unknown'): Promise<void> {
     const threadId = selectedThreadId.value
     if (!threadId) return
@@ -9534,6 +9537,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
           if (isFirstAttempt) {
             mergeMessageOutboxFromStorage()
             void recoverPersistentMessageOutbox()
+            void restoreRuntimeMessageQueue()
           }
           const attemptAtMs = Date.now()
           const activeThreadId = selectedThreadId.value
@@ -9635,7 +9639,9 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         return
       }
       if (event.key === QUEUED_MESSAGES_STORAGE_KEY) {
-        queuedMessagesByThreadId.value = loadQueuedMessagesMap()
+        void import('../api/runtimeMessageQueue').then((api) => {
+          queuedMessagesByThreadId.value = api.loadQueuedMessagesMap(QUEUED_MESSAGES_STORAGE_KEY)
+        })
         return
       }
       if (event.key !== MESSAGE_OUTBOX_STORAGE_KEY) return
@@ -9764,6 +9770,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (state === 'connected') {
       clearSyncError()
       void recoverPersistentMessageOutbox()
+      void restoreRuntimeMessageQueue()
     }
 
     const activeThreadId = selectedThreadId.value
@@ -9800,6 +9807,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (realtimeConnectionManager.isStarted()) return
     void loadPendingServerRequestsFromBridge()
     void recoverPersistentMessageOutbox()
+    void restoreRuntimeMessageQueue()
     scheduleBackgroundSync()
     scheduleVisibilitySync()
     realtimeConnectionManager.start()
@@ -9841,6 +9849,16 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     notification: RpcNotification,
     source: NotificationReplaySource,
   ): void {
+    if (notification.method === 'runtime/queue/updated') {
+      const params = asRecord(notification.params)
+      const threadId = readString(params?.threadId)
+      const requestId = readString(params?.requestId)
+      const action = readString(params?.action)
+      if (threadId && requestId && action === 'starting') {
+        promoteQueuedMessageToOptimistic(threadId, requestId)
+      }
+      if (threadId) void syncRuntimeMessageQueue(threadId).catch(() => {})
+    }
     if (notification.method === SKILLS_CHANGED_METHOD) {
       scheduleSkillsRefreshFromNotification()
     }
@@ -10033,6 +10051,13 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     const queue = queuedMessagesByThreadId.value[threadId]
     if (!queue || queue[0]?.id !== messageId || queue[0].deliveryState !== 'failed') return
     setQueuedMessageDeliveryState(threadId, messageId, 'queued')
+    const message = queue[0]
+    if (message.serverRequestId) {
+      void retryRuntimeQueuedMessage(message.serverRequestId)
+        .then(() => syncRuntimeMessageQueue(threadId))
+        .catch(() => setQueuedMessageDeliveryState(threadId, messageId, 'failed'))
+      return
+    }
     void processQueuedMessages(threadId)
   }
 
diff --git a/src/server/appServerNotificationDiagnostics.ts b/src/server/appServerNotificationDiagnostics.ts
index 291e508..641bf95 100644
--- a/src/server/appServerNotificationDiagnostics.ts
+++ b/src/server/appServerNotificationDiagnostics.ts
@@ -203,6 +203,7 @@ const KNOWN_NOTIFICATION_METHODS = new Set([
   'thread/compacted',
   'thread/goal/cleared',
   'thread/goal/updated',
+  'runtime/queue/updated',
   'thread/interrupted',
   'thread/name/updated',
   'thread/realtime/closed',
diff --git a/src/server/codexAppServerBridge.ts b/src/server/codexAppServerBridge.ts
index 2ea5683..6e18b0b 100644
--- a/src/server/codexAppServerBridge.ts
+++ b/src/server/codexAppServerBridge.ts
@@ -33,6 +33,7 @@ import {
   createCodexSessionFileChangedNotification,
 } from './codexSessionFileChangeObserver.js'
 import { shouldInvalidateThreadCollectionForCxSessionFileChange } from '../sessionFileChange.js'
+import { RuntimeMessageQueue } from './runtimeMessageQueue.js'
 
 type CodexBridgeMiddleware = ((req: IncomingMessage, res: ServerResponse, next: () => void) => Promise<void>) & {
   dispose: () => void
@@ -80,6 +81,7 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
     runtimeStateStore.getActiveThreadCount(),
   ))
   const mobilePushCoordinator = new MobilePushCoordinator({ store: runtimeStore })
+  let runtimeMessageQueue: RuntimeMessageQueue | null = null
   const {
     persistRuntimeSnapshot,
     readThreadRuntimeSnapshot,
@@ -120,6 +122,7 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
     statusDiagnostics,
     persistRuntimeSnapshot,
     onRuntimeEvent: (event) => {
+      runtimeMessageQueue?.handleRuntimeEvent(event.method, event.threadId)
       void mobilePushCoordinator.handleRuntimeEvent(event).catch((error) => {
         writeBridgeLog('warn', 'Mobile push terminal wake failed', {
           method: event.method,
@@ -130,6 +133,14 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
       })
     },
   })
+  runtimeMessageQueue = new RuntimeMessageQueue({
+    store: runtimeStore,
+    startRuntimeTurn,
+    rpc: (method, params) => appServer.rpc(method, params),
+    publishNotification: (notification) => { publishBridgeNotification(notification) },
+    getErrorMessage,
+  })
+  runtimeMessageQueue.start()
   const sessionFileChangeObserver = new CodexSessionFileChangeObserver({
     onChange: (change) => {
       if (shouldInvalidateThreadCollectionForCxSessionFileChange(change)) {
@@ -193,6 +204,10 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
         persistRuntimeSnapshot,
         startRuntimeTurn,
         interruptRuntimeTurn,
+        enqueueRuntimeTurn: (payload) => runtimeMessageQueue!.enqueue(payload),
+        listRuntimeQueue: (threadId = '') => runtimeMessageQueue!.list(threadId),
+        cancelQueuedRuntimeTurn: (requestId) => runtimeMessageQueue!.cancel(requestId),
+        retryQueuedRuntimeTurn: (requestId) => runtimeMessageQueue!.retry(requestId),
         augmentThreadListRpcResult,
         reconcileRuntimeThread,
         readLocalRuntimeSnapshot,
@@ -220,6 +235,7 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
   middleware.dispose = () => {
     disposeCodexBridgeMiddlewareResources({
       runtimeReconcileScheduler,
+      runtimeMessageQueue,
       threadSearchIndexStore,
       bridgeNotificationListeners,
       unsubscribeAppServerNotifications,
diff --git a/src/server/codexBridgeMiddlewareDispose.ts b/src/server/codexBridgeMiddlewareDispose.ts
index a37f5eb..29776dc 100644
--- a/src/server/codexBridgeMiddlewareDispose.ts
+++ b/src/server/codexBridgeMiddlewareDispose.ts
@@ -2,6 +2,9 @@ export type CodexBridgeMiddlewareDisposeDependencies = {
   runtimeReconcileScheduler: {
     dispose: () => void
   }
+  runtimeMessageQueue?: {
+    dispose: () => void
+  }
   threadSearchIndexStore: {
     clear: () => void
   }
@@ -40,6 +43,7 @@ export function disposeCodexBridgeMiddlewareResources(
 ): void {
   dependencies.sessionFileChangeObserver.dispose()
   dependencies.runtimeReconcileScheduler.dispose()
+  dependencies.runtimeMessageQueue?.dispose()
   dependencies.threadSearchIndexStore.clear()
   dependencies.bridgeNotificationListeners.clear()
   dependencies.unsubscribeAppServerNotifications()
diff --git a/src/server/codexBridgeRouteHandlers.ts b/src/server/codexBridgeRouteHandlers.ts
index 3d8873e..db8b131 100644
--- a/src/server/codexBridgeRouteHandlers.ts
+++ b/src/server/codexBridgeRouteHandlers.ts
@@ -124,6 +124,10 @@ export type CodexBridgeRouteHandlersDependencies = {
   persistRuntimeSnapshot(threadId: string, snapshot?: ThreadRuntimeSnapshot): ThreadRuntimeSnapshot
   startRuntimeTurn: RuntimeActionRoutesDependencies['startRuntimeTurn']
   interruptRuntimeTurn: RuntimeActionRoutesDependencies['interruptRuntimeTurn']
+  enqueueRuntimeTurn: RuntimeActionRoutesDependencies['enqueueRuntimeTurn']
+  listRuntimeQueue: RuntimeActionRoutesDependencies['listRuntimeQueue']
+  cancelQueuedRuntimeTurn: RuntimeActionRoutesDependencies['cancelQueuedRuntimeTurn']
+  retryQueuedRuntimeTurn: RuntimeActionRoutesDependencies['retryQueuedRuntimeTurn']
   augmentThreadListRpcResult: RpcProxyRouteDependencies['augmentThreadListRpcResult']
   reconcileRuntimeThread: RuntimeStateRoutesDependencies['reconcileRuntimeThread']
   readLocalRuntimeSnapshot: RuntimeStateRoutesDependencies['readLocalRuntimeSnapshot']
@@ -181,6 +185,10 @@ export function createCodexBridgeRouteHandlers(
       startRuntimeTurn: dependencies.startRuntimeTurn,
       interruptRuntimeTurn: dependencies.interruptRuntimeTurn,
       getLatestRequestByClientMessageId: (clientMessageId) => runtimeStore.getLatestRequestByClientMessageId(clientMessageId),
+      enqueueRuntimeTurn: dependencies.enqueueRuntimeTurn,
+      listRuntimeQueue: dependencies.listRuntimeQueue,
+      cancelQueuedRuntimeTurn: dependencies.cancelQueuedRuntimeTurn,
+      retryQueuedRuntimeTurn: dependencies.retryQueuedRuntimeTurn,
     }),
     () => handleMobilePushRoutes(req, res, url, {
       readJsonBody,
diff --git a/src/server/runtimeActionRoutes.ts b/src/server/runtimeActionRoutes.ts
index ef7548e..b7e7993 100644
--- a/src/server/runtimeActionRoutes.ts
+++ b/src/server/runtimeActionRoutes.ts
@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http'
 
 import { setJson } from './httpJsonResponse.js'
 import { RuntimeThreadBusyError, type RuntimeRequestRecord } from './runtimeStore.js'
+import type { RuntimeMessageQueueEntry } from './runtimeMessageQueue.js'
 
 type RuntimeActionResult = {
   status: string
@@ -12,6 +13,10 @@ export type RuntimeActionRoutesDependencies = {
   startRuntimeTurn: (payload: unknown) => Promise<RuntimeActionResult>
   interruptRuntimeTurn: (payload: unknown) => Promise<RuntimeActionResult>
   getLatestRequestByClientMessageId: (clientMessageId: string) => RuntimeRequestRecord | null
+  enqueueRuntimeTurn?: (payload: unknown) => RuntimeMessageQueueEntry
+  listRuntimeQueue?: (threadId?: string) => RuntimeMessageQueueEntry[]
+  cancelQueuedRuntimeTurn?: (requestId: string) => boolean
+  retryQueuedRuntimeTurn?: (requestId: string) => boolean
 }
 
 export async function handleRuntimeActionRoutes(
@@ -20,6 +25,39 @@ export async function handleRuntimeActionRoutes(
   url: URL,
   dependencies: RuntimeActionRoutesDependencies,
 ): Promise<boolean> {
+  if (req.method === 'POST' && url.pathname === '/codex-api/runtime/queue' && dependencies.enqueueRuntimeTurn) {
+    const payload = await dependencies.readJsonBody(req)
+    const result = dependencies.enqueueRuntimeTurn(payload)
+    setJson(res, 202, { data: result })
+    return true
+  }
+
+  if (req.method === 'GET' && url.pathname === '/codex-api/runtime/queue' && dependencies.listRuntimeQueue) {
+    const threadId = url.searchParams.get('threadId')?.trim() ?? ''
+    setJson(res, 200, { data: dependencies.listRuntimeQueue(threadId) })
+    return true
+  }
+
+  if (url.pathname.startsWith('/codex-api/runtime/queue/')) {
+    const suffix = decodeURIComponent(url.pathname.slice('/codex-api/runtime/queue/'.length)).trim()
+    const isRetry = suffix.endsWith('/retry')
+    const requestId = (isRetry ? suffix.slice(0, -'/retry'.length) : suffix).trim()
+    if (!requestId) {
+      setJson(res, 400, { error: 'Missing queue request id' })
+      return true
+    }
+    if (req.method === 'DELETE' && !isRetry && dependencies.cancelQueuedRuntimeTurn) {
+      const removed = dependencies.cancelQueuedRuntimeTurn(requestId)
+      setJson(res, removed ? 200 : 404, removed ? { ok: true } : { error: 'Queued message not found' })
+      return true
+    }
+    if (req.method === 'POST' && isRetry && dependencies.retryQueuedRuntimeTurn) {
+      const retried = dependencies.retryQueuedRuntimeTurn(requestId)
+      setJson(res, retried ? 202 : 409, retried ? { ok: true } : { error: 'Queued message is not retryable' })
+      return true
+    }
+  }
+
   if (req.method === 'POST' && url.pathname === '/codex-api/runtime/send') {
     const payload = await dependencies.readJsonBody(req)
     try {
diff --git a/src/server/runtimeMessageQueue.ts b/src/server/runtimeMessageQueue.ts
new file mode 100644
index 0000000..aa6f339
--- /dev/null
+++ b/src/server/runtimeMessageQueue.ts
@@ -0,0 +1,258 @@
+import { createRuntimePromptHash, parseRuntimeSendPayload } from './runtimePayload.js'
+import {
+  RuntimeThreadBusyError,
+  type RuntimeRequestRecord,
+  type RuntimeRequestStatus,
+} from './runtimeStore.js'
+
+const QUEUE_SWEEP_INTERVAL_MS = 4_000
+const QUEUE_STATUSES: RuntimeRequestStatus[] = ['queued', 'queue_failed']
+
+type RuntimeMessageQueueStore = {
+  createRequest(record: {
+    requestId: string
+    clientMessageId: string
+    threadId: string
+    status: RuntimeRequestStatus
+    promptHash: string
+    mode: string
+    payload: unknown
+  }): RuntimeRequestRecord
+  updateRequest(
+    requestId: string,
+    patch: { status?: RuntimeRequestStatus; lastError?: string | null; incrementRetry?: boolean },
+  ): RuntimeRequestRecord | null
+  getRequest(requestId: string): RuntimeRequestRecord | null
+  getLatestRequestByClientMessageId(clientMessageId: string): RuntimeRequestRecord | null
+  getThreadLease(threadId: string): { requestId: string } | null
+  listQueuedRequests(threadId?: string, limit?: number): RuntimeRequestRecord[]
+  listQueuedThreadIds(limit?: number): string[]
+}
+
+export type RuntimeMessageQueueEntry = {
+  requestId: string
+  clientMessageId: string
+  threadId: string
+  status: 'queued' | 'queue_failed'
+  createdAtIso: string
+  updatedAtIso: string
+  lastError: string | null
+  payload: unknown
+}
+
+export type RuntimeMessageQueueDependencies = {
+  store: RuntimeMessageQueueStore
+  startRuntimeTurn(payload: unknown): Promise<unknown>
+  rpc(method: string, params: unknown): Promise<unknown>
+  publishNotification(notification: { method: string; params: unknown }): void
+  getErrorMessage(error: unknown, fallback: string): string
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+}
+
+function toQueueEntry(request: RuntimeRequestRecord): RuntimeMessageQueueEntry {
+  return {
+    requestId: request.requestId,
+    clientMessageId: request.clientMessageId,
+    threadId: request.threadId,
+    status: request.status === 'queue_failed' ? 'queue_failed' : 'queued',
+    createdAtIso: request.createdAtIso,
+    updatedAtIso: request.updatedAtIso,
+    lastError: request.lastError,
+    payload: request.payload,
+  }
+}
+
+function requestsMatch(existing: RuntimeRequestRecord, threadId: string, mode: string, promptHash: string): boolean {
+  return existing.threadId === threadId
+    && existing.mode === mode
+    && existing.promptHash === promptHash
+}
+
+export class RuntimeMessageQueue {
+  private readonly processingThreadIds = new Set<string>()
+  private readonly scheduledThreadIds = new Set<string>()
+  private sweepTimer: ReturnType<typeof setInterval> | null = null
+  private disposed = false
+
+  constructor(private readonly dependencies: RuntimeMessageQueueDependencies) {}
+
+  start(): void {
+    if (this.disposed || this.sweepTimer) return
+    this.sweepTimer = setInterval(() => this.scheduleAll(), QUEUE_SWEEP_INTERVAL_MS)
+    this.sweepTimer.unref?.()
+    this.scheduleAll()
+  }
+
+  dispose(): void {
+    this.disposed = true
+    if (this.sweepTimer) clearInterval(this.sweepTimer)
+    this.sweepTimer = null
+    this.processingThreadIds.clear()
+    this.scheduledThreadIds.clear()
+  }
+
+  enqueue(payload: unknown): RuntimeMessageQueueEntry {
+    const parsed = parseRuntimeSendPayload(payload)
+    if (!parsed.threadId) throw new Error('runtime/queue requires threadId')
+
+    const clientMessageId = parsed.clientMessageId || `queue-${parsed.requestId}`
+    const durablePayload = {
+      ...(asRecord(payload) ?? {}),
+      requestId: parsed.requestId,
+      clientMessageId,
+      threadId: parsed.threadId,
+    }
+    const promptHash = createRuntimePromptHash(parsed.input)
+    const existing = this.dependencies.store.getLatestRequestByClientMessageId(clientMessageId)
+    if (existing) {
+      if (!requestsMatch(existing, parsed.threadId, parsed.mode, promptHash)) {
+        throw new Error('clientMessageId already belongs to different message content')
+      }
+      if (QUEUE_STATUSES.includes(existing.status)) this.scheduleThread(parsed.threadId)
+      return toQueueEntry(existing)
+    }
+
+    const request = this.dependencies.store.createRequest({
+      requestId: parsed.requestId,
+      clientMessageId,
+      threadId: parsed.threadId,
+      status: 'queued',
+      promptHash,
+      mode: parsed.mode,
+      payload: durablePayload,
+    })
+    this.publish(request.threadId, request.requestId, 'queued')
+    this.scheduleThread(request.threadId)
+    return toQueueEntry(request)
+  }
+
+  list(threadId = ''): RuntimeMessageQueueEntry[] {
+    return this.dependencies.store.listQueuedRequests(threadId, 500).map(toQueueEntry)
+  }
+
+  cancel(requestId: string): boolean {
+    const request = this.dependencies.store.getRequest(requestId)
+    if (!request || !QUEUE_STATUSES.includes(request.status)) return false
+    const updated = this.dependencies.store.updateRequest(requestId, {
+      status: 'interrupted',
+      lastError: 'Removed from message queue',
+    })
+    if (!updated) return false
+    this.publish(request.threadId, requestId, 'removed')
+    this.scheduleThread(request.threadId)
+    return true
+  }
+
+  retry(requestId: string): boolean {
+    const request = this.dependencies.store.getRequest(requestId)
+    if (!request || request.status !== 'queue_failed') return false
+    const updated = this.dependencies.store.updateRequest(requestId, {
+      status: 'queued',
+      lastError: null,
+      incrementRetry: true,
+    })
+    if (!updated) return false
+    this.publish(request.threadId, requestId, 'retried')
+    this.scheduleThread(request.threadId)
+    return true
+  }
+
+  handleRuntimeEvent(method: string, threadId: string): void {
+    if (!threadId || method === 'runtime/queue/updated') return
+    if (method === 'turn/completed' || method === 'turn/started' || method === 'error') {
+      this.scheduleThread(threadId)
+    }
+  }
+
+  private scheduleAll(): void {
+    if (this.disposed) return
+    for (const threadId of this.dependencies.store.listQueuedThreadIds()) {
+      this.scheduleThread(threadId)
+    }
+  }
+
+  private scheduleThread(threadId: string): void {
+    const normalizedThreadId = threadId.trim()
+    if (this.disposed || !normalizedThreadId || this.scheduledThreadIds.has(normalizedThreadId)) return
+    this.scheduledThreadIds.add(normalizedThreadId)
+    queueMicrotask(() => {
+      this.scheduledThreadIds.delete(normalizedThreadId)
+      void this.processThread(normalizedThreadId)
+    })
+  }
+
+  private async processThread(threadId: string): Promise<void> {
+    if (this.disposed || this.processingThreadIds.has(threadId)) return
+    if (this.dependencies.store.getThreadLease(threadId)) return
+    const next = this.dependencies.store.listQueuedRequests(threadId, 1)[0]
+    if (!next || next.status === 'queue_failed') return
+
+    this.processingThreadIds.add(threadId)
+    try {
+      await this.applyQueuedSpeedMode(next.payload)
+      const pending = this.dependencies.store.getRequest(next.requestId)
+      if (!pending || pending.status !== 'queued') return
+      const claimed = this.dependencies.store.updateRequest(pending.requestId, {
+        status: 'pending_start',
+        lastError: null,
+      })
+      if (!claimed) return
+      this.publish(threadId, next.requestId, 'starting')
+      await this.dependencies.startRuntimeTurn(claimed.payload)
+    } catch (error) {
+      if (error instanceof RuntimeThreadBusyError) return
+      const lastError = this.dependencies.getErrorMessage(error, 'Queued message failed to start')
+      this.dependencies.store.updateRequest(next.requestId, {
+        status: 'queue_failed',
+        lastError,
+      })
+      this.publish(threadId, next.requestId, 'failed')
+    } finally {
+      this.processingThreadIds.delete(threadId)
+    }
+  }
+
+  private async applyQueuedSpeedMode(payload: unknown): Promise<void> {
+    const speedMode = asRecord(asRecord(payload)?.queueMetadata)?.speedMode === 'fast'
+      ? 'fast'
+      : 'standard'
+    const configPayload = asRecord(await this.dependencies.rpc('config/read', {}))
+    const config = asRecord(configPayload?.config)
+    const features = asRecord(config?.features)
+    const currentSpeedMode = config?.service_tier === 'fast' ? 'fast' : 'standard'
+    const fastModeEnabled = features?.fast_mode === true
+    const edits: Array<Record<string, unknown>> = []
+    if (speedMode === 'fast' && !fastModeEnabled) {
+      edits.push({
+        keyPath: 'features.fast_mode',
+        value: true,
+        mergeStrategy: 'upsert',
+      })
+    }
+    if (speedMode !== currentSpeedMode) {
+      edits.push({
+        keyPath: 'service_tier',
+        value: speedMode === 'fast' ? 'fast' : null,
+        mergeStrategy: speedMode === 'fast' ? 'upsert' : 'replace',
+      })
+    }
+    if (edits.length === 0) return
+    await this.dependencies.rpc('config/batchWrite', {
+      edits,
+      filePath: null,
+      expectedVersion: null,
+    })
+  }
+
+  private publish(threadId: string, requestId: string, action: string): void {
+    this.dependencies.publishNotification({
+      method: 'runtime/queue/updated',
+      params: { threadId, requestId, action },
+    })
+  }
+}
diff --git a/src/server/runtimeStore.ts b/src/server/runtimeStore.ts
index 748bf88..f028962 100644
--- a/src/server/runtimeStore.ts
+++ b/src/server/runtimeStore.ts
@@ -5,6 +5,8 @@ import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 
 export type RuntimeRequestStatus =
+  | 'queued'
+  | 'queue_failed'
   | 'pending_start'
   | 'starting'
   | 'running'
@@ -683,6 +685,37 @@ export class RuntimeStore {
     return rows.map(fromRequestRow)
   }
 
+  listQueuedRequests(threadId = '', limit = 100): RuntimeRequestRecord[] {
+    const normalizedThreadId = threadId.trim()
+    const boundedLimit = Math.max(1, Math.min(500, Math.trunc(limit)))
+    const rows = normalizedThreadId
+      ? this.db.prepare(`
+          SELECT * FROM runtime_requests
+          WHERE thread_id = ? AND status IN ('queued', 'queue_failed')
+          ORDER BY created_at_iso ASC, request_id ASC
+          LIMIT ?
+        `).all(normalizedThreadId, boundedLimit) as RuntimeRequestRow[]
+      : this.db.prepare(`
+          SELECT * FROM runtime_requests
+          WHERE status IN ('queued', 'queue_failed')
+          ORDER BY created_at_iso ASC, request_id ASC
+          LIMIT ?
+        `).all(boundedLimit) as RuntimeRequestRow[]
+    return rows.map(fromRequestRow)
+  }
+
+  listQueuedThreadIds(limit = 500): string[] {
+    const rows = this.db.prepare(`
+      SELECT thread_id, MIN(created_at_iso) AS first_created_at_iso
+      FROM runtime_requests
+      WHERE status IN ('queued', 'queue_failed') AND thread_id <> ''
+      GROUP BY thread_id
+      ORDER BY first_created_at_iso ASC
+      LIMIT ?
+    `).all(Math.max(1, Math.min(1000, Math.trunc(limit)))) as Array<{ thread_id: string }>
+    return rows.map((row) => row.thread_id)
+  }
+
   listUncertainRequests(limit = 50): RuntimeRequestRecord[] {
     const rows = this.db.prepare(`
       SELECT * FROM runtime_requests
diff --git a/src/server/threadRoutes.ts b/src/server/threadRoutes.ts
index 667963a..cf9de5e 100644
--- a/src/server/threadRoutes.ts
+++ b/src/server/threadRoutes.ts
@@ -71,13 +71,14 @@ export async function handleThreadRoutes(
     const payload = asRecord(await dependencies.readJsonBody(req))
     const id = typeof payload?.id === 'string' ? payload.id : ''
     const title = typeof payload?.title === 'string' ? payload.title : ''
+    const manual = payload?.manual === true
     if (!id) {
       setJson(res, 400, { error: 'Missing id' })
       return true
     }
     const statePath = getStatePath()
     const cache = await readTitles(statePath)
-    const next = title ? updateTitles(cache, id, title) : removeTitle(cache, id)
+    const next = title ? updateTitles(cache, id, title, { manual }) : removeTitle(cache, id)
     await writeTitles(statePath, next)
     setJson(res, 200, { ok: true })
     return true
diff --git a/src/server/threadTitleCache.ts b/src/server/threadTitleCache.ts
index 9c58809..08b466e 100644
--- a/src/server/threadTitleCache.ts
+++ b/src/server/threadTitleCache.ts
@@ -2,10 +2,10 @@ import { createReadStream } from 'node:fs'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { createInterface } from 'node:readline'
 
-export type ThreadTitleCache = { titles: Record<string, string>; order: string[] }
+export type ThreadTitleCache = { titles: Record<string, string>; order: string[]; manualTitleIds?: string[] }
 
 const MAX_THREAD_TITLES = 500
-const EMPTY_THREAD_TITLE_CACHE: ThreadTitleCache = { titles: {}, order: [] }
+const EMPTY_THREAD_TITLE_CACHE: ThreadTitleCache = { titles: {}, order: [], manualTitleIds: [] }
 
 type SessionIndexThreadTitleCacheState = {
   sessionIndexPath: string | null
@@ -56,22 +56,43 @@ export function normalizeThreadTitleCache(value: unknown): ThreadTitleCache {
     }
   }
   const order = normalizeStringArray(record.order)
-  return { titles, order }
-}
-
-export function updateThreadTitleCache(cache: ThreadTitleCache, id: string, title: string): ThreadTitleCache {
+  const manualTitleIds = normalizeStringArray(record.manualTitleIds).filter((id) => Boolean(titles[id]))
+  return { titles, order, manualTitleIds }
+}
+
+export function updateThreadTitleCache(
+  cache: ThreadTitleCache,
+  id: string,
+  title: string,
+  options: { manual?: boolean } = {},
+): ThreadTitleCache {
+  const manualTitleIds = cache.manualTitleIds ?? []
+  if (options.manual !== true && manualTitleIds.includes(id) && cache.titles[id] !== title) {
+    return cache
+  }
   const titles = { ...cache.titles, [id]: title }
   const order = [id, ...cache.order.filter((o) => o !== id)]
+  const nextManualTitleIds = options.manual === true
+    ? [id, ...manualTitleIds.filter((candidate) => candidate !== id)]
+    : [...manualTitleIds]
   while (order.length > MAX_THREAD_TITLES) {
     const removed = order.pop()
-    if (removed) delete titles[removed]
+    if (removed) {
+      delete titles[removed]
+      const manualIndex = nextManualTitleIds.indexOf(removed)
+      if (manualIndex >= 0) nextManualTitleIds.splice(manualIndex, 1)
+    }
   }
-  return { titles, order }
+  return { titles, order, manualTitleIds: nextManualTitleIds }
 }
 
 export function removeFromThreadTitleCache(cache: ThreadTitleCache, id: string): ThreadTitleCache {
   const { [id]: _, ...titles } = cache.titles
-  return { titles, order: cache.order.filter((o) => o !== id) }
+  return {
+    titles,
+    order: cache.order.filter((o) => o !== id),
+    manualTitleIds: (cache.manualTitleIds ?? []).filter((candidate) => candidate !== id),
+  }
 }
 
 function normalizeSessionIndexThreadTitle(value: unknown): SessionIndexThreadTitle | null {
@@ -104,11 +125,19 @@ function trimThreadTitleCache(cache: ThreadTitleCache): ThreadTitleCache {
     }
   }
 
-  return { titles, order }
+  return {
+    titles,
+    order,
+    manualTitleIds: (cache.manualTitleIds ?? []).filter((id) => order.includes(id)),
+  }
 }
 
 export function mergeThreadTitleCaches(base: ThreadTitleCache, overlay: ThreadTitleCache): ThreadTitleCache {
   const titles = { ...base.titles, ...overlay.titles }
+  const manualTitleIds = [...(base.manualTitleIds ?? [])]
+  for (const id of manualTitleIds) {
+    if (base.titles[id]) titles[id] = base.titles[id]
+  }
   const order: string[] = []
 
   for (const id of [...overlay.order, ...base.order]) {
@@ -122,7 +151,7 @@ export function mergeThreadTitleCaches(base: ThreadTitleCache, overlay: ThreadTi
     }
   }
 
-  return trimThreadTitleCache({ titles, order })
+  return trimThreadTitleCache({ titles, order, manualTitleIds })
 }
 
 export async function readThreadTitleCache(statePath: string): Promise<ThreadTitleCache> {
@@ -185,7 +214,7 @@ export async function parseThreadTitlesFromSessionIndex(sessionIndexPath: string
     order.push(entry.id)
   }
 
-  return trimThreadTitleCache({ titles, order })
+  return trimThreadTitleCache({ titles, order, manualTitleIds: [] })
 }
 
 export async function readThreadTitlesFromSessionIndex(sessionIndexPath: string): Promise<ThreadTitleCache> {
diff --git a/tests.md b/tests.md
index ba1d11e..c4d6948 100644
--- a/tests.md
+++ b/tests.md
@@ -13078,8 +13078,8 @@ The pending home conversation must derive `is-turn-in-progress` from its current
 10. Run `npm.cmd run test:7420:frontend -- -BaseUrl http://127.0.0.1:7420 -RequireThreadTitle 分析项目 -ThreadId 019f27ae-0ecd-7c50-9701-8ec003e66447 -AgentBrowserTimeoutSec 90`.
 
 #### Expected Results
-- Desktop viewport mounts only `.message-table-scroll` for table blocks.
-- Phone viewport mounts only `.message-table-cards` for table blocks.
+- Desktop and phone viewports both retain the semantic `<table>` inside `.message-table-scroll`.
+- Phone tables scroll horizontally inside their own region, use 13px cells, and never expand the document width or collapse rows into vertical cards.
 - Switching viewport updates the rendered table representation without breaking the conversation.
 - The real `分析项目` phone thread page and conversation fixture remain nonblank.
 
@@ -15624,9 +15624,34 @@ Current evidence:
 - `npm.cmd run verify:frontend-normalizers`, `npm.cmd run build:frontend`, PowerShell parser validation, and `git diff --check` passed. The production main entry is 399,671 bytes, 329 bytes inside the 400,000-byte budget.
 - The complete 35-surface frontend regression passed in 452.6 seconds, including sidebar recency, search continuity, scroll anchoring, current-thread reveal, mobile drawer, Composer, conversation recovery, notifications, and Task Pet.
 - Final 7420 health remained `ok`, running, and initialized on PID 51368 with `approvalPolicy=never` and `sandboxMode=danger-full-access`. Pending, queued, and active RPCs, pending server requests, blocking restarts, uncertain Runtime requests, and thread leases were all zero.
+
 ## Quick Tunnel stale-session recovery and sidebar outside-dismissal (2026-08-02)
 
 1. Start a verified Quick Tunnel, then invoke start again while its child process is still alive. The existing URL may be reused only after public health, HTTP authentication, and WebSocket authentication all pass again.
 2. Simulate an alive child whose public URL no longer resolves or whose three public checks fail. Starting mobile access must terminate the stale child and continue into a fresh tunnel attempt instead of returning the stale `ready` snapshot.
 3. Open a conversation action menu from either the pinned section or a project group and press Escape. The menu closes and focus returns to the exact trigger.
 4. Open the conversation action menu again and click or tap outside it. The menu closes even when no project menu is open.
+
+## Durable background queue and conversation fidelity (2026-08-03)
+
+1. Queue two messages while a turn is running, switch to another conversation, and close the Android Activity. Both queue records must already exist under `/codex-api/runtime/queue`; the 7420 server starts them in order after the owning thread settles without requiring that conversation or WebView to be open.
+2. Restart only the mobile app while the server queue is active. The queue panel must rehydrate from the server. A failed first item pauses later items until retry, edit, or delete; deleting it allows the next item to continue.
+3. Send a prompt and force a refresh after `runtime/send` is accepted but before `thread/read` contains the user item. The optimistic user bubble must restore before newer assistant output and remain durable until an authoritative matching `userMessage` acknowledges it.
+4. Manually rename a conversation, then receive a different automatic `thread/name/updated`. The manual title remains unchanged locally and in the durable title cache; a session-index refresh must not overwrite it.
+5. Normalize an `imageGeneration` item that contains both `savedPath` and a raw base64 `result`. Render only the local saved image first; when a message image fails, its failure surface remains actionable and remounts the request when tapped.
+6. At phone width, Markdown tables remain semantic tables with a 620px minimum width, 13px text, and an independently focusable horizontal scroll region. The document itself must have no horizontal overflow and no vertical table-card DOM may be mounted.
+7. Start a queued standard-speed message while `config/read` already reports standard speed. The queue must not issue `config/batchWrite`. When a speed change is required, finish that configuration while the request is still `queued`; an idle restart snapshot during the write must not convert it to `queue_failed` before `turn/start` is attempted.
+
+Verification:
+
+- Run `npm run verify:frontend-normalizers`, `npm run verify:server-modules`, `npm run build:frontend`, and `npm run build:cli`.
+- Run the focused 7420 frontend regression and inspect the phone conversation fixture for table-local scrolling, image retry, and zero document overflow.
+- Stop the Android Activity after the server acknowledges queued messages, wait for the current turn to finish, then reopen the app and confirm the next queued turn started while the app was closed.
+
+Current evidence:
+
+- `npm run verify:frontend-normalizers`, `npm run verify:server-modules`, `npm run build:frontend`, `npm run build:cli`, Vue type checking, and `git diff --check` passed. The Runtime queue server smoke proves an active lease blocks the first queued row, a terminal event starts it, a failed row pauses its successors, and retry/delete remain recoverable.
+- Headless Playwright at 393 x 852 measured one semantic table scroll region, zero mobile table cards, a 322 px viewport over 620 px table content, and 13 px computed cell text. The inspected screenshot is `output/regression-7420/message-fidelity-20260803/mobile-table-horizontal.png`.
+- The complete frontend regression passed the updated queue source contracts and reached the live browser phase, then stopped on the pre-existing mobile Settings fixture with `settings panel did not open`, before the conversation fixture. The focused Playwright conversation fixture passed without console errors.
+- The production main entry is 411,336 bytes with the current locked Vite toolchain. A clean HEAD baseline under the same toolchain is 409,169 bytes, so this change adds 2,167 bytes to the cold entry; queue parsing, migration, persistence, and network ownership remain in the 7.81 KB lazy chunk.
+- The restart-race smoke reproduces the configuration-triggered app-server lifecycle boundary. Matching speed performs only `config/read`; changing speed keeps the row `queued` through both config RPCs and still reaches `running` after an injected idle restart snapshot. The mobile queue fixture has no browser errors and its screenshot is `output/regression-7420/queue-restart-race-20260803/queue-accepted-element.png`.

From c724b4f0b408b6faa1974080c8a53728770743e6 Mon Sep 17 00:00:00 2001
From: shaowei <466995322@qq.com>
Date: Mon, 3 Aug 2026 22:56:12 +0800
Subject: [PATCH 3/4] fix: render Codex file citations reliably

---
 .agents/skills/codex-app-parity/SKILL.md      |   8 +
 scripts/verify-frontend-normalizers.mjs       |  53 +++++++
 .../content/ConversationRegressionFixture.vue |  20 ++-
 src/components/content/ThreadConversation.vue |  50 ++++++-
 src/localPreview.ts                           |   4 +-
 src/utils/codexFileCitation.ts                | 140 ++++++++++++++++++
 tests.md                                      |  20 +++
 7 files changed, 290 insertions(+), 5 deletions(-)
 create mode 100644 src/utils/codexFileCitation.ts

diff --git a/.agents/skills/codex-app-parity/SKILL.md b/.agents/skills/codex-app-parity/SKILL.md
index 91e0444..113bef9 100644
--- a/.agents/skills/codex-app-parity/SKILL.md
+++ b/.agents/skills/codex-app-parity/SKILL.md
@@ -1256,3 +1256,11 @@ After each feature implementation session that uses this skill:
 - Queue speed configuration now remains preflight work. A row stays `queued` until any required configuration change has completed, so restart reconciliation cannot mistake preflight for a dispatched turn. A deletion during preflight is re-read and cannot be resurrected as `pending_start`.
 - `config/read` suppresses no-op speed writes. Standard speed already represented by `service_tier: null` no longer performs the configuration write that triggered the observed restart; fast mode still enables its feature and changes service tier only when necessary.
 - This preserves the desktop queue contract: genuine first-item failures still pause for retry, edit, or delete, while renderer-independent server ownership and stable `clientMessageId` ordering remain unchanged.
+
+## Findings: Structured File Citations and Legacy PDF Preview (2026-08-03)
+
+- Installed Windows Codex `26.721.4979` parses `codex-file-citation` as structured content, displays the basename, keeps the complete path as secondary context, and does not expose the transport directive or descriptive metadata in conversation text.
+- CX-Codex previously let its broad plain-path matcher consume the directive prefix, which converted a valid absolute resume path into a nonexistent workspace-relative path. Historical local messages contain the same directive across PDF, DOCX, XLSX, and PPTX outputs, so the fix is a shared parser rather than a PDF-only string replacement.
+- CX-Codex now adapts the desktop citation boundary to mobile: the basename is the compact link label, the full path remains the title and open target, and internal links stay in the current Android WebView. Invalid or incomplete directives degrade to safe text.
+- The current `pdfjs-dist` standard build requires `Promise.withResolvers` and `Math.sumPrecise`, which are absent in some Android WebViews. The isolated local preview now uses PDF.js's official legacy main and worker bundles so compatibility applies on both execution contexts.
+- Headless phone verification at 393 x 852 showed no protocol or metadata leakage, no document overflow, two rendered resume pages, and no browser errors or compatibility warnings. Evidence is under `output/regression-7420/file-citation-20260803`.
diff --git a/scripts/verify-frontend-normalizers.mjs b/scripts/verify-frontend-normalizers.mjs
index f11da4a..908678b 100644
--- a/scripts/verify-frontend-normalizers.mjs
+++ b/scripts/verify-frontend-normalizers.mjs
@@ -32,6 +32,7 @@ const taskPetReadPolicyImport = toImportPath(relative(outputRoot, join(repoRoot,
 const sessionFileChangeImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'sessionFileChange.ts')))
 const composerEnterBehaviorImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'composerEnterBehavior.ts')))
 const threadGoalImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'threadGoal.ts')))
+const codexFileCitationImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'utils', 'codexFileCitation.ts')))
 
 try {
   writeFileSync(entryPath, `
@@ -110,6 +111,58 @@ import {
 } from '${sessionFileChangeImport}'
 import { resolveSendWithEnterPreference } from '${composerEnterBehaviorImport}'
 import { normalizeThreadGoal } from '${threadGoalImport}'
+import {
+  readCodexFileCitationAt,
+  splitCodexFileCitations,
+} from '${codexFileCitationImport}'
+
+const resumePdfCitation = ':codex-file-citation{path="E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf" purpose="产品与项目经理通用投递简历"}'
+assert.deepEqual(readCodexFileCitationAt(resumePdfCitation, 0), {
+  raw: resumePdfCitation,
+  start: 0,
+  end: resumePdfCitation.length,
+  path: 'E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf',
+  purpose: '产品与项目经理通用投递简历',
+  attributes: {
+    path: 'E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf',
+    purpose: '产品与项目经理通用投递简历',
+  },
+})
+assert.deepEqual(
+  splitCodexFileCitations('PDF：' + resumePdfCitation + '。'),
+  [
+    { kind: 'text', value: 'PDF：' },
+    {
+      kind: 'citation',
+      citation: {
+        raw: resumePdfCitation,
+        start: 4,
+        end: 4 + resumePdfCitation.length,
+        path: 'E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf',
+        purpose: '产品与项目经理通用投递简历',
+        attributes: {
+          path: 'E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf',
+          purpose: '产品与项目经理通用投递简历',
+        },
+      },
+    },
+    { kind: 'text', value: '。' },
+  ],
+)
+const windowsSeparator = String.fromCharCode(92)
+const spacedDocxPath = ['E:', '投递材料', '产品 经理', '邵卫 简历.docx'].join(windowsSeparator)
+const spacedDocxCitation = ':codex-file-citation{purpose="带 ' + windowsSeparator + '"引号' + windowsSeparator + '" 的定制简历" path="' + spacedDocxPath + '" artifact_kind="document" page_number="2"}'
+assert.equal(readCodexFileCitationAt(spacedDocxCitation, 0)?.path, spacedDocxPath)
+assert.equal(readCodexFileCitationAt(spacedDocxCitation, 0)?.purpose, '带 "引号" 的定制简历')
+assert.equal(readCodexFileCitationAt(spacedDocxCitation, 0)?.attributes.page_number, '2')
+const unquotedXlsxCitation = ':codex-file-citation{path=E:/reports/项目清单.xlsx artifact_kind=workbook range=Sheet1!A1:D20}'
+assert.equal(readCodexFileCitationAt(unquotedXlsxCitation, 0)?.path, 'E:/reports/项目清单.xlsx')
+assert.equal(readCodexFileCitationAt(unquotedXlsxCitation, 0)?.attributes.range, 'Sheet1!A1:D20')
+assert.equal(splitCodexFileCitations(resumePdfCitation + unquotedXlsxCitation).filter((part) => part.kind === 'citation').length, 2)
+assert.equal(readCodexFileCitationAt(':codex-file-citation{purpose="缺少路径"}', 0)?.path, '')
+assert.deepEqual(splitCodexFileCitations('保留 :codex-file-citation{path="E:/unfinished.pdf"'), [
+  { kind: 'text', value: '保留 :codex-file-citation{path="E:/unfinished.pdf"' },
+])
 
 assert.equal(CONVERSATION_BOTTOM_THRESHOLD_PX, 24)
 assert.equal(CX_SESSION_FILES_CHANGED_METHOD, 'cx/session-files/changed')
diff --git a/src/components/content/ConversationRegressionFixture.vue b/src/components/content/ConversationRegressionFixture.vue
index 68194b8..88805af 100644
--- a/src/components/content/ConversationRegressionFixture.vue
+++ b/src/components/content/ConversationRegressionFixture.vue
@@ -53,7 +53,7 @@
         :pending-requests="pendingRequests"
         :live-overlay="liveOverlay"
         :is-loading="false"
-        :is-turn-in-progress="!isLoadFailureFixture && !isScrollSwitchRaceFixture && !isPlanFixture"
+        :is-turn-in-progress="!isLoadFailureFixture && !isScrollSwitchRaceFixture && !isPlanFixture && !isFileCitationFixture"
         :load-error="isLoadFailureFixture ? '连接不到桌面端，会话内容暂时未加载。页面会自动重试，也可以检查或修改连接地址。' : ''"
         :show-connection-settings-action="isLoadFailureFixture"
         compact-runtime-chrome
@@ -373,6 +373,7 @@ const isMessageActionHitFixture = fixtureParams.get('messageActionHit') === '1'
 const isPlanFixture = fixtureParams.get('plan') === '1'
 const isPlanSubmittedFixture = fixtureParams.get('planSubmitted') === '1'
 const isPlanHistoryImplementedFixture = fixtureParams.get('planHistoryImplemented') === '1'
+const isFileCitationFixture = fixtureParams.get('fileCitation') === '1'
 const fixtureImplementingPlanId = ref(fixtureParams.get('planSubmitting') === '1' ? 'plan:fixture-plan-turn' : '')
 const fixtureImplementedPlanIds = ref<string[]>(isPlanSubmittedFixture ? ['plan:fixture-plan-turn'] : [])
 const activeThreadId = ref(isScrollSwitchRaceFixture ? 'regression-scroll-a' : 'regression-conversation-blocks')
@@ -402,6 +403,20 @@ const markdownImageMessages: UiMessage[] = [
     turnIndex: 9,
   },
 ]
+const fileCitationMessages: UiMessage[] = [
+  {
+    id: 'fixture-codex-file-citation',
+    role: 'assistant',
+    text: [
+      '已生成产品与项目经理通用投递版简历。',
+      '',
+      ':codex-file-citation{path="E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf" purpose="产品与项目经理通用投递简历"}',
+      '',
+      '可编辑内容：:codex-file-citation{path="E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.md" purpose="产品与项目经理简历 Markdown 版本"}',
+    ].join('\n'),
+    turnIndex: 10,
+  },
+]
 const planMessages: UiMessage[] = [
   {
     id: 'plan:fixture-older-plan-turn',
@@ -468,6 +483,7 @@ const fixtureMessages = computed(() => {
   }
   if (isImagePreviewFixture) return [...messages, imagePreviewMessage]
   if (isMarkdownImageFixture) return [...messages, ...markdownImageMessages]
+  if (isFileCitationFixture) return fileCitationMessages
   if (isPlanFixture) {
     return isPlanHistoryImplementedFixture
       ? [...planMessages, {
@@ -495,7 +511,7 @@ const liveOverlay = ref<UiLiveOverlay | null>({
   errorText: '',
 })
 
-if (isLoadFailureFixture || isScrollSwitchRaceFixture || isPlanFixture) {
+if (isLoadFailureFixture || isScrollSwitchRaceFixture || isPlanFixture || isFileCitationFixture) {
   liveOverlay.value = null
 }
 
diff --git a/src/components/content/ThreadConversation.vue b/src/components/content/ThreadConversation.vue
index 7478512..1389fbb 100644
--- a/src/components/content/ThreadConversation.vue
+++ b/src/components/content/ThreadConversation.vue
@@ -1297,6 +1297,11 @@ import {
 } from '../../composables/conversationViewport'
 import { hasPlanImplementationConfirmation } from '../../composables/conversationProjection'
 import { copyTextToClipboard } from '../../utils/clipboard'
+import {
+  CODEX_FILE_CITATION_PREFIX,
+  splitCodexFileCitations,
+  type CodexFileCitation,
+} from '../../utils/codexFileCitation'
 
 export type ThreadConversationExposed = {
   focusMessage: (messageId: string) => Promise<boolean>
@@ -3347,7 +3352,7 @@ function applyBoldMarkersAcrossTextSegments(segments: InlineSegment[]): InlineSe
 
   return output
 }
-function splitTextByFileUrls(text: string): InlineSegment[] {
+function splitTextByMarkdownLinks(text: string): InlineSegment[] {
   const segments: InlineSegment[] = []
   let cursor = 0
 
@@ -3378,6 +3383,49 @@ function splitTextByFileUrls(text: string): InlineSegment[] {
   return segments
 }
 
+function pushCodexFileCitationSegment(
+  segments: InlineSegment[],
+  citation: CodexFileCitation,
+): void {
+  const fileReference = parseFileReference(citation.path)
+  if (!fileReference) {
+    const fallbackText = citation.purpose || citation.raw
+    if (fallbackText) segments.push({ kind: 'text', value: fallbackText })
+    return
+  }
+
+  segments.push({
+    kind: 'file',
+    value: citation.raw,
+    path: fileReference.path,
+    displayPath: getBasename(fileReference.path),
+    downloadName: getBasename(fileReference.path),
+  })
+}
+
+function splitTextByFileUrls(text: string): InlineSegment[] {
+  const parts = splitCodexFileCitations(text)
+  const segments: InlineSegment[] = []
+
+  for (const part of parts) {
+    if (part.kind === 'citation') {
+      pushCodexFileCitationSegment(segments, part.citation)
+      continue
+    }
+    const invalidDirectiveStart = part.value.indexOf(CODEX_FILE_CITATION_PREFIX)
+    if (invalidDirectiveStart < 0) {
+      segments.push(...splitTextByMarkdownLinks(part.value))
+      continue
+    }
+    if (invalidDirectiveStart > 0) {
+      segments.push(...splitTextByMarkdownLinks(part.value.slice(0, invalidDirectiveStart)))
+    }
+    segments.push({ kind: 'text', value: part.value.slice(invalidDirectiveStart) })
+  }
+
+  return segments
+}
+
 function collectMarkdownLinkRanges(text: string): TextRange[] {
   const ranges: TextRange[] = []
   let cursor = 0
diff --git a/src/localPreview.ts b/src/localPreview.ts
index 3dc2664..ebb1050 100644
--- a/src/localPreview.ts
+++ b/src/localPreview.ts
@@ -1,8 +1,8 @@
 import MarkdownIt from 'markdown-it'
 import DOMPurify from 'dompurify'
 import { renderAsync } from 'docx-preview'
-import * as pdfjsLib from 'pdfjs-dist'
-import pdfWorkerUrl from 'pdfjs-dist/build/pdf.worker.mjs?url'
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.mjs'
+import pdfWorkerUrl from 'pdfjs-dist/legacy/build/pdf.worker.mjs?url'
 
 declare global {
   interface Window {
diff --git a/src/utils/codexFileCitation.ts b/src/utils/codexFileCitation.ts
new file mode 100644
index 0000000..4020d06
--- /dev/null
+++ b/src/utils/codexFileCitation.ts
@@ -0,0 +1,140 @@
+export const CODEX_FILE_CITATION_PREFIX = ':codex-file-citation{'
+
+export type CodexFileCitation = {
+  raw: string
+  start: number
+  end: number
+  path: string
+  purpose: string
+  attributes: Record<string, string>
+}
+
+export type CodexFileCitationPart =
+  | { kind: 'text'; value: string }
+  | { kind: 'citation'; citation: CodexFileCitation }
+
+type AttributeValue = {
+  value: string
+  end: number
+}
+
+function readQuotedAttributeValue(text: string, start: number, quote: string): AttributeValue | null {
+  let cursor = start + 1
+  let value = ''
+
+  while (cursor < text.length) {
+    const character = text[cursor]
+    if (character === quote) {
+      return { value, end: cursor + 1 }
+    }
+    if (character === '\\' && cursor + 1 < text.length) {
+      const escaped = text[cursor + 1]
+      if (escaped === quote || escaped === '\\') {
+        value += escaped
+        cursor += 2
+        continue
+      }
+    }
+    value += character
+    cursor += 1
+  }
+
+  return null
+}
+
+function readAttributeValue(text: string, start: number): AttributeValue | null {
+  const firstCharacter = text[start]
+  if (firstCharacter === '"' || firstCharacter === "'") {
+    return readQuotedAttributeValue(text, start, firstCharacter)
+  }
+
+  let cursor = start
+  while (cursor < text.length && !/[\s,}]/u.test(text[cursor] ?? '')) {
+    cursor += 1
+  }
+  if (cursor === start) return null
+  return { value: text.slice(start, cursor), end: cursor }
+}
+
+function decodeCitationPath(pathValue: string): string {
+  try {
+    return decodeURI(pathValue)
+  } catch {
+    return pathValue
+  }
+}
+
+export function readCodexFileCitationAt(text: string, start: number): CodexFileCitation | null {
+  if (start < 0 || !text.startsWith(CODEX_FILE_CITATION_PREFIX, start)) return null
+
+  const attributes: Record<string, string> = {}
+  let cursor = start + CODEX_FILE_CITATION_PREFIX.length
+
+  while (cursor < text.length) {
+    while (cursor < text.length && /[\s,]/u.test(text[cursor] ?? '')) cursor += 1
+
+    if (text[cursor] === '}') {
+      const end = cursor + 1
+      return {
+        raw: text.slice(start, end),
+        start,
+        end,
+        path: decodeCitationPath((attributes.path ?? '').trim()),
+        purpose: (attributes.purpose ?? '').trim(),
+        attributes,
+      }
+    }
+
+    const keyMatch = text.slice(cursor).match(/^([A-Za-z_][A-Za-z0-9_-]*)/u)
+    if (!keyMatch) return null
+    const key = keyMatch[1]
+    cursor += key.length
+
+    while (cursor < text.length && /\s/u.test(text[cursor] ?? '')) cursor += 1
+    if (text[cursor] !== '=') return null
+    cursor += 1
+    while (cursor < text.length && /\s/u.test(text[cursor] ?? '')) cursor += 1
+
+    const parsedValue = readAttributeValue(text, cursor)
+    if (!parsedValue) return null
+    attributes[key] = parsedValue.value
+    cursor = parsedValue.end
+  }
+
+  return null
+}
+
+export function findCodexFileCitation(text: string, fromIndex = 0): CodexFileCitation | null {
+  let searchFrom = Math.max(0, fromIndex)
+
+  while (searchFrom < text.length) {
+    const start = text.indexOf(CODEX_FILE_CITATION_PREFIX, searchFrom)
+    if (start < 0) return null
+    const citation = readCodexFileCitationAt(text, start)
+    if (citation) return citation
+    searchFrom = start + CODEX_FILE_CITATION_PREFIX.length
+  }
+
+  return null
+}
+
+export function splitCodexFileCitations(text: string): CodexFileCitationPart[] {
+  const parts: CodexFileCitationPart[] = []
+  let cursor = 0
+
+  while (cursor < text.length) {
+    const citation = findCodexFileCitation(text, cursor)
+    if (!citation) break
+    if (citation.start > cursor) {
+      parts.push({ kind: 'text', value: text.slice(cursor, citation.start) })
+    }
+    parts.push({ kind: 'citation', citation })
+    cursor = citation.end
+  }
+
+  if (cursor < text.length) {
+    parts.push({ kind: 'text', value: text.slice(cursor) })
+  }
+
+  return parts
+}
diff --git a/tests.md b/tests.md
index c4d6948..ab2a803 100644
--- a/tests.md
+++ b/tests.md
@@ -15655,3 +15655,23 @@ Current evidence:
 - The complete frontend regression passed the updated queue source contracts and reached the live browser phase, then stopped on the pre-existing mobile Settings fixture with `settings panel did not open`, before the conversation fixture. The focused Playwright conversation fixture passed without console errors.
 - The production main entry is 411,336 bytes with the current locked Vite toolchain. A clean HEAD baseline under the same toolchain is 409,169 bytes, so this change adds 2,167 bytes to the cold entry; queue parsing, migration, persistence, and network ownership remain in the 7.81 KB lazy chunk.
 - The restart-race smoke reproduces the configuration-triggered app-server lifecycle boundary. Matching speed performs only `config/read`; changing speed keeps the row `queued` through both config RPCs and still reaches `running` after an injected idle restart snapshot. The mobile queue fixture has no browser errors and its screenshot is `output/regression-7420/queue-restart-race-20260803/queue-accepted-element.png`.
+
+## Structured Codex file citations and mobile PDF preview (2026-08-03)
+
+1. Render `:codex-file-citation{path="..." ...}` as a local-file link whose visible label is the basename. The raw directive and metadata such as `purpose` must not appear in conversation text.
+2. Preserve complete Windows and POSIX paths, spaces, escaped quotes, backslashes, Unicode names, and additional attributes. An incomplete or pathless directive must remain safe text and must not become a link to the current workspace.
+3. At phone width, tapping an internal file link opens the existing local preview in the current WebView. The document must not gain horizontal overflow.
+4. PDF preview must use the PDF.js legacy main and worker builds so Android WebViews without `Promise.withResolvers` or `Math.sumPrecise` can still render every page.
+
+Verification:
+
+- Run `npm.cmd run verify:frontend-normalizers` and `npm.cmd run build:frontend`.
+- Open `/#/__regression/conversation-blocks?fileCitation=1` at 393 x 852. Confirm the PDF and Markdown labels are basenames, the raw protocol and `purpose` metadata are absent, and `scrollWidth === clientWidth`.
+- Tap the PDF link. Confirm the URL changes to `/local-preview.html`, the status reaches `PDF 预览已就绪，共 2 页。`, two canvases render, and there are no browser errors or compatibility warnings.
+- Inspect `output/regression-7420/file-citation-20260803/file-citation-phone.png` and `output/regression-7420/file-citation-20260803/pdf-preview-phone.png`.
+
+Current evidence:
+
+- The parser smoke covers the reported resume PDF, a Markdown companion, quoted and unquoted attributes, Windows backslashes, spaces, escaped metadata, adjacent citations, pathless directives, and incomplete directives.
+- Headless Chrome at 393 x 852 measured 393 px document width over a 393 px viewport, rendered both file labels without leaking internal metadata, and opened the exact encoded local path.
+- The reported 297.1 KB resume rendered two PDF canvases. Both compatibility APIs were functions after the legacy bundle initialized, and browser errors and warnings were empty.

From 097e332a6f326ec7281179b2d80238f4112a636f Mon Sep 17 00:00:00 2001
From: shaowei <466995322@qq.com>
Date: Tue, 4 Aug 2026 02:12:46 +0800
Subject: [PATCH 4/4] release: prepare CX-Codex 2.7.3

---
 .agents/skills/codex-app-parity/SKILL.md      |  33 +-
 .opencodereview/rule.json                     |  37 ++
 README.md                                     |   1 +
 .../java/com/cxcodex/bridge/MainActivity.java |  21 +
 .../cxcodex/bridge/TaskPetOverlayService.java | 426 ++++++++++++++----
 .../cxcodex/bridge/TaskPetRuntimePolicy.java  |  50 ++
 .../bridge/TaskPetRuntimePolicyTest.java      |  51 +++
 docs/changelog.zh-CN.md                       |  12 +
 docs/release-notes-2.7.3.zh-CN.md             |  63 +++
 package-lock.json                             |   4 +-
 package.json                                  |   2 +-
 scripts/regression-7420-frontend.ps1          | 122 ++++-
 scripts/server-module-smoke.ts                | 354 +++++++++++++--
 scripts/verify-frontend-normalizers.mjs       |  71 ++-
 src/api/runtimeMessageQueue.ts                |  77 +++-
 src/components/mobile/TaskPetPreview.vue      | 298 ++++++------
 .../mobile/TaskPetRegressionFixture.vue       |   5 +
 src/composables/runtimeExecutionRecovery.ts   |  25 +
 src/composables/useDesktopState.ts            | 147 ++++--
 .../appServerNotificationRuntimeSync.ts       |  29 +-
 src/server/appServerRpcCache.ts               |  23 +-
 src/server/appServerSessionLogThreadRead.ts   | 267 ++++++++---
 src/server/appServerThreadRuntimeSnapshot.ts  |   2 +-
 src/server/codexAppServerBridge.ts            |  23 +-
 src/server/codexBridgeRouteHandlers.ts        |   2 +
 src/server/codexSessionFileChangeObserver.ts  |  18 +-
 src/server/runtimeActionRoutes.ts             |  15 +
 src/server/runtimeMessageQueue.ts             |   9 +
 src/server/runtimeState.ts                    |  11 +-
 src/server/runtimeStore.ts                    |  28 ++
 src/sessionFileChange.ts                      |  18 +-
 tests.md                                      |  93 +++-
 32 files changed, 1943 insertions(+), 394 deletions(-)
 create mode 100644 .opencodereview/rule.json
 create mode 100644 docs/release-notes-2.7.3.zh-CN.md
 create mode 100644 src/composables/runtimeExecutionRecovery.ts

diff --git a/.agents/skills/codex-app-parity/SKILL.md b/.agents/skills/codex-app-parity/SKILL.md
index 113bef9..359be12 100644
--- a/.agents/skills/codex-app-parity/SKILL.md
+++ b/.agents/skills/codex-app-parity/SKILL.md
@@ -1250,12 +1250,19 @@ After each feature implementation session that uses this skill:
 - Manual conversation titles now have explicit durable ownership and reject later automatic name notifications. Generated images prefer the saved local path over oversized raw base64 payloads and expose a real remounting retry action on failure.
 - Phone Markdown tables retain the semantic desktop table and use a focusable horizontal scroll owner instead of changing rows into cards. Headless Playwright at 393 x 852 measured 322 px visible width over 620 px content, 13 px cells, zero table-card DOM, and no browser console errors.
 
+## Findings: Quiet Docked Android Task Pet (2026-08-03)
+
+- Installed Windows Codex `26.721.4979` keeps exact-conversation navigation on the activity owner through `localConversationId` and `open-in-main-window`, carries a bounded notification count on the avatar frame, and distinguishes waiting (`Needs input`) from settled review (`Ready`).
+- CX-Codex adapts those state and navigation boundaries to Android instead of reproducing the desktop window: the edge pet is a compact attention owner, a new assistant item gets one transient reply peek, a tap opens a bounded task stack, and full reading or input stays in the conversation.
+- Unread ownership is now a persisted reply-event cursor. Stream chunks from the same assistant item update visible text without extending the five-second interruption window; opening the exact conversation advances the cursor and prevents stale completion attention after restart.
+- The app foreground is deliberately quiet, restart returns to the docked state, and transient panel/peek state is not persisted. The native monitor remains authoritative in the background, while notification actions continue to provide the system-level fallback.
+
 ## Findings: Restart-safe Queued Speed Handoff (2026-08-03)
 
 - A real failed 7420 queue record showed `queued -> queue_failed` in 53 ms with `Turn start was not confirmed after bridge restart`; its prompt was absent from the full authoritative thread history. The queued coordinator had marked the request `pending_start` before `config/batchWrite`, while that configuration call could restart app-server and trigger pending-start reconciliation.
 - Queue speed configuration now remains preflight work. A row stays `queued` until any required configuration change has completed, so restart reconciliation cannot mistake preflight for a dispatched turn. A deletion during preflight is re-read and cannot be resurrected as `pending_start`.
 - `config/read` suppresses no-op speed writes. Standard speed already represented by `service_tier: null` no longer performs the configuration write that triggered the observed restart; fast mode still enables its feature and changes service tier only when necessary.
-- This preserves the desktop queue contract: genuine first-item failures still pause for retry, edit, or delete, while renderer-independent server ownership and stable `clientMessageId` ordering remain unchanged.
+- This preserves the desktop queue contract: genuine first-item failures still pause for retry, edit, or delete, while renderer-independent server ownership and stable `clientMessageId` ordering remain unchanged.
 
 ## Findings: Structured File Citations and Legacy PDF Preview (2026-08-03)
 
@@ -1264,3 +1271,27 @@ After each feature implementation session that uses this skill:
 - CX-Codex now adapts the desktop citation boundary to mobile: the basename is the compact link label, the full path remains the title and open target, and internal links stay in the current Android WebView. Invalid or incomplete directives degrade to safe text.
 - The current `pdfjs-dist` standard build requires `Promise.withResolvers` and `Math.sumPrecise`, which are absent in some Android WebViews. The isolated local preview now uses PDF.js's official legacy main and worker bundles so compatibility applies on both execution contexts.
 - Headless phone verification at 393 x 852 showed no protocol or metadata leakage, no document overflow, two rendered resume pages, and no browser errors or compatibility warnings. Evidence is under `output/regression-7420/file-citation-20260803`.
+
+## Findings: External-session Progress and Bounded History Recovery (2026-08-03)
+
+- Installed Windows Codex `26.727.51351` keeps request dispatch, turn start, first data, and first visible response as separate milestones. Its avatar overlay retains the owning `localConversationId`, opens through `open-in-main-window`, and keeps queued messages as a distinct composer-adjacent surface with retry and steer states.
+- CX-Codex must preserve those ownership boundaries when mirroring a task executed by another desktop process. A session-file append is authoritative new progress, but it must not make 7420 re-read the complete rollout or invent a local Runtime-running state.
+- Default recent-message and Runtime reads now use a bounded session-log projection. High-frequency response, reasoning, plan, command, file, MCP, and process deltas no longer evict that projection; explicit full-history and older-turn reads still use the authoritative App Server.
+- Session-log recovery retains `phase: commentary`, so a progress-only tail renders under phase replies instead of becoming a fake final answer or an empty result. Native Task Pet reply freshness remains tied only to a newer `latestReplyEventSeq`.
+- A 72 MB real conversation previously issued 6.7-8.0 second heavy reads every 8-10 seconds. After the boundary change, a fresh reload plus 35 seconds of live external updates produced zero heavy reads; light metadata reads peaked at 24 ms, with no RPC queue, pending server request, or uncertain Runtime request.
+
+## Findings: Task-pet Wake and Lossless Session Convergence (2026-08-03)
+
+- Installed Windows Codex `26.727.6591` still owns avatar attention through an exact `localConversationId`, dispatches `open-in-main-window`, presents a bounded notification count, and labels waiting work separately from review-ready work.
+- A docked CX-Codex task pet previously stayed minimized when work arrived after an idle snapshot, and running-task replies were excluded from its badge. It now restores on task arrival, shows one five-second reply peek, counts unread reply cursors alongside waiting tasks, and clears only the exact conversation that is opened.
+- Empty expanded stacks now return to the minimized pet after eight seconds. Close confirmation pauses that timer and cancellation starts a fresh timeout, matching the native Android interaction owner instead of allowing a destructive prompt to disappear mid-decision.
+- Session-log ownership is split deliberately: the bounded file projection supplies immediate text, but it is not treated as structurally complete. File notifications reset a 1.8-second quiet window, after which one coalesced authoritative read restores plans, commands, file changes, approvals, and tool items without returning to per-append heavy reads.
+- Real 7420 browser checks covered idle-to-task wake, `2 -> 1` unread acknowledgement, exact `fixture-running` navigation, empty-stack minimization, and close-confirmation timer ownership. Frontend normalization, production build, CLI build, server-module smoke, Android policy tests, and the full frontend regression remained the verification boundary.
+
+## Findings: Queue Generation Isolation and Stable Local Merge (2026-08-04)
+
+- Installed Windows Codex `26.727.6591` keeps queued work as a composer-adjacent list with stable message identity, explicit retry/edit/delete ownership, and first-failure blocking. Queue UI changes do not impersonate App Server turn lifecycle events.
+- CX-Codex had two ownership leaks: its internal `runtime/queue/updated` broadcast reconciled a newly claimed request against the previous turn's completed snapshot, and a second-precision pre-start `thread/read` could release the active lease before `turn/start` materialized.
+- Internal queue notifications now remain replayable UI signals but cannot mutate or reconcile Runtime state. A same-second non-running thread snapshot is ignored during a bounded 20-second materialization window, keeping queued work isolated behind the real active turn without making restart recovery permanent.
+- Frontend persistence acknowledgements merge into the latest queue by stable `clientMessageId`, cancel server rows deleted during an in-flight write, and stop behind the first failed local row. After a complete sync, an exact-set server reorder makes the retained UI order authoritative without letting stale or partial client state move another client's message.
+- A real controlled 7420 run recorded `BASE2 -> QUEUE2-A -> QUEUE2-B` as three distinct turns. A/B reached first token in 2.27/1.85 seconds, while a separate direct no-tool reply reached first token in 1.71 seconds; no queued prompt was lost or injected into the previous turn. A second run reordered `A -> B -> C` into `C -> A -> B`, and both the immediate server list and authoritative history followed that exact order.
diff --git a/.opencodereview/rule.json b/.opencodereview/rule.json
new file mode 100644
index 0000000..6afe634
--- /dev/null
+++ b/.opencodereview/rule.json
@@ -0,0 +1,37 @@
+{
+  "include": [
+    "android/app/src/test/**/*.java",
+    "**/*Test.java",
+    "**/*Tests.java",
+    "**/*.{test,spec}.{ts,tsx,js,jsx,mjs,cjs}"
+  ],
+  "exclude": [
+    "node_modules/**",
+    "dist/**",
+    "dist-cli/**",
+    "coverage/**",
+    "android/**/build/**"
+  ],
+  "rules": [
+    {
+      "path": "src/server/**/*.{ts,js}",
+      "rule": "Preserve the CLI -> Express bridge -> Codex app-server contract. Treat session-log reads as potentially lossy fallback data, keep normal thread/read responses authoritative, and verify cache invalidation, thread identity, response-view windows, abort handling, and per-thread ordering. Flag optimizations that can hide structured messages such as plans, command executions, file changes, approvals, or tool calls.",
+      "merge_system_rule": true
+    },
+    {
+      "path": "src/**/*.{ts,vue}",
+      "rule": "Preserve Vue reactivity and the desktop/mobile runtime state contract. Check cleanup of timers, listeners, and abort controllers; guard stale async responses by thread identity or version; retain optimistic messages until authoritative reconciliation; and avoid visual-only changes that diverge from the installed Codex desktop behavior.",
+      "merge_system_rule": true
+    },
+    {
+      "path": "android/app/src/**/*.java",
+      "rule": "Preserve Android foreground-service, notification, overlay, and activity lifecycle behavior. Check main-thread UI access, background execution restrictions, PendingIntent identity, configuration changes, accessibility timeouts, lock-screen privacy, resource cleanup, and parity between native task-pet state and the web preview.",
+      "merge_system_rule": true
+    },
+    {
+      "path": "scripts/**/*.{ts,mjs,js,ps1}",
+      "rule": "Keep verification deterministic and behavior-based. Distinguish expected diagnostic logs from failures, avoid timing-only assertions when state can be observed directly, preserve Windows PowerShell compatibility, and make regression checks fail with a specific actionable message.",
+      "merge_system_rule": true
+    }
+  ]
+}
diff --git a/README.md b/README.md
index 8f3952d..8ffd9af 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ Self-hosted OpenAI Codex Web UI and Android client bridge.
 ## 快速入口
 
 - 最新 Release: [github.com/Qjzn/CX-Codex/releases/latest](https://github.com/Qjzn/CX-Codex/releases/latest)
+- 2.7.3 发布说明: [docs/release-notes-2.7.3.zh-CN.md](./docs/release-notes-2.7.3.zh-CN.md)
 - 2.7.2 发布说明: [docs/release-notes-2.7.2.zh-CN.md](./docs/release-notes-2.7.2.zh-CN.md)
 - 2.6.0 发布说明: [docs/release-notes-2.6.0.zh-CN.md](./docs/release-notes-2.6.0.zh-CN.md)
 - 2.5.9 发布说明: [docs/release-notes-2.5.9.zh-CN.md](./docs/release-notes-2.5.9.zh-CN.md)
diff --git a/android/app/src/main/java/com/cxcodex/bridge/MainActivity.java b/android/app/src/main/java/com/cxcodex/bridge/MainActivity.java
index 39662d7..9acc42a 100644
--- a/android/app/src/main/java/com/cxcodex/bridge/MainActivity.java
+++ b/android/app/src/main/java/com/cxcodex/bridge/MainActivity.java
@@ -35,6 +35,7 @@
 public class MainActivity extends BridgeActivity {
 
     private static final long CONNECTION_TIMEOUT_MS = 15000L;
+    private static volatile boolean appForeground;
     private boolean initialCreateComplete;
     private boolean mainFrameLoadFailed;
     private LinearLayout connectionOverlay;
@@ -84,6 +85,26 @@ public void onResume() {
         openPendingTaskPetThread();
     }
 
+    @Override
+    public void onStart() {
+        super.onStart();
+        appForeground = true;
+        TaskPetOverlayService.refreshPresentation(this);
+    }
+
+    @Override
+    public void onStop() {
+        if (!isChangingConfigurations()) {
+            appForeground = false;
+            TaskPetOverlayService.refreshPresentation(this);
+        }
+        super.onStop();
+    }
+
+    static boolean isAppForeground() {
+        return appForeground;
+    }
+
     private void captureTaskPetThreadFromIntent(Intent intent) {
         if (intent == null || !intent.hasExtra(TaskPetOverlayService.EXTRA_THREAD_ID)) {
             return;
diff --git a/android/app/src/main/java/com/cxcodex/bridge/TaskPetOverlayService.java b/android/app/src/main/java/com/cxcodex/bridge/TaskPetOverlayService.java
index 6365653..b8797ba 100644
--- a/android/app/src/main/java/com/cxcodex/bridge/TaskPetOverlayService.java
+++ b/android/app/src/main/java/com/cxcodex/bridge/TaskPetOverlayService.java
@@ -1,6 +1,7 @@
 package com.cxcodex.bridge;
 
 import android.animation.ValueAnimator;
+import android.app.KeyguardManager;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
@@ -31,6 +32,7 @@
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.WindowManager;
+import android.view.accessibility.AccessibilityManager;
 import android.view.animation.Interpolator;
 import android.view.animation.PathInterpolator;
 import android.view.inputmethod.InputMethodManager;
@@ -97,14 +99,18 @@ public final class TaskPetOverlayService extends Service {
     private static final int OMITTED_PROVISIONAL_MISSING_LIMIT = 3;
     private static final int REPLY_CONFIRMATION_MISSING_LIMIT = 3;
     private static final int ROOT_PADDING_DP = 6;
-    private static final int PANEL_WIDTH_DP = 282;
-    private static final int PANEL_CONTENT_WIDTH_DP = 258;
-    private static final int MASCOT_WIDTH_DP = 72;
-    private static final int MASCOT_HEIGHT_DP = 79;
+    private static final int PANEL_WIDTH_DP = 248;
+    private static final int PANEL_CONTENT_WIDTH_DP = 224;
+    private static final int MASCOT_WIDTH_DP = 56;
+    private static final int MASCOT_HEIGHT_DP = 62;
     private static final int MINI_SIZE_DP = 48;
-    private static final int TASK_ROW_HEIGHT_DP = 88;
-    private static final int COMPACT_PREVIEW_HEIGHT_DP = 86;
+    private static final int TASK_ROW_HEIGHT_DP = 64;
+    private static final int COMPACT_PREVIEW_WIDTH_DP = 224;
+    private static final int COMPACT_PREVIEW_HEIGHT_DP = 60;
     private static final int COMPACT_PREVIEW_GAP_DP = 4;
+    private static final int EDGE_VISIBLE_HANDLE_DP = 32;
+    private static final long REPLY_PEEK_TIMEOUT_MS = 5_000L;
+    private static final long TASK_STACK_TIMEOUT_MS = 8_000L;
     private static final AtomicBoolean RUNNING = new AtomicBoolean(false);
     private static final Interpolator EASE_OUT = new PathInterpolator(0.22f, 1f, 0.36f, 1f);
 
@@ -157,6 +163,7 @@ public final class TaskPetOverlayService extends Service {
     private boolean destroyed;
     private boolean sendingReply;
     private boolean closeConfirmationVisible;
+    private boolean replyPeekVisible;
     private int panelAnimationToken;
     private int pendingCollapsedPetX = -1;
     private int pendingCollapsedPetY = -1;
@@ -232,6 +239,13 @@ public void run() {
         }
     };
 
+    private final Runnable hideReplyPeekRunnable = () -> hideTransientReplyPeek(true);
+
+    private final Runnable collapseTaskStackRunnable = () -> {
+        if (!expanded || sendingReply || closeConfirmationVisible) return;
+        setExpanded(false);
+    };
+
     public static boolean isRunning() {
         return RUNNING.get();
     }
@@ -271,6 +285,13 @@ public static void stop(Context context) {
         context.stopService(new Intent(context, TaskPetOverlayService.class));
     }
 
+    public static void refreshPresentation(Context context) {
+        if (!isRunning()) return;
+        context.startService(
+            new Intent(context, TaskPetOverlayService.class).setAction(ACTION_UPDATE)
+        );
+    }
+
     public static void submitNotificationReply(
         Context context,
         String threadId,
@@ -529,6 +550,8 @@ public void onDestroy() {
         persistMonitorDiagnostics(true);
         mainHandler.removeCallbacks(pollRunnable);
         mainHandler.removeCallbacks(eventStreamReconnectRunnable);
+        mainHandler.removeCallbacks(hideReplyPeekRunnable);
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
         stopEventStream();
         releaseTaskWakeLock();
         removeOverlay();
@@ -630,6 +653,10 @@ private boolean shouldShowOverlay() {
             && android.provider.Settings.canDrawOverlays(this);
     }
 
+    private boolean shouldAttachOverlay() {
+        return shouldShowOverlay() && !MainActivity.isAppForeground();
+    }
+
     private int activeTaskCount() {
         int count = 0;
         for (TaskItem task : tasks) {
@@ -694,7 +721,7 @@ private void releaseTaskWakeLock() {
     }
 
     private void syncOverlayVisibility() {
-        if (shouldShowOverlay()) {
+        if (shouldAttachOverlay()) {
             if (overlayRoot == null && windowManager != null) createOverlay();
             return;
         }
@@ -702,6 +729,8 @@ private void syncOverlayVisibility() {
     }
 
     private void removeOverlay() {
+        mainHandler.removeCallbacks(hideReplyPeekRunnable);
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
         if (positionAnimator != null) positionAnimator.cancel();
         positionAnimator = null;
         if (mascot != null) mascot.animate().cancel();
@@ -743,6 +772,7 @@ private void removeOverlay() {
         replySendButton = null;
         windowParams = null;
         expanded = false;
+        replyPeekVisible = false;
         closeConfirmationVisible = false;
         lastPetMode = "";
         lastRenderedTaskSignature = "";
@@ -782,19 +812,7 @@ private void createOverlay() {
         taskPanel.addView(panelHeader, new LinearLayout.LayoutParams(dp(PANEL_CONTENT_WIDTH_DP), dp(48)));
         taskPanel.addView(taskList, listParams);
         recentSection = buildRecentSection();
-        LinearLayout.LayoutParams recentParams = new LinearLayout.LayoutParams(
-            dp(PANEL_CONTENT_WIDTH_DP),
-            LinearLayout.LayoutParams.WRAP_CONTENT
-        );
-        recentParams.topMargin = dp(8);
-        taskPanel.addView(recentSection, recentParams);
         replyComposer = buildReplyComposer();
-        LinearLayout.LayoutParams composerParams = new LinearLayout.LayoutParams(
-            dp(PANEL_CONTENT_WIDTH_DP),
-            LinearLayout.LayoutParams.WRAP_CONTENT
-        );
-        composerParams.topMargin = dp(8);
-        taskPanel.addView(replyComposer, composerParams);
         closeConfirmPanel = buildCloseConfirmPanel();
         LinearLayout.LayoutParams closeConfirmParams = new LinearLayout.LayoutParams(
             dp(PANEL_CONTENT_WIDTH_DP),
@@ -806,7 +824,7 @@ private void createOverlay() {
 
         compactPreview = buildCompactPreview();
         LinearLayout.LayoutParams compactPreviewParams = new LinearLayout.LayoutParams(
-            dp(PANEL_WIDTH_DP),
+            dp(COMPACT_PREVIEW_WIDTH_DP),
             dp(COMPACT_PREVIEW_HEIGHT_DP)
         );
         compactPreviewParams.bottomMargin = dp(COMPACT_PREVIEW_GAP_DP);
@@ -824,10 +842,11 @@ private void createOverlay() {
         overlayRoot.addView(miniMascot, miniParams);
         attachDragAndClick(miniMascot, () -> {
             setMinimized(false);
-            if (tasks.isEmpty()) setExpanded(true);
+            setExpanded(true);
         });
 
         minimized = true;
+        replyPeekVisible = false;
         mascot.setVisibility(minimized ? View.GONE : View.VISIBLE);
         miniMascot.setVisibility(minimized ? View.VISIBLE : View.GONE);
 
@@ -851,13 +870,14 @@ private void createOverlay() {
         windowParams.x = initialX;
         windowParams.y = initialY;
         windowManager.addView(overlayRoot, windowParams);
+        overlayRoot.post(this::snapPetToNearestEdge);
     }
 
     private LinearLayout buildCompactPreview() {
         LinearLayout preview = new LinearLayout(this);
         preview.setOrientation(LinearLayout.VERTICAL);
         preview.setGravity(Gravity.CENTER_VERTICAL);
-        preview.setPadding(dp(12), dp(8), dp(12), dp(8));
+        preview.setPadding(dp(11), dp(6), dp(11), dp(6));
         preview.setBackground(touchBackground(Color.rgb(253, 253, 254), 15, Color.argb(28, 42, 114, 232)));
         preview.setElevation(dp(7));
         preview.setVisibility(View.GONE);
@@ -867,23 +887,23 @@ private LinearLayout buildCompactPreview() {
         compactPreviewContext.setEllipsize(android.text.TextUtils.TruncateAt.END);
         preview.addView(compactPreviewContext, new LinearLayout.LayoutParams(
             LinearLayout.LayoutParams.MATCH_PARENT,
-            dp(18)
+            dp(14)
         ));
 
         compactPreviewReply = text("", 13, Color.rgb(30, 36, 48), Typeface.BOLD);
-        compactPreviewReply.setMaxLines(2);
+        compactPreviewReply.setMaxLines(1);
         compactPreviewReply.setEllipsize(android.text.TextUtils.TruncateAt.END);
         compactPreviewReply.setGravity(Gravity.CENTER_VERTICAL);
         preview.addView(compactPreviewReply, new LinearLayout.LayoutParams(
             LinearLayout.LayoutParams.MATCH_PARENT,
-            dp(38)
+            dp(24)
         ));
 
         compactPreviewFreshness = text("", 9, Color.rgb(42, 103, 190), Typeface.NORMAL);
         compactPreviewFreshness.setSingleLine(true);
         preview.addView(compactPreviewFreshness, new LinearLayout.LayoutParams(
             LinearLayout.LayoutParams.MATCH_PARENT,
-            dp(14)
+            dp(12)
         ));
         return preview;
     }
@@ -1033,23 +1053,18 @@ private FrameLayout buildMascot() {
         petImage = new ImageView(this);
         petImage.setImageResource(R.drawable.cx_pet_idle);
         petImage.setScaleType(ImageView.ScaleType.FIT_CENTER);
-        FrameLayout.LayoutParams imageParams = new FrameLayout.LayoutParams(dp(70), dp(73), Gravity.TOP | Gravity.CENTER_HORIZONTAL);
+        FrameLayout.LayoutParams imageParams = new FrameLayout.LayoutParams(dp(56), dp(60), Gravity.TOP | Gravity.CENTER_HORIZONTAL);
         root.addView(petImage, imageParams);
 
         petStatus = text("待命", 10, Color.rgb(53, 62, 78), Typeface.BOLD);
-        petStatus.setGravity(Gravity.CENTER);
-        petStatus.setBackground(rounded(Color.argb(238, 255, 255, 255), 999));
-        FrameLayout.LayoutParams statusParams = new FrameLayout.LayoutParams(dp(44), dp(20), Gravity.BOTTOM | Gravity.START);
-        statusParams.leftMargin = dp(1);
-        root.addView(petStatus, statusParams);
+        petStatus.setVisibility(View.GONE);
 
         badge = text("", 11, Color.WHITE, Typeface.BOLD);
         badge.setGravity(Gravity.CENTER);
         badge.setBackground(rounded(Color.rgb(42, 114, 232), 999));
         badge.setElevation(dp(4));
-        FrameLayout.LayoutParams badgeParams = new FrameLayout.LayoutParams(dp(24), dp(24), Gravity.TOP | Gravity.END);
-        badgeParams.topMargin = dp(3);
-        badgeParams.rightMargin = dp(1);
+        FrameLayout.LayoutParams badgeParams = new FrameLayout.LayoutParams(dp(20), dp(20), Gravity.TOP | Gravity.END);
+        badgeParams.topMargin = dp(1);
         root.addView(badge, badgeParams);
         return root;
     }
@@ -1081,12 +1096,19 @@ private void renderTasks() {
         int activeCount = 0;
         int completedCount = 0;
         int retryCount = 0;
+        int attentionCount = 0;
         boolean waiting = false;
         for (TaskItem task : tasks) {
             if (TaskPetRuntimePolicy.isActiveTaskState(task.state)) activeCount += 1;
             if ("completed".equals(task.state)) completedCount += 1;
             if ("retry".equals(task.state)) retryCount += 1;
             if ("waiting".equals(task.state)) waiting = true;
+            if (TaskPetRuntimePolicy.shouldCountAttention(
+                task.state,
+                task.readAcknowledged,
+                task.latestReplyEventSeq,
+                task.readThroughReplyEventSeq
+            )) attentionCount += 1;
         }
         String foregroundTaskSignature = foregroundTaskSignature(activeCount);
         if (
@@ -1099,21 +1121,20 @@ private void renderTasks() {
         }
         if (
             taskList == null || badge == null || miniBadge == null || petImage == null
-                || miniPetImage == null || petStatus == null || recentList == null
+                || miniPetImage == null || petStatus == null
         ) return;
         if (tasks.isEmpty() && !expanded && !minimized) {
+            hideTransientReplyPeek(false);
             setMinimized(true);
-        } else if (!tasks.isEmpty() && minimized) {
-            setMinimized(false);
         }
-        badge.setVisibility(tasks.isEmpty() ? View.GONE : View.VISIBLE);
-        badge.setText(tasks.size() > 99 ? "99+" : String.valueOf(tasks.size()));
+        badge.setVisibility(attentionCount == 0 ? View.GONE : View.VISIBLE);
+        badge.setText(attentionCount > 99 ? "99+" : String.valueOf(attentionCount));
         int badgeColor = retryCount > 0
             ? Color.rgb(196, 73, 65)
             : waiting ? Color.rgb(214, 126, 28) : Color.rgb(42, 114, 232);
         badge.setBackground(rounded(badgeColor, 999));
-        miniBadge.setVisibility(tasks.isEmpty() ? View.GONE : View.VISIBLE);
-        miniBadge.setText(tasks.size() > 9 ? "9+" : String.valueOf(tasks.size()));
+        miniBadge.setVisibility(attentionCount == 0 ? View.GONE : View.VISIBLE);
+        miniBadge.setText(attentionCount > 9 ? "9+" : String.valueOf(attentionCount));
         miniBadge.setBackground(rounded(badgeColor, 999));
         String petMode = waiting || retryCount > 0
             ? "waiting"
@@ -1123,13 +1144,15 @@ private void renderTasks() {
             : waiting ? "待处理" : activeCount > 0 ? "工作中" : completedCount > 0 ? "已完成" : "待命";
         updatePetImage(petMode);
         petStatus.setText(stateLabel);
-        String countLabel = tasks.isEmpty() ? "没有任务" : tasks.size() + " 个任务";
+        String countLabel = tasks.isEmpty()
+            ? "没有任务"
+            : tasks.size() + " 个任务，" + attentionCount + " 条待处理";
         mascot.setContentDescription("CX-Codex 任务宠物，" + stateLabel + "，" + countLabel + "，点击查看任务进展");
         miniMascot.setContentDescription("已最小化的 CX-Codex 任务宠物，" + stateLabel + "，" + countLabel + "，点击恢复");
         if (panelSummary != null) {
             panelSummary.setText(
                 activeCount > 0
-                    ? activeCount + " 个任务 · 最新回复实时更新" + (retryCount > 0 ? " · " + retryCount + " 条待重试" : "")
+                    ? activeCount + " 个任务" + (attentionCount > 0 ? " · " + attentionCount + " 条待处理" : "")
                     : retryCount > 0
                         ? retryCount + " 条回复待重试"
                     : completedCount > 0
@@ -1209,10 +1232,95 @@ private boolean shouldShowCompactPreview() {
         return compactPreview != null
             && !expanded
             && !minimized
+            && replyPeekVisible
             && !tasks.isEmpty()
             && (taskPanel == null || taskPanel.getVisibility() != View.VISIBLE);
     }
 
+    private void showTransientReplyPeek(TaskItem task, boolean replyItemChanged) {
+        if (overlayRoot == null || windowParams == null || !shouldAttachOverlay()) return;
+        PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
+        KeyguardManager keyguardManager = (KeyguardManager) getSystemService(KEYGUARD_SERVICE);
+        boolean screenInteractive = powerManager != null && powerManager.isInteractive();
+        boolean deviceLocked = keyguardManager != null && keyguardManager.isKeyguardLocked();
+        if (!TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            MainActivity.isAppForeground(),
+            screenInteractive,
+            deviceLocked,
+            replyItemChanged,
+            task.latestReplyEventSeq,
+            task.readThroughReplyEventSeq
+        )) return;
+        if (expanded) {
+            scheduleTaskStackCollapse();
+            return;
+        }
+        if (minimized) setMinimized(false);
+        setReplyPeekVisible(true);
+        mainHandler.removeCallbacks(hideReplyPeekRunnable);
+        mainHandler.postDelayed(
+            hideReplyPeekRunnable,
+            recommendedTimeoutMs(
+                REPLY_PEEK_TIMEOUT_MS,
+                AccessibilityManager.FLAG_CONTENT_TEXT | AccessibilityManager.FLAG_CONTENT_CONTROLS
+            )
+        );
+    }
+
+    private void hideTransientReplyPeek(boolean tuckAfterHide) {
+        mainHandler.removeCallbacks(hideReplyPeekRunnable);
+        if (!replyPeekVisible) return;
+        setReplyPeekVisible(false);
+        if (tuckAfterHide && !expanded) snapPetToNearestEdge();
+    }
+
+    private void setReplyPeekVisible(boolean visible) {
+        if (replyPeekVisible == visible) {
+            syncCompactPreviewVisibility();
+            return;
+        }
+        int petX = windowParams == null
+            ? 0
+            : windowParams.x + collapsedMascotOffsetX(minimized);
+        int petY = windowParams == null
+            ? 0
+            : windowParams.y + collapsedCompactOffsetY(minimized);
+        replyPeekVisible = visible;
+        syncCompactPreviewVisibility();
+        if (windowParams == null || windowManager == null || overlayRoot == null || expanded) return;
+        windowParams.x = petX - collapsedMascotOffsetX(minimized);
+        windowParams.y = Math.max(0, petY - collapsedCompactOffsetY(minimized));
+        if (visible) {
+            int rootWidth = dp(collapsedRootWidthDp(minimized));
+            int margin = dp(8);
+            int maxX = Math.max(margin, getResources().getDisplayMetrics().widthPixels - rootWidth - margin);
+            windowParams.x = anchoredRight ? maxX : margin;
+        }
+        windowManager.updateViewLayout(overlayRoot, windowParams);
+    }
+
+    private void scheduleTaskStackCollapse() {
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
+        if (!expanded) return;
+        mainHandler.postDelayed(
+            collapseTaskStackRunnable,
+            recommendedTimeoutMs(
+                TASK_STACK_TIMEOUT_MS,
+                AccessibilityManager.FLAG_CONTENT_TEXT | AccessibilityManager.FLAG_CONTENT_CONTROLS
+            )
+        );
+    }
+
+    private long recommendedTimeoutMs(long originalTimeoutMs, int contentFlags) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return originalTimeoutMs;
+        AccessibilityManager manager = (AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE);
+        if (manager == null) return originalTimeoutMs;
+        return Math.max(
+            originalTimeoutMs,
+            manager.getRecommendedTimeoutMillis((int) originalTimeoutMs, contentFlags)
+        );
+    }
+
     private void updatePetImage(String mode) {
         if (mode.equals(lastPetMode)) return;
         lastPetMode = mode;
@@ -1303,10 +1411,8 @@ private void stopPetAnimation(@Nullable ImageView target) {
 
     private String renderTaskList() {
         taskList.removeAllViews();
-        renderRecentThreads();
         String renderedReplyTaskKey = "";
         int maxVisibleRows = getResources().getDisplayMetrics().heightPixels < dp(700) ? 2 : 3;
-        if (!replyThreadId.isEmpty()) maxVisibleRows = 1;
         int visibleCount = Math.min(tasks.size(), maxVisibleRows);
         if (visibleCount == 0) {
             TextView empty = text("没有正在运行的任务", 13, Color.rgb(87, 98, 117), Typeface.NORMAL);
@@ -1428,7 +1534,7 @@ private View buildTaskRow(TaskItem task) {
         LinearLayout row = new LinearLayout(this);
         row.setOrientation(LinearLayout.HORIZONTAL);
         row.setGravity(Gravity.CENTER_VERTICAL);
-        row.setPadding(dp(10), dp(7), dp(9), dp(7));
+        row.setPadding(dp(9), dp(5), dp(8), dp(5));
         row.setBackground(touchBackground(Color.rgb(242, 245, 249), 11, Color.argb(28, 42, 114, 232)));
         row.setClickable(canOpenThread);
         row.setFocusable(canOpenThread);
@@ -1464,7 +1570,7 @@ private View buildTaskRow(TaskItem task) {
         contextView.setSingleLine(true);
         contextView.setEllipsize(android.text.TextUtils.TruncateAt.END);
         TextView replyView = text(replyPreview, 12, Color.rgb(30, 36, 48), Typeface.NORMAL);
-        replyView.setMaxLines(2);
+        replyView.setMaxLines(1);
         replyView.setEllipsize(android.text.TextUtils.TruncateAt.END);
         replyView.setGravity(Gravity.CENTER_VERTICAL);
         TextView freshness = text(
@@ -1476,23 +1582,10 @@ private View buildTaskRow(TaskItem task) {
             Typeface.NORMAL
         );
         freshness.setSingleLine(true);
-        copy.addView(contextView, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(18)));
-        copy.addView(replyView, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(38)));
-        copy.addView(freshness, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(16)));
-        row.addView(copy, new LinearLayout.LayoutParams(0, dp(72), 1f));
-
-        TextView reply = text("回复", 11, Color.rgb(42, 103, 190), Typeface.BOLD);
-        reply.setGravity(Gravity.CENTER);
-        reply.setClickable(true);
-        reply.setFocusable(true);
-        reply.setContentDescription("直接回复" + task.title);
-        reply.setBackground(touchBackground(Color.WHITE, 999, Color.argb(30, 42, 114, 232)));
-        reply.setOnClickListener(view -> {
-            view.performHapticFeedback(android.view.HapticFeedbackConstants.KEYBOARD_TAP);
-            showReplyComposer(task);
-        });
-        reply.setVisibility(canOpenThread ? View.VISIBLE : View.GONE);
-        row.addView(reply, new LinearLayout.LayoutParams(dp(44), dp(38)));
+        copy.addView(contextView, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(15)));
+        copy.addView(replyView, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(24)));
+        copy.addView(freshness, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, dp(13)));
+        row.addView(copy, new LinearLayout.LayoutParams(0, dp(52), 1f));
         return row;
     }
 
@@ -1729,6 +1822,8 @@ private boolean applySuccessfulReply(
                 nextRuntimeState,
                 0L,
                 0L,
+                "",
+                0L,
                 System.currentTimeMillis(),
                 0L,
                 !awaitingConfirmation,
@@ -1748,6 +1843,9 @@ private boolean applySuccessfulReply(
             task.latestActivity = clean(message, 80);
             task.latestReply = "";
             task.latestReplyEventSeq = 0L;
+            task.latestReplyItemId = "";
+            task.readThroughReplyEventSeq = 0L;
+            task.latestReplyUpdatedAtMs = 0L;
             task.lastUpdatedAtMs = System.currentTimeMillis();
             task.lastNoProgressReminderAtMs = 0L;
             task.requestAccepted = !awaitingConfirmation;
@@ -1794,6 +1892,8 @@ private void handleNotificationReply(Intent intent) {
                 "pending_start",
                 0L,
                 0L,
+                "",
+                0L,
                 now,
                 0L,
                 false,
@@ -1812,6 +1912,9 @@ private void handleNotificationReply(Intent intent) {
             task.latestActivity = clean(message, 80);
             task.latestReply = "";
             task.latestReplyEventSeq = 0L;
+            task.latestReplyItemId = "";
+            task.readThroughReplyEventSeq = 0L;
+            task.latestReplyUpdatedAtMs = 0L;
             task.lastUpdatedAtMs = now;
             task.lastNoProgressReminderAtMs = 0L;
             task.requestAccepted = false;
@@ -2034,6 +2137,8 @@ private void ensurePersistedReplyAttemptTask() {
                 awaitingConfirmation ? "pending_start" : "retry",
                 0L,
                 0L,
+                "",
+                0L,
                 now,
                 0L,
                 false,
@@ -2054,6 +2159,9 @@ private void ensurePersistedReplyAttemptTask() {
             task.latestReply = "";
             task.lastEventSeq = 0L;
             task.latestReplyEventSeq = 0L;
+            task.latestReplyItemId = "";
+            task.readThroughReplyEventSeq = 0L;
+            task.latestReplyUpdatedAtMs = 0L;
             task.lastUpdatedAtMs = now;
             task.lastNoProgressReminderAtMs = 0L;
             task.requestAccepted = false;
@@ -2087,20 +2195,26 @@ private String taskListSignature() {
     }
 
     private int freshnessBucket(TaskItem task) {
-        long ageMs = Math.max(0L, System.currentTimeMillis() - task.lastUpdatedAtMs);
+        long ageMs = Math.max(0L, System.currentTimeMillis() - freshnessTimestampMs(task));
         if (ageMs < 15_000L) return 0;
         if (ageMs < 60_000L) return 1;
         return 2 + (int) Math.min(59L, ageMs / 60_000L);
     }
 
     private String freshnessText(TaskItem task) {
-        long ageMs = Math.max(0L, System.currentTimeMillis() - task.lastUpdatedAtMs);
+        long ageMs = Math.max(0L, System.currentTimeMillis() - freshnessTimestampMs(task));
         if (ageMs < 15_000L) return "刚刚";
         if (ageMs < 60_000L) return "1 分钟内";
         long minutes = Math.max(1L, ageMs / 60_000L);
         return Math.min(59L, minutes) + " 分钟前";
     }
 
+    private long freshnessTimestampMs(TaskItem task) {
+        return !task.latestReply.isEmpty() && task.latestReplyUpdatedAtMs > 0L
+            ? task.latestReplyUpdatedAtMs
+            : task.lastUpdatedAtMs;
+    }
+
     private boolean isNoProgress(TaskItem task) {
         return TaskPetRuntimePolicy.shouldNotifyNoProgress(
             task.state,
@@ -2205,14 +2319,22 @@ public boolean onTouch(View view, MotionEvent event) {
     private void snapPetToNearestEdge() {
         int screenWidth = getResources().getDisplayMetrics().widthPixels;
         int screenHeight = getResources().getDisplayMetrics().heightPixels;
-        int margin = dp(8);
-        int maxX = Math.max(margin, screenWidth - overlayRoot.getWidth() - margin);
-        int maxY = Math.max(margin, screenHeight - overlayRoot.getHeight() - margin);
-        int centerX = windowParams.x + overlayRoot.getWidth() / 2;
+        boolean tuckAtEdge = !expanded && !replyPeekVisible;
+        int margin = tuckAtEdge ? 0 : dp(8);
+        int verticalMargin = dp(8);
+        int visibleHandle = dp(EDGE_VISIBLE_HANDLE_DP);
+        int rootWidth = expanded
+            ? Math.max(dp(PANEL_WIDTH_DP + ROOT_PADDING_DP * 2), overlayRoot.getWidth())
+            : dp(collapsedRootWidthDp(minimized));
+        int maxX = Math.max(margin, screenWidth - rootWidth - margin);
+        int maxY = Math.max(verticalMargin, screenHeight - overlayRoot.getHeight() - verticalMargin);
+        int centerX = windowParams.x + rootWidth / 2;
         anchoredRight = centerX >= screenWidth / 2;
         updateMascotGravity();
-        int targetX = anchoredRight ? maxX : margin;
-        int targetY = Math.max(margin, Math.min(maxY, windowParams.y));
+        int targetX = tuckAtEdge
+            ? anchoredRight ? screenWidth - visibleHandle : -(rootWidth - visibleHandle)
+            : anchoredRight ? maxX : margin;
+        int targetY = Math.max(verticalMargin, Math.min(maxY, windowParams.y));
         animateWindowTo(targetX, targetY);
     }
 
@@ -2266,6 +2388,7 @@ private void scheduleDragLayoutUpdate() {
 
     private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
         List<TaskItem> next = new ArrayList<>();
+        TaskItem frontendPeekCandidate = null;
         long now = System.currentTimeMillis();
         try {
             JSONArray rows = new JSONArray(tasksJson);
@@ -2320,6 +2443,26 @@ private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
                 long resolvedLatestReplyEventSeq = preserveKnownLatestReply
                     ? previous.latestReplyEventSeq
                     : incomingLatestReplyEventSeq;
+                String incomingLatestReplyItemId = clean(row.optString("latestReplyItemId"), 160);
+                String resolvedLatestReplyItemId = preserveKnownLatestReply && previous != null
+                    ? previous.latestReplyItemId
+                    : incomingLatestReplyItemId.isEmpty() && previous != null && sameGeneration
+                        ? previous.latestReplyItemId
+                        : incomingLatestReplyItemId;
+                boolean resolvedReadAcknowledged = previous != null && sameGeneration
+                    ? previous.readAcknowledged
+                    : !frontendSnapshot && row.optBoolean("readAcknowledged", false);
+                long resolvedReadThroughReplyEventSeq = previous != null && sameGeneration
+                    ? previous.readThroughReplyEventSeq
+                    : !frontendSnapshot
+                        ? row.has("readThroughReplyEventSeq")
+                            ? Math.max(0L, row.optLong("readThroughReplyEventSeq", 0L))
+                            : resolvedReadAcknowledged ? resolvedLatestReplyEventSeq : 0L
+                        : 0L;
+                if (TaskPetRuntimePolicy.hasUnreadReply(
+                    resolvedLatestReplyEventSeq,
+                    resolvedReadThroughReplyEventSeq
+                )) resolvedReadAcknowledged = false;
                 TaskItem incoming = new TaskItem(
                     resolvedThreadId,
                     resolvedClientMessageId,
@@ -2341,6 +2484,8 @@ private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
                     ),
                     incomingLastEventSeq,
                     resolvedLatestReplyEventSeq,
+                    resolvedLatestReplyItemId,
+                    resolvedReadThroughReplyEventSeq,
                     row.optLong("lastUpdatedAtMs", now),
                     row.optLong(
                         "lastNoProgressReminderAtMs",
@@ -2349,12 +2494,19 @@ private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
                     row.has("requestAccepted")
                         ? row.optBoolean("requestAccepted", false)
                         : previous != null && sameGeneration && previous.requestAccepted,
-                    previous != null && sameGeneration
-                        ? previous.readAcknowledged
-                        : !frontendSnapshot && row.optBoolean("readAcknowledged", false),
+                    resolvedReadAcknowledged,
                     frontendSnapshot ? false : row.optBoolean("omittedFromFrontend", false),
                     frontendSnapshot ? 0 : row.optInt("missingRequestPollCount", 0)
                 );
+                long incomingReplyObservedAtMs = row.has("latestReplyUpdatedAtMs")
+                    ? Math.max(0L, row.optLong("latestReplyUpdatedAtMs", 0L))
+                    : Math.max(0L, row.optLong("lastUpdatedAtMs", now));
+                incoming.latestReplyUpdatedAtMs = TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+                    previous != null && sameGeneration ? previous.latestReplyEventSeq : 0L,
+                    incoming.latestReplyEventSeq,
+                    previous != null && sameGeneration ? previous.latestReplyUpdatedAtMs : 0L,
+                    incomingReplyObservedAtMs
+                );
                 if (
                     previous != null
                     && !sameGeneration
@@ -2396,6 +2548,20 @@ private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
                 if (previous != null && sameGeneration && incoming.hasSameVisibleContent(previous)) {
                     incoming.lastUpdatedAtMs = previous.lastUpdatedAtMs;
                 }
+                if (
+                    frontendSnapshot
+                    && previous != null
+                    && sameGeneration
+                    && !TaskPetRuntimePolicy.hasUnreadReply(
+                        previous.latestReplyEventSeq,
+                        previous.readThroughReplyEventSeq
+                    )
+                    && TaskPetRuntimePolicy.hasUnreadReply(
+                        incoming.latestReplyEventSeq,
+                        incoming.readThroughReplyEventSeq
+                    )
+                    && !incoming.latestReply.isEmpty()
+                ) frontendPeekCandidate = incoming;
                 next.add(incoming);
             }
         } catch (Exception ignored) {
@@ -2429,6 +2595,9 @@ private void replaceTasks(String tasksJson, boolean frontendSnapshot) {
         tasks.addAll(next);
         reconcileNoProgressNotifications();
         persistTasks();
+        if (frontendPeekCandidate != null) {
+            showTransientReplyPeek(frontendPeekCandidate, true);
+        }
     }
 
     private void replaceRecentThreads(String recentThreadsJson) {
@@ -2488,6 +2657,9 @@ private void persistTasks(boolean synchronous) {
                     .put("executionState", task.runtimeState)
                     .put("lastEventSeq", task.lastEventSeq)
                     .put("latestReplyEventSeq", task.latestReplyEventSeq)
+                    .put("latestReplyItemId", task.latestReplyItemId)
+                    .put("readThroughReplyEventSeq", task.readThroughReplyEventSeq)
+                    .put("latestReplyUpdatedAtMs", task.latestReplyUpdatedAtMs)
                     .put("lastUpdatedAtMs", task.lastUpdatedAtMs)
                     .put("lastNoProgressReminderAtMs", task.lastNoProgressReminderAtMs)
                     .put("requestAccepted", task.requestAccepted)
@@ -2853,6 +3025,7 @@ private List<RuntimeResult> readRuntimeResults(List<TaskItem> active) {
                         false,
                         0L,
                         0L,
+                        "",
                         ""
                     ));
                     continue;
@@ -2889,6 +3062,7 @@ private List<RuntimeResult> readRuntimeResults(List<TaskItem> active) {
                         false,
                         0L,
                         0L,
+                        "",
                         ""
                     ));
                     continue;
@@ -2921,6 +3095,7 @@ private List<RuntimeResult> readRuntimeResults(List<TaskItem> active) {
                 false,
                 0L,
                 0L,
+                "",
                 ""
             ));
         }
@@ -2967,6 +3142,7 @@ private List<RuntimeResult> readRuntimeResults(List<TaskItem> active) {
                 long latestReplyEventSeq = snapshot.has("latestReplyEventSeq")
                     ? Math.max(0L, snapshot.optLong("latestReplyEventSeq", 0L))
                     : latestReply.isEmpty() ? 0L : lastEventSeq;
+                String latestReplyItemId = clean(snapshot.optString("latestReplyItemId"), 160);
                 results.add(new RuntimeResult(
                     threadId,
                     clientMessageId,
@@ -2978,6 +3154,7 @@ private List<RuntimeResult> readRuntimeResults(List<TaskItem> active) {
                     snapshot.optBoolean("stale", false),
                     lastEventSeq,
                     latestReplyEventSeq,
+                    latestReplyItemId,
                     latestReply
                 ));
             }
@@ -3028,6 +3205,8 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
         boolean replyDiagnosticsChanged = false;
         TaskItem latestReplyCandidate = null;
         long latestReplyCandidateEventSeq = 0L;
+        TaskItem latestReplyPeekCandidate = null;
+        long latestReplyPeekCandidateEventSeq = 0L;
         for (RuntimeResult result : results) {
             TaskItem requestedGeneration = null;
             for (TaskItem requested : requestedTasks) {
@@ -3058,6 +3237,7 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
                 String previousRuntimeState = task.runtimeState;
                 String previousDetail = task.detail;
                 String previousReply = task.latestReply;
+                String previousReplyItemId = task.latestReplyItemId;
                 boolean replyDeliveryAttempt = TaskPetRuntimePolicy.shouldReconcileReplyAttempt(
                     replyAttemptClientMessageId,
                     replyAttemptThreadId,
@@ -3132,9 +3312,26 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
                     || result.latestReplyEventSeq > task.latestReplyEventSeq
                 );
                 if (canApplyReply) {
+                    long previousReplyEventSeq = task.latestReplyEventSeq;
                     boolean replyChanged = !result.latestReply.equals(task.latestReply);
+                    boolean replyItemChanged = !result.latestReplyItemId.isEmpty()
+                        ? !result.latestReplyItemId.equals(previousReplyItemId)
+                        : previousReply.isEmpty() && replyChanged;
                     task.latestReply = result.latestReply;
                     task.latestReplyEventSeq = Math.max(0L, result.latestReplyEventSeq);
+                    task.latestReplyUpdatedAtMs = TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+                        previousReplyEventSeq,
+                        task.latestReplyEventSeq,
+                        task.latestReplyUpdatedAtMs,
+                        System.currentTimeMillis()
+                    );
+                    if (!result.latestReplyItemId.isEmpty()) {
+                        task.latestReplyItemId = result.latestReplyItemId;
+                    }
+                    if (TaskPetRuntimePolicy.hasUnreadReply(
+                        task.latestReplyEventSeq,
+                        task.readThroughReplyEventSeq
+                    )) task.readAcknowledged = false;
                     if (replyChanged) {
                         replySnapshotApplyCount += 1L;
                         replyDiagnosticsChanged = true;
@@ -3146,6 +3343,16 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
                             latestReplyCandidateEventSeq = result.latestReplyEventSeq;
                         }
                     }
+                    if (
+                        replyItemChanged
+                        && TaskPetRuntimePolicy.shouldPreferReplyCandidate(
+                            latestReplyPeekCandidateEventSeq,
+                            result.latestReplyEventSeq
+                        )
+                    ) {
+                        latestReplyPeekCandidate = task;
+                        latestReplyPeekCandidateEventSeq = result.latestReplyEventSeq;
+                    }
                 }
                 if (
                     result.stale
@@ -3156,7 +3363,9 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
                 } else if (!result.inProgress) {
                     boolean wasCompleted = "completed".equals(task.state);
                     boolean retainUnreadCompletion = TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(
-                        task.readAcknowledged
+                        task.readAcknowledged,
+                        task.latestReplyEventSeq,
+                        task.readThroughReplyEventSeq
                     );
                     task.state = "completed";
                     task.activeTurnId = "";
@@ -3247,6 +3456,9 @@ private void applyRuntimeResults(List<TaskItem> requestedTasks, List<RuntimeResu
             tasks.remove(latestReplyCandidate);
             tasks.add(0, latestReplyCandidate);
         }
+        if (latestReplyPeekCandidate != null) {
+            showTransientReplyPeek(latestReplyPeekCandidate, true);
+        }
         reconcileNoProgressNotifications();
         persistTasks();
         if (replyDiagnosticsChanged) persistMonitorDiagnostics(true);
@@ -3266,6 +3478,9 @@ private void markReplyForManualRetry(TaskItem task) {
         task.detail = "回复未送达 · 点击回复重试";
         task.latestReply = "";
         task.latestReplyEventSeq = 0L;
+        task.latestReplyItemId = "";
+        task.readThroughReplyEventSeq = 0L;
+        task.latestReplyUpdatedAtMs = 0L;
         task.missingRequestPollCount = 0;
         task.lastNoProgressReminderAtMs = 0L;
         task.omittedFromFrontend = true;
@@ -3374,6 +3589,7 @@ private void openThread(String threadId) {
 
     private void showCloseConfirmation() {
         if (closeConfirmPanel == null || closeConfirmationVisible || sendingReply) return;
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
         if (replyComposer != null && replyComposer.getVisibility() == View.VISIBLE) hideReplyComposer();
         int petY = windowParams.y + taskPanel.getHeight();
         closeConfirmationVisible = true;
@@ -3393,6 +3609,7 @@ private void hideCloseConfirmation() {
         taskList.setVisibility(View.VISIBLE);
         renderRecentThreads();
         relayoutExpandedPanel(petY);
+        scheduleTaskStackCollapse();
     }
 
     private void closeTaskPet() {
@@ -3417,9 +3634,17 @@ private void clearCompletedThread(@Nullable String threadId) {
         String notificationKey = taskNotificationKey(task);
         if (TaskPetRuntimePolicy.isActiveTaskState(task.state)) {
             task.readAcknowledged = true;
+            task.readThroughReplyEventSeq = Math.max(
+                task.readThroughReplyEventSeq,
+                task.latestReplyEventSeq
+            );
+            if (!tasks.isEmpty() && sameTaskIdentity(tasks.get(0), task)) {
+                hideTransientReplyPeek(true);
+            }
             persistTasksSynchronously();
             NotificationManagerCompat.from(this).cancel(completionNotificationId(notificationKey));
             TaskPetNoProgressReviewReceiver.cancelNotification(this, notificationKey);
+            renderTasks();
             return;
         }
         if (!"completed".equals(task.state)) return;
@@ -3430,6 +3655,7 @@ private void clearCompletedThread(@Nullable String threadId) {
         NotificationManagerCompat.from(this).cancel(completionNotificationId(notificationKey));
         TaskPetNoProgressReviewReceiver.cancelNotification(this, notificationKey);
         syncTaskWakeLock();
+        renderTasks();
         if (!shouldKeepMonitorRunning()) stopSelf();
     }
 
@@ -3444,16 +3670,16 @@ private int expandedAnchorOffset() {
 
     private int collapsedContentWidthDp(boolean minimizedState) {
         if (minimizedState) return MINI_SIZE_DP;
-        return tasks.isEmpty() ? MASCOT_WIDTH_DP : PANEL_WIDTH_DP;
+        return replyPeekVisible ? COMPACT_PREVIEW_WIDTH_DP : MASCOT_WIDTH_DP;
     }
 
     private int collapsedMascotOffsetX(boolean minimizedState) {
-        if (minimizedState || tasks.isEmpty() || !anchoredRight) return 0;
-        return dp(PANEL_WIDTH_DP - MASCOT_WIDTH_DP);
+        if (minimizedState || !replyPeekVisible || !anchoredRight) return 0;
+        return dp(COMPACT_PREVIEW_WIDTH_DP - MASCOT_WIDTH_DP);
     }
 
     private int collapsedCompactOffsetY(boolean minimizedState) {
-        if (minimizedState || tasks.isEmpty()) return 0;
+        if (minimizedState || !replyPeekVisible) return 0;
         return dp(COMPACT_PREVIEW_HEIGHT_DP + COMPACT_PREVIEW_GAP_DP);
     }
 
@@ -3525,6 +3751,7 @@ private void setMinimized(boolean nextMinimized) {
             .setInterpolator(EASE_OUT)
             .start();
         persistPetPosition();
+        if (minimized) overlayRoot.post(this::snapPetToNearestEdge);
     }
 
     private void setExpanded(boolean nextExpanded) {
@@ -3538,6 +3765,7 @@ private void setExpanded(boolean nextExpanded) {
             hideReplyComposer();
         }
         if (!nextExpanded && closeConfirmationVisible) hideCloseConfirmation();
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
         int animationToken = ++panelAnimationToken;
         taskPanel.animate().cancel();
         if (nextExpanded) {
@@ -3547,6 +3775,8 @@ private void setExpanded(boolean nextExpanded) {
             int petY = pendingCollapsedPetY >= 0
                 ? pendingCollapsedPetY
                 : windowParams.y + collapsedCompactOffsetY(minimized);
+            mainHandler.removeCallbacks(hideReplyPeekRunnable);
+            replyPeekVisible = false;
             pendingCollapsedPetX = -1;
             pendingCollapsedPetY = -1;
             lastRenderedTaskSignature = "";
@@ -3574,7 +3804,10 @@ private void setExpanded(boolean nextExpanded) {
                 .translationY(0f)
                 .setDuration(190L)
                 .setInterpolator(EASE_OUT)
-                .withEndAction(() -> commitPendingReplyRender(renderedReplyTaskKey))
+                .withEndAction(() -> {
+                    commitPendingReplyRender(renderedReplyTaskKey);
+                    scheduleTaskStackCollapse();
+                })
                 .start();
             return;
         }
@@ -3606,6 +3839,7 @@ private void setExpanded(boolean nextExpanded) {
                 pendingCollapsedPetX = -1;
                 pendingCollapsedPetY = -1;
                 if (tasks.isEmpty()) setMinimized(true);
+                else snapPetToNearestEdge();
             })
             .start();
     }
@@ -3615,6 +3849,9 @@ private void collapsePanelImmediately() {
         if (sendingReply) return;
         if (replyComposer != null && replyComposer.getVisibility() == View.VISIBLE) hideReplyComposer();
         if (closeConfirmationVisible) hideCloseConfirmation();
+        mainHandler.removeCallbacks(collapseTaskStackRunnable);
+        mainHandler.removeCallbacks(hideReplyPeekRunnable);
+        replyPeekVisible = false;
         panelAnimationToken += 1;
         taskPanel.animate().cancel();
         int petX = windowParams.x + (anchoredRight ? expandedAnchorOffset() : 0);
@@ -3631,6 +3868,7 @@ private void collapsePanelImmediately() {
         );
         windowParams.y = Math.max(0, petY - collapsedCompactOffsetY(minimized));
         windowManager.updateViewLayout(overlayRoot, windowParams);
+        overlayRoot.post(this::snapPetToNearestEdge);
     }
 
     private Intent createThreadIntent(String threadId) {
@@ -3718,6 +3956,12 @@ private NotificationCompat.Builder buildCompactTaskNotification(
     }
 
     private void notifyTaskSettled(TaskItem task, boolean failed) {
+        if (MainActivity.isAppForeground()) {
+            lastCompletionNotificationResult = "suppressed_foreground";
+            lastCompletionNotificationBodySource = "none";
+            persistMonitorDiagnostics(true);
+            return;
+        }
         ensureCompletionNotificationChannel();
         String runtimeState = failed ? "failed" : task.runtimeState;
         if (runtimeState.isEmpty() || "running".equals(runtimeState)) runtimeState = "completed";
@@ -4165,6 +4409,9 @@ private static final class TaskItem {
         String runtimeState;
         long lastEventSeq;
         long latestReplyEventSeq;
+        String latestReplyItemId;
+        long readThroughReplyEventSeq;
+        long latestReplyUpdatedAtMs;
         long lastUpdatedAtMs;
         long lastNoProgressReminderAtMs;
         boolean requestAccepted;
@@ -4187,6 +4434,8 @@ private static final class TaskItem {
             String runtimeState,
             long lastEventSeq,
             long latestReplyEventSeq,
+            String latestReplyItemId,
+            long readThroughReplyEventSeq,
             long lastUpdatedAtMs,
             long lastNoProgressReminderAtMs,
             boolean requestAccepted,
@@ -4208,6 +4457,9 @@ private static final class TaskItem {
             this.runtimeState = runtimeState;
             this.lastEventSeq = lastEventSeq;
             this.latestReplyEventSeq = latestReplyEventSeq;
+            this.latestReplyItemId = latestReplyItemId;
+            this.readThroughReplyEventSeq = readThroughReplyEventSeq;
+            this.latestReplyUpdatedAtMs = latestReply.isEmpty() ? 0L : lastUpdatedAtMs;
             this.lastUpdatedAtMs = lastUpdatedAtMs;
             this.lastNoProgressReminderAtMs = lastNoProgressReminderAtMs;
             this.requestAccepted = requestAccepted;
@@ -4217,7 +4469,7 @@ private static final class TaskItem {
         }
 
         TaskItem copy() {
-            return new TaskItem(
+            TaskItem copy = new TaskItem(
                 threadId,
                 clientMessageId,
                 activityId,
@@ -4232,6 +4484,8 @@ TaskItem copy() {
                 runtimeState,
                 lastEventSeq,
                 latestReplyEventSeq,
+                latestReplyItemId,
+                readThroughReplyEventSeq,
                 lastUpdatedAtMs,
                 lastNoProgressReminderAtMs,
                 requestAccepted,
@@ -4239,6 +4493,8 @@ TaskItem copy() {
                 omittedFromFrontend,
                 missingRequestPollCount
             );
+            copy.latestReplyUpdatedAtMs = latestReplyUpdatedAtMs;
+            return copy;
         }
 
         boolean hasSameVisibleContent(TaskItem other) {
@@ -4247,6 +4503,7 @@ boolean hasSameVisibleContent(TaskItem other) {
                 && detail.equals(other.detail)
                 && latestActivity.equals(other.latestActivity)
                 && latestReply.equals(other.latestReply)
+                && latestReplyItemId.equals(other.latestReplyItemId)
                 && state.equals(other.state)
                 && runtimeState.equals(other.runtimeState)
                 && activeTurnId.equals(other.activeTurnId);
@@ -4276,6 +4533,7 @@ private static final class RuntimeResult {
         final boolean stale;
         final long lastEventSeq;
         final long latestReplyEventSeq;
+        final String latestReplyItemId;
         final String latestReply;
 
         RuntimeResult(
@@ -4289,6 +4547,7 @@ private static final class RuntimeResult {
             boolean stale,
             long lastEventSeq,
             long latestReplyEventSeq,
+            String latestReplyItemId,
             String latestReply
         ) {
             this.threadId = threadId;
@@ -4301,6 +4560,7 @@ private static final class RuntimeResult {
             this.stale = stale;
             this.lastEventSeq = lastEventSeq;
             this.latestReplyEventSeq = latestReplyEventSeq;
+            this.latestReplyItemId = latestReplyItemId;
             this.latestReply = latestReply;
         }
     }
diff --git a/android/app/src/main/java/com/cxcodex/bridge/TaskPetRuntimePolicy.java b/android/app/src/main/java/com/cxcodex/bridge/TaskPetRuntimePolicy.java
index f5c249f..f378b6f 100644
--- a/android/app/src/main/java/com/cxcodex/bridge/TaskPetRuntimePolicy.java
+++ b/android/app/src/main/java/com/cxcodex/bridge/TaskPetRuntimePolicy.java
@@ -52,6 +52,56 @@ static boolean shouldRetainUnreadSettledTask(boolean readAcknowledged) {
         return !readAcknowledged;
     }
 
+    static boolean hasUnreadReply(long latestReplyEventSeq, long readThroughReplyEventSeq) {
+        return latestReplyEventSeq > 0L && latestReplyEventSeq > readThroughReplyEventSeq;
+    }
+
+    static long resolveReplyUpdatedAtMs(
+        long currentReplyEventSeq,
+        long incomingReplyEventSeq,
+        long currentReplyUpdatedAtMs,
+        long observedAtMs
+    ) {
+        return incomingReplyEventSeq > 0L && incomingReplyEventSeq > currentReplyEventSeq
+            ? Math.max(0L, observedAtMs)
+            : Math.max(0L, currentReplyUpdatedAtMs);
+    }
+
+    static boolean shouldRetainUnreadSettledTask(
+        boolean readAcknowledged,
+        long latestReplyEventSeq,
+        long readThroughReplyEventSeq
+    ) {
+        return !readAcknowledged || hasUnreadReply(latestReplyEventSeq, readThroughReplyEventSeq);
+    }
+
+    static boolean shouldCountAttention(
+        String state,
+        boolean readAcknowledged,
+        long latestReplyEventSeq,
+        long readThroughReplyEventSeq
+    ) {
+        return "waiting".equals(state)
+            || "retry".equals(state)
+            || hasUnreadReply(latestReplyEventSeq, readThroughReplyEventSeq)
+            || ("completed".equals(state) && !readAcknowledged);
+    }
+
+    static boolean shouldShowTransientReplyPeek(
+        boolean appForeground,
+        boolean screenInteractive,
+        boolean deviceLocked,
+        boolean replyItemChanged,
+        long latestReplyEventSeq,
+        long readThroughReplyEventSeq
+    ) {
+        return !appForeground
+            && screenInteractive
+            && !deviceLocked
+            && replyItemChanged
+            && hasUnreadReply(latestReplyEventSeq, readThroughReplyEventSeq);
+    }
+
     static boolean shouldDropOmittedProvisional(
         boolean omittedFromFrontend,
         boolean hasThreadId,
diff --git a/android/app/src/test/java/com/cxcodex/bridge/TaskPetRuntimePolicyTest.java b/android/app/src/test/java/com/cxcodex/bridge/TaskPetRuntimePolicyTest.java
index 4d03393..444476d 100644
--- a/android/app/src/test/java/com/cxcodex/bridge/TaskPetRuntimePolicyTest.java
+++ b/android/app/src/test/java/com/cxcodex/bridge/TaskPetRuntimePolicyTest.java
@@ -278,6 +278,25 @@ public void promotesTheNewestReplyIntoTheVisibleTaskRows() {
         assertEquals(0, TaskPetRuntimePolicy.compareTaskRecency(100L, 100L));
     }
 
+    @Test
+    public void advancesReplyFreshnessOnlyForANewerReplyEvent() {
+        long previousReplyAtMs = 1_000L;
+        long observedAtMs = 2_000L;
+
+        assertEquals(previousReplyAtMs, TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+            42L, 42L, previousReplyAtMs, observedAtMs
+        ));
+        assertEquals(previousReplyAtMs, TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+            42L, 0L, previousReplyAtMs, observedAtMs
+        ));
+        assertEquals(observedAtMs, TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+            42L, 43L, previousReplyAtMs, observedAtMs
+        ));
+        assertEquals(observedAtMs, TaskPetRuntimePolicy.resolveReplyUpdatedAtMs(
+            0L, 1L, 0L, observedAtMs
+        ));
+    }
+
     @Test
     public void commitsReplyRenderEvidenceOnlyAfterThePanelIsActuallyVisible() {
         assertTrue(TaskPetRuntimePolicy.shouldCommitReplyRender(true, true, 1f, true));
@@ -301,6 +320,38 @@ public void commitsReplyRenderEvidenceWhenTheCompactPreviewIsActuallyVisible() {
     public void retainsAndNotifiesOnlyUnreadSettledTasks() {
         assertTrue(TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(false));
         assertFalse(TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(true));
+
+        assertTrue(TaskPetRuntimePolicy.hasUnreadReply(43L, 42L));
+        assertFalse(TaskPetRuntimePolicy.hasUnreadReply(42L, 42L));
+        assertFalse(TaskPetRuntimePolicy.hasUnreadReply(0L, 0L));
+        assertFalse(TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(true, 42L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(true, 43L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldRetainUnreadSettledTask(false, 0L, 0L));
+    }
+
+    @Test
+    public void separatesExecutionStateFromAttentionAndTransientPresentation() {
+        assertFalse(TaskPetRuntimePolicy.shouldCountAttention("running", true, 42L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldCountAttention("running", false, 43L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldCountAttention("waiting", true, 42L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldCountAttention("retry", true, 42L, 42L));
+        assertTrue(TaskPetRuntimePolicy.shouldCountAttention("completed", false, 42L, 42L));
+
+        assertTrue(TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            false, true, false, true, 43L, 42L
+        ));
+        assertFalse(TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            true, true, false, true, 43L, 42L
+        ));
+        assertFalse(TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            false, false, false, true, 43L, 42L
+        ));
+        assertFalse(TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            false, true, true, true, 43L, 42L
+        ));
+        assertFalse(TaskPetRuntimePolicy.shouldShowTransientReplyPeek(
+            false, true, false, false, 43L, 42L
+        ));
     }
 
     @Test
diff --git a/docs/changelog.zh-CN.md b/docs/changelog.zh-CN.md
index 2633896..9aa1a9c 100644
--- a/docs/changelog.zh-CN.md
+++ b/docs/changelog.zh-CN.md
@@ -2,6 +2,18 @@
 
 ## 未发布
 
+## 2.7.3 - 2026-08-04
+
+- 计划模式改为持续生效，并新增结构化计划卡、一步提交实施和线程级持续目标；目标的暂停、继续、编辑、清除、预算与耗时都以 App Server 状态为准。
+- 消息排队改由 7420 服务端持久接管：切换会话、刷新页面或关闭 Android 页面后仍会按顺序发送；修复排队消息被旧完成快照误判成功、并入上一轮或静默丢失的问题。
+- 快速连续排队、删除、重试和失败阻塞改为按稳定消息 ID 合并；完整同步后才执行服务端精确重排，遇到并发变化会回退到权威顺序，不再由旧异步写入覆盖新队列。
+- 长会话优先读取最近 40 轮的本地有界投影，连续追加只读取新增字节；静默 1.8 秒后再做一次权威收敛，既减少 6–8 秒重读，也保留计划、命令、文件、审批和工具记录。
+- 已发送但尚未进入权威历史的用户消息可跨刷新恢复；外部 Codex 进程写入的 commentary 会及时显示，不再被误判为最终回复或触发高频完整会话读取。
+- Codex 文件引用会显示为可打开的真实文件名，Windows/Unicode 路径与附加属性安全保留；Android 旧版 WebView 改用 PDF.js legacy 主线程和 worker，PDF 预览不再因缺少新 JavaScript API 而空白。
+- Android 任务宠物改为安静贴边模式：默认只保留侧边入口，新助手回复短暂显示五秒，任务列表八秒自动收起，避免长期遮挡桌面。
+- 未读提醒改用持久化回复事件游标；进入对应会话后立即标记已读，普通执行中任务不再被误计为未读，也不会持续显示“工作中”。
+- 浮窗任务列表收敛为最多三条并继续直达对应会话；移除最近会话和浮窗输入框，应用位于前台时不重复展示浮窗或完成通知。
+
 ## 2.7.2 - 2026-08-02
 
 - 左侧会话区收敛为“置顶会话 + 最近活动目录 + 目录内最近会话”的固定层级，目录和会话都随最近活动自然上移；新增全部收起/展开和“定位当前会话”，不再暴露与最近排序冲突的手动置顶目录或排序入口。
diff --git a/docs/release-notes-2.7.3.zh-CN.md b/docs/release-notes-2.7.3.zh-CN.md
new file mode 100644
index 0000000..9ea8255
--- /dev/null
+++ b/docs/release-notes-2.7.3.zh-CN.md
@@ -0,0 +1,63 @@
+# CX-Codex 2.7.3：会话队列不丢消息，长会话回复更快
+
+2.7.3 集中收口会话模块的可靠性与响应速度：排队消息真正由 7420 服务端持久接管，刷新、切换会话或关闭 Android 页面后仍能继续；长会话先展示最近内容，再在后台恢复完整结构；计划、持续目标、文件引用和任务宠物也一起完成稳定化。
+
+## 本版重点
+
+- 计划模式会持续开启，直到用户主动关闭或提交实施；结构化计划卡支持折叠、进度状态和“一步实施”。
+- 新增线程级持续目标，可暂停、继续、编辑和清除，并展示预算与耗时。目标状态以 App Server 为唯一事实来源，不会与用户消息或待处理审批抢占执行。
+- 已发送但尚未进入权威历史的消息会跨刷新恢复；外部 Codex 进程追加的 commentary 能及时出现，不再被当成空白或最终答复。
+
+## 真实消息队列
+
+- 排队消息在进入界面队列后立即持久化到 7420 服务端。切换会话、刷新浏览器或关闭 Android Activity 后，服务端仍会在当前轮次结束后按顺序继续发送。
+- 修复内部队列通知拿上一轮完成快照结算新消息的问题；新排队消息不会再“显示完成但没有 turnId”，也不会静默消失。
+- 修复 App Server 秒级时间戳导致新消息在启动阶段并入上一轮的问题。每条排队消息都由独立 turn 承载。
+- 快速连续添加、删除、重试和失败阻塞按稳定 `clientMessageId` 合并；完整同步后才会应用服务端精确重排，并发变化时回退到服务器权威顺序。
+
+## 长会话与回复速度
+
+- 默认最近消息读取优先使用本地会话日志的有界投影，最多保留最近 40 轮；大文件追加时只读取新增字节，不再每 8–10 秒重新扫描完整历史。
+- 连续写入停止 1.8 秒后只做一次权威收敛，补回计划、命令执行、文件变化、审批、MCP 和工具项目，速度优化不会牺牲结构化消息。
+- 72 MB 真实长会话中，原先反复出现的 6.7–8.0 秒重读已消失；最终普通无工具回复从接受到首个助手数据约 1.7 秒，排队回复首字约 1.9–2.3 秒。
+
+## 文件引用与 Android
+
+- `:codex-file-citation` 现在显示真实文件名并打开完整路径，不再泄漏内部指令文本或附加元数据；Windows 路径、空格、Unicode 和转义属性都能安全处理。
+- Android 本地 PDF 预览改用 PDF.js legacy 主线程与 worker，在缺少 `Promise.withResolvers` 或 `Math.sumPrecise` 的旧 WebView 中也能渲染。
+- Android 任务宠物默认安静贴边，只在新助手回复时短暂显示五秒，任务栈八秒后自动收起；进入 CX-Codex 前台后不重复显示浮窗或完成通知。
+- 未读状态由持久化回复事件游标管理。打开准确会话后立即清除对应提醒，普通运行状态不再被误计为未读。
+
+## 安全与兼容边界
+
+- 本版没有放宽文件、工作区、Cookie、WebSocket、远程入口或 App Server 权限边界；文件预览仍受服务端允许路径和登录态约束。
+- 会话日志投影只用于快速显示可恢复文本，完整结构仍由权威 `thread/read` 收敛，不宣称完全对齐所有未来 App Server schema。
+- 正式 Android APK 继续由 GitHub Release 工作流使用固定证书构建并校验证书 SHA-256；源码不内置私人服务地址或 Firebase 项目凭据。
+
+## 安装或升级
+
+Windows 服务端可继续使用正式 Release 安装或升级；`RemoteQuick` 和 `JsonOutput` 合同保持兼容：
+
+```powershell
+& ([scriptblock]::Create((irm 'https://raw.githubusercontent.com/Qjzn/CX-Codex/main/scripts/bootstrap-windows.ps1'))) -RemoteQuick -JsonOutput
+```
+
+Android 用户可从本 Release 下载 `cx-codex-android-v2.7.3.apk` 覆盖安装。正式 APK 与 `2.5.9+` 使用同一签名，可保留已有服务地址和设置。
+
+官方卸载入口仍可默认保留访问配置、Codex 登录态、工作区和 Android 正式签名：
+
+```powershell
+& ([scriptblock]::Create((irm 'https://raw.githubusercontent.com/Qjzn/CX-Codex/main/scripts/uninstall-windows.ps1'))) -JsonOutput
+```
+
+请同时下载对应 `.sha256` 文件校验 Release ZIP 或 APK 的 SHA-256。
+
+## 发布验证
+
+- 前端 normalizer、服务模块、前端生产构建、CLI 构建和侧栏数据回归通过。
+- 完整 7420 前端套件在最终队列顺序实现上再次覆盖 36 个桌面、手机横竖屏和折叠屏场景，耗时 590.3 秒。
+- 真实队列验证得到 `BASE -> A -> B` 三个独立 turn；重排验证得到 `BASE -> C -> A -> B` 四个独立 turn，服务端列表与权威会话历史一致。
+- 最终会话列表检查覆盖 239 个活跃会话、20 个目录和 6 个可读置顶会话，零 RPC 重试；服务健康状态中活动/等待 RPC、待处理请求、未知执行、线程租约和消息队列均为零。
+- Release ZIP、npm 打包边界、Windows 产品化、Android 正式签名和所有 SHA-256 会在标签工作流中再次验证。
+
+标签发布前，本版仍属于候选版本。只有主分支 CI、Release 工作流、公开 ZIP/APK、SHA-256 和固定 Android 签名全部通过后，才视为正式稳定版本。
diff --git a/package-lock.json b/package-lock.json
index de15e96..e4e975f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "cx-codex",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "cx-codex",
-      "version": "2.7.2",
+      "version": "2.7.3",
       "license": "MIT",
       "dependencies": {
         "@capacitor/app": "^8.1.1",
diff --git a/package.json b/package.json
index 868ae98..8cb73d3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cx-codex",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "description": "CX-Codex Web UI and browser bridge for Windows, Linux, Android, LAN, and remote self-hosted access",
   "type": "module",
   "license": "MIT",
diff --git a/scripts/regression-7420-frontend.ps1 b/scripts/regression-7420-frontend.ps1
index 43640c8..f1a700d 100644
--- a/scripts/regression-7420-frontend.ps1
+++ b/scripts/regression-7420-frontend.ps1
@@ -412,6 +412,8 @@ function Assert-RuntimeSnapshotOrderingSource {
   $sourcePath = Join-Path (Get-Location) "src\composables\useDesktopState.ts"
   $source = Get-Content -Raw -Encoding UTF8 -LiteralPath $sourcePath
   $gatewaySource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\api\codexGateway.ts")
+  $runtimeQueueClientSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\api\runtimeMessageQueue.ts")
+  $runtimeQueueServerSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\runtimeMessageQueue.ts")
   $serverSnapshotSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\appServerThreadRuntimeSnapshot.ts")
   $conversationSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\components\content\ThreadConversation.vue")
   Assert-True ($source -match "const\s+currentEventSeq\s*=\s*Math\.max\([\s\S]*?latestRuntimeEventSeqByThreadId\.get\(threadId\)[\s\S]*?shouldApplyRuntimeSnapshotVersion\(\{\s*lastEventSeq:\s*currentEventSeq\s*\},\s*snapshot\)") "runtime snapshots must be checked against the latest buffered event sequence"
@@ -419,13 +421,15 @@ function Assert-RuntimeSnapshotOrderingSource {
   Assert-True ($source -match "rememberLatestRuntimeEventSequence\(threadId,\s*notification\.seq\)[\s\S]*?method\.endsWith\('/delta'\)") "delta events must record their latest sequence before taking the non-reactive fast path"
   Assert-True ($source -match "method\.endsWith\('/delta'\)[\s\S]*?isRuntimeExecutionActiveState\(currentState\)[\s\S]*?markThreadLiveExecutionSignal\(threadId\)[\s\S]*?isRuntimeExecutionSettledState\(currentState\)\)\s*return") "high-frequency deltas must not rewrite reactive runtime state or revive a settled turn"
   Assert-True ($source -match "const\s+initialRuntimeSnapshotApplied\s*=\s*applyRuntimeSnapshotState\(threadId,\s*snapshot\)[\s\S]*?refreshSettledSnapshotMessagesFromRpc") "foreground recovery must apply the lightweight runtime snapshot before a heavy history refresh"
-  Assert-True ($source -match "preferCachedMessages:\s*shouldShowLoading") "cold thread selection must request recoverable cached messages before a heavy history read"
-  Assert-True ($source -match "preferCachedMessages:\s*shouldShowLoading\s*\|\|\s*options\.fullHistory\s*===\s*true\s*\|\|\s*Boolean\(options\.olderHistory\)") "explicit history paging must reuse the lightweight cached state before its authoritative RPC"
+  Assert-True ($source -match "preferCachedMessages:\s*options\.preferSessionLogMessages\s*===\s*true\s*\|\|\s*shouldShowLoading") "session-log notifications and cold thread selection must request recoverable cached messages before a heavy history read"
+  Assert-True ($source -match "preferCachedMessages:\s*options\.preferSessionLogMessages\s*===\s*true\s*\|\|\s*shouldShowLoading\s*\|\|\s*options\.fullHistory\s*===\s*true\s*\|\|\s*Boolean\(options\.olderHistory\)") "session-log refreshes and explicit history paging must reuse the lightweight cached state before an authoritative RPC"
   Assert-True ($gatewaySource -match "preferCachedMessages\s*\?\s*'\?preferCachedMessages=1'") "the frontend gateway must opt into the cache-first thread-state route"
   Assert-True ($serverSnapshotSource -match "options\.preferCachedMessages\s*===\s*true[\s\S]*?readSessionLogThreadRead[\s\S]*?messageState\s*=\s*'cached'") "cache-first state must recover local session messages without presenting them as authoritative"
   Assert-True ($serverSnapshotSource -match "trimThreadTurnsInRpcResult\('thread/read',\s*recoveredThreadRead\)") "cache-first session recovery must retain the bounded initial message window"
   Assert-True ($source -match "shouldDeferCachedRpcRefresh[\s\S]*?scheduleSettledSnapshotMessagesRpcRefresh") "cache-first messages must trigger an immediate background authoritative refresh"
   Assert-True ($source -match "shouldDeferCachedRpcRefresh\s*=\s*options\.forceSettledRpcRefresh\s*!==\s*true") "the forced authoritative refresh must not defer itself again"
+  Assert-True ($source -match "options\.preferSessionLogMessages\s*===\s*true\s*&&\s*snapshot\.messageState\s*===\s*'cached'[\s\S]*?scheduleSessionLogAuthoritativeRefresh\(threadId") "session-log projections must coalesce a quiet-period authoritative refresh instead of remaining permanently lossy"
+  Assert-True ($source -match "pendingSessionLogMessageRefresh\.add\(threadId\)[\s\S]{0,240}?scheduleSessionLogAuthoritativeRefresh\(threadId\)") "each session-log notification must reset the authoritative quiet window before its local projection begins"
   Assert-True ($source -match "shouldForceCachedSnapshotRefresh\s*=\s*options\.force\s*===\s*true\s*&&\s*snapshot\.messageState\s*===\s*'cached'") "cached historical threads without a terminal event key must still receive an authoritative refresh"
   Assert-True ($source -match "!options\.olderHistory\s*&&\s*!shouldForceCachedSnapshotRefresh") "explicit older-history reads must not be blocked when a legacy thread has no terminal refresh key"
   Assert-True ($conversationSource -match "pendingRemoteOlderHistoryAnchor\s*=\s*anchorSnapshot[\s\S]*?emit\('loadOlderHistory'\)[\s\S]*?props\.messages\.length[\s\S]*?restoreScrollAnchorOverFrames\(anchorSnapshot,\s*6\)") "remote older-history insertion must restore the pre-request reading anchor after messages arrive"
@@ -445,12 +449,12 @@ function Assert-RuntimeSnapshotOrderingSource {
   Assert-True ($source -match "const\s+UNREAD_STATE_STORAGE_KEY[\s\S]*?function\s+saveUnreadStateMap") "completion unread state must survive mobile process restarts"
   Assert-True ($source -match "function\s+applyReplayedRuntimeTerminalCleanup[\s\S]*?markThreadUnreadByEvent\(threadId\)") "replayed terminal events must restore unread completion feedback"
   Assert-True ($source -match "clearSettledRuntimeResidue\(threadId,\s*snapshot\.executionState\)[\s\S]*?processQueuedMessages\(threadId\)") "a settled runtime snapshot must release the previous turn and advance queued work"
-  Assert-True ($source -match "if\s*\(queue\[0\]\?\.deliveryState\s*===\s*'failed'\)\s*return") "a failed queued follow-up must pause instead of retrying indefinitely"
-  Assert-True ($source -match "catch\s*\(unknownError\)[\s\S]*?setQueuedMessageDeliveryState\([\s\S]*?threadId,[\s\S]*?next\.id,[\s\S]*?'failed'") "queued send failures must remain visible and retryable"
+  Assert-True ($runtimeQueueServerSource -match "next\.status\s*===\s*'queue_failed'[\s\S]*?return") "a failed durable queued follow-up must pause instead of retrying indefinitely"
+  Assert-True ($runtimeQueueClientSource -match "persistRuntimeQueuedMessages[\s\S]*?isRetryableQueueError[\s\S]*?deliveryState:\s*'failed'") "queued handoff failures must remain visible and retryable"
   Assert-True ($source -match "function\s+retryQueuedMessage[\s\S]*?setQueuedMessageDeliveryState\(threadId,\s*messageId,\s*'queued'\)[\s\S]*?processQueuedMessages\(threadId\)") "manual queue retry must resume the paused first item"
   Assert-True ($source -match "function\s+deleteQueuedMessage[\s\S]*?removeQueuedMessageByThreadId\(threadId,\s*messageId\)[\s\S]*?processQueuedMessages\(threadId\)") "deleting a failed queue item must release the following item"
-  Assert-True ($source -match "clientMessageId:\s*next\.clientMessageId") "queued follow-ups must reuse a stable idempotency key across pages and retries"
-  Assert-True ($source -match "event\.key\s*===\s*QUEUED_MESSAGES_STORAGE_KEY[\s\S]*?queuedMessagesByThreadId\.value\s*=\s*loadQueuedMessagesMap\(\)") "parallel 7420 pages must converge queued-message state without auto-running it"
+  Assert-True ($runtimeQueueClientSource -match "clientMessageId:\s*message\.clientMessageId") "queued follow-ups must reuse a stable idempotency key across pages and retries"
+  Assert-True ($source -match "event\.key\s*===\s*QUEUED_MESSAGES_STORAGE_KEY[\s\S]*?api\.loadQueuedMessagesMap\(QUEUED_MESSAGES_STORAGE_KEY\)") "parallel 7420 pages must converge queued-message state without browser-owned execution"
   $strongSignalMatch = [regex]::Match($source, "function\s+hasStrongExecutionSignal[\s\S]*?\n\s*}")
   Assert-True ($strongSignalMatch.Success -and $strongSignalMatch.Value -notmatch "hasQueuedThreadWork") "queued follow-up work must not keep the completed turn marked as running"
   $messageRefreshMatch = [regex]::Match($source, "function\s+shouldRefreshMessagesFromNotification[\s\S]*?\n}")
@@ -667,6 +671,8 @@ function Assert-BoundedRuntimeSendRecoverySource {
   $serverSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\appServerRuntimeStart.ts")
   $runtimeActionSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\runtimeActionRoutes.ts")
   $runtimeStoreSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\runtimeStore.ts")
+  $runtimeQueueClientSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\api\runtimeMessageQueue.ts")
+  $runtimeQueueServerSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\runtimeMessageQueue.ts")
   $codexBridgeSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\codexAppServerBridge.ts")
   $codexBridgeDisposeSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "src\server\codexBridgeMiddlewareDispose.ts")
   $androidTaskPetSource = Get-Content -Raw -Encoding UTF8 -LiteralPath (Join-Path (Get-Location) "android\app\src\main\java\com\cxcodex\bridge\TaskPetOverlayService.java")
@@ -765,11 +771,12 @@ function Assert-BoundedRuntimeSendRecoverySource {
   Assert-True ($appSource -match "useDesktopState\(\{[\s\S]*?onDeliveryPersisted:[\s\S]*?ensureMobileShellTaskNotificationPermission\(\)[\s\S]*?onPendingRequestCreated:[\s\S]*?syncMobileShellTaskPet\(true\)[\s\S]*?onRequestDispatched:[\s\S]*?ensureMobileShellTaskNotificationPermission\(\)") "the App must install native monitoring callbacks for retries, rollback resend, and automatic queue execution"
   $processQueuedMessagesMatch = [regex]::Match($source, "async\s+function\s+processQueuedMessages[\s\S]*?\n\s*async\s+function\s+interruptSelectedThreadTurn")
   Assert-True ($processQueuedMessagesMatch.Success) "could not find automatic queued-message execution source"
-  Assert-True ($processQueuedMessagesMatch.Value -match "notifyPendingRequestCreated\(undefined,\s*next\.clientMessageId\)[\s\S]*?await\s+startTurnForThread") "automatic queued-message execution must hand the stable client id to Android before the network await"
-  Assert-True ($processQueuedMessagesMatch.Value -match "clientMessageId:\s*next\.clientMessageId[\s\S]*?onRequestDispatched:\s*submitCallbacks\.onRequestDispatched") "automatic queued-message execution must preserve request-dispatched notification ownership"
-  Assert-True ($source -match "function\s+latestTaskPetClientMessageId[\s\S]*?queueProcessingByThreadId\.value\[threadId\][\s\S]*?queuedMessagesByThreadId\.value\[threadId\][\s\S]*?clientMessageId") "native task sync must expose the stable id of an automatically promoted queue row"
+  Assert-True ($processQueuedMessagesMatch.Value -match "api\.persistRuntimeQueuedMessages\(threadId,\s*queue\)[\s\S]*?syncRuntimeMessageQueue\(threadId\)") "browser queue processing must hand local rows to the durable 7420 queue instead of owning turn execution"
+  Assert-True ($runtimeQueueClientSource -match "persistRuntimeQueuedMessages[\s\S]*?clientMessageId:\s*message\.clientMessageId") "durable queue handoff must preserve the stable idempotency key"
+  Assert-True ($source -match "function\s+promoteQueuedMessageToOptimistic[\s\S]*?createMessageOutboxEntry[\s\S]*?clientMessageId:\s*queued\.clientMessageId") "a server-started queue row must transfer its stable id to the durable optimistic outbox"
+  Assert-True ($runtimeQueueServerSource -match "setInterval\(\(\)\s*=>\s*this\.scheduleAll\(\),\s*QUEUE_SWEEP_INTERVAL_MS\)" -and $runtimeQueueServerSource -match "listQueuedThreadIds[\s\S]*?processThread") "7420 must advance queued messages independently of the selected conversation and Android renderer lifecycle"
   Assert-True ($appSource -match "const\s+ownsSyncSlot\s*=\s*!mobileShellTaskPetSyncInFlight[\s\S]*?if\s*\(!ownsSyncSlot\s*&&\s*!force\)") "an immediate send handoff must bypass an older renderer sync already awaiting its bridge response"
-  Assert-True ($source -match "setQueuedMessagesForThread\(threadId,\s*nextQueue\)[\s\S]*?notifyDeliveryPersisted\(internalOptions\.onDeliveryPersisted\)[\s\S]*?await\s+recoverThreadExecutionState") "queued delivery must be persisted before contextual notification permission work begins"
+  Assert-True ($source -match "setQueuedMessagesForThread\(threadId,\s*nextQueue\)[\s\S]*?notifyDeliveryPersisted\(internalOptions\.onDeliveryPersisted\)[\s\S]*?await\s+processQueuedMessages\(threadId\)") "queued delivery must be persisted locally before its immediate durable 7420 handoff"
   Assert-True ($functionMatch.Value -match "const\s+runtimeRequest\s*=\s*startRuntimeThreadTurn\(args\)[\s\S]*?onRequestDispatched\?\.\(\)[\s\S]*?await\s+runtimeRequest") "contextual permission work must begin only after runtime/send has been dispatched"
   Assert-True ($appSource -match "onDeliveryPersisted:[\s\S]*?ensureMobileShellTaskNotificationPermission[\s\S]*?onRequestDispatched:[\s\S]*?ensureMobileShellTaskNotificationPermission") "existing-thread queue and immediate sends must use their respective durable or dispatched permission boundaries"
   Assert-True ($appSource -match "onPendingRequestCreated:[\s\S]*?syncMobileShellTaskPet\(true\)[\s\S]*?onRequestDispatched:[\s\S]*?ensureMobileShellTaskNotificationPermission") "new-thread sends must register provisional native tracking before requesting permission after runtime/send dispatch"
@@ -899,9 +906,16 @@ function Assert-BoundedRuntimeSendRecoverySource {
   Assert-True ($androidTaskPetSource -match 'next\.sort\(\(left,\s*right\)\s*->[\s\S]*?compareTaskRecency[\s\S]*?tasks\.addAll\(next\)') "frontend task snapshots must preserve newest-progress-first native ordering"
   Assert-True ($androidTaskPetSource -match 'latestReplyCandidate[\s\S]*?shouldPreferReplyCandidate[\s\S]*?pendingReplyRenderTaskKey\s*=\s*taskNotificationKey\(latestReplyCandidate\)[\s\S]*?tasks\.remove\(latestReplyCandidate\)[\s\S]*?tasks\.add\(0,\s*latestReplyCandidate\)') "the task with the newest assistant reply must enter the visible overlay rows before render evidence is committed"
   Assert-True ($androidTaskPetPolicySource -match 'shouldCommitReplyRender[\s\S]*?overlayExpanded[\s\S]*?panelShown[\s\S]*?panelAlpha\s*>\s*0f[\s\S]*?renderedTaskMatchesPendingReply') "reply-render evidence must require an expanded and actually shown overlay panel"
-  Assert-True ($androidTaskPetSource -match 'commitPendingReplyRender\(String renderedReplyTaskKey\)[\s\S]*?taskPanel\.isShown\(\)[\s\S]*?taskPanel\.getAlpha\(\)[\s\S]*?replyRenderCount\s*\+=\s*1L' -and $androidTaskPetSource -match 'withEndAction\(\(\)\s*->\s*commitPendingReplyRender\(renderedReplyTaskKey\)\)') "opening a collapsed panel must commit reply-render evidence only after its visible animation completes"
-  Assert-True ($taskPetPreviewSource -match 'task-pet-preview-compact[\s\S]*?primaryItem[\s\S]*?\$emit\(''open'',\s*primaryItem\.threadId\)') "the collapsed web task-pet surface must show one latest-reply preview that opens its exact conversation"
+  Assert-True ($androidTaskPetSource -match 'commitPendingReplyRender\(String renderedReplyTaskKey\)[\s\S]*?taskPanel\.isShown\(\)[\s\S]*?taskPanel\.getAlpha\(\)[\s\S]*?replyRenderCount\s*\+=\s*1L' -and $androidTaskPetSource -match 'withEndAction\(\(\)\s*->\s*\{[\s\S]*?commitPendingReplyRender\(renderedReplyTaskKey\)[\s\S]*?scheduleTaskStackCollapse\(\)') "opening a collapsed panel must commit reply-render evidence only after its visible animation completes"
+  Assert-True ($taskPetPreviewSource -match 'task-pet-preview-compact[\s\S]*?primaryItem[\s\S]*?openTask\(primaryItem\)' -and $taskPetPreviewSource -match 'function\s+openTask[\s\S]*?emit\(''open'',\s*item\.threadId\)') "the collapsed web task-pet surface must show one latest-reply preview that opens its exact conversation"
+  Assert-True ($taskPetPreviewSource -match 'watch\(\(\)\s*=>\s*props\.items\.length[\s\S]*?count\s*>\s*0[\s\S]*?minimized\.value\s*=\s*false') "a web task arriving after idle must restore the task pet before reply presentation"
+  Assert-True ($taskPetPreviewSource -match 'unreadReplyTaskKeys[\s\S]*?item\.state\s*===\s*''waiting''\s*\|\|\s*unreadReplyTaskKeys\.value\.has') "web task-pet attention must count waiting tasks and unread running replies separately"
+  Assert-True ($taskPetPreviewSource -match 'function\s+showCloseConfirmation[\s\S]*?stopStackTimer\(\)[\s\S]*?closeConfirmationVisible\.value\s*=\s*true' -and $taskPetPreviewSource -match 'function\s+cancelCloseConfirmation[\s\S]*?closeConfirmationVisible\.value\s*=\s*false[\s\S]*?scheduleStackCollapse\(\)') "web task-pet close confirmation must pause auto-collapse and resume it only after cancellation"
   Assert-True ($androidTaskPetSource -match 'buildCompactPreview[\s\S]*?renderCompactPreview[\s\S]*?compactPreviewReply\.setText\(replyPreview\)[\s\S]*?openThread\(task\.threadId\)' -and $androidTaskPetPolicySource -match 'shouldCommitCompactReplyRender[\s\S]*?!overlayExpanded[\s\S]*?!overlayMinimized[\s\S]*?previewShown[\s\S]*?previewAlpha\s*>\s*0f') "the collapsed native task pet must render the newest reply, open its exact thread, and record visibility only while the compact preview is shown"
+  Assert-True ($androidTaskPetPolicySource -match 'hasUnreadReply[\s\S]*?latestReplyEventSeq\s*>\s*readThroughReplyEventSeq' -and $androidTaskPetSource -match 'put\("readThroughReplyEventSeq",\s*task\.readThroughReplyEventSeq\)' -and $androidTaskPetSource -match 'task\.readThroughReplyEventSeq\s*=\s*Math\.max[\s\S]*?task\.latestReplyEventSeq') "native task attention must use a persisted reply-event read cursor instead of a sticky boolean alone"
+  Assert-True ($androidTaskPetSource -match 'latestReplyItemId[\s\S]*?replyItemChanged[\s\S]*?showTransientReplyPeek' -and $androidTaskPetSource -match 'REPLY_PEEK_TIMEOUT_MS\s*=\s*5_000L' -and $androidTaskPetSource -match 'getRecommendedTimeoutMillis') "one assistant item may open one accessible five-second reply peek without stream chunks restarting the timer"
+  Assert-True ($androidTaskPetSource -match 'TASK_STACK_TIMEOUT_MS\s*=\s*8_000L[\s\S]*?collapseTaskStackRunnable[\s\S]*?setExpanded\(false\)' -and $androidTaskPetSource -match 'EDGE_VISIBLE_HANDLE_DP\s*=\s*32[\s\S]*?screenWidth\s*-\s*visibleHandle[\s\S]*?-\(rootWidth\s*-\s*visibleHandle\)') "the Android task stack must auto-collapse and leave only a bounded side handle"
+  Assert-True ($androidMainActivitySource -match 'appForeground\s*=\s*true[\s\S]*?refreshPresentation' -and $androidMainActivitySource -match 'appForeground\s*=\s*false[\s\S]*?refreshPresentation' -and $androidTaskPetSource -match 'shouldAttachOverlay[\s\S]*?!MainActivity\.isAppForeground\(\)' -and $androidTaskPetSource -match 'suppressed_foreground') "the overlay and terminal notification must stay quiet while the Android app itself is foreground"
   Assert-True ($androidTaskPetSource -match 'restorePendingReplyRender\(\)[\s\S]*?PREF_TASK_PET_PENDING_REPLY_RENDER_KEY[\s\S]*?PREF_TASK_PET_PENDING_REPLY_RENDER_EVENT_SEQ' -and $androidTaskPetSource -match 'pendingReplyRenderTaskKey\s*=\s*taskNotificationKey\(latestReplyCandidate\)[\s\S]*?persistPendingReplyRender\(\)' -and $androidTaskPetSource -match 'replyRenderCount\s*\+=\s*1L[\s\S]*?persistPendingReplyRender\(\)') "a collapsed latest-reply render boundary must survive service recreation and clear only after visible render"
   Assert-True ($androidTaskPetPolicySource -match 'shouldPreserveKnownLatestReply[\s\S]*?frontendSnapshot[\s\S]*?sameTaskGeneration[\s\S]*?!currentReply\.isEmpty\(\)[\s\S]*?incomingReplyEventSeq\s*<=\s*0L\s*\|\|\s*incomingReplyEventSeq\s*<=\s*currentReplyEventSeq' -and $androidTaskPetSource -match 'incomingLatestReplyEventSeq[\s\S]*?preserveKnownLatestReply[\s\S]*?resolvedLatestReplyEventSeq[\s\S]*?previous\.latestReplyEventSeq') "an unversioned, equal-version, or older recovering frontend reply must not overwrite a same-generation reply already persisted by the native monitor"
   $nativeSettledStatePolicyMatch = [regex]::Match($androidTaskPetPolicySource, 'static\s+boolean\s+shouldPreserveNativeSettledState[\s\S]*?\n\s*\}')
@@ -3615,6 +3629,9 @@ JSON.stringify((() => {
   const tableScrolls = Array.from(document.querySelectorAll('.message-table-scroll'));
   const tableCardGroups = Array.from(document.querySelectorAll('.message-table-cards'));
   const tableCards = Array.from(document.querySelectorAll('.message-table-card'));
+  const tableScrollableCount = tableScrolls.filter((node) => node.scrollWidth > node.clientWidth + 2).length;
+  const tableFontSizes = tableScrolls.flatMap((node) => Array.from(node.querySelectorAll('th, td')))
+    .map((node) => Number.parseFloat(window.getComputedStyle(node).fontSize || '0'));
   const runtimeStatusBars = Array.from(document.querySelectorAll('.conversation-regression-fixture .runtime-status-bar'));
   const runtimeStatusHeights = runtimeStatusBars.map((node) => Math.round(node.getBoundingClientRect().height));
   const queuedPanels = Array.from(document.querySelectorAll('.conversation-regression-fixture .queued-messages-inner'));
@@ -3709,6 +3726,8 @@ JSON.stringify((() => {
     tableScrollCount: tableScrolls.length,
     tableCardGroupCount: tableCardGroups.length,
     tableCardCount: tableCards.length,
+    tableScrollableCount,
+    tableMaxFontSize: tableFontSizes.length ? Math.max(...tableFontSizes) : 0,
     runtimeStatusBarCount: runtimeStatusBars.length,
     runtimeStatusMaxHeight: runtimeStatusHeights.length ? Math.max(...runtimeStatusHeights) : 0,
     viewportWidth,
@@ -4348,9 +4367,10 @@ function Assert-ConversationFixture {
   Assert-True ($Metrics.toolPanelCount -ge 1) "conversation fixture is missing tool call panel"
   Assert-True ($Metrics.requestButtonCount -ge 3) "conversation fixture is missing permission action buttons"
   if ([int]$Metrics.viewportWidth -lt 768) {
-    Assert-True ([int]$Metrics.tableScrollCount -eq 0) "conversation fixture phone viewport mounted desktop table DOM: $($Metrics.tableScrollCount)"
-    Assert-True ([int]$Metrics.tableCardGroupCount -ge 1) "conversation fixture phone viewport is missing mobile table card group"
-    Assert-True ([int]$Metrics.tableCardCount -ge 1) "conversation fixture phone viewport is missing mobile table cards"
+    Assert-True ([int]$Metrics.tableScrollCount -ge 1) "conversation fixture phone viewport is missing semantic table scroll region"
+    Assert-True ([int]$Metrics.tableScrollableCount -ge 1) "conversation fixture phone table is not horizontally scrollable"
+    Assert-True ([double]$Metrics.tableMaxFontSize -le 13.5) "conversation fixture phone table font is too large: $($Metrics.tableMaxFontSize)"
+    Assert-True ([int]$Metrics.tableCardGroupCount -eq 0) "conversation fixture phone viewport still mounted vertical table cards"
   } else {
     Assert-True ([int]$Metrics.tableScrollCount -ge 1) "conversation fixture $ViewportName viewport is missing desktop table DOM"
     Assert-True ([int]$Metrics.tableCardGroupCount -eq 0) "conversation fixture $ViewportName viewport mounted mobile table DOM: $($Metrics.tableCardGroupCount)"
@@ -7265,9 +7285,78 @@ Assert-ThreadAttentionChromeSource
   Assert-True ($notificationRecoveryFixture.hasCompletionNotificationRecovery -eq $true) "completion notification recovery fixture phone is missing the blocked-channel state or recovery action"
   Add-RegressionResult -Name "completion-notification-recovery-phone" -Page $notificationRecoveryFixture
 
+  $taskPetWakeFixtureUrl = $BaseUrl + "/#/__regression/task-pet?regression=frontend"
+  $taskPetWakeFixture = Open-And-ReadPage -Session $session -Url $taskPetWakeFixtureUrl -Width $PhoneWidth -Height $PhoneHeight
+  Assert-Page -Page $taskPetWakeFixture -Name "task-pet idle wake fixture phone"
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="toggle-task-state"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "100") | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="toggle-task-state"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "100") | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="simulate-latest-reply"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "200") | Out-Null
+  $taskPetWakeMetrics = Invoke-BrowserEvalJson -Session $session -Script @'
+JSON.stringify((() => {
+  const root = document.querySelector('[aria-label="任务宠物预览"]');
+  const badge = root?.querySelector('.task-pet-preview-badge');
+  return {
+    minimized: Boolean(root?.querySelector('[aria-label="恢复任务宠物"]')),
+    compactCount: root?.querySelectorAll('.task-pet-preview-compact').length || 0,
+    compactText: root?.querySelector('.task-pet-preview-compact')?.textContent?.replace(/\s+/g, ' ').trim() || '',
+    attentionCount: Number(badge?.textContent?.trim() || 0)
+  };
+})())
+'@
+  Assert-True ($taskPetWakeMetrics.minimized -eq $false) "a task arriving after idle must restore the task pet instead of leaving it minimized"
+  Assert-True ([int]$taskPetWakeMetrics.compactCount -eq 1) "a new assistant reply after idle must show exactly one transient reply preview"
+  Assert-True ([string]$taskPetWakeMetrics.compactText -match '浮窗已实时同步最新回复') "the reply preview after idle did not show the new assistant reply"
+  Assert-True ([int]$taskPetWakeMetrics.attentionCount -eq 2) "one waiting task plus one unread running reply must show attention count 2"
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", ".task-pet-preview-mascot") | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="toggle-task-state"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "8250") | Out-Null
+  $taskPetIdleCollapseMetrics = Invoke-BrowserEvalJson -Session $session -Script @'
+JSON.stringify({
+  expanded: Boolean(document.querySelector('.task-pet-preview-panel')),
+  minimized: Boolean(document.querySelector('[aria-label="恢复任务宠物"]'))
+})
+'@
+  Assert-True ($taskPetIdleCollapseMetrics.expanded -eq $false) "an empty task stack must auto-collapse after its visibility timeout"
+  Assert-True ($taskPetIdleCollapseMetrics.minimized -eq $true) "an empty task stack must return to the minimized pet after auto-collapse"
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="toggle-task-state"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", ".task-pet-preview-mascot") | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[aria-label="关闭浮窗"]') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "8250") | Out-Null
+  $taskPetCloseConfirmationMetrics = Invoke-BrowserEvalJson -Session $session -Script @'
+JSON.stringify({
+  dialog: Boolean(document.querySelector('[aria-label="确认关闭浮窗"]')),
+  expanded: Boolean(document.querySelector('.task-pet-preview-panel'))
+})
+'@
+  Assert-True ($taskPetCloseConfirmationMetrics.dialog -eq $true) "task-pet close confirmation must pause auto-collapse while awaiting a decision"
+  Assert-True ($taskPetCloseConfirmationMetrics.expanded -eq $true) "task-pet close confirmation must keep its panel expanded"
+  Invoke-AgentBrowser -Arguments @("--session", $session, "click", '.task-pet-preview-close-confirm button:not([data-tone="danger"])') | Out-Null
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "100") | Out-Null
+  Add-RegressionResult -Name "task-pet-idle-wake-phone" -Page $taskPetWakeFixture
+
   $latestReplyFixtureUrl = $BaseUrl + "/#/__regression/task-pet?regression=frontend&latestReplyBurst=1"
   $latestReplyFixture = Open-And-ReadPage -Session $session -Url $latestReplyFixtureUrl -Width $PhoneWidth -Height $PhoneHeight
   Assert-Page -Page $latestReplyFixture -Name "latest reply promoted fixture phone"
+  $latestReplyDockedMetrics = Invoke-BrowserEvalJson -Session $session -Script @'
+JSON.stringify({
+  visibleRowCount: document.querySelectorAll('.task-pet-preview-row').length,
+  compactCount: document.querySelectorAll('.task-pet-preview-compact').length
+})
+'@
+  Assert-True ([int]$latestReplyDockedMetrics.visibleRowCount -eq 0) "task pet must start quietly docked until the user expands it"
+  Assert-True ([int]$latestReplyDockedMetrics.compactCount -eq 0) "quietly docked task pet must not expose a stale reply preview"
+  $expandLatestReplyPreview = Invoke-BrowserEvalJson -Session $session -Script @'
+JSON.stringify((() => {
+  const mascot = document.querySelector('.task-pet-preview-mascot');
+  mascot?.click();
+  return { expanded: Boolean(mascot) };
+})())
+'@
+  Assert-True ($expandLatestReplyPreview.expanded -eq $true) "task-pet latest-reply fixture could not expand its task stack"
+  Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "250") | Out-Null
   $latestReplyFixtureMetrics = Invoke-BrowserEvalJson -Session $session -Script @'
 JSON.stringify((() => {
   const rows = Array.from(document.querySelectorAll('.task-pet-preview-row'));
@@ -7304,8 +7393,7 @@ JSON.stringify((() => {
   };
 })())
 '@
-  Assert-True ([int]$compactLatestReplyBefore.compactCount -eq 1) "collapsed task pet must show exactly one latest-reply preview"
-  Assert-True ([string]$compactLatestReplyBefore.text -match '最新回复已提升到浮窗可见首行') "collapsed task pet did not retain the newest visible reply"
+  Assert-True ([int]$compactLatestReplyBefore.compactCount -eq 0) "collapsed task pet must remain quiet until a new reply arrives"
   Assert-True ([int]$compactLatestReplyBefore.documentWidth -eq [int]$compactLatestReplyBefore.viewportWidth) "collapsed latest-reply preview has horizontal overflow"
   Invoke-AgentBrowser -Arguments @("--session", $session, "click", '[data-testid="simulate-latest-reply"]') | Out-Null
   Invoke-AgentBrowser -Arguments @("--session", $session, "wait", "200") | Out-Null
diff --git a/scripts/server-module-smoke.ts b/scripts/server-module-smoke.ts
index 5c181ef..95d43e2 100644
--- a/scripts/server-module-smoke.ts
+++ b/scripts/server-module-smoke.ts
@@ -134,6 +134,7 @@ import {
 import {
   isSessionLogThreadReadCandidateLine,
   parseThreadReadFromSessionLog,
+  readThreadReadFromSessionLog,
 } from '../src/server/appServerSessionLogThreadRead.js'
 import { createAppServerRuntimeReaders } from '../src/server/appServerRuntimeReaders.js'
 import {
@@ -302,6 +303,7 @@ import {
 import { handleThreadRoutes } from '../src/server/threadRoutes.js'
 import {
   isRuntimeActiveState,
+  RUNTIME_START_THREAD_READ_GRACE_MS,
   RuntimeStateStore,
   toPersistableRuntimeSnapshot,
   type RuntimeSnapshotOverlay,
@@ -446,6 +448,7 @@ import {
   CodexSessionFileChangeObserver,
   classifyCodexSessionFileChange,
   createCodexSessionFileChangedNotification,
+  resolveCodexSessionFileChangeOrigin,
 } from '../src/server/codexSessionFileChangeObserver.js'
 import {
   CX_SESSION_FILES_CHANGED_METHOD,
@@ -3854,6 +3857,14 @@ async function smokeAppServerRpcCache(): Promise<void> {
   assert.equal(shouldInvalidateThreadReadCacheForRpc('model/list'), false)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('thread/goal/updated'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification(CX_SESSION_FILES_CHANGED_METHOD), true)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification(CX_SESSION_FILES_CHANGED_METHOD, {
+    source: 'session-log',
+    origin: 'live-app-server',
+  }), true)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification(CX_SESSION_FILES_CHANGED_METHOD, {
+    source: 'session-log',
+    origin: 'external',
+  }), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('thread/goal/cleared'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('thread/compacted'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('turn/completed'), true)
@@ -3861,18 +3872,18 @@ async function smokeAppServerRpcCache(): Promise<void> {
   assert.equal(shouldInvalidateThreadReadCacheForNotification('turn/plan/updated'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('item/updated'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('rawResponseItem/completed'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/agentMessage/delta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/plan/delta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/summaryTextDelta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/summaryPartAdded'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/textDelta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/commandExecution/outputDelta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/commandExecution/terminalInteraction'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/fileChange/outputDelta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/fileChange/patchUpdated'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/mcpToolCall/progress'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('command/exec/outputDelta'), true)
-  assert.equal(shouldInvalidateThreadReadCacheForNotification('process/outputDelta'), true)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/agentMessage/delta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/plan/delta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/summaryTextDelta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/summaryPartAdded'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/reasoning/textDelta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/commandExecution/outputDelta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/commandExecution/terminalInteraction'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/fileChange/outputDelta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/fileChange/patchUpdated'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('item/mcpToolCall/progress'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('command/exec/outputDelta'), false)
+  assert.equal(shouldInvalidateThreadReadCacheForNotification('process/outputDelta'), false)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('process/exited'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('tool/failed'), true)
   assert.equal(shouldInvalidateThreadReadCacheForNotification('thread/name/updated'), false)
@@ -4972,6 +4983,7 @@ function smokeCodexBridgeNotificationRuntime(): void {
   const observedRuntimeEvents: unknown[] = []
   const deletedThreadReads: string[] = []
   const emittedEvents: unknown[] = []
+  const persistedRuntimeThreads: string[] = []
 
   const runtime = createCodexBridgeNotificationRuntime({
     subscribeAppServerNotifications: (listener) => {
@@ -5016,7 +5028,10 @@ function smokeCodexBridgeNotificationRuntime(): void {
         observedStatusNotifications.push(observation)
       },
     },
-    persistRuntimeSnapshot: () => ({} as never),
+    persistRuntimeSnapshot: (threadId) => {
+      persistedRuntimeThreads.push(threadId)
+      return {} as never
+    },
   })
 
   const unsubscribeBridgeListener = runtime.bridgeNotificationListeners.subscribe((event) => {
@@ -5048,20 +5063,42 @@ function smokeCodexBridgeNotificationRuntime(): void {
   assert.equal(observedStatusNotifications.length, 1)
   assert.equal(observedRuntimeEvents.length, 1)
   assert.deepEqual(deletedThreadReads, ['thread-a'])
+  assert.deepEqual(persistedRuntimeThreads, ['thread-a'])
   assert.deepEqual(emittedEvents, [observedRuntimeEvents[0]])
   assert.equal(runtime.listNotificationEventsAfter(10, 5).notifications.length, 1)
   assert.equal(runtime.listNotificationEventsAfter(10, 5).streamId, 'stream-runtime')
 
-  const externalEvent = runtime.publishBridgeNotification(createCodexSessionFileChangedNotification({
+  const commandOutputEvent = runtime.publishBridgeNotification({
+    method: 'item/commandExecution/outputDelta',
+    params: { threadId: 'thread-a', turnId: 'turn-a', itemId: 'command-a', delta: 'chunk' },
+  })
+  assert.equal(commandOutputEvent.seq, 12)
+  assert.equal(observedRuntimeEvents.length, 2)
+  assert.deepEqual(deletedThreadReads, ['thread-a'])
+  assert.deepEqual(persistedRuntimeThreads, ['thread-a'])
+  assert.equal(emittedEvents.length, 2)
+
+  const coveredSessionEvent = runtime.publishBridgeNotification(createCodexSessionFileChangedNotification({
     source: 'session-log',
     threadId: 'thread-a',
+    origin: 'live-app-server',
   }))
-  assert.equal(externalEvent.seq, 12)
-  assert.equal(externalEvent.method, CX_SESSION_FILES_CHANGED_METHOD)
-  assert.equal(observedRuntimeEvents.length, 1)
+  assert.equal(coveredSessionEvent.seq, 13)
+  assert.equal(coveredSessionEvent.method, CX_SESSION_FILES_CHANGED_METHOD)
+  assert.equal(observedRuntimeEvents.length, 2)
   assert.deepEqual(deletedThreadReads, ['thread-a', 'thread-a'])
-  assert.equal(emittedEvents.length, 2)
-  assert.equal(runtime.listNotificationEventsAfter(10, 5).notifications.length, 2)
+  assert.deepEqual(persistedRuntimeThreads, ['thread-a'])
+  assert.equal(emittedEvents.length, 3)
+  assert.equal(runtime.listNotificationEventsAfter(10, 5).notifications.length, 3)
+
+  const externalEvent = runtime.publishBridgeNotification(createCodexSessionFileChangedNotification({
+    source: 'session-log',
+    threadId: 'thread-a',
+    origin: 'external',
+  }))
+  assert.equal(externalEvent.seq, 14)
+  assert.deepEqual(deletedThreadReads, ['thread-a', 'thread-a', 'thread-a'])
+  assert.equal(emittedEvents.length, 4)
 
   unsubscribeBridgeListener()
   assert.equal(runtime.bridgeNotificationListeners.count, 0)
@@ -5071,6 +5108,21 @@ function smokeCodexBridgeNotificationRuntime(): void {
 
 async function smokeCodexSessionFileChangeObserver(): Promise<void> {
   const threadId = '019f7e69-25a4-7aa2-8166-b8257873b8ab'
+  assert.equal(resolveCodexSessionFileChangeOrigin(
+    { source: 'session-log', threadId },
+    1_000,
+    5_000,
+  ), 'live-app-server')
+  assert.equal(resolveCodexSessionFileChangeOrigin(
+    { source: 'session-log', threadId },
+    1_000,
+    6_001,
+  ), 'external')
+  assert.equal(resolveCodexSessionFileChangeOrigin(
+    { source: 'session-index', threadId: '' },
+    5_000,
+    5_000,
+  ), 'external')
   assert.equal(shouldInvalidateThreadCollectionForCxSessionFileChange({ source: 'session-log' }), false)
   assert.equal(shouldInvalidateThreadCollectionForCxSessionFileChange({ source: 'session-index' }), true)
   assert.equal(shouldInvalidateThreadCollectionForCxSessionFileChange({ source: 'unknown' }), true)
@@ -8242,6 +8294,47 @@ function smokeRuntimeStateStore(): void {
   store.markRunning('thread-timer', 'turn-new')
   assert.equal(store.snapshot('thread-timer').lastStartedAtIso, restarted.lastStartedAtIso)
 
+  store.markStarting('thread-start-second')
+  const currentStart = store.snapshot('thread-start-second')
+  const currentStartAtMs = Date.parse(currentStart.lastStartedAtIso ?? '')
+  const currentStartSecondIso = new Date(Math.floor(currentStartAtMs / 1_000) * 1_000).toISOString()
+  store.observeThreadRead('thread-start-second', false, '', currentStartSecondIso, 'thread-read')
+  assert.equal(
+    store.snapshot('thread-start-second').executionState,
+    'starting',
+    'a second-precision thread read from the start second must not settle a materializing turn',
+  )
+
+  const expiredStartAtMs = Date.now() - RUNTIME_START_THREAD_READ_GRACE_MS - 1_000
+  const expiredStartAtIso = new Date(expiredStartAtMs).toISOString()
+  const expiredStartStore = new RuntimeStateStore({
+    readThreadIdFromPayload,
+    readTurnIdFromPayload,
+    readItemIdFromPayload,
+    readThreadInProgressFromThreadReadPayload: (payload) => readBooleanProperty(payload, 'inProgress'),
+    getErrorMessage: (_payload, fallback) => fallback,
+  }, {
+    loadPersistedSnapshot: (threadId) => createThreadRuntimeSnapshot({
+      threadId,
+      executionState: 'starting',
+      inProgress: true,
+      updatedAtIso: expiredStartAtIso,
+      lastStartedAtIso: expiredStartAtIso,
+    }),
+  })
+  expiredStartStore.observeThreadRead(
+    'thread-expired-start-second',
+    false,
+    '',
+    new Date(Math.floor(expiredStartAtMs / 1_000) * 1_000).toISOString(),
+    'thread-read',
+  )
+  assert.equal(
+    expiredStartStore.snapshot('thread-expired-start-second').executionState,
+    'completed',
+    'an expired same-second snapshot must remain recoverable after lifecycle notifications are lost',
+  )
+
   store.markStarting('thread-failed-start')
   store.markFailed('thread-failed-start', 'thread is archived')
   const failedStart = store.snapshot('thread-failed-start')
@@ -9537,8 +9630,46 @@ function smokeAppServerNotificationRuntimeSync(): void {
     },
   }])
 
-  const noThreadEvent: BridgeNotificationEvent = {
+  const queueEvent: BridgeNotificationEvent = {
     seq: 8,
+    method: 'runtime/queue/updated',
+    params: { threadId: 'thread-a', requestId: 'queued-request', action: 'starting' },
+    atIso: '2026-01-01T00:00:01.000Z',
+  }
+  const queueEmits: BridgeNotificationEvent[] = []
+  assert.equal(syncBridgeNotificationRuntimeState({
+    method: queueEvent.method,
+    params: queueEvent.params,
+  }, {
+    rememberNotificationEvent: () => queueEvent,
+    runtimeStateStore: {
+      observeEvent: () => {
+        throw new Error('internal queue notifications must not mutate runtime state')
+      },
+    },
+    readThreadIdFromPayload,
+    persistRuntimeSnapshot: () => {
+      throw new Error('internal queue notifications must not persist a stale runtime snapshot')
+    },
+    runtimeStore: {
+      listRequestsByThread: () => {
+        throw new Error('internal queue notifications must not reconcile a pending queue request')
+      },
+      updateRequest: () => {
+        throw new Error('internal queue notifications must not settle a pending queue request')
+      },
+    },
+    deleteCachedThreadRead: () => {
+      throw new Error('internal queue notifications must not invalidate thread reads')
+    },
+    emitNotification: (emittedEvent) => {
+      queueEmits.push(emittedEvent)
+    },
+  }), queueEvent)
+  assert.deepEqual(queueEmits, [queueEvent])
+
+  const noThreadEvent: BridgeNotificationEvent = {
+    seq: 9,
     method: 'app/list/updated',
     params: {},
     atIso: '2026-01-01T00:00:01.000Z',
@@ -9808,6 +9939,7 @@ async function smokeRuntimeActionRoutes(): Promise<void> {
   const listedQueueThreadIds: string[] = []
   const cancelledQueueRequestIds: string[] = []
   const retriedQueueRequestIds: string[] = []
+  const reorderedQueues: Array<{ threadId: string; requestIds: string[] }> = []
   const queueDependencies = {
     ...dependencies,
     readJsonBody: async () => ({ input: 'queue route' }),
@@ -9824,6 +9956,10 @@ async function smokeRuntimeActionRoutes(): Promise<void> {
       retriedQueueRequestIds.push(requestId)
       return true
     },
+    reorderQueuedRuntimeTurns: (threadId: string, requestIds: string[]) => {
+      reorderedQueues.push({ threadId, requestIds })
+      return true
+    },
   }
   const queued = createRouteTestResponse()
   assert.equal(await handleRuntimeActionRoutes(
@@ -9865,6 +10001,25 @@ async function smokeRuntimeActionRoutes(): Promise<void> {
   assert.equal(retried.response.statusCode, 202)
   assert.deepEqual(retriedQueueRequestIds, ['queue-request-a'])
 
+  const reordered = createRouteTestResponse()
+  assert.equal(await handleRuntimeActionRoutes(
+    { method: 'POST' } as never,
+    reordered.response as never,
+    new URL('http://127.0.0.1/codex-api/runtime/queue/reorder'),
+    {
+      ...queueDependencies,
+      readJsonBody: async () => ({
+        threadId: 'thread-queue',
+        requestIds: ['queue-request-b', 'queue-request-a'],
+      }),
+    },
+  ), true)
+  assert.equal(reordered.response.statusCode, 200)
+  assert.deepEqual(reorderedQueues, [{
+    threadId: 'thread-queue',
+    requestIds: ['queue-request-b', 'queue-request-a'],
+  }])
+
   assert.equal(await handleRuntimeActionRoutes(
     { method: 'GET' } as never,
     createRouteTestResponse().response as never,
@@ -10416,7 +10571,7 @@ async function smokeAppServerSessionLogThreadRead(): Promise<void> {
         title: string
         cwd: string
         preview: string
-        turns: Array<{ items: Array<{ type: string; text?: string; content?: Array<{ text: string }> }> }>
+        turns: Array<{ items: Array<{ type: string; phase?: string; text?: string; content?: Array<{ text: string }> }> }>
       }
     } | null
 
@@ -10429,13 +10584,81 @@ async function smokeAppServerSessionLogThreadRead(): Promise<void> {
     assert.equal(threadRead?.thread.turns[0]?.items[0]?.type, 'userMessage')
     assert.equal(threadRead?.thread.turns[0]?.items[0]?.content?.[0]?.text, 'Restore this session')
     assert.equal(threadRead?.thread.turns[0]?.items[1]?.type, 'agentMessage')
-    assert.equal(threadRead?.thread.turns[0]?.items[1]?.text, 'Recovered answer')
-    assert.equal(threadRead?.thread.turns[0]?.items.length, 2)
+    assert.equal(threadRead?.thread.turns[0]?.items[1]?.phase, 'commentary')
+    assert.equal(threadRead?.thread.turns[0]?.items[1]?.text, 'Intermediate progress should not be restored')
+    assert.equal(threadRead?.thread.turns[0]?.items[2]?.text, 'Recovered answer')
+    assert.equal(threadRead?.thread.turns[0]?.items.length, 3)
     assert.equal(threadRead?.thread.turns[1]?.items[0]?.content?.[0]?.text, '继续')
     assert.equal(threadRead?.thread.turns[1]?.items[1]?.text, 'Second recovered answer')
     assert.equal(threadRead?.thread.turns[2]?.items[0]?.content?.[0]?.text, '继续')
     assert.equal(threadRead?.thread.turns[2]?.items[1]?.text, 'Third recovered answer')
 
+    const incrementalSessionPath = join(dir, 'rollout-2026-07-06T10-02-00-thread-incremental.jsonl')
+    const incrementalFallback = {
+      thread: {
+        id: 'thread-incremental',
+        preview: '',
+        createdAt: 0,
+        updatedAt: 0,
+        path: incrementalSessionPath,
+        cwd: 'E:/workspace/incremental',
+        turns: [],
+      },
+    }
+    await writeFile(incrementalSessionPath, `${[
+      JSON.stringify({
+        timestamp: '2026-07-06T10:02:01.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'message',
+          id: 'incremental-user-1',
+          role: 'user',
+          content: [{ type: 'input_text', text: 'Incremental request one' }],
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-07-06T10:02:02.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'message',
+          id: 'incremental-agent-1',
+          role: 'assistant',
+          content: [{ type: 'output_text', text: 'Incremental answer one' }],
+        },
+      }),
+    ].join('\n')}\n`, 'utf8')
+    await readThreadReadFromSessionLog(incrementalSessionPath, incrementalFallback)
+    await appendFile(incrementalSessionPath, `${[
+      JSON.stringify({
+        timestamp: '2026-07-06T10:02:03.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'message',
+          id: 'incremental-user-2',
+          role: 'user',
+          content: [{ type: 'input_text', text: 'Incremental request two' }],
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-07-06T10:02:04.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'message',
+          id: 'incremental-agent-2',
+          role: 'assistant',
+          content: [{ type: 'output_text', text: 'Incremental answer two' }],
+        },
+      }),
+    ].join('\n')}\n`, 'utf8')
+    const incrementalThreadRead = await readThreadReadFromSessionLog(
+      incrementalSessionPath,
+      incrementalFallback,
+    ) as {
+      thread: { turns: Array<{ items: Array<{ text?: string }> }> }
+    } | null
+    assert.equal(incrementalThreadRead?.thread.turns.length, 2)
+    assert.equal(incrementalThreadRead?.thread.turns[1]?.items[1]?.text, 'Incremental answer two')
+
     const largeSessionPath = join(dir, 'rollout-2026-07-06T10-05-00-thread-large-fallback.jsonl')
     await writeFile(largeSessionPath, [
       'x'.repeat(2_100_000),
@@ -10745,13 +10968,11 @@ async function smokeAppServerThreadRuntimeSnapshot(): Promise<void> {
       sessionFallbackWarnings.push({ message, details })
     },
   })
-  assert.deepEqual(sessionFallbackRpcCalls.map(readIncludeTurns), [false, true])
+  assert.deepEqual(sessionFallbackRpcCalls.map(readIncludeTurns), [false])
   assert.deepEqual(sessionFallbackRemembered, [sessionFallbackThreadReadPayload])
   assert.equal(sessionFallbackSnapshot.threadRead, sessionFallbackThreadReadPayload)
   assert.equal(sessionFallbackSnapshot.messageState, 'cached')
-  assert.deepEqual(sessionFallbackWarnings.map((warning) => warning.message), [
-    'Heavy thread snapshot fell back to session log messages',
-  ])
+  assert.deepEqual(sessionFallbackWarnings, [])
 
   const cacheFirstRpcCalls: unknown[] = []
   const cacheFirstRemembered: unknown[] = []
@@ -10822,6 +11043,70 @@ async function smokeAppServerThreadRuntimeSnapshot(): Promise<void> {
   assert.deepEqual(cacheFirstRemembered, [{ threadRead: cacheFirstThreadRead, source: 'session-log' }])
   assert.equal(cacheFirstSnapshot.messageState, 'cached')
 
+  const activeSessionRpcCalls: unknown[] = []
+  const activeSessionThreadRead = {
+    thread: {
+      id: 'thread-active-session',
+      updatedAt: updatedAtSeconds,
+      inProgress: true,
+      activeTurnId: 'turn-active-session',
+      path: 'session-active.jsonl',
+      turns: [{
+        id: 'turn-active-session',
+        status: 'inProgress',
+        items: [{ type: 'agentMessage', id: 'agent-active-session', text: 'Live session progress' }],
+      }],
+    },
+  }
+  const activeSessionSnapshot = await readAppServerThreadRuntimeSnapshot('thread-active-session', {
+    rpc: async (_method, params) => {
+      activeSessionRpcCalls.push(params)
+      if (readIncludeTurns(params) === true) {
+        throw new Error('active session snapshot must not issue a heavy thread read')
+      }
+      return {
+        thread: {
+          id: 'thread-active-session',
+          updatedAt: updatedAtSeconds,
+          inProgress: true,
+          activeTurnId: 'turn-active-session',
+          path: 'session-active.jsonl',
+        },
+      }
+    },
+    observeThreadRead: () => {},
+    getCachedThreadRead: () => null,
+    rememberCachedThreadRead: (_threadId, threadRead, source) => createCachedThreadRead(
+      threadRead,
+      () => '2026-01-01T00:00:30.000Z',
+      source,
+    ),
+    snapshotRuntime: (threadId, overlay = {}) => createThreadRuntimeSnapshot({
+      threadId,
+      executionState: 'running',
+      activeTurnId: 'turn-active-session',
+      threadRead: overlay.threadRead ?? null,
+      messageState: overlay.messageState ?? 'unavailable',
+      pendingServerRequests: overlay.pendingServerRequests ?? [],
+      tokenUsage: overlay.tokenUsage ?? null,
+    }),
+    observeRuntimeThreadRead: () => {},
+    markRuntimeDegraded: () => {
+      throw new Error('active session recovery should not mark degraded')
+    },
+    persistRuntimeSnapshot: (_threadId, snapshot) => snapshot,
+    listPendingServerRequestsForThread: () => [],
+    getThreadTokenUsage: () => null,
+    readSessionLogThreadRead: async () => activeSessionThreadRead,
+    getErrorMessage,
+    writeWarning: () => {
+      throw new Error('active session recovery should not warn')
+    },
+  })
+  assert.deepEqual(activeSessionRpcCalls.map(readIncludeTurns), [false])
+  assert.equal(activeSessionSnapshot.threadRead, activeSessionThreadRead)
+  assert.equal(activeSessionSnapshot.messageState, 'cached')
+
   const sessionFallbackCacheHit = createCachedThreadRead(
     sessionFallbackThreadReadPayload,
     () => '2026-01-01T00:00:30.000Z',
@@ -11343,6 +11628,21 @@ async function smokeRuntimeMessageQueue(): Promise<void> {
       queueMetadata: { speedMode: 'standard', text: 'First queued prompt' },
     })
     assert.equal(first.status, 'queued')
+    const reorderPeer = queue.enqueue({
+      threadId: 'thread-queue',
+      clientMessageId: 'queued-client-reorder-peer',
+      input: [{ type: 'text', text: 'Temporary reorder peer' }],
+      collaborationMode: 'execute',
+      queueMetadata: { speedMode: 'standard', text: 'Temporary reorder peer' },
+    })
+    assert.equal(queue.reorder('thread-queue', [reorderPeer.requestId, first.requestId]), true)
+    assert.deepEqual(
+      queue.list('thread-queue').map((entry) => entry.clientMessageId),
+      ['queued-client-reorder-peer', 'queued-client-1'],
+    )
+    assert.equal(queue.reorder('thread-queue', [first.requestId]), false)
+    assert.equal(queue.reorder('thread-queue', [first.requestId, reorderPeer.requestId]), true)
+    assert.equal(queue.cancel(reorderPeer.requestId), true)
     await new Promise((resolve) => setTimeout(resolve, 30))
     assert.deepEqual(startedClientMessageIds, [])
     assert.equal(queue.list('thread-queue').length, 1)
diff --git a/scripts/verify-frontend-normalizers.mjs b/scripts/verify-frontend-normalizers.mjs
index 908678b..f443618 100644
--- a/scripts/verify-frontend-normalizers.mjs
+++ b/scripts/verify-frontend-normalizers.mjs
@@ -16,6 +16,7 @@ const notificationReplayImport = toImportPath(relative(outputRoot, join(repoRoot
 const connectionManagerImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'connectionManager.ts')))
 const conversationViewportImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'conversationViewport.ts')))
 const runtimeSnapshotOrderingImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'runtimeSnapshotOrdering.ts')))
+const runtimeExecutionRecoveryImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'runtimeExecutionRecovery.ts')))
 const messageOutboxMergeImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'messageOutboxMerge.ts')))
 const messageIdentityImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'messageIdentity.ts')))
 const composerTurnOptionsImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'composerTurnOptions.ts')))
@@ -33,6 +34,7 @@ const sessionFileChangeImport = toImportPath(relative(outputRoot, join(repoRoot,
 const composerEnterBehaviorImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'composerEnterBehavior.ts')))
 const threadGoalImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'composables', 'threadGoal.ts')))
 const codexFileCitationImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'utils', 'codexFileCitation.ts')))
+const runtimeMessageQueueImport = toImportPath(relative(outputRoot, join(repoRoot, 'src', 'api', 'runtimeMessageQueue.ts')))
 
 try {
   writeFileSync(entryPath, `
@@ -50,6 +52,7 @@ import {
   isConversationViewportAtBottom,
 } from '${conversationViewportImport}'
 import { shouldApplyRuntimeSnapshotVersion } from '${runtimeSnapshotOrderingImport}'
+import { isOptimisticOnlyExecutionEvidence } from '${runtimeExecutionRecoveryImport}'
 import { mergeMessageOutboxEntries, mergeMessageOutboxState } from '${messageOutboxMergeImport}'
 import {
   createClientMessageId,
@@ -107,6 +110,7 @@ import {
   CX_SESSION_FILES_CHANGED_METHOD,
   getCxSessionFileChangeSyncPolicy,
   isCxSessionFilesChangedMethod,
+  readCxSessionFileChangeOrigin,
   readCxSessionFileChangeSource,
 } from '${sessionFileChangeImport}'
 import { resolveSendWithEnterPreference } from '${composerEnterBehaviorImport}'
@@ -115,6 +119,33 @@ import {
   readCodexFileCitationAt,
   splitCodexFileCitations,
 } from '${codexFileCitationImport}'
+import {
+  mergePersistedRuntimeQueuedMessages,
+  mergeRuntimeMessageQueueThreadState,
+} from '${runtimeMessageQueueImport}'
+
+const queuedA = { id: 'local-a', clientMessageId: 'client-a', deliveryState: 'queued' } as any
+const queuedB = { id: 'local-b', clientMessageId: 'client-b', deliveryState: 'queued' } as any
+const queuedC = { id: 'local-c', clientMessageId: 'client-c', deliveryState: 'queued' } as any
+const serverA = { ...queuedA, id: 'server-a', serverRequestId: 'server-a', backgroundPersisted: true }
+const serverC = { ...queuedC, id: 'server-c', serverRequestId: 'server-c', backgroundPersisted: true }
+assert.deepEqual(mergePersistedRuntimeQueuedMessages([queuedA, queuedB], [serverA]), {
+  queue: [serverA, queuedB],
+  orphanedServerRequestIds: [],
+})
+assert.deepEqual(mergePersistedRuntimeQueuedMessages([queuedB], [serverA]), {
+  queue: [queuedB],
+  orphanedServerRequestIds: ['server-a'],
+})
+assert.deepEqual(
+  mergeRuntimeMessageQueueThreadState([serverA, queuedB, serverC], [serverC, serverA]),
+  [serverA, queuedB, serverC],
+)
+assert.deepEqual(
+  mergeRuntimeMessageQueueThreadState([serverA, queuedB, serverC], [serverC, serverA], false),
+  [serverC, serverA, queuedB],
+)
+assert.deepEqual(mergeRuntimeMessageQueueThreadState([serverA], []), [])
 
 const resumePdfCitation = ':codex-file-citation{path="E:/javaword/CXCodex/role_resumes/邵卫-产品与项目经理-优化投递版-2026-08-03.pdf" purpose="产品与项目经理通用投递简历"}'
 assert.deepEqual(readCodexFileCitationAt(resumePdfCitation, 0), {
@@ -171,19 +202,53 @@ assert.equal(isCxSessionFilesChangedMethod('turn/completed'), false)
 assert.equal(readCxSessionFileChangeSource({ source: 'session-log' }), 'session-log')
 assert.equal(readCxSessionFileChangeSource({ source: 'session-index' }), 'session-index')
 assert.equal(readCxSessionFileChangeSource({ source: 'unknown' }), '')
+assert.equal(readCxSessionFileChangeOrigin({ origin: 'live-app-server' }), 'live-app-server')
+assert.equal(readCxSessionFileChangeOrigin({ origin: 'external' }), 'external')
+assert.equal(readCxSessionFileChangeOrigin({ origin: 'unknown' }), '')
 assert.deepEqual(
   getCxSessionFileChangeSyncPolicy(CX_SESSION_FILES_CHANGED_METHOD, { source: 'session-log' }),
-  { refreshMessages: true, refreshThreads: false },
+  { refreshMessages: true, refreshThreads: false, preferSessionLogMessages: true },
+)
+assert.deepEqual(
+  getCxSessionFileChangeSyncPolicy(CX_SESSION_FILES_CHANGED_METHOD, {
+    source: 'session-log',
+    origin: 'live-app-server',
+  }),
+  { refreshMessages: true, refreshThreads: false, preferSessionLogMessages: true },
 )
 assert.deepEqual(
   getCxSessionFileChangeSyncPolicy(CX_SESSION_FILES_CHANGED_METHOD, { source: 'session-index' }),
-  { refreshMessages: false, refreshThreads: true },
+  { refreshMessages: false, refreshThreads: true, preferSessionLogMessages: false },
 )
 assert.deepEqual(
   getCxSessionFileChangeSyncPolicy(CX_SESSION_FILES_CHANGED_METHOD, {}),
-  { refreshMessages: true, refreshThreads: true },
+  { refreshMessages: true, refreshThreads: true, preferSessionLogMessages: false },
 )
 assert.equal(getCxSessionFileChangeSyncPolicy('turn/completed', { source: 'session-log' }), null)
+assert.equal(isOptimisticOnlyExecutionEvidence({
+  executionActive: true,
+  sourceInProgress: false,
+  runtimeFreshActive: true,
+  hasRunningCommand: false,
+  hasPendingServerRequest: false,
+  hasFreshExecutionSignal: false,
+  pendingTurnAgeMs: null,
+  recoveryGraceMs: 2_500,
+  hasActiveTurnId: true,
+  queueProcessing: false,
+}), false)
+assert.equal(isOptimisticOnlyExecutionEvidence({
+  executionActive: true,
+  sourceInProgress: false,
+  runtimeFreshActive: false,
+  hasRunningCommand: false,
+  hasPendingServerRequest: false,
+  hasFreshExecutionSignal: false,
+  pendingTurnAgeMs: null,
+  recoveryGraceMs: 2_500,
+  hasActiveTurnId: true,
+  queueProcessing: false,
+}), true)
 assert.equal(resolveSendWithEnterPreference(null, false), true)
 assert.equal(resolveSendWithEnterPreference(null, true), false)
 assert.equal(resolveSendWithEnterPreference('1', true), true)
diff --git a/src/api/runtimeMessageQueue.ts b/src/api/runtimeMessageQueue.ts
index 1e64595..7c92785 100644
--- a/src/api/runtimeMessageQueue.ts
+++ b/src/api/runtimeMessageQueue.ts
@@ -269,9 +269,59 @@ export function saveQueuedMessagesMap(
   }
 }
 
+export function mergeRuntimeMessageQueueThreadState(
+  currentQueue: RuntimeQueuedMessage[],
+  serverQueue: RuntimeQueuedMessage[],
+  preserveCurrentOrder = true,
+): RuntimeQueuedMessage[] {
+  if (!preserveCurrentOrder) {
+    const serverClientMessageIds = new Set(serverQueue.map((message) => message.clientMessageId))
+    const localOnly = currentQueue.filter((message) => (
+      !message.serverRequestId && !serverClientMessageIds.has(message.clientMessageId)
+    ))
+    return [...serverQueue, ...localOnly]
+  }
+  const serverByClientMessageId = new Map(
+    serverQueue.map((message) => [message.clientMessageId, message] as const),
+  )
+  const next: RuntimeQueuedMessage[] = []
+  for (const message of currentQueue) {
+    const serverMessage = serverByClientMessageId.get(message.clientMessageId)
+    if (serverMessage) {
+      next.push(serverMessage)
+      serverByClientMessageId.delete(message.clientMessageId)
+    } else if (!message.serverRequestId) {
+      next.push(message)
+    }
+  }
+  next.push(...serverByClientMessageId.values())
+  return next
+}
+
+export function mergePersistedRuntimeQueuedMessages(
+  currentQueue: RuntimeQueuedMessage[],
+  persistedQueue: RuntimeQueuedMessage[],
+): { queue: RuntimeQueuedMessage[]; orphanedServerRequestIds: string[] } {
+  const currentClientMessageIds = new Set(currentQueue.map((message) => message.clientMessageId))
+  const persistedByClientMessageId = new Map(
+    persistedQueue.map((message) => [message.clientMessageId, message] as const),
+  )
+  return {
+    queue: currentQueue.map((message) => (
+      persistedByClientMessageId.get(message.clientMessageId) ?? message
+    )),
+    orphanedServerRequestIds: persistedQueue.flatMap((message) => (
+      message.serverRequestId && !currentClientMessageIds.has(message.clientMessageId)
+        ? [message.serverRequestId]
+        : []
+    )),
+  }
+}
+
 export async function syncRuntimeMessageQueueState(
   current: Record<string, RuntimeQueuedMessage[]>,
   threadId = '',
+  preserveCurrentOrder = true,
 ): Promise<Record<string, RuntimeQueuedMessage[]>> {
   const normalizedThreadId = threadId.trim()
   const entries = await listRuntimeMessageQueue(normalizedThreadId)
@@ -283,10 +333,11 @@ export async function syncRuntimeMessageQueueState(
   }
   const merge = (targetThreadId: string): RuntimeQueuedMessage[] => {
     const serverQueue = serverByThreadId.get(targetThreadId) ?? []
-    const serverClientIds = new Set(serverQueue.map((message) => message.clientMessageId))
-    const localOnly = (current[targetThreadId] ?? [])
-      .filter((message) => !message.serverRequestId && !serverClientIds.has(message.clientMessageId))
-    return [...serverQueue, ...localOnly]
+    return mergeRuntimeMessageQueueThreadState(
+      current[targetThreadId] ?? [],
+      serverQueue,
+      preserveCurrentOrder,
+    )
   }
   if (normalizedThreadId) {
     const queue = merge(normalizedThreadId)
@@ -318,7 +369,8 @@ export async function persistRuntimeQueuedMessages(
 ): Promise<RuntimeQueuedMessage[]> {
   let next = [...queue]
   for (const message of queue) {
-    if (message.serverRequestId || message.deliveryState === 'failed') continue
+    if (message.deliveryState === 'failed') break
+    if (message.serverRequestId) continue
     try {
       const entry = await enqueueRuntimeThreadTurn({
         threadId,
@@ -342,6 +394,7 @@ export async function persistRuntimeQueuedMessages(
           ? { ...candidate, deliveryState: 'failed' }
           : candidate)
       }
+      break
     }
   }
   return next
@@ -412,3 +465,17 @@ export async function retryRuntimeQueuedMessage(requestId: string): Promise<void
     throw new Error(errorMessageFromPayload(await response.json(), 'Failed to retry queued message'))
   }
 }
+
+export async function reorderRuntimeQueuedMessages(threadId: string, requestIds: string[]): Promise<boolean> {
+  if (!threadId.trim() || requestIds.length < 2) return true
+  const response = await queueFetch('/codex-api/runtime/queue/reorder', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ threadId: threadId.trim(), requestIds }),
+  }, 'Runtime queue reorder request')
+  if (response.status === 409) return false
+  if (!response.ok) {
+    throw new Error(errorMessageFromPayload(await response.json(), 'Failed to reorder queued messages'))
+  }
+  return true
+}
diff --git a/src/components/mobile/TaskPetPreview.vue b/src/components/mobile/TaskPetPreview.vue
index 3f78953..f94261c 100644
--- a/src/components/mobile/TaskPetPreview.vue
+++ b/src/components/mobile/TaskPetPreview.vue
@@ -1,7 +1,7 @@
 <template>
   <div
     class="task-pet-preview"
-    :class="{ 'is-expanded': expanded, 'is-minimized': minimized }"
+    :class="{ 'is-expanded': expanded, 'is-minimized': minimized, 'is-docked': !expanded && !peekVisible }"
     aria-label="任务宠物预览"
   >
     <Transition name="task-pet-panel">
@@ -15,7 +15,7 @@
             <button class="task-pet-preview-brand-action" type="button" aria-label="进入平台" @click.stop="$emit('enter')">
               <img src="/branding/cx-codex-logo.png" alt="" aria-hidden="true">
             </button>
-            <button class="task-pet-preview-close-action" type="button" aria-label="关闭浮窗" @click.stop="closeConfirmationVisible = true">×</button>
+            <button class="task-pet-preview-close-action" type="button" aria-label="关闭浮窗" @click.stop="showCloseConfirmation">×</button>
           </span>
         </div>
         <template v-if="!closeConfirmationVisible">
@@ -24,7 +24,7 @@
             :key="item.threadId"
             class="task-pet-preview-row"
             type="button"
-            @click="$emit('open', item.threadId)"
+            @click="openTask(item)"
           >
             <span class="task-pet-preview-dot" :data-state="item.state" />
             <span class="task-pet-preview-copy">
@@ -41,50 +41,12 @@
             <span class="task-pet-preview-arrow" aria-hidden="true">›</span>
           </button>
           <p v-if="visibleItems.length === 0" class="task-pet-preview-empty">没有正在运行的任务</p>
-          <section v-if="visibleRecentThreads.length > 0" class="task-pet-preview-recents" aria-label="最近会话">
-            <strong>最近会话</strong>
-            <button
-              v-for="thread in visibleRecentThreads"
-              :key="thread.threadId"
-              type="button"
-              :aria-label="`${thread.title}，点击打开，长按直接回复`"
-              @pointerdown="beginRecentPress(thread, $event)"
-              @pointerup="cancelRecentPress"
-              @pointercancel="cancelRecentPress"
-              @pointerleave="cancelRecentPress"
-              @contextmenu.prevent="openRecentReply(thread)"
-              @click="openRecentThread(thread)"
-            >
-              <span>{{ thread.title }}</span>
-              <small>{{ thread.projectName ? `${thread.projectName} · 长按回复` : '长按回复' }}</small>
-              <span aria-hidden="true">›</span>
-            </button>
-          </section>
-          <form
-            v-if="recentReplyThread"
-            class="task-pet-preview-reply"
-            aria-label="快捷回复最近会话"
-            @submit.prevent="submitRecentReply"
-          >
-            <strong>回复 · {{ recentReplyThread.title }}</strong>
-            <textarea
-              ref="recentReplyInput"
-              v-model="recentReplyDraft"
-              rows="2"
-              maxlength="2000"
-              placeholder="输入回复内容…"
-            />
-            <div>
-              <button type="button" @click="closeRecentReply">取消</button>
-              <button type="submit" :disabled="!recentReplyDraft.trim()">发送</button>
-            </div>
-          </form>
         </template>
         <section v-else class="task-pet-preview-close-confirm" role="alertdialog" aria-label="确认关闭浮窗">
           <strong>关闭任务宠物浮窗？</strong>
           <p>关闭后不再显示，但可随时在设置中重新开启。</p>
           <div>
-            <button type="button" @click="closeConfirmationVisible = false">取消</button>
+            <button type="button" @click="cancelCloseConfirmation">取消</button>
             <button type="button" data-tone="danger" @click="confirmClose">确认关闭</button>
           </div>
         </section>
@@ -93,11 +55,11 @@
 
     <Transition name="task-pet-compact">
       <button
-        v-if="!expanded && !minimized && primaryItem"
+        v-if="!expanded && !minimized && peekVisible && primaryItem"
         class="task-pet-preview-compact"
         type="button"
         :aria-label="`${taskReply(primaryItem)}，点击打开会话 ${primaryItem.title}`"
-        @click="$emit('open', primaryItem.threadId)"
+        @click="openTask(primaryItem)"
       >
         <small>
           {{ primaryItem.title }}<template v-if="primaryItem.projectName"> · {{ primaryItem.projectName }}</template>
@@ -117,8 +79,8 @@
         @click="restore"
       >
         <img :key="`mini-${mascotState}`" :src="mascotStaticAsset" alt="" aria-hidden="true">
-        <span v-if="items.length > 0" class="task-pet-preview-mini-badge" :data-waiting="hasWaitingTask">
-          {{ items.length > 9 ? '9+' : items.length }}
+        <span v-if="attentionCount > 0" class="task-pet-preview-mini-badge" :data-waiting="hasWaitingTask">
+          {{ attentionCount > 9 ? '9+' : attentionCount }}
         </span>
       </button>
       <button
@@ -135,9 +97,8 @@
           <source media="(prefers-reduced-motion: reduce)" :srcset="mascotStaticAsset">
           <img class="task-pet-preview-character" :src="mascotAnimatedAsset" alt="" aria-hidden="true">
         </picture>
-        <span class="task-pet-preview-state">{{ hasWaitingTask ? '待处理' : visibleItems.length > 0 ? '工作中' : '待命' }}</span>
-        <span v-if="items.length > 0" class="task-pet-preview-badge" :data-waiting="hasWaitingTask">
-          {{ items.length > 99 ? '99+' : items.length }}
+        <span v-if="attentionCount > 0" class="task-pet-preview-badge" :data-waiting="hasWaitingTask">
+          {{ attentionCount > 99 ? '99+' : attentionCount }}
         </span>
       </button>
     </Transition>
@@ -145,7 +106,7 @@
 </template>
 
 <script setup lang="ts">
-import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
 import type { UiTaskPetItem, UiTaskPetRecentThread } from '../../types/codex'
 
 const props = withDefaults(defineProps<{
@@ -154,7 +115,7 @@ const props = withDefaults(defineProps<{
   initiallyExpanded?: boolean
 }>(), {
   recentThreads: () => [],
-  initiallyExpanded: true,
+  initiallyExpanded: false,
 })
 
 const emit = defineEmits<{
@@ -166,15 +127,19 @@ const emit = defineEmits<{
 
 const expanded = ref(props.initiallyExpanded && props.items.length > 0)
 const minimized = ref(props.items.length === 0)
+const peekVisible = ref(false)
+const unreadReplyTaskKeys = ref<ReadonlySet<string>>(new Set())
+const seenReplyEventSeqByTaskKey = new Map(
+  props.items.map((item) => [taskKey(item), Math.max(0, item.latestReplyEventSeq ?? 0)]),
+)
 const closeConfirmationVisible = ref(false)
-const recentReplyThread = ref<UiTaskPetRecentThread | null>(null)
-const recentReplyDraft = ref('')
-const recentReplyInput = ref<HTMLTextAreaElement | null>(null)
-const suppressRecentOpenThreadId = ref('')
 const nowMs = ref(Date.now())
-let recentPressTimer: ReturnType<typeof setTimeout> | null = null
 let freshnessTimer: ReturnType<typeof setInterval> | null = null
+let peekTimer: ReturnType<typeof setTimeout> | null = null
+let stackTimer: ReturnType<typeof setTimeout> | null = null
 const NO_PROGRESS_THRESHOLD_MS = 10 * 60_000
+const REPLY_PEEK_TIMEOUT_MS = 5_000
+const TASK_STACK_TIMEOUT_MS = 8_000
 
 function stopFreshnessTimer(): void {
   if (freshnessTimer === null) return
@@ -199,18 +164,22 @@ function onFreshnessVisibilityChange(): void {
 }
 
 onBeforeUnmount(() => {
-  cancelRecentPress()
+  stopPeekTimer()
+  stopStackTimer()
   stopFreshnessTimer()
   document.removeEventListener('visibilitychange', onFreshnessVisibilityChange)
 })
 onMounted(() => {
   startFreshnessTimer()
   document.addEventListener('visibilitychange', onFreshnessVisibilityChange)
+  if (expanded.value) scheduleStackCollapse()
 })
 const visibleItems = computed(() => props.items.slice(0, 3))
 const primaryItem = computed(() => visibleItems.value[0] ?? null)
-const visibleRecentThreads = computed(() => props.recentThreads.slice(0, 2))
 const hasWaitingTask = computed(() => props.items.some((item) => item.state === 'waiting'))
+const attentionCount = computed(() => props.items.filter((item) => (
+  item.state === 'waiting' || unreadReplyTaskKeys.value.has(taskKey(item))
+)).length)
 const mascotState = computed(() => hasWaitingTask.value ? 'waiting' : visibleItems.value.length > 0 ? 'working' : 'idle')
 const mascotAnimatedAsset = computed(() => `/assets/task-pet/cx-pet-${mascotState.value}-animated.webp`)
 const mascotStaticAsset = computed(() => `/assets/task-pet/cx-pet-${mascotState.value}.png`)
@@ -220,23 +189,121 @@ watch(() => props.items.length, (count) => {
     minimized.value = false
     return
   }
+  peekVisible.value = false
+  stopPeekTimer()
   if (!expanded.value && !closeConfirmationVisible.value) minimized.value = true
 })
 
+watch(
+  () => props.items.map((item) => `${taskKey(item)}:${Math.max(0, item.latestReplyEventSeq ?? 0)}`).join('|'),
+  () => {
+    const currentTaskKeys = new Set(props.items.map(taskKey))
+    const nextUnreadTaskKeys = new Set(
+      [...unreadReplyTaskKeys.value].filter((key) => currentTaskKeys.has(key)),
+    )
+    const primaryTaskKey = primaryItem.value ? taskKey(primaryItem.value) : ''
+    let primaryReplyChanged = false
+
+    for (const item of props.items) {
+      const key = taskKey(item)
+      const eventSeq = Math.max(0, item.latestReplyEventSeq ?? 0)
+      const previousEventSeq = seenReplyEventSeqByTaskKey.get(key) ?? 0
+      if (eventSeq > previousEventSeq) {
+        nextUnreadTaskKeys.add(key)
+        if (key === primaryTaskKey) primaryReplyChanged = true
+      }
+      seenReplyEventSeqByTaskKey.set(key, Math.max(previousEventSeq, eventSeq))
+    }
+
+    unreadReplyTaskKeys.value = nextUnreadTaskKeys
+    if (primaryReplyChanged && !expanded.value) {
+      minimized.value = false
+      showReplyPeek()
+    }
+  },
+)
+
+function taskKey(item: UiTaskPetItem): string {
+  return `${item.threadId}\u0000${item.activityId || item.startedAtMs || ''}`
+}
+
+function openTask(item: UiTaskPetItem): void {
+  const key = taskKey(item)
+  if (unreadReplyTaskKeys.value.has(key)) {
+    const nextUnreadTaskKeys = new Set(unreadReplyTaskKeys.value)
+    nextUnreadTaskKeys.delete(key)
+    unreadReplyTaskKeys.value = nextUnreadTaskKeys
+  }
+  emit('open', item.threadId)
+}
+
 function restore() {
   minimized.value = false
-  if (props.items.length === 0) expanded.value = true
+  expanded.value = true
+  peekVisible.value = false
+  scheduleStackCollapse()
 }
 
 function toggleExpanded() {
   expanded.value = !expanded.value
+  if (expanded.value) {
+    peekVisible.value = false
+    stopPeekTimer()
+    scheduleStackCollapse()
+    return
+  }
+  stopStackTimer()
+  peekVisible.value = false
+  stopPeekTimer()
   if (!expanded.value && props.items.length === 0) {
-    void nextTick(() => {
-      minimized.value = true
-    })
+    minimized.value = true
   }
 }
 
+function stopPeekTimer() {
+  if (!peekTimer) return
+  clearTimeout(peekTimer)
+  peekTimer = null
+}
+
+function stopStackTimer() {
+  if (!stackTimer) return
+  clearTimeout(stackTimer)
+  stackTimer = null
+}
+
+function showReplyPeek() {
+  stopPeekTimer()
+  if (!primaryItem.value || minimized.value || expanded.value) return
+  peekVisible.value = true
+  peekTimer = setTimeout(() => {
+    peekTimer = null
+    peekVisible.value = false
+  }, REPLY_PEEK_TIMEOUT_MS)
+}
+
+function scheduleStackCollapse() {
+  stopStackTimer()
+  if (!expanded.value) return
+  stackTimer = setTimeout(() => {
+    stackTimer = null
+    if (closeConfirmationVisible.value) return
+    expanded.value = false
+    peekVisible.value = false
+    if (props.items.length === 0 && !closeConfirmationVisible.value) minimized.value = true
+  }, TASK_STACK_TIMEOUT_MS)
+}
+
+function showCloseConfirmation() {
+  stopStackTimer()
+  closeConfirmationVisible.value = true
+}
+
+function cancelCloseConfirmation() {
+  closeConfirmationVisible.value = false
+  if (expanded.value) scheduleStackCollapse()
+}
+
 function taskReply(item: UiTaskPetItem): string {
   return item.latestReply || item.latestActivity || item.detail || '正在等待新的回复…'
 }
@@ -263,55 +330,12 @@ function taskFreshness(item: UiTaskPetItem): string {
 }
 
 function confirmClose() {
+  stopPeekTimer()
+  stopStackTimer()
   closeConfirmationVisible.value = false
   expanded.value = false
   emit('close')
 }
-
-function beginRecentPress(thread: UiTaskPetRecentThread, event: PointerEvent) {
-  if (event.pointerType === 'mouse' && event.button !== 0) return
-  cancelRecentPress()
-  recentPressTimer = setTimeout(() => {
-    recentPressTimer = null
-    suppressRecentOpenThreadId.value = thread.threadId
-    openRecentReply(thread)
-  }, 520)
-}
-
-function cancelRecentPress() {
-  if (!recentPressTimer) return
-  clearTimeout(recentPressTimer)
-  recentPressTimer = null
-}
-
-function openRecentThread(thread: UiTaskPetRecentThread) {
-  cancelRecentPress()
-  if (suppressRecentOpenThreadId.value === thread.threadId) {
-    suppressRecentOpenThreadId.value = ''
-    return
-  }
-  emit('open', thread.threadId)
-}
-
-function openRecentReply(thread: UiTaskPetRecentThread) {
-  cancelRecentPress()
-  recentReplyThread.value = thread
-  recentReplyDraft.value = ''
-  void nextTick(() => recentReplyInput.value?.focus())
-}
-
-function closeRecentReply() {
-  recentReplyThread.value = null
-  recentReplyDraft.value = ''
-}
-
-function submitRecentReply() {
-  const threadId = recentReplyThread.value?.threadId.trim() ?? ''
-  const message = recentReplyDraft.value.trim()
-  if (!threadId || !message) return
-  emit('reply', threadId, message)
-  closeRecentReply()
-}
 </script>
 
 <style scoped>
@@ -320,7 +344,7 @@ function submitRecentReply() {
   min-height: 100px;
   align-items: flex-end;
   justify-content: flex-end;
-  gap: 8px;
+  gap: 6px;
   padding: 10px;
   overflow: hidden;
   background: color-mix(in srgb, var(--color-bg-secondary, #f4f5f7) 88%, transparent);
@@ -328,7 +352,7 @@ function submitRecentReply() {
 }
 
 .task-pet-preview-panel {
-  width: min(258px, calc(100% - 84px));
+  width: min(248px, calc(100% - 64px));
   padding: 10px;
   background: var(--color-bg-primary, #fff);
   border-radius: 14px;
@@ -338,13 +362,13 @@ function submitRecentReply() {
 
 .task-pet-preview-compact {
   display: flex;
-  width: min(258px, calc(100% - 84px));
+  width: min(224px, calc(100% - 64px));
   min-width: 0;
-  min-height: 82px;
+  min-height: 60px;
   flex-direction: column;
   justify-content: center;
   gap: 2px;
-  padding: 10px 12px;
+  padding: 7px 11px;
   border: 0;
   border-radius: 14px;
   background: var(--color-bg-primary, #fff);
@@ -383,7 +407,7 @@ function submitRecentReply() {
   font-weight: 650;
   line-height: 1.42;
   -webkit-box-orient: vertical;
-  -webkit-line-clamp: 2;
+  -webkit-line-clamp: 1;
 }
 
 .task-pet-preview-compact > span {
@@ -498,8 +522,8 @@ function submitRecentReply() {
   align-items: center;
   gap: 8px;
   margin-top: 6px;
-  min-height: 88px;
-  padding: 8px;
+  min-height: 64px;
+  padding: 6px 8px;
   border: 0;
   border-radius: 10px;
   background: var(--color-bg-secondary, #f2f5f9);
@@ -555,7 +579,7 @@ function submitRecentReply() {
   font-weight: 600;
   line-height: 1.42;
   -webkit-box-orient: vertical;
-  -webkit-line-clamp: 2;
+  -webkit-line-clamp: 1;
 }
 
 .task-pet-preview-copy small {
@@ -711,8 +735,8 @@ function submitRecentReply() {
 
 .task-pet-preview-mascot {
   position: relative;
-  width: 66px;
-  height: 78px;
+  width: 56px;
+  height: 62px;
   flex: none;
   border: 0;
   background: transparent;
@@ -733,9 +757,9 @@ function submitRecentReply() {
 
 .task-pet-preview-character-wrap {
   position: absolute;
-  inset: 0 0 7px;
-  width: 66px;
-  height: 73px;
+  inset: 0;
+  width: 56px;
+  height: 60px;
   filter: drop-shadow(0 4px 5px rgb(43 31 24 / 18%));
   transform-origin: 50% 82%;
   transition: opacity 120ms ease-out;
@@ -756,7 +780,6 @@ function submitRecentReply() {
   animation: task-pet-waiting 520ms ease-out 1;
 }
 
-.task-pet-preview-state,
 .task-pet-preview-badge {
   position: absolute;
   display: grid;
@@ -765,26 +788,15 @@ function submitRecentReply() {
   font-weight: 700;
 }
 
-.task-pet-preview-state {
-  bottom: 0;
-  left: 0;
-  min-width: 42px;
-  height: 21px;
-  padding: 0 7px;
-  background: rgb(255 255 255 / 94%);
-  color: #354052;
-  font-size: 10px;
-}
-
 .task-pet-preview-badge {
-  top: 3px;
+  top: 1px;
   right: 0;
-  min-width: 24px;
-  height: 24px;
+  min-width: 20px;
+  height: 20px;
   padding: 0 5px;
   background: #2a72e8;
   color: white;
-  font-size: 11px;
+  font-size: 10px;
 }
 
 .task-pet-preview-badge[data-waiting='true'] {
@@ -842,6 +854,16 @@ function submitRecentReply() {
   background: #b9670c;
 }
 
+.task-pet-preview.is-docked .task-pet-preview-mini,
+.task-pet-preview.is-docked .task-pet-preview-mascot {
+  transform: translateX(16px);
+}
+
+.task-pet-preview.is-docked .task-pet-preview-mini:active,
+.task-pet-preview.is-docked .task-pet-preview-mascot:active {
+  transform: translateX(16px) scale(0.96);
+}
+
 .task-pet-mode-enter-active,
 .task-pet-mode-leave-active {
   transition: opacity 120ms ease-out, transform 170ms cubic-bezier(0.22, 1, 0.36, 1);
@@ -910,7 +932,7 @@ function submitRecentReply() {
   }
 
   .task-pet-preview-panel {
-    width: calc(100% - 70px);
+    width: calc(100% - 64px);
   }
 
   .task-pet-preview-copy small {
diff --git a/src/components/mobile/TaskPetRegressionFixture.vue b/src/components/mobile/TaskPetRegressionFixture.vue
index 8be648e..03cf18b 100644
--- a/src/components/mobile/TaskPetRegressionFixture.vue
+++ b/src/components/mobile/TaskPetRegressionFixture.vue
@@ -58,6 +58,7 @@ const fixtureItems: UiTaskPetItem[] = [
     detail: '构建并验证安卓浮窗',
     latestActivity: '正在编译原生触控与吸边动画',
     latestReply: '原生浮窗的拖拽、吸边和后台状态同步已经完成，现在正在做最终 APK 构建验证。',
+    latestReplyEventSeq: 101,
     state: 'running',
     updatedAtIso: new Date(Date.now() - 2 * 60_000).toISOString(),
   },
@@ -68,6 +69,7 @@ const fixtureItems: UiTaskPetItem[] = [
     detail: '等待确认',
     latestActivity: '需要允许系统悬浮窗权限',
     latestReply: '发布前还需要你确认系统悬浮窗权限；确认后我会继续完成安装包验证。',
+    latestReplyEventSeq: 91,
     state: 'waiting',
     updatedAtIso: new Date(Date.now() - 32 * 60_000).toISOString(),
   },
@@ -80,6 +82,7 @@ const multiTaskLatestReplyItems: UiTaskPetItem[] = [
     detail: '实时同步',
     latestActivity: '权威快照已经应用',
     latestReply: '最新回复已提升到浮窗可见首行。',
+    latestReplyEventSeq: 121,
     state: 'running',
     updatedAtIso: new Date().toISOString(),
   },
@@ -91,6 +94,7 @@ const multiTaskLatestReplyItems: UiTaskPetItem[] = [
     detail: '继续运行',
     latestActivity: '保持后台监控',
     latestReply: '这条较早回复应留在前三条之外。',
+    latestReplyEventSeq: 71,
     state: 'running',
     updatedAtIso: new Date(Date.now() - 45 * 60_000).toISOString(),
   },
@@ -128,6 +132,7 @@ function simulateLatestReply() {
     {
       ...first,
       latestReply: '浮窗已实时同步最新回复；点击这条气泡会打开当前会话。',
+      latestReplyEventSeq: (first.latestReplyEventSeq ?? 0) + 1,
       updatedAtIso: new Date().toISOString(),
     },
     ...items.value.slice(1),
diff --git a/src/composables/runtimeExecutionRecovery.ts b/src/composables/runtimeExecutionRecovery.ts
new file mode 100644
index 0000000..dbb4711
--- /dev/null
+++ b/src/composables/runtimeExecutionRecovery.ts
@@ -0,0 +1,25 @@
+export type RuntimeExecutionRecoveryEvidence = {
+  executionActive: boolean
+  sourceInProgress: boolean
+  runtimeFreshActive: boolean
+  hasRunningCommand: boolean
+  hasPendingServerRequest: boolean
+  hasFreshExecutionSignal: boolean
+  pendingTurnAgeMs: number | null
+  recoveryGraceMs: number
+  hasActiveTurnId: boolean
+  queueProcessing: boolean
+}
+
+export function isOptimisticOnlyExecutionEvidence(
+  evidence: RuntimeExecutionRecoveryEvidence,
+): boolean {
+  if (!evidence.executionActive) return false
+  if (evidence.sourceInProgress || evidence.runtimeFreshActive) return false
+  if (evidence.hasRunningCommand || evidence.hasPendingServerRequest) return false
+  if (evidence.hasFreshExecutionSignal) return false
+  if (evidence.pendingTurnAgeMs !== null) {
+    return evidence.pendingTurnAgeMs >= evidence.recoveryGraceMs
+  }
+  return evidence.hasActiveTurnId || evidence.queueProcessing
+}
diff --git a/src/composables/useDesktopState.ts b/src/composables/useDesktopState.ts
index ebca7db..9b113bb 100644
--- a/src/composables/useDesktopState.ts
+++ b/src/composables/useDesktopState.ts
@@ -131,6 +131,7 @@ import {
   shouldRestartNotificationStreamOnForeground,
 } from './connectionManager'
 import { shouldApplyRuntimeSnapshotVersion } from './runtimeSnapshotOrdering'
+import { isOptimisticOnlyExecutionEvidence } from './runtimeExecutionRecovery'
 import {
   isRuntimeRequestAwaitingDeliveryConfirmation,
   shouldSettleOptimisticDeliveryFromRuntimeSnapshot,
@@ -265,6 +266,7 @@ const ANDROID_RESUME_SYNC_DEBOUNCE_MS = 2500
 const FOREGROUND_RECOVERY_FEEDBACK_MIN_MS = 500
 const FOREGROUND_RECOVERY_FEEDBACK_TIMEOUT_MS = 8000
 const NON_FRESH_THREAD_DETAIL_RETRY_DELAYS_MS = [2500, 9000, 20000]
+const SESSION_LOG_AUTHORITATIVE_REFRESH_QUIET_MS = 1800
 const ACTIVE_SYNC_THREAD_LIST_INTERVAL_MS = 120000
 const ACTIVE_SYNC_STALE_MS = 14000
 const STALE_THREAD_ACTIVE_TURN_TTL_MS = 5 * 60 * 1000
@@ -1537,6 +1539,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   let activeSyncBoostUntilMs = 0
   let pendingThreadsRefresh = false
   const pendingThreadMessageRefresh = new Set<string>()
+  const pendingSessionLogMessageRefresh = new Set<string>()
   let visibilitySyncTimer: number | null = null
   const resumeSyncTimers = new Set<number>()
   let foregroundRecoveryFeedbackTimer: number | null = null
@@ -1553,6 +1556,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   const settledRuntimeMessageRefreshKeyByThreadId = new Map<string, string>()
   const settledRuntimeRpcRefreshKeyByThreadId = new Map<string, string>()
   const settledRuntimeRpcRefreshInFlightByThreadId = new Map<string, string>()
+  const sessionLogAuthoritativeRefreshGenerationByThreadId = new Map<string, number>()
+  let sessionLogAuthoritativeRefreshGeneration = 0
   const cachedThreadMessageSignatureByThreadId = new Map<string, string>()
   const latestRuntimeEventSeqByThreadId = new Map<string, number>()
   const lastExecutionSignalPublishedAtByThreadId = new Map<string, number>()
@@ -2617,11 +2622,15 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     replaceQueuedMessagesState(nextState)
   }
 
-  function syncRuntimeMessageQueue(threadId = ''): Promise<void> {
+  function syncRuntimeMessageQueue(threadId = '', preserveCurrentOrder = true): Promise<void> {
     const normalizedThreadId = threadId.trim()
     const sync = async (): Promise<void> => {
       const api = await import('../api/runtimeMessageQueue')
-      const next = await api.syncRuntimeMessageQueueState(queuedMessagesByThreadId.value, normalizedThreadId)
+      const next = await api.syncRuntimeMessageQueueState(
+        queuedMessagesByThreadId.value,
+        normalizedThreadId,
+        preserveCurrentOrder,
+      )
       replaceQueuedMessagesState(next)
     }
 
@@ -3248,6 +3257,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     setTurnErrorForThread(threadId, errorMessage)
     error.value = errorMessage
     pendingThreadMessageRefresh.delete(threadId)
+    pendingSessionLogMessageRefresh.delete(threadId)
     pendingThreadsRefresh = true
 
     if (!isMissingThreadError(terminalError)) {
@@ -4210,20 +4220,19 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   }
 
   function hasOptimisticOnlyExecutionState(threadId: string): boolean {
-    if (!threadId || !isThreadExecutionActive(threadId)) return false
-    if (sourceThreadById.value[threadId]?.inProgress === true) return false
-    if (hasRunningLiveCommand(threadId) || hasPersistedRunningCommand(threadId)) return false
-    if (hasPendingServerRequestSignal(threadId)) return false
-    if (hasFreshExecutionSignal(threadId, OPTIMISTIC_EXECUTION_RECOVERY_GRACE_MS)) return false
-
     const pendingTurnRequest = pendingTurnRequestByThreadId.value[threadId]
-    if (pendingTurnRequest) {
-      return Date.now() - pendingTurnRequest.createdAtMs >= OPTIMISTIC_EXECUTION_RECOVERY_GRACE_MS
-    }
-
-    if (activeTurnIdByThreadId.value[threadId]) return true
-    if (queueProcessingByThreadId.value[threadId] === true) return true
-    return false
+    return isOptimisticOnlyExecutionEvidence({
+      executionActive: Boolean(threadId) && isThreadExecutionActive(threadId),
+      sourceInProgress: sourceThreadById.value[threadId]?.inProgress === true,
+      runtimeFreshActive: isRuntimeExecutionFreshActiveState(threadId),
+      hasRunningCommand: hasRunningLiveCommand(threadId) || hasPersistedRunningCommand(threadId),
+      hasPendingServerRequest: hasPendingServerRequestSignal(threadId),
+      hasFreshExecutionSignal: hasFreshExecutionSignal(threadId, OPTIMISTIC_EXECUTION_RECOVERY_GRACE_MS),
+      pendingTurnAgeMs: pendingTurnRequest ? Date.now() - pendingTurnRequest.createdAtMs : null,
+      recoveryGraceMs: OPTIMISTIC_EXECUTION_RECOVERY_GRACE_MS,
+      hasActiveTurnId: Boolean(activeTurnIdByThreadId.value[threadId]),
+      queueProcessing: queueProcessingByThreadId.value[threadId] === true,
+    })
   }
 
   function reconcileLiveThreadState(threadId: string, inProgress: boolean): void {
@@ -6944,6 +6953,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
   ): void {
     const threadId = extractThreadIdFromNotification(notification)
     const method = notification.method
+    const sessionFileChangePolicy = getCxSessionFileChangeSyncPolicy(method, notification.params)
     const urgentRefresh = shouldUrgentlyRefreshFromNotification(method)
     const shouldRefreshMessages =
       shouldRefreshMessagesFromNotification(notification) &&
@@ -6961,6 +6971,10 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
     if (threadId && shouldRefreshMessages) {
       pendingThreadMessageRefresh.add(threadId)
+      if (sessionFileChangePolicy?.preferSessionLogMessages === true) {
+        pendingSessionLogMessageRefresh.add(threadId)
+        scheduleSessionLogAuthoritativeRefresh(threadId)
+      }
     }
 
     if (shouldRefreshThreads) {
@@ -7271,11 +7285,15 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
     settledRuntimeRpcRefreshInFlightByThreadId.set(threadId, refreshKey)
     const runRefresh = () => {
-      void loadMessages(threadId, { silent: true, forceSettledRpcRefresh: true }).finally(() => {
-        if (settledRuntimeRpcRefreshInFlightByThreadId.get(threadId) === refreshKey) {
-          settledRuntimeRpcRefreshInFlightByThreadId.delete(threadId)
-        }
-      })
+      void loadMessages(threadId, { silent: true, forceSettledRpcRefresh: true })
+        .catch((error) => {
+          if (!isAbortLikeError(error)) setSyncErrorFromUnknown(error)
+        })
+        .finally(() => {
+          if (settledRuntimeRpcRefreshInFlightByThreadId.get(threadId) === refreshKey) {
+            settledRuntimeRpcRefreshInFlightByThreadId.delete(threadId)
+          }
+        })
     }
 
     if (typeof window === 'undefined') {
@@ -7285,6 +7303,20 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     window.setTimeout(runRefresh, 80)
   }
 
+  function scheduleSessionLogAuthoritativeRefresh(threadId: string): void {
+    if (!threadId || typeof window === 'undefined') return
+    const generation = ++sessionLogAuthoritativeRefreshGeneration
+    sessionLogAuthoritativeRefreshGenerationByThreadId.set(threadId, generation)
+    window.setTimeout(() => {
+      if (sessionLogAuthoritativeRefreshGenerationByThreadId.get(threadId) !== generation) return
+      sessionLogAuthoritativeRefreshGenerationByThreadId.delete(threadId)
+      if (selectedThreadId.value !== threadId) return
+      void loadMessages(threadId, { silent: true, forceSettledRpcRefresh: true }).catch((error) => {
+        if (!isAbortLikeError(error)) setSyncErrorFromUnknown(error)
+      })
+    }, SESSION_LOG_AUTHORITATIVE_REFRESH_QUIET_MS)
+  }
+
   async function refreshSettledSnapshotMessagesFromRpc(
     threadId: string,
     snapshot: ThreadRuntimeSnapshot,
@@ -7358,6 +7390,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       silent?: boolean
       signal?: AbortSignal
       forceSettledRpcRefresh?: boolean
+      preferSessionLogMessages?: boolean
       fullHistory?: boolean
       olderHistory?: { beforeTurnIndex: number; limit?: number }
     } = {},
@@ -7375,6 +7408,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (
       options.silent === true &&
       options.forceSettledRpcRefresh !== true &&
+      options.preferSessionLogMessages !== true &&
       options.fullHistory !== true &&
       !options.olderHistory &&
       alreadyLoaded &&
@@ -7405,7 +7439,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         }
       }
       if (options.signal?.aborted) return
-      if (options.forceSettledRpcRefresh !== true) {
+      if (options.forceSettledRpcRefresh !== true && options.preferSessionLogMessages !== true) {
         return
       }
       if (existingWasAuthoritative && options.fullHistory !== true && !options.olderHistory) {
@@ -7423,7 +7457,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       try {
         snapshot = await getThreadRuntimeSnapshot(threadId, {
           signal: options.signal,
-          preferCachedMessages: shouldShowLoading || options.fullHistory === true || Boolean(options.olderHistory),
+          preferCachedMessages:
+            options.preferSessionLogMessages === true ||
+            shouldShowLoading ||
+            options.fullHistory === true ||
+            Boolean(options.olderHistory),
         })
       } catch (error) {
         if (resumedThreadById.value[threadId] === true || !isThreadMaterializingError(error)) {
@@ -7432,7 +7470,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         await ensureThreadResumed(threadId, { signal: options.signal })
         snapshot = await getThreadRuntimeSnapshot(threadId, {
           signal: options.signal,
-          preferCachedMessages: shouldShowLoading || options.fullHistory === true || Boolean(options.olderHistory),
+          preferCachedMessages:
+            options.preferSessionLogMessages === true ||
+            shouldShowLoading ||
+            options.fullHistory === true ||
+            Boolean(options.olderHistory),
         })
       }
       if (options.signal?.aborted) return
@@ -7454,7 +7496,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       const deferredRefreshKey = settledRefreshKey || (shouldDeferCachedRpcRefresh
         ? `cached:${snapshot.updatedAtIso}:${String(snapshot.lastEventSeq)}`
         : '')
-      if ((shouldDeferSettledRpcRefresh || shouldDeferCachedRpcRefresh) && deferredRefreshKey) {
+      if (options.preferSessionLogMessages === true && snapshot.messageState === 'cached') {
+        // Apply the bounded local projection immediately, then converge once after the
+        // session file has been quiet so structured items cannot remain permanently lossy.
+        scheduleSessionLogAuthoritativeRefresh(threadId)
+      } else if ((shouldDeferSettledRpcRefresh || shouldDeferCachedRpcRefresh) && deferredRefreshKey) {
         scheduleSettledSnapshotMessagesRpcRefresh(threadId, deferredRefreshKey)
       } else {
         snapshot = await refreshSettledSnapshotMessagesFromRpc(threadId, snapshot, previousPersisted, options.signal, {
@@ -7464,6 +7510,9 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
         })
       }
       if (options.signal?.aborted) return
+      if (snapshot.messageState === 'fresh') {
+        sessionLogAuthoritativeRefreshGenerationByThreadId.delete(threadId)
+      }
 
       const refreshedRuntimeSnapshotApplied = snapshot === initialRuntimeSnapshot
         ? false
@@ -7546,7 +7595,11 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       }
 
       const version = snapshot.updatedAtIso || currentThreadVersion(threadId)
-      if (runtimeSnapshotApplied && version && snapshot.messageState === 'fresh') {
+      if (
+        runtimeSnapshotApplied &&
+        version &&
+        (snapshot.messageState === 'fresh' || options.preferSessionLogMessages === true)
+      ) {
         loadedVersionByThreadId.value = {
           ...loadedVersionByThreadId.value,
           [threadId]: version,
@@ -7824,6 +7877,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       abortCurrentSync()
       clearBufferedLiveDeltas()
       pendingThreadMessageRefresh.delete(threadId)
+      pendingSessionLogMessageRefresh.delete(threadId)
 
       try {
         const reconciledSnapshot = await reconcileThreadRuntime(threadId)
@@ -7873,6 +7927,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       abortCurrentSync()
       clearBufferedLiveDeltas()
       pendingThreadMessageRefresh.delete(threadId)
+      pendingSessionLogMessageRefresh.delete(threadId)
       await loadMessages(threadId, {
         silent: true,
         forceSettledRpcRefresh: true,
@@ -8868,18 +8923,40 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
     if (queueProcessingByThreadId.value[threadId] === true) return
     const queue = queuedMessagesByThreadId.value[threadId]
     if (!queue || queue.length === 0) return
+    const attemptedClientMessageIds = new Set(
+      queue.filter((message) => !message.serverRequestId).map((message) => message.clientMessageId),
+    )
     queueProcessingByThreadId.value = {
       ...queueProcessingByThreadId.value,
       [threadId]: true,
     }
     try {
       const api = await import('../api/runtimeMessageQueue')
-      setQueuedMessagesForThread(threadId, await api.persistRuntimeQueuedMessages(threadId, queue))
+      const persisted = await api.persistRuntimeQueuedMessages(threadId, queue)
+      const merged = api.mergePersistedRuntimeQueuedMessages(
+        queuedMessagesByThreadId.value[threadId] ?? [],
+        persisted,
+      )
+      setQueuedMessagesForThread(threadId, merged.queue)
+      await Promise.allSettled(merged.orphanedServerRequestIds.map((requestId) => (
+        api.removeRuntimeQueuedMessage(requestId)
+      )))
       await syncRuntimeMessageQueue(threadId)
+      const serverRequestIds = (queuedMessagesByThreadId.value[threadId] ?? []).flatMap((message) => (
+        message.serverRequestId ? [message.serverRequestId] : []
+      ))
+      const reordered = await api.reorderRuntimeQueuedMessages(threadId, serverRequestIds)
+      if (!reordered) await syncRuntimeMessageQueue(threadId, false)
     } catch {
       // The local queue remains durable and will migrate when 7420 reconnects.
     } finally {
       queueProcessingByThreadId.value = omitKey(queueProcessingByThreadId.value, threadId)
+      const hasNewLocalMessage = (queuedMessagesByThreadId.value[threadId] ?? []).some((message) => (
+        !message.serverRequestId
+        && message.deliveryState !== 'failed'
+        && !attemptedClientMessageIds.has(message.clientMessageId)
+      ))
+      if (hasNewLocalMessage) void processQueuedMessages(threadId)
     }
   }
 
@@ -9264,8 +9341,13 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
     const refreshSelectedMessagesNow = async (threadId: string): Promise<void> => {
       if (!threadId) return
-      await loadMessages(threadId, { silent: true, signal: controller?.signal })
+      await loadMessages(threadId, {
+        silent: true,
+        signal: controller?.signal,
+        preferSessionLogMessages: pendingSessionLogMessageRefresh.has(threadId),
+      })
       pendingThreadMessageRefresh.delete(threadId)
+      pendingSessionLogMessageRefresh.delete(threadId)
       refreshedMessageThreadId = threadId
     }
 
@@ -9703,14 +9785,20 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
     const shouldRefreshThreads = pendingThreadsRefresh
     const threadIdsToRefresh = new Set(pendingThreadMessageRefresh)
+    const sessionLogThreadIdsToRefresh = new Set(pendingSessionLogMessageRefresh)
     pendingThreadsRefresh = false
     pendingThreadMessageRefresh.clear()
+    pendingSessionLogMessageRefresh.clear()
     let wasAborted = false
     let refreshedMessageThreadId = ''
 
     const refreshActiveMessagesNow = async (threadId: string): Promise<void> => {
       if (!threadId) return
-      await loadMessages(threadId, { silent: true, signal: controller?.signal })
+      await loadMessages(threadId, {
+        silent: true,
+        signal: controller?.signal,
+        preferSessionLogMessages: sessionLogThreadIdsToRefresh.has(threadId),
+      })
       refreshedMessageThreadId = threadId
     }
 
@@ -9908,6 +9996,7 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
       })
       if (signal.aborted) return
       pendingThreadMessageRefresh.delete(activeThreadId)
+      pendingSessionLogMessageRefresh.delete(activeThreadId)
     }
     pendingThreadsRefresh = false
   }
@@ -9942,6 +10031,8 @@ export function useDesktopState(submitCallbacks: DesktopStateSubmitCallbacks = {
 
     pendingThreadsRefresh = false
     pendingThreadMessageRefresh.clear()
+    pendingSessionLogMessageRefresh.clear()
+    sessionLogAuthoritativeRefreshGenerationByThreadId.clear()
     pendingTurnStartsById.clear()
     clearNonFreshThreadDetailRetries()
     clearEventSyncTimer()
diff --git a/src/server/appServerNotificationRuntimeSync.ts b/src/server/appServerNotificationRuntimeSync.ts
index 2fccd67..30e985d 100644
--- a/src/server/appServerNotificationRuntimeSync.ts
+++ b/src/server/appServerNotificationRuntimeSync.ts
@@ -37,23 +37,46 @@ export type BridgeNotificationRuntimeSyncSubscriberDependencies = BridgeNotifica
   subscribeNotifications(listener: (notification: AppServerNotification) => void): () => void
 }
 
+const TRANSIENT_RUNTIME_PROGRESS_METHODS = new Set([
+  'item/commandExecution/outputDelta',
+  'item/commandExecution/terminalInteraction',
+  'item/fileChange/outputDelta',
+  'item/fileChange/patchUpdated',
+  'item/mcpToolCall/progress',
+  'command/exec/outputDelta',
+  'process/outputDelta',
+])
+const INTERNAL_RUNTIME_NOTIFICATION_METHODS = new Set([
+  'runtime/queue/updated',
+])
+
+function shouldPersistRuntimeSnapshot(method: string): boolean {
+  return !TRANSIENT_RUNTIME_PROGRESS_METHODS.has(method)
+}
+
 export function syncBridgeNotificationRuntimeState(
   notification: AppServerNotification,
   dependencies: BridgeNotificationRuntimeSyncDependencies,
 ): BridgeNotificationEvent {
   const event = dependencies.rememberNotificationEvent(notification)
   const externalSessionFileChange = isCxSessionFilesChangedMethod(notification.method)
-  if (!externalSessionFileChange) {
+  const internalRuntimeNotification = INTERNAL_RUNTIME_NOTIFICATION_METHODS.has(notification.method)
+  if (!externalSessionFileChange && !internalRuntimeNotification) {
     dependencies.runtimeStateStore.observeEvent(event)
   }
 
   const eventThreadId = dependencies.readThreadIdFromPayload(notification.params)
-  if (eventThreadId && !externalSessionFileChange) {
+  if (
+    eventThreadId
+    && !externalSessionFileChange
+    && !internalRuntimeNotification
+    && shouldPersistRuntimeSnapshot(notification.method)
+  ) {
     const snapshot = dependencies.persistRuntimeSnapshot(eventThreadId)
     updateRuntimeRequestsFromSnapshot(eventThreadId, snapshot, dependencies.runtimeStore)
   }
 
-  if (eventThreadId && shouldInvalidateThreadReadCacheForNotification(notification.method)) {
+  if (eventThreadId && shouldInvalidateThreadReadCacheForNotification(notification.method, notification.params)) {
     dependencies.deleteCachedThreadRead(eventThreadId)
   }
 
diff --git a/src/server/appServerRpcCache.ts b/src/server/appServerRpcCache.ts
index ed07332..70ee75c 100644
--- a/src/server/appServerRpcCache.ts
+++ b/src/server/appServerRpcCache.ts
@@ -2,7 +2,10 @@ import { readFileSync } from 'node:fs'
 import { mkdir, writeFile } from 'node:fs/promises'
 import { dirname } from 'node:path'
 
-import { isCxSessionFilesChangedMethod } from '../sessionFileChange.js'
+import {
+  getCxSessionFileChangeSyncPolicy,
+  isCxSessionFilesChangedMethod,
+} from '../sessionFileChange.js'
 import { logBridgeError } from './bridgeLog.js'
 import { getWebThreadListCachePath } from './codexPaths.js'
 
@@ -127,8 +130,10 @@ export function shouldInvalidateThreadReadCacheForRpc(method: string): boolean {
   )
 }
 
-export function shouldInvalidateThreadReadCacheForNotification(method: string): boolean {
-  if (isCxSessionFilesChangedMethod(method)) return true
+export function shouldInvalidateThreadReadCacheForNotification(method: string, params?: unknown): boolean {
+  if (isCxSessionFilesChangedMethod(method)) {
+    return getCxSessionFileChangeSyncPolicy(method, params)?.refreshMessages ?? true
+  }
   if (
     method === 'thread/goal/updated' ||
     method === 'thread/goal/cleared' ||
@@ -152,18 +157,6 @@ export function shouldInvalidateThreadReadCacheForNotification(method: string):
     method === 'item/updated' ||
     method === 'item/completed' ||
     method === 'rawResponseItem/completed' ||
-    method === 'item/agentMessage/delta' ||
-    method === 'item/plan/delta' ||
-    method === 'item/reasoning/summaryTextDelta' ||
-    method === 'item/reasoning/summaryPartAdded' ||
-    method === 'item/reasoning/textDelta' ||
-    method === 'item/commandExecution/outputDelta' ||
-    method === 'item/commandExecution/terminalInteraction' ||
-    method === 'item/fileChange/outputDelta' ||
-    method === 'item/fileChange/patchUpdated' ||
-    method === 'item/mcpToolCall/progress' ||
-    method === 'command/exec/outputDelta' ||
-    method === 'process/outputDelta' ||
     method === 'process/exited'
   )
 }
diff --git a/src/server/appServerSessionLogThreadRead.ts b/src/server/appServerSessionLogThreadRead.ts
index 594fa58..a8028a3 100644
--- a/src/server/appServerSessionLogThreadRead.ts
+++ b/src/server/appServerSessionLogThreadRead.ts
@@ -1,5 +1,5 @@
 import { createReadStream } from 'node:fs'
-import { stat } from 'node:fs/promises'
+import { open, stat } from 'node:fs/promises'
 import { createInterface } from 'node:readline'
 
 const FALLBACK_TURN_LIMIT = 40
@@ -14,6 +14,7 @@ const TRAILING_MEMORY_CITATION_PATTERN = /\s*<oai-mem-citation>[\s\S]*<\/oai-mem
 type FallbackItem = {
   type: 'userMessage' | 'agentMessage'
   id: string
+  phase?: 'commentary'
   content?: Array<{ type: 'text'; text: string }>
   text?: string
 }
@@ -22,6 +23,7 @@ type RecoveredMessage = {
   role: 'user' | 'assistant'
   text: string
   id: string
+  phase?: 'commentary'
   hidden?: boolean
 }
 
@@ -33,6 +35,8 @@ type FallbackTurn = {
 
 type SessionLogThreadReadCacheState = {
   fileSignature: string
+  fileSize: number
+  incrementalReady: boolean
   threadRead: unknown | null
 }
 
@@ -81,6 +85,78 @@ function readFallbackThreadTitle(thread: Record<string, unknown>, preview: strin
   )
 }
 
+function cloneFallbackTurns(value: unknown): FallbackTurn[] {
+  if (!Array.isArray(value)) return []
+
+  const turns: FallbackTurn[] = []
+  for (const row of value) {
+    const turn = asRecord(row)
+    if (!turn || !Array.isArray(turn.items)) continue
+    const items: FallbackItem[] = []
+    for (const itemValue of turn.items) {
+      const item = asRecord(itemValue)
+      if (!item) continue
+      const id = readTrimmedString(item.id)
+      if (item.type === 'userMessage') {
+        const text = readTextContent(item.content)
+        if (text) {
+          items.push({ type: 'userMessage', id, content: [{ type: 'text', text }] })
+        }
+      } else if (item.type === 'agentMessage') {
+        const text = readTrimmedString(item.text)
+        const phase = readTrimmedString(item.phase)
+        if (text) items.push({
+          type: 'agentMessage',
+          id,
+          text,
+          ...(phase === 'commentary' ? { phase } : {}),
+        })
+      }
+    }
+    turns.push({
+      id: readTrimmedString(turn.id) || `fallback-turn-${String(turns.length + 1)}`,
+      status: 'completed',
+      items,
+    })
+  }
+  return turns.slice(-FALLBACK_TURN_LIMIT)
+}
+
+function hydrateRecoveredMessageState(
+  turns: FallbackTurn[],
+  seenMessageIds: Set<string>,
+): RecoveredMessage | null {
+  let lastRecoveredMessage: RecoveredMessage | null = null
+  for (const turn of turns) {
+    for (const item of turn.items) {
+      if (item.id) seenMessageIds.add(item.id)
+      const role = item.type === 'userMessage' ? 'user' : 'assistant'
+      const text = item.type === 'userMessage'
+        ? readTextContent(item.content)
+        : readTrimmedString(item.text)
+      if (text) lastRecoveredMessage = {
+        role,
+        text,
+        id: item.id,
+        ...(item.phase === 'commentary' ? { phase: item.phase } : {}),
+      }
+    }
+  }
+  return lastRecoveredMessage
+}
+
+async function doesFileEndWithNewline(sessionPath: string, fileSize: number): Promise<boolean> {
+  if (fileSize <= 0) return false
+  const handle = await open(sessionPath, 'r')
+  try {
+    const byte = Buffer.allocUnsafe(1)
+    const result = await handle.read(byte, 0, 1, fileSize - 1)
+    return result.bytesRead === 1 && byte[0] === 10
+  } finally {
+    await handle.close()
+  }
+}
+
 function readTextContent(content: unknown): string {
   if (typeof content === 'string') return content.trim()
   if (!Array.isArray(content)) return ''
@@ -124,7 +200,9 @@ function readResponseItemMessage(entry: Record<string, unknown>): RecoveredMessa
   if (payload?.type !== 'message') return null
   const role = payload.role === 'user' || payload.role === 'assistant' ? payload.role : null
   if (!role) return null
-  if (role === 'assistant' && readTrimmedString(payload.phase) === 'commentary') return null
+  const phase = role === 'assistant' && readTrimmedString(payload.phase) === 'commentary'
+    ? 'commentary' as const
+    : undefined
   const rawText = readTextContent(payload.content)
   const text = role === 'assistant' ? normalizeRecoveredAssistantText(rawText) : rawText
   if (!text) return null
@@ -132,7 +210,7 @@ function readResponseItemMessage(entry: Record<string, unknown>): RecoveredMessa
   if (isInternalContextMessageText(text)) {
     return role === 'user' ? { role, text: '', id, hidden: true } : null
   }
-  return { role, text, id }
+  return { role, text, id, ...(phase ? { phase } : {}) }
 }
 
 function readEventMessage(entry: Record<string, unknown>): RecoveredMessage | null {
@@ -181,6 +259,7 @@ function appendMessageTurn(turns: FallbackTurn[], message: RecoveredMessage): vo
         type: 'agentMessage',
         id: itemId,
         text,
+        ...(message.phase === 'commentary' ? { phase: message.phase } : {}),
       })
 
   while (turns.length > FALLBACK_TURN_LIMIT) {
@@ -193,7 +272,12 @@ function isDuplicateRecoveredMessage(
   second: RecoveredMessage,
 ): boolean {
   if (second.hidden) return false
-  if (!first || first.role !== second.role || first.text !== second.text) return false
+  if (
+    !first ||
+    first.role !== second.role ||
+    first.text !== second.text ||
+    first.phase !== second.phase
+  ) return false
   return !first.id || !second.id
 }
 
@@ -209,9 +293,10 @@ function writeCacheState(sessionPath: string, cacheState: SessionLogThreadReadCa
   }
 }
 
-export async function parseThreadReadFromSessionLog(
+async function parseThreadReadFromSessionLogRange(
   sessionPath: string,
   fallbackThreadRead: unknown,
+  options: { startOffset?: number; seedTurns?: boolean } = {},
 ): Promise<unknown | null> {
   const fallbackRoot = asRecord(fallbackThreadRead)
   const fallbackThread = asRecord(fallbackRoot?.thread)
@@ -224,71 +309,95 @@ export async function parseThreadReadFromSessionLog(
   let source = fallbackThread?.source ?? 'unknown'
   let createdAt = readUnixSeconds(fallbackThread?.createdAt)
   let updatedAt = readUnixSeconds(fallbackThread?.updatedAt)
-  const turns: FallbackTurn[] = []
+  const turns = options.seedTurns === true ? cloneFallbackTurns(fallbackThread.turns) : []
   const seenMessageIds = new Set<string>()
-  let lastRecoveredMessage: RecoveredMessage | null = null
+  let lastRecoveredMessage = hydrateRecoveredMessageState(turns, seenMessageIds)
   const stats = await stat(sessionPath)
-  const startOffset = Math.max(0, stats.size - FALLBACK_READ_BYTE_LIMIT)
-
-  const input = createReadStream(sessionPath, { encoding: 'utf8', start: startOffset })
-  const lines = createInterface({
-    input,
-    crlfDelay: Infinity,
-  })
-  let skipPartialFirstLine = startOffset > 0
-
-  try {
-    for await (const line of lines) {
-      if (skipPartialFirstLine) {
-        skipPartialFirstLine = false
-        continue
+  const startOffset = typeof options.startOffset === 'number'
+    ? Math.max(0, Math.min(options.startOffset, stats.size))
+    : Math.max(0, stats.size - FALLBACK_READ_BYTE_LIMIT)
+
+  const processLine = (line: string): void => {
+    const trimmed = line.trim()
+    if (!trimmed || !isSessionLogThreadReadCandidateLine(trimmed)) return
+
+    try {
+      const entry = asRecord(JSON.parse(trimmed) as unknown)
+      if (!entry) return
+
+      updatedAt = Math.max(updatedAt, readUnixSeconds(entry.timestamp))
+      if (entry.type === 'session_meta') {
+        const payload = asRecord(entry.payload)
+        if (payload) {
+          cwd = cwd || readTrimmedString(payload.cwd)
+          source = payload.source ?? source
+          createdAt = createdAt || readUnixSeconds(payload.timestamp)
+        }
       }
 
-      const trimmed = line.trim()
-      if (!trimmed) continue
-      if (!isSessionLogThreadReadCandidateLine(trimmed)) continue
-
-      try {
-        const entry = asRecord(JSON.parse(trimmed) as unknown)
-        if (!entry) continue
-
-        updatedAt = Math.max(updatedAt, readUnixSeconds(entry.timestamp))
-        if (entry.type === 'session_meta') {
-          const payload = asRecord(entry.payload)
-          if (payload) {
-            cwd = cwd || readTrimmedString(payload.cwd)
-            source = payload.source ?? source
-            createdAt = createdAt || readUnixSeconds(payload.timestamp)
-          }
+      const message = readResponseItemMessage(entry) ?? readEventMessage(entry)
+      if (!message || isDuplicateRecoveredMessage(lastRecoveredMessage, message)) return
+      if (message.id) {
+        if (seenMessageIds.has(message.id)) return
+        seenMessageIds.add(message.id)
+      }
+      if (message.hidden && turns.length === 0) return
+      appendMessageTurn(turns, message)
+      if (!message.hidden) {
+        lastRecoveredMessage = {
+          role: message.role,
+          text: message.text,
+          id: message.id,
+          ...(message.phase === 'commentary' ? { phase: message.phase } : {}),
         }
+      }
+      if (!preview && message.role === 'user') {
+        preview = message.text.split('\n')[0]?.trim() ?? ''
+      }
+    } catch {
+      // Skip malformed lines and keep the rest of the recoverable history.
+    }
+  }
 
-        const message = readResponseItemMessage(entry) ?? readEventMessage(entry)
-        if (!message) continue
-
-        if (isDuplicateRecoveredMessage(lastRecoveredMessage, message)) {
-          continue
+  if (options.startOffset !== undefined) {
+    const byteCount = Math.max(0, stats.size - startOffset)
+    if (byteCount > 0) {
+      const handle = await open(sessionPath, 'r')
+      try {
+        const buffer = Buffer.allocUnsafe(byteCount)
+        let bytesRead = 0
+        while (bytesRead < byteCount) {
+          const result = await handle.read(buffer, bytesRead, byteCount - bytesRead, startOffset + bytesRead)
+          if (result.bytesRead === 0) break
+          bytesRead += result.bytesRead
         }
-        if (message.id) {
-          if (seenMessageIds.has(message.id)) continue
-          seenMessageIds.add(message.id)
+        for (const line of buffer.subarray(0, bytesRead).toString('utf8').split(/\r?\n/u)) {
+          processLine(line)
         }
-        if (message.hidden && turns.length === 0) {
+      } finally {
+        await handle.close()
+      }
+    }
+  } else {
+    const input = createReadStream(sessionPath, {
+      encoding: 'utf8',
+      start: startOffset,
+      end: Math.max(startOffset, stats.size - 1),
+    })
+    const lines = createInterface({ input, crlfDelay: Infinity })
+    let skipPartialFirstLine = startOffset > 0
+    try {
+      for await (const line of lines) {
+        if (skipPartialFirstLine) {
+          skipPartialFirstLine = false
           continue
         }
-        appendMessageTurn(turns, message)
-        if (!message.hidden) {
-          lastRecoveredMessage = { role: message.role, text: message.text, id: message.id }
-        }
-        if (!preview && message.role === 'user') {
-          preview = message.text.split('\n')[0]?.trim() ?? ''
-        }
-      } catch {
-        // Skip malformed lines and keep the rest of the recoverable history.
+        processLine(line)
       }
+    } finally {
+      lines.close()
+      input.close()
     }
-  } finally {
-    lines.close()
-    input.close()
   }
 
   if (turns.length === 0) return null
@@ -313,6 +422,13 @@ export async function parseThreadReadFromSessionLog(
   }
 }
 
+export async function parseThreadReadFromSessionLog(
+  sessionPath: string,
+  fallbackThreadRead: unknown,
+): Promise<unknown | null> {
+  return parseThreadReadFromSessionLogRange(sessionPath, fallbackThreadRead)
+}
+
 export async function readThreadReadFromSessionLog(
   sessionPath: string,
   fallbackThreadRead: unknown,
@@ -326,11 +442,40 @@ export async function readThreadReadFromSessionLog(
     const cached = sessionLogThreadReadCacheStateByPath.get(normalizedSessionPath)
     if (cached?.fileSignature === fileSignature) return cached.threadRead
 
-    const threadRead = await parseThreadReadFromSessionLog(normalizedSessionPath, fallbackThreadRead)
-    writeCacheState(normalizedSessionPath, { fileSignature, threadRead })
+    const appendedByteCount = cached ? stats.size - cached.fileSize : 0
+    const canReadIncrementally = Boolean(
+      cached?.incrementalReady &&
+      cached.threadRead &&
+      appendedByteCount > 0 &&
+      appendedByteCount <= FALLBACK_READ_BYTE_LIMIT,
+    )
+    const threadRead = canReadIncrementally
+      ? await parseThreadReadFromSessionLogRange(normalizedSessionPath, {
+          thread: {
+            ...asRecord(asRecord(cached?.threadRead)?.thread),
+            ...asRecord(asRecord(fallbackThreadRead)?.thread),
+            turns: asRecord(asRecord(cached?.threadRead)?.thread)?.turns ?? [],
+          },
+        }, {
+          startOffset: cached?.fileSize,
+          seedTurns: true,
+        })
+      : await parseThreadReadFromSessionLog(normalizedSessionPath, fallbackThreadRead)
+    const incrementalReady = await doesFileEndWithNewline(normalizedSessionPath, stats.size)
+    writeCacheState(normalizedSessionPath, {
+      fileSignature,
+      fileSize: stats.size,
+      incrementalReady,
+      threadRead,
+    })
     return threadRead
   } catch {
-    writeCacheState(normalizedSessionPath, { fileSignature: 'missing', threadRead: null })
+    writeCacheState(normalizedSessionPath, {
+      fileSignature: 'missing',
+      fileSize: 0,
+      incrementalReady: false,
+      threadRead: null,
+    })
     return null
   }
 }
diff --git a/src/server/appServerThreadRuntimeSnapshot.ts b/src/server/appServerThreadRuntimeSnapshot.ts
index 46a098d..132f886 100644
--- a/src/server/appServerThreadRuntimeSnapshot.ts
+++ b/src/server/appServerThreadRuntimeSnapshot.ts
@@ -102,7 +102,7 @@ export async function readAppServerThreadRuntimeSnapshot(
     threadRead = cachedThreadRead.threadRead
     messageState = cachedThreadRead.source === 'session-log' ? 'cached' : 'fresh'
   } else {
-    if (options.preferCachedMessages === true && lightThreadRead && sessionPath) {
+    if (lightThreadRead && sessionPath) {
       sessionLogReadAttempted = true
       const recoveredThreadRead = await (dependencies.readSessionLogThreadRead ?? readThreadReadFromSessionLog)(sessionPath, lightThreadRead)
       if (recoveredThreadRead) {
diff --git a/src/server/codexAppServerBridge.ts b/src/server/codexAppServerBridge.ts
index 6e18b0b..fa19eb8 100644
--- a/src/server/codexAppServerBridge.ts
+++ b/src/server/codexAppServerBridge.ts
@@ -31,8 +31,12 @@ import { MobilePushCoordinator } from './mobilePush.js'
 import {
   CodexSessionFileChangeObserver,
   createCodexSessionFileChangedNotification,
+  resolveCodexSessionFileChangeOrigin,
 } from './codexSessionFileChangeObserver.js'
-import { shouldInvalidateThreadCollectionForCxSessionFileChange } from '../sessionFileChange.js'
+import {
+  CX_SESSION_FILES_CHANGED_METHOD,
+  shouldInvalidateThreadCollectionForCxSessionFileChange,
+} from '../sessionFileChange.js'
 import { RuntimeMessageQueue } from './runtimeMessageQueue.js'
 
 type CodexBridgeMiddleware = ((req: IncomingMessage, res: ServerResponse, next: () => void) => Promise<void>) & {
@@ -82,6 +86,7 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
   ))
   const mobilePushCoordinator = new MobilePushCoordinator({ store: runtimeStore })
   let runtimeMessageQueue: RuntimeMessageQueue | null = null
+  const recentLiveRuntimeEventAtMsByThreadId = new Map<string, number>()
   const {
     persistRuntimeSnapshot,
     readThreadRuntimeSnapshot,
@@ -122,6 +127,13 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
     statusDiagnostics,
     persistRuntimeSnapshot,
     onRuntimeEvent: (event) => {
+      if (event.method !== CX_SESSION_FILES_CHANGED_METHOD && event.threadId) {
+        recentLiveRuntimeEventAtMsByThreadId.set(event.threadId, Date.now())
+        if (recentLiveRuntimeEventAtMsByThreadId.size > 512) {
+          const oldestThreadId = recentLiveRuntimeEventAtMsByThreadId.keys().next().value
+          if (typeof oldestThreadId === 'string') recentLiveRuntimeEventAtMsByThreadId.delete(oldestThreadId)
+        }
+      }
       runtimeMessageQueue?.handleRuntimeEvent(event.method, event.threadId)
       void mobilePushCoordinator.handleRuntimeEvent(event).catch((error) => {
         writeBridgeLog('warn', 'Mobile push terminal wake failed', {
@@ -148,7 +160,13 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
         threadSearchIndexStore.clear()
       }
       invalidateSupplementalThreadListCache(change.threadId)
-      publishBridgeNotification(createCodexSessionFileChangedNotification(change))
+      publishBridgeNotification(createCodexSessionFileChangedNotification({
+        ...change,
+        origin: resolveCodexSessionFileChangeOrigin(
+          change,
+          recentLiveRuntimeEventAtMsByThreadId.get(change.threadId) ?? 0,
+        ),
+      }))
     },
     onError: (error) => {
       writeBridgeLog('warn', 'Codex session file change observer failed', {
@@ -208,6 +226,7 @@ export function createCodexBridgeMiddleware(options: CodexBridgeMiddlewareOption
         listRuntimeQueue: (threadId = '') => runtimeMessageQueue!.list(threadId),
         cancelQueuedRuntimeTurn: (requestId) => runtimeMessageQueue!.cancel(requestId),
         retryQueuedRuntimeTurn: (requestId) => runtimeMessageQueue!.retry(requestId),
+        reorderQueuedRuntimeTurns: (threadId, requestIds) => runtimeMessageQueue!.reorder(threadId, requestIds),
         augmentThreadListRpcResult,
         reconcileRuntimeThread,
         readLocalRuntimeSnapshot,
diff --git a/src/server/codexBridgeRouteHandlers.ts b/src/server/codexBridgeRouteHandlers.ts
index db8b131..54e91c6 100644
--- a/src/server/codexBridgeRouteHandlers.ts
+++ b/src/server/codexBridgeRouteHandlers.ts
@@ -128,6 +128,7 @@ export type CodexBridgeRouteHandlersDependencies = {
   listRuntimeQueue: RuntimeActionRoutesDependencies['listRuntimeQueue']
   cancelQueuedRuntimeTurn: RuntimeActionRoutesDependencies['cancelQueuedRuntimeTurn']
   retryQueuedRuntimeTurn: RuntimeActionRoutesDependencies['retryQueuedRuntimeTurn']
+  reorderQueuedRuntimeTurns: RuntimeActionRoutesDependencies['reorderQueuedRuntimeTurns']
   augmentThreadListRpcResult: RpcProxyRouteDependencies['augmentThreadListRpcResult']
   reconcileRuntimeThread: RuntimeStateRoutesDependencies['reconcileRuntimeThread']
   readLocalRuntimeSnapshot: RuntimeStateRoutesDependencies['readLocalRuntimeSnapshot']
@@ -189,6 +190,7 @@ export function createCodexBridgeRouteHandlers(
       listRuntimeQueue: dependencies.listRuntimeQueue,
       cancelQueuedRuntimeTurn: dependencies.cancelQueuedRuntimeTurn,
       retryQueuedRuntimeTurn: dependencies.retryQueuedRuntimeTurn,
+      reorderQueuedRuntimeTurns: dependencies.reorderQueuedRuntimeTurns,
     }),
     () => handleMobilePushRoutes(req, res, url, {
       readJsonBody,
diff --git a/src/server/codexSessionFileChangeObserver.ts b/src/server/codexSessionFileChangeObserver.ts
index 5dab40e..9eeb517 100644
--- a/src/server/codexSessionFileChangeObserver.ts
+++ b/src/server/codexSessionFileChangeObserver.ts
@@ -1,12 +1,16 @@
 import { watch, type FSWatcher } from 'node:fs'
 import { join } from 'node:path'
 
-import { CX_SESSION_FILES_CHANGED_METHOD } from '../sessionFileChange.js'
+import {
+  CX_SESSION_FILES_CHANGED_METHOD,
+  type CxSessionFileChangeOrigin,
+} from '../sessionFileChange.js'
 import { getCodexHomeDir } from './codexPaths.js'
 
 export type CodexSessionFileChange = {
   source: 'session-index' | 'session-log'
   threadId: string
+  origin?: CxSessionFileChangeOrigin
 }
 
 export type CodexSessionFileChangeObserverOptions = {
@@ -37,6 +41,18 @@ const SESSION_LOG_ROOTS = new Set(['sessions', 'archived_sessions'])
 const THREAD_ID_PATTERN = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?=\.jsonl$)/iu
 const DEFAULT_DEBOUNCE_MS = 700
 const DEFAULT_MAX_WAIT_MS = 2_500
+const DEFAULT_LIVE_EVENT_COVERAGE_MS = 5_000
+
+export function resolveCodexSessionFileChangeOrigin(
+  change: CodexSessionFileChange,
+  lastLiveRuntimeEventAtMs: number,
+  nowMs = Date.now(),
+  coverageMs = DEFAULT_LIVE_EVENT_COVERAGE_MS,
+): CxSessionFileChangeOrigin {
+  if (change.source !== 'session-log' || !change.threadId || lastLiveRuntimeEventAtMs <= 0) return 'external'
+  const ageMs = nowMs - lastLiveRuntimeEventAtMs
+  return ageMs >= 0 && ageMs <= Math.max(0, coverageMs) ? 'live-app-server' : 'external'
+}
 
 export function classifyCodexSessionFileChange(filename: string | Buffer | null): CodexSessionFileChange | null {
   if (filename === null) return null
diff --git a/src/server/runtimeActionRoutes.ts b/src/server/runtimeActionRoutes.ts
index b7e7993..6dedccb 100644
--- a/src/server/runtimeActionRoutes.ts
+++ b/src/server/runtimeActionRoutes.ts
@@ -17,6 +17,7 @@ export type RuntimeActionRoutesDependencies = {
   listRuntimeQueue?: (threadId?: string) => RuntimeMessageQueueEntry[]
   cancelQueuedRuntimeTurn?: (requestId: string) => boolean
   retryQueuedRuntimeTurn?: (requestId: string) => boolean
+  reorderQueuedRuntimeTurns?: (threadId: string, requestIds: string[]) => boolean
 }
 
 export async function handleRuntimeActionRoutes(
@@ -38,6 +39,20 @@ export async function handleRuntimeActionRoutes(
     return true
   }
 
+  if (req.method === 'POST' && url.pathname === '/codex-api/runtime/queue/reorder' && dependencies.reorderQueuedRuntimeTurns) {
+    const payload = await dependencies.readJsonBody(req)
+    const row = payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? payload as Record<string, unknown>
+      : {}
+    const threadId = typeof row.threadId === 'string' ? row.threadId.trim() : ''
+    const requestIds = Array.isArray(row.requestIds)
+      ? row.requestIds.filter((requestId): requestId is string => typeof requestId === 'string')
+      : []
+    const reordered = dependencies.reorderQueuedRuntimeTurns(threadId, requestIds)
+    setJson(res, reordered ? 200 : 409, reordered ? { ok: true } : { error: 'Runtime queue changed before reorder' })
+    return true
+  }
+
   if (url.pathname.startsWith('/codex-api/runtime/queue/')) {
     const suffix = decodeURIComponent(url.pathname.slice('/codex-api/runtime/queue/'.length)).trim()
     const isRetry = suffix.endsWith('/retry')
diff --git a/src/server/runtimeMessageQueue.ts b/src/server/runtimeMessageQueue.ts
index aa6f339..bc60ac3 100644
--- a/src/server/runtimeMessageQueue.ts
+++ b/src/server/runtimeMessageQueue.ts
@@ -26,6 +26,7 @@ type RuntimeMessageQueueStore = {
   getLatestRequestByClientMessageId(clientMessageId: string): RuntimeRequestRecord | null
   getThreadLease(threadId: string): { requestId: string } | null
   listQueuedRequests(threadId?: string, limit?: number): RuntimeRequestRecord[]
+  reorderQueuedRequests(threadId: string, requestIds: string[]): boolean
   listQueuedThreadIds(limit?: number): string[]
 }
 
@@ -162,6 +163,14 @@ export class RuntimeMessageQueue {
     return true
   }
 
+  reorder(threadId: string, requestIds: string[]): boolean {
+    const normalizedThreadId = threadId.trim()
+    if (!this.dependencies.store.reorderQueuedRequests(normalizedThreadId, requestIds)) return false
+    this.publish(normalizedThreadId, '', 'reordered')
+    this.scheduleThread(normalizedThreadId)
+    return true
+  }
+
   handleRuntimeEvent(method: string, threadId: string): void {
     if (!threadId || method === 'runtime/queue/updated') return
     if (method === 'turn/completed' || method === 'turn/started' || method === 'error') {
diff --git a/src/server/runtimeState.ts b/src/server/runtimeState.ts
index 2202d7b..11cbac7 100644
--- a/src/server/runtimeState.ts
+++ b/src/server/runtimeState.ts
@@ -91,6 +91,7 @@ type RuntimeStateStoreOptions = {
 }
 
 export const RUNTIME_SNAPSHOT_STALE_MS = 90_000
+export const RUNTIME_START_THREAD_READ_GRACE_MS = 20_000
 
 export function isRuntimeActiveState(state: RuntimeExecutionState): boolean {
   return (
@@ -615,6 +616,12 @@ function isThreadReadOlderThanPendingStart(current: ThreadRuntimeState, updatedA
   if (!Number.isFinite(startedAtMs)) return false
   const readUpdatedAtMs = Date.parse(updatedAtIso)
   if (!Number.isFinite(readUpdatedAtMs)) return true
-  // App Server thread timestamps have second precision; tolerate the current start second.
-  return readUpdatedAtMs + 1_000 < startedAtMs
+  const startedSecondMs = Math.floor(startedAtMs / 1_000) * 1_000
+  if (readUpdatedAtMs < startedSecondMs) return true
+  // App Server thread timestamps have second precision. A non-running read from
+  // the start second can still describe the previous turn while turn/start is
+  // materializing. Ignore it for one bounded start window, then allow recovery
+  // when lifecycle notifications were lost across a restart.
+  return readUpdatedAtMs === startedSecondMs
+    && Date.now() - startedAtMs < RUNTIME_START_THREAD_READ_GRACE_MS
 }
diff --git a/src/server/runtimeStore.ts b/src/server/runtimeStore.ts
index f028962..d7b2355 100644
--- a/src/server/runtimeStore.ts
+++ b/src/server/runtimeStore.ts
@@ -704,6 +704,34 @@ export class RuntimeStore {
     return rows.map(fromRequestRow)
   }
 
+  reorderQueuedRequests(threadId: string, requestIds: string[]): boolean {
+    const normalizedThreadId = threadId.trim()
+    const normalizedRequestIds = requestIds.map((requestId) => requestId.trim()).filter(Boolean)
+    if (!normalizedThreadId || normalizedRequestIds.length === 0) return false
+    if (new Set(normalizedRequestIds).size !== normalizedRequestIds.length) return false
+
+    return this.db.transaction(() => {
+      const queued = this.listQueuedRequests(normalizedThreadId, 500)
+      const queuedIds = new Set(queued.map((request) => request.requestId))
+      if (
+        queued.length !== normalizedRequestIds.length
+        || normalizedRequestIds.some((requestId) => !queuedIds.has(requestId))
+      ) return false
+
+      const earliestCreatedAtMs = Math.min(...queued.map((request) => Date.parse(request.createdAtIso)))
+      const baseCreatedAtMs = Number.isFinite(earliestCreatedAtMs) ? earliestCreatedAtMs : Date.now()
+      const update = this.db.prepare(`
+        UPDATE runtime_requests
+        SET created_at_iso = ?
+        WHERE request_id = ? AND thread_id = ? AND status IN ('queued', 'queue_failed')
+      `)
+      normalizedRequestIds.forEach((requestId, index) => {
+        update.run(new Date(baseCreatedAtMs + index).toISOString(), requestId, normalizedThreadId)
+      })
+      return true
+    }).immediate()
+  }
+
   listQueuedThreadIds(limit = 500): string[] {
     const rows = this.db.prepare(`
       SELECT thread_id, MIN(created_at_iso) AS first_created_at_iso
diff --git a/src/sessionFileChange.ts b/src/sessionFileChange.ts
index 6ade120..0df4821 100644
--- a/src/sessionFileChange.ts
+++ b/src/sessionFileChange.ts
@@ -1,8 +1,10 @@
 export const CX_SESSION_FILES_CHANGED_METHOD = 'cx/session-files/changed'
 
 export type CxSessionFileChangeSource = 'session-index' | 'session-log'
+export type CxSessionFileChangeOrigin = 'live-app-server' | 'external'
 
 export type CxSessionFileChangeSyncPolicy = {
+  preferSessionLogMessages: boolean
   refreshMessages: boolean
   refreshThreads: boolean
 }
@@ -17,6 +19,12 @@ export function readCxSessionFileChangeSource(params: unknown): CxSessionFileCha
   return source === 'session-index' || source === 'session-log' ? source : ''
 }
 
+export function readCxSessionFileChangeOrigin(params: unknown): CxSessionFileChangeOrigin | '' {
+  if (typeof params !== 'object' || params === null || Array.isArray(params)) return ''
+  const origin = (params as { origin?: unknown }).origin
+  return origin === 'live-app-server' || origin === 'external' ? origin : ''
+}
+
 export function getCxSessionFileChangeSyncPolicy(
   method: string,
   params: unknown,
@@ -24,12 +32,16 @@ export function getCxSessionFileChangeSyncPolicy(
   if (!isCxSessionFilesChangedMethod(method)) return null
   const source = readCxSessionFileChangeSource(params)
   if (source === 'session-log') {
-    return { refreshMessages: true, refreshThreads: false }
+    return {
+      preferSessionLogMessages: true,
+      refreshMessages: true,
+      refreshThreads: false,
+    }
   }
   if (source === 'session-index') {
-    return { refreshMessages: false, refreshThreads: true }
+    return { preferSessionLogMessages: false, refreshMessages: false, refreshThreads: true }
   }
-  return { refreshMessages: true, refreshThreads: true }
+  return { preferSessionLogMessages: false, refreshMessages: true, refreshThreads: true }
 }
 
 export function shouldInvalidateThreadCollectionForCxSessionFileChange(params: unknown): boolean {
diff --git a/tests.md b/tests.md
index ab2a803..31362d1 100644
--- a/tests.md
+++ b/tests.md
@@ -15625,6 +15625,26 @@ Current evidence:
 - The complete 35-surface frontend regression passed in 452.6 seconds, including sidebar recency, search continuity, scroll anchoring, current-thread reveal, mobile drawer, Composer, conversation recovery, notifications, and Task Pet.
 - Final 7420 health remained `ok`, running, and initialized on PID 51368 with `approvalPolicy=never` and `sandboxMode=danger-full-access`. Pending, queued, and active RPCs, pending server requests, blocking restarts, uncertain Runtime requests, and thread leases were all zero.
 
+## Keep the Android Task Pet quiet, docked, and cursor-driven (2026-08-03)
+
+1. The native overlay is a background companion only. Returning to the CX-Codex Activity removes the overlay immediately and suppresses completion notifications while the app is foreground; authoritative monitoring continues without duplicating the visible app UI.
+2. Reply attention is owned by the persisted cursor `latestReplyEventSeq > readThroughReplyEventSeq`. Confirming that the exact conversation is visible advances the cursor, clears its badge and completion notification, and prevents an already-read result from reappearing after service recreation.
+3. One new assistant item may show one transient latest-reply strip for an accessibility-adjusted five seconds. Further stream chunks update that strip without restarting its lifetime. Normal running state does not count as unread attention.
+4. The resting pet automatically tucks to either screen edge with only a 32 dp handle visible. Tapping it opens a 248 dp task stack with at most three rows; the stack closes after an accessibility-adjusted eight seconds and returns to the edge.
+5. The overlay no longer owns recent conversations, an inline reply composer, or a persistent `工作中` label. The latest-reply strip and every task row still open the exact owning conversation; Android notification reply remains the system fallback.
+
+Verification:
+
+- Run `npm run build:frontend`, parse `scripts/regression-7420-frontend.ps1`, execute its Task Pet source-contract functions, and run `git diff --check`.
+- At 393 x 852, confirm the initial state is docked with no panel or reply strip. Simulate a new reply, confirm the strip is 224 px wide and disappears after five seconds, then open the pet and confirm a 248 px stack with three rows closes after eight seconds.
+- Confirm the fixture has no recent-conversation section, inline reply form, or `工作中` pill and that clicking the reply strip retains the exact thread id.
+- Run `:app:testDebugUnitTest --tests com.cxcodex.bridge.TaskPetRuntimePolicyTest`, `:app:lintDebug`, and `:app:assembleRelease`; verify the resulting APK signature and package metadata.
+
+Current evidence:
+
+- Headless Chrome measured an initially docked surface, a 224 x 63 latest-reply strip, a 248 x 278 three-row stack, five-second reply-strip dismissal, and eight-second stack dismissal. Browser errors were empty; screenshots are under `output/task-pet-quiet-overlay-20260803`.
+- Task Pet source contracts, the focused Android policy unit tests, production frontend build, Capacitor Android sync, Android lint, release assembly, APK v2 signature verification, and `git diff --check` passed.
+- The broad `test:7420:frontend` run stopped at its environment health gate before browser checks because the already-running 7420 process reported `uncertainRequestCount=2`. The affected Task Pet source and real-browser contracts were run independently and passed.
 ## Quick Tunnel stale-session recovery and sidebar outside-dismissal (2026-08-02)
 
 1. Start a verified Quick Tunnel, then invoke start again while its child process is still alive. The existing URL may be reused only after public health, HTTP authentication, and WebSocket authentication all pass again.
@@ -15654,7 +15674,7 @@ Current evidence:
 - Headless Playwright at 393 x 852 measured one semantic table scroll region, zero mobile table cards, a 322 px viewport over 620 px table content, and 13 px computed cell text. The inspected screenshot is `output/regression-7420/message-fidelity-20260803/mobile-table-horizontal.png`.
 - The complete frontend regression passed the updated queue source contracts and reached the live browser phase, then stopped on the pre-existing mobile Settings fixture with `settings panel did not open`, before the conversation fixture. The focused Playwright conversation fixture passed without console errors.
 - The production main entry is 411,336 bytes with the current locked Vite toolchain. A clean HEAD baseline under the same toolchain is 409,169 bytes, so this change adds 2,167 bytes to the cold entry; queue parsing, migration, persistence, and network ownership remain in the 7.81 KB lazy chunk.
-- The restart-race smoke reproduces the configuration-triggered app-server lifecycle boundary. Matching speed performs only `config/read`; changing speed keeps the row `queued` through both config RPCs and still reaches `running` after an injected idle restart snapshot. The mobile queue fixture has no browser errors and its screenshot is `output/regression-7420/queue-restart-race-20260803/queue-accepted-element.png`.
+- The restart-race smoke reproduces the configuration-triggered app-server lifecycle boundary. Matching speed performs only `config/read`; changing speed keeps the row `queued` through both config RPCs and still reaches `running` after an injected idle restart snapshot. The mobile queue fixture has no browser errors and its screenshot is `output/regression-7420/queue-restart-race-20260803/queue-accepted-element.png`.
 
 ## Structured Codex file citations and mobile PDF preview (2026-08-03)
 
@@ -15675,3 +15695,74 @@ Current evidence:
 - The parser smoke covers the reported resume PDF, a Markdown companion, quoted and unquoted attributes, Windows backslashes, spaces, escaped metadata, adjacent citations, pathless directives, and incomplete directives.
 - Headless Chrome at 393 x 852 measured 393 px document width over a 393 px viewport, rendered both file labels without leaking internal metadata, and opened the exact encoded local path.
 - The reported 297.1 KB resume rendered two PDF canvases. Both compatibility APIs were functions after the legacy bundle initialized, and browser errors and warnings were empty.
+
+## Runtime notification pressure and truthful reply freshness (2026-08-03)
+
+1. Every `cx/session-files/changed` notification with `source: session-log` refreshes selected-thread messages from the bounded local session-log projection without refreshing the thread collection. The heuristic `origin` value may describe likely ownership but must never suppress correctness; `session-index` changes still refresh the collection.
+2. Transient command, process, file-change, and MCP progress deltas must remain available to live notification consumers without invalidating the cached thread read or persisting a Runtime snapshot per chunk. Terminal and reply events must retain their existing invalidation and snapshot behavior.
+3. Native Task Pet progress freshness and reply freshness are separate clocks. Advancing `lastEventSeq` without advancing `latestReplyEventSeq` must not relabel an old reply as “刚刚”. A strictly newer positive reply event advances the persisted reply clock.
+4. A queued message with `backgroundPersisted !== true` must continue to say it is local-only; only a row returned from the durable 7420 queue may claim background ownership.
+5. A genuinely external `session-log` append must refresh the selected conversation from the local session file without scheduling an immediate authoritative `thread/read`. After the first bounded tail read, complete JSONL appends must reuse the cached 40-turn projection and read only the newly appended bytes; once the append burst has been quiet for 1.8 seconds, one coalesced authoritative read must restore structured items that the local projection cannot represent.
+6. Session-log recovery must preserve assistant `phase: commentary` items as phase replies. It must not discard a progress-only tail and fall back to a heavy history read, and it must not relabel commentary as a final answer.
+7. Default recent-message reads and Runtime snapshots must try the bounded session-log projection before `thread/read includeTurns: true`. Explicit full-history and older-turn requests remain authoritative and bypass this shortcut.
+8. If the task-pet stack becomes empty while expanded, its eight-second auto-collapse must return to the minimized pet instead of leaving an empty full-size mascot behind.
+9. Opening the task-pet close confirmation must pause the eight-second auto-collapse timer. Cancelling the confirmation keeps the panel open and starts a fresh collapse timeout.
+
+Verification:
+
+- Run `npm.cmd run verify:frontend-normalizers`.
+- Run `npm.cmd run verify:server-modules`.
+- From `android/`, run `.\gradlew.bat testDebugUnitTest --tests com.cxcodex.bridge.TaskPetRuntimePolicyTest`.
+- Run `npm.cmd run build:frontend` and `npm.cmd run build:cli` before restarting the local 7420 process, so frontend and server modules come from the same source revision.
+
+Current evidence:
+
+- The frontend policy test first failed because a `live-app-server` heuristic suppressed the same selected-thread refresh needed by a concurrent external writer. It now passes with every session-log origin using the bounded local projection, and the source contract requires both notification-time quiet-window reset and one post-quiet authoritative convergence.
+- Server smoke covers cached session-log append recovery, all-origin thread-read cache invalidation, and confirms transient progress chunks neither invalidate heavy thread reads nor persist one Runtime snapshot per chunk.
+- A 24,000,000-byte local session-tail benchmark measured a 215-261 ms bounded first read and a 34.99-38.04 ms median append refresh on this Windows machine. The append path no longer scans the 24 MB tail or issues a full app-server `thread/read`.
+- Before the final recovery boundary, the 72 MB dogfood conversation issued a heavy read every 8-10 seconds; observed calls took 6.7-8.0 seconds and blocked current-page recovery. Its 24 MB tail contained only commentary and tool records, which exposed the discarded-commentary fallback defect.
+- The final 2.7.3 verification passed frontend normalizer smoke, production frontend build, CLI build, server-module smoke, Android `TaskPetRuntimePolicyTest`, real 7420 sidebar data checks, and the complete 36-surface frontend regression in 521.4 seconds.
+- Real task-pet fixtures verified idle-to-task wake, one transient reply peek, attention `2 -> 1` after exact `fixture-running` navigation, empty-stack auto-minimization, and a close confirmation that stays open beyond eight seconds before cancellation restarts collapse.
+
+## Session queue isolation and reply-latency stability (2026-08-04)
+
+1. `runtime/queue/updated` is an internal delivery notification. It must remain replayable to clients, but it must not observe or persist Runtime state, reconcile active requests, or settle a newly claimed `pending_start` row against the previous turn's terminal snapshot.
+2. A non-running `thread/read` from the same second as `lastStartedAtIso` must not settle a materializing turn during the bounded 20-second start window. Strictly older reads remain stale; after the bounded window, a same-second terminal read may recover a request whose lifecycle notifications were lost across restart.
+3. Rapid local enqueues merge persistence acknowledgements into the latest in-memory queue by stable `clientMessageId`; an older async snapshot must not drop a later enqueue or resurrect a deleted row. A newly persisted row deleted during the request is removed from the server queue.
+4. Server reconciliation preserves the current stable queue order for matching messages, drops server-owned rows that have actually left the server queue, retains unsynced local rows, and appends only genuinely server-only rows.
+5. A failed first local row pauses later persistence. Retry, edit, or delete must resolve the blocked row before later local messages are handed to 7420.
+6. After persistence and a complete server sync, 7420 atomically applies the exact stable request-id order only when the server queue set still matches. A concurrent queue change returns conflict instead of applying a partial or stale reorder, and the frontend then adopts the authoritative server order.
+
+Verification:
+
+- Run `npm.cmd run verify:server-modules`; the notification-boundary and same-start-second tests must both fail on the pre-fix code and pass after the fix.
+- Run `npm.cmd run verify:frontend-normalizers` and `npm.cmd run build:frontend`.
+- Run `npm.cmd run build:cli`, restart the exact local 7420 process only after restart protection reports zero blockers, then enqueue two uniquely marked messages behind a controlled running turn.
+- Confirm the authoritative session log contains `BASE`, queue A, and queue B in that order with three distinct `turnId` values. Confirm the Runtime Store records all three as completed with no error and the queue becomes empty.
+- Send one no-tool direct reply and record HTTP acceptance, first-token, and completion latency separately.
+
+Current evidence:
+
+- The pre-fix real run accepted both queued messages but marked them completed without `turnId` and omitted both from history. The first boundary regression reproduced the stale terminal snapshot settlement exactly.
+- After the first fix, A/B reached history but A shared the still-running base turn, exposing second-precision pre-start settlement. The second regression reproduced that materialization race before the timestamp boundary changed.
+- The final real run returned HTTP 202 in 81 ms for the base and 5/10 ms for A/B. The session log recorded `BASE2 -> QUEUE2-A -> QUEUE2-B` with distinct turns; queued A/B time-to-first-token was 2,272/1,853 ms and total duration was 2,642/1,972 ms.
+- A separate no-tool direct reply was accepted in 104 ms, produced first assistant data in 1,712 ms, and completed in 2,110 ms.
+- A final real reorder changed queued `A -> B -> C` to `C -> A -> B`. The immediate server list and authoritative session log both preserved `BASE -> C -> A -> B`, with four distinct turns and no failed request.
+- The complete 36-surface frontend regression passed first in 540.2 seconds and again on the final exact-order implementation in 590.3 seconds. The endpoint/store/frontend-order follow-up also passed server-module smoke, frontend normalizer smoke, production frontend build, CLI build, and the real reordered execution above.
+- The final review added bounded same-second restart recovery and authoritative conflict fallback. Both focused regressions, both production builds, `git diff --check`, and a post-restart real sidebar-data pass succeeded; the final list pass covered 239 active conversations with zero RPC retry.
+
+## CX-Codex 2.7.3 release gate (2026-08-04)
+
+1. `package.json`, `package-lock.json`, the GitHub tag and `docs/release-notes-2.7.3.zh-CN.md` must all resolve to `2.7.3`; the public notes must describe the queue, long-session, plan/goal, file-preview and Android changes without claiming complete future App Server compatibility.
+2. Run `npm.cmd run verify:release -- -AllowDirty -SchemaAudit warn` before the release commit, then repeat with `-RequireCleanGit` from the isolated release worktree.
+3. Confirm the schema-audit counts match the committed governance checkpoint. If any count changes, update the redacted summary and protocol matrix before tagging; never commit raw generated schema output.
+4. Run a production-only dependency audit with npm 10 or newer because the machine's prefix-level npm 6 cannot parse lockfile v3 correctly.
+5. The tag workflow must build the source ZIP and officially signed Android APK, verify every SHA-256, publish no debug APK, and complete before the release is called stable.
+
+Current evidence:
+
+- Alibaba OpenCodeReview `1.8.6` previewed 26 reviewable workspace files under `.opencodereview/rule.json`. Its delegated host-agent review applied the server, Vue, Android and deterministic-test rules and found no additional release blocker.
+- `npm.cmd run verify:release -- -AllowDirty -SchemaAudit warn` completed in 206.9 seconds with governance, frontend/CLI, normalizer, server-module, CJS launcher, release-package, checksum and npm-package smoke gates passing.
+- The regenerated schema counts exactly matched `docs/app-server-schema-audit-summary.json`: TypeScript root `236 -> 77`, TypeScript v2 `199 -> 445`, JSON root `37 -> 35`, and JSON v2 `102 -> 202`. The existing protocol matrix already classifies thread goals/status/realtime, plugins, permissions and unknown notifications as partial, diagnostic or deferred capabilities, so no baseline replacement is required for this patch release.
+- npm `10.9.3` audited 131 production dependencies through the official registry with zero info, low, moderate, high or critical vulnerabilities. The default prefix-level npm `6.14.6` audit error was a local tool incompatibility, not a dependency finding.
+- GitHub authentication is active for `Qjzn/CX-Codex`, the latest public release remains `v2.7.2`, and all four required Android signing secret names are present. Publication still requires clean-worktree verification, main/tag CI, public asset inspection and certificate/checksum proof.