feat(chat): derive activity indicator from per-session state and unify provider lifecycle events

Replace the chat processing banner with a minimal activity indicator and rebuild the state model underneath it. The old banner was driven by five overlapping pieces of state (isLoading, canAbortSession, claudeStatus in the chat, plus two app-level Sets updated in lockstep through four callbacks) that had to be kept in sync imperatively. Because completion and status events mutated the *viewed* session's flags regardless of which session they belonged to, a background session finishing could hide the indicator for a still-running session, returning to a finished session could briefly show a stale banner, and a late status reply could override a newer request. The fix is structural rather than patch-by-patch: a single Map<sessionId, {statusText, canInterrupt, startedAt}> in useSessionProtection is now the only source of truth for "this session is working". The indicator, stop button, composer streaming state, and session protection are all derived from the viewed session's entry on render, so there is no stale local copy to restore or reset when switching sessions. A PENDING_SESSION_ID sentinel covers the window before a new conversation receives its real session id. Terminal events delete the entry atomically, which is why the indicator disappears the instant the final chunk arrives. Stale check-session-status replies are discarded via an ifStartedBefore guard (an idle reply older than the entry's startedAt describes a previous request, not the current one). The second half unifies the provider lifecycle contract, because the frontend could not be made race-free while each provider terminated differently: - cursor emitted complete twice per run (result line + process close), which double-played the completion sound and let a late close-complete clear a newer request's indicator - aborts produced two completes (the abort-session reply plus the provider's own non-aborted one), so cancelling a run played the celebration sound - codex omitted exitCode; others attached ad-hoc fields (resultText, isError, isNewSession) the client had to know about - claude/codex failures ended with only an error event while gemini/cursor also emit kind:'error' for mid-run stderr noise, so 'error' was ambiguous between "the run died" and "a process wrote to stderr" Every run now ends with exactly one complete built by createCompleteMessage() ({sessionId, actualSessionId, exitCode, success, aborted}); abort-session sends it on behalf of cancelled runs and providers detect the abort and skip their own. error is demoted to an informational row, so stderr noise no longer kills the indicator mid-run, and the client celebrates only success: true completes. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-06-12 00:42:06 +08:00 · 2026-06-10 19:39:04 +03:00
32 changed files with 491 additions and 609 deletions
--- a/README.de.md
+++ b/README.de.md
@@ -164,14 +164,6 @@ CloudCLI verfügt über ein Plugin-System, mit dem benutzerdefinierte Tabs mit e
 | Plugin | Beschreibung |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | Zeigt Dateianzahl, Codezeilen, Dateityp-Aufschlüsselung, größte Dateien und zuletzt geänderte Dateien des aktuellen Projekts |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | Vollwertiges xterm.js-Terminal mit Multi-Tab-Unterstützung |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | Überwacht lange laufende Claude-Code-Sitzungen auf Hänger und stellt Prozesssteuerungen bereit |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | Erstellt arbeitsbereichsbezogene geplante Prompts und führt sie über eine lokale CLI wie Codex, Claude Code oder Gemini CLI aus |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | Sitzungsintelligenz für Claude Code in CloudCLI, inklusive Sichtbarkeit des Token-Verbrauchs |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | Aktive Claude-Code-Sitzungen anzeigen, verwalten und beenden |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | API-Kosten anhand von Modellpreisen und Token-Nutzung berechnen, mit Unterstützung für Preisvorlagen |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | Task-Queue-Dashboard zum Anzeigen, Filtern und Starten von Agent-Aufgaben |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | Kanban-Board für GitHub Issues mit bidirektionaler TaskMaster-Synchronisierung und automatischer Installation des /github-task CLI-Skills |

 ### Eigenes Plugin erstellen

--- a/README.ja.md
+++ b/README.ja.md
@@ -158,14 +158,6 @@ CloudCLI にはプラグインシステムがあり、独自のフロントエ
 | プラグイン | 説明 |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | 現在のプロジェクトについて、ファイル数、コード行数、ファイル種別の内訳、最大ファイル、最近変更されたファイルを表示 |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | 複数タブに対応した本格的な xterm.js ターミナル |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | 長時間実行中の Claude Code セッションのハングを監視し、プロセス操作を提供 |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | ワークスペース単位のスケジュール済みプロンプトを作成し、Codex、Claude Code、Gemini CLI などのローカル CLI で実行 |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | CloudCLI 内で Claude Code のセッション分析を行い、トークン消費の可視化も提供 |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | アクティブな Claude Code セッションを表示、管理、終了 |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | モデル価格とトークン使用量から API コストを計算し、モデル価格プリセットにも対応 |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | エージェントタスクを表示、フィルタリング、起動するためのタスクキューダッシュボード |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | GitHub Issues 用の Kanban ボード。TaskMaster との双方向同期と /github-task CLI スキルの自動インストールに対応 |

 ### 自作する

--- a/README.ko.md
+++ b/README.ko.md
@@ -158,14 +158,6 @@ CloudCLI는 커스텀 탭과 선택적 Node.js 백엔드가 포함된 플러그
 | 플러그인 | 설명 |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | 현재 프로젝트의 파일 수, 코드 줄 수, 파일 유형 분포, 가장 큰 파일, 최근 수정 파일을 표시 |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | 다중 탭을 지원하는 전체 xterm.js 터미널 |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | 장시간 실행 중인 Claude Code 세션의 중단 상태를 감시하고 프로세스 제어를 제공 |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | 워크스페이스 범위 예약 프롬프트를 만들고 Codex, Claude Code, Gemini CLI 같은 로컬 CLI로 실행 |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | CloudCLI 안에서 Claude Code 세션 인텔리전스와 토큰 소모 가시성을 제공 |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | 활성 Claude Code 세션을 보고, 관리하고, 종료 |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | 모델 가격과 토큰 사용량으로 API 비용을 계산하고 모델 가격 프리셋을 지원 |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | 에이전트 작업을 보고, 필터링하고, 실행하는 작업 큐 대시보드 |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | GitHub Issues용 Kanban 보드. TaskMaster 양방향 동기화와 /github-task CLI 스킬 자동 설치 지원 |

 ### 직접 만들기

--- a/README.md
+++ b/README.md
@@ -163,15 +163,8 @@ CloudCLI has a plugin system that lets you add custom tabs with their own fronte
 | Plugin | Description |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | Shows file counts, lines of code, file-type breakdown, largest files, and recently modified files for your current project |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | Full xterm.js terminal with multi-tab support |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | Watches long-running Claude Code sessions for hangs and exposes process controls |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | Create workspace-scoped scheduled prompts and execute them through a local CLI such as Codex, Claude Code, or Gemini CLI |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | Session intelligence for Claude Code inside CloudCLI, including token burn visibility |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | View, manage, and kill active Claude Code sessions |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | Calculate API costs from model prices and token usage, with preset model pricing support |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | Task queue dashboard to view, filter, and launch agent tasks |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | Kanban board for GitHub Issues with bidirectional TaskMaster sync and /github-task CLI skill auto-install |
-
+| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | Full xterm.js terminal with multi-tab support|
+| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | Create workspace-scoped scheduled prompts and execute them through a local CLI such as Codex, Claude Code, or Gemini CLI|
 ### Build Your Own

 **[Plugin Starter Template →](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** — fork this repo to create your own plugin. It includes a working example with frontend rendering, live context updates, and RPC communication to a backend server.
--- a/README.ru.md
+++ b/README.ru.md
@@ -164,14 +164,6 @@ CloudCLI UI — это open source UI-слой, на котором постро
 | Плагин | Описание |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | Показывает количество файлов, строки кода, разбивку по типам файлов, самые большие файлы и недавно изменённые файлы для текущего проекта |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | Полноценный терминал xterm.js с поддержкой нескольких вкладок |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | Отслеживает зависания долгих сессий Claude Code и предоставляет управление процессами |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | Создаёт запланированные промпты для рабочей области и запускает их через локальную CLI, например Codex, Claude Code или Gemini CLI |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | Аналитика сессий Claude Code внутри CloudCLI, включая видимость расхода токенов |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | Просмотр, управление и завершение активных сессий Claude Code |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | Расчёт стоимости API по ценам моделей и использованию токенов, с поддержкой пресетов цен |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | Дашборд очереди задач для просмотра, фильтрации и запуска агентских задач |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | Kanban-доска для GitHub Issues с двусторонней синхронизацией TaskMaster и автоустановкой CLI-навыка /github-task |

 ### Создать свой

--- a/README.tr.md
+++ b/README.tr.md
@@ -164,13 +164,6 @@ CloudCLI, kendi frontend UI'sı ve isteğe bağlı Node.js arka ucu olan özel s
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | Mevcut projen için dosya sayıları, kod satırları, dosya türü dağılımı, en büyük dosyalar ve son değiştirilen dosyaları gösterir |
 | **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | Çoklu sekme destekli tam xterm.js terminali |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | Uzun süren Claude Code oturumlarını takılmalara karşı izler ve süreç kontrolleri sunar |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | Çalışma alanı kapsamlı zamanlanmış prompt'lar oluşturur ve bunları Codex, Claude Code veya Gemini CLI gibi yerel CLI'larla çalıştırır |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | CloudCLI içinde Claude Code oturum zekası ve token tüketimi görünürlüğü sağlar |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | Aktif Claude Code oturumlarını görüntülemeni, yönetmeni ve sonlandırmanı sağlar |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | Model fiyatları ve token kullanımından API maliyetlerini hesaplar; model fiyatı hazır ayarlarını destekler |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | Ajan görevlerini görüntülemek, filtrelemek ve başlatmak için görev kuyruğu paneli |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | GitHub Issues için Kanban panosu; çift yönlü TaskMaster senkronizasyonu ve /github-task CLI becerisi otomatik kurulumu içerir |

 ### Kendi Eklentini Yaz

--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -158,14 +158,6 @@ CloudCLI 配备插件系统，允许你添加带自定义前端 UI 和可选 Nod
 | 插件 | 描述 |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | 展示当前项目的文件数、代码行数、文件类型分布、最大文件以及最近修改的文件 |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | 支持多标签页的完整 xterm.js 终端 |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | 监控长时间运行的 Claude Code 会话是否卡住，并提供进程控制 |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | 创建工作区范围的定时提示词，并通过 Codex、Claude Code 或 Gemini CLI 等本地 CLI 执行 |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | 在 CloudCLI 中提供 Claude Code 会话智能分析，包括 token 消耗可视化 |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | 查看、管理并终止活动的 Claude Code 会话 |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | 根据模型价格和 token 用量计算 API 成本，并支持模型价格预设 |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | 用于查看、筛选和启动代理任务的任务队列仪表板 |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | 用于 GitHub Issues 的看板，支持 TaskMaster 双向同步和 /github-task CLI 技能自动安装 |

 ### 自行构建

--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -158,14 +158,6 @@ CloudCLI 配備外掛系統，允許你新增帶有自訂前端 UI 和選用 Nod
 | 外掛 | 描述 |
 |---|---|
 | **[Project Stats](https://github.com/cloudcli-ai/cloudcli-plugin-starter)** | 展示目前專案的檔案數、程式碼行數、檔案類型分佈、最大檔案以及最近修改的檔案 |
-| **[Web Terminal](https://github.com/cloudcli-ai/cloudcli-plugin-terminal)** | 支援多分頁的完整 xterm.js 終端機 |
-| **[Claude Watch](https://github.com/satsuki19980613/cloudcli-claude-watch)** | 監控長時間執行的 Claude Code 工作階段是否卡住，並提供程序控制 |
-| **[CloudCLI Scheduler](https://github.com/grostim/cloudcli-cron)** | 建立工作區範圍的排程提示詞，並透過 Codex、Claude Code 或 Gemini CLI 等本機 CLI 執行 |
-| **[PRISM CloudCLI](https://github.com/jakeefr/cloudcli-plugin-prism)** | 在 CloudCLI 中提供 Claude Code 工作階段智慧分析，包括 token 消耗可視化 |
-| **[Sessions](https://github.com/strykereye2/cloudcli-plugin-session-manager)** | 檢視、管理並終止作用中的 Claude Code 工作階段 |
-| **[Token Cost Calculator](https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator)** | 根據模型價格與 token 用量計算 API 成本，並支援模型價格預設 |
-| **[Task Queue](https://github.com/TadMSTR/cloudcli-plugin-task-queue)** | 用於檢視、篩選和啟動代理任務的任務佇列儀表板 |
-| **[GitHub Issues Board](https://github.com/szmidtpiotr/claude-github-issue)** | 用於 GitHub Issues 的看板，支援 TaskMaster 雙向同步和 /github-task CLI 技能自動安裝 |

 ### 自行建構

--- a/server/claude-sdk.js
+++ b/server/claude-sdk.js
@@ -28,10 +28,14 @@ import {
 } from './services/notification-orchestrator.js';
 import { sessionsService } from './modules/providers/services/sessions.service.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
-import { createNormalizedMessage } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';

 const activeSessions = new Map();
 const pendingToolApprovals = new Map();
+// Sessions cancelled via abort-session. The abort handler already sent the
+// terminal `complete` (aborted: true) to the client, so the run loop must not
+// emit a second one when its generator winds down.
+const abortedSessionIds = new Set();

 const TOOL_APPROVAL_TIMEOUT_MS = parseInt(process.env.CLAUDE_TOOL_APPROVAL_TIMEOUT_MS, 10) || 55000;

@@ -731,14 +735,18 @@ async function queryClaudeSDK(command, options = {}, ws) {
    // Clean up temporary image files
    await cleanupTempFiles(tempImagePaths, tempDir);

-    // Send completion event
-    ws.send(createNormalizedMessage({ kind: 'complete', exitCode: 0, isNewSession: !sessionId && !!command, sessionId: capturedSessionId, provider: 'claude' }));
+    // Send the terminal completion event — skipped for aborted runs, whose
+    // terminal `complete` (aborted: true) was already sent by abort-session.
+    const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
+    if (!wasAborted) {
+      ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 0 }));
+    }
    notifyRunStopped({
      userId: ws?.userId || null,
      provider: 'claude',
      sessionId: capturedSessionId || sessionId || null,
      sessionName: sessionSummary,
-      stopReason: 'completed'
+      stopReason: wasAborted ? 'aborted' : 'completed'
    });
    // Complete

@@ -753,14 +761,22 @@ async function queryClaudeSDK(command, options = {}, ws) {
    // Clean up temporary image files on error
    await cleanupTempFiles(tempImagePaths, tempDir);

+    const wasAborted = capturedSessionId ? abortedSessionIds.delete(capturedSessionId) : false;
+    if (wasAborted) {
+      // The abort already produced the terminal complete; a generator throw
+      // caused by interrupt() is expected noise, not a user-facing error.
+      return;
+    }
+
    // Check if Claude CLI is installed for a clearer error message
    const installed = await providerAuthService.isProviderInstalled('claude');
    const errorContent = !installed
      ? 'Claude Code is not installed. Please install it first: https://docs.anthropic.com/en/docs/claude-code'
      : error.message;

-    // Send error to WebSocket
+    // Send error to WebSocket, then the terminal complete
    ws.send(createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'claude' }));
+    ws.send(createCompleteMessage({ provider: 'claude', sessionId: capturedSessionId || sessionId || null, exitCode: 1 }));
    notifyRunFailed({
      userId: ws?.userId || null,
      provider: 'claude',
@@ -787,6 +803,10 @@ async function abortClaudeSDKSession(sessionId) {
  try {
    console.log(`Aborting SDK session: ${sessionId}`);

+    // Mark before interrupting so the run loop knows not to emit its own
+    // terminal complete (the abort handler sends the aborted one).
+    abortedSessionIds.add(sessionId);
+
    // Call interrupt() on the query instance
    await session.instance.interrupt();

@@ -802,6 +822,8 @@ async function abortClaudeSDKSession(sessionId) {
    return true;
  } catch (error) {
    console.error(`Error aborting session ${sessionId}:`, error);
+    // The run keeps going; let it emit its own terminal complete.
+    abortedSessionIds.delete(sessionId);
    return false;
  }
 }
--- a/server/cursor-cli.js
+++ b/server/cursor-cli.js
@@ -4,7 +4,7 @@ import { notifyRunFailed, notifyRunStopped } from './services/notification-orche
 import { sessionsService } from './modules/providers/services/sessions.service.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { createNormalizedMessage } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';

 // Use cross-spawn on Windows for better command execution
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
@@ -34,6 +34,10 @@ async function spawnCursor(command, options = {}, ws) {
    let sessionCreatedSent = false; // Track if we've already sent session-created event
    let hasRetriedWithTrust = false;
    let settled = false;
+    // The unified lifecycle contract requires exactly one terminal `complete`
+    // per run. Cursor surfaces completion twice (the `result` JSON line and
+    // the process close), so the first emission wins.
+    let completeSent = false;

    // Use tools settings passed from frontend, or defaults
    const settings = toolsSettings || {
@@ -197,15 +201,15 @@ async function spawnCursor(command, options = {}, ws) {
              break;

            case 'result': {
-              // Session complete — send stream end + lifecycle complete with result payload
-              const resultText = typeof response.result === 'string' ? response.result : '';
-              ws.send(createNormalizedMessage({
-                kind: 'complete',
-                exitCode: response.subtype === 'success' ? 0 : 1,
-                resultText,
-                isError: response.subtype !== 'success',
-                sessionId: capturedSessionId || sessionId, provider: 'cursor',
-              }));
+              // Session complete — terminal lifecycle event for this run
+              if (!completeSent) {
+                completeSent = true;
+                ws.send(createCompleteMessage({
+                  provider: 'cursor',
+                  sessionId: capturedSessionId || sessionId || null,
+                  exitCode: response.subtype === 'success' ? 0 : 1,
+                }));
+              }
              break;
            }

@@ -271,7 +275,12 @@ async function spawnCursor(command, options = {}, ws) {
          return;
        }

-        ws.send(createNormalizedMessage({ kind: 'complete', exitCode: code, isNewSession: !sessionId && !!command, sessionId: finalSessionId, provider: 'cursor' }));
+        // Terminal complete — unless the `result` line already sent it, or the
+        // run was aborted (abort-session sent the aborted complete).
+        if (!completeSent && !cursorProcess.aborted) {
+          completeSent = true;
+          ws.send(createCompleteMessage({ provider: 'cursor', sessionId: finalSessionId, exitCode: code }));
+        }

        if (code === 0) {
          notifyTerminalState({ code });
@@ -297,6 +306,10 @@ async function spawnCursor(command, options = {}, ws) {
          : error.message;

        ws.send(createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'cursor' }));
+        if (!completeSent && !cursorProcess.aborted) {
+          completeSent = true;
+          ws.send(createCompleteMessage({ provider: 'cursor', sessionId: capturedSessionId || sessionId || null, exitCode: 1 }));
+        }
        notifyTerminalState({ error });

        settleOnce(() => reject(error));
@@ -314,6 +327,9 @@ function abortCursorSession(sessionId) {
  const process = activeCursorProcesses.get(sessionId);
  if (process) {
    console.log(`Aborting Cursor session: ${sessionId}`);
+    // The abort handler sends the terminal complete (aborted: true); flag the
+    // process so its close handler does not emit a second one.
+    process.aborted = true;
    process.kill('SIGTERM');
    activeCursorProcesses.delete(sessionId);
    return true;
--- a/server/gemini-cli.js
+++ b/server/gemini-cli.js
@@ -10,7 +10,7 @@ import GeminiResponseHandler from './gemini-response-handler.js';
 import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { createNormalizedMessage } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';

 // Use cross-spawn on Windows for correct .cmd resolution (same pattern as cursor-cli.js)
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
@@ -129,6 +129,9 @@ async function spawnGemini(command, options = {}, ws) {
    let capturedSessionId = sessionId; // Track session ID throughout the process
    let sessionCreatedSent = false; // Track if we've already sent session-created event
    let assistantBlocks = []; // Accumulate the full response blocks including tools
+    // Unified lifecycle contract: exactly one terminal `complete` per run
+    // (close and error handlers can both fire for spawn failures).
+    let completeSent = false;

    // Use tools settings passed from frontend, or defaults
    const settings = toolsSettings || {
@@ -486,7 +489,12 @@ async function spawnGemini(command, options = {}, ws) {
                sessionManager.addMessage(finalSessionId, 'assistant', assistantBlocks);
            }

-            ws.send(createNormalizedMessage({ kind: 'complete', exitCode: code, isNewSession: !sessionId && !!command, sessionId: finalSessionId, provider: 'gemini' }));
+            // Terminal complete — skipped for aborted runs (abort-session
+            // already sent the aborted complete on this run's behalf).
+            if (!completeSent && !geminiProcess.aborted) {
+                completeSent = true;
+                ws.send(createCompleteMessage({ provider: 'gemini', sessionId: finalSessionId, exitCode: code }));
+            }

            // Clean up temporary image files if any
            if (geminiProcess.tempImagePaths && geminiProcess.tempImagePaths.length > 0) {
@@ -566,6 +574,10 @@ async function spawnGemini(command, options = {}, ws) {

            const errorSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : finalSessionId;
            ws.send(createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: errorSessionId, provider: 'gemini' }));
+            if (!completeSent && !geminiProcess.aborted) {
+                completeSent = true;
+                ws.send(createCompleteMessage({ provider: 'gemini', sessionId: errorSessionId, exitCode: 1 }));
+            }
            notifyTerminalState({ error });

            reject(error);
@@ -590,6 +602,9 @@ function abortGeminiSession(sessionId) {

    if (geminiProc) {
        try {
+            // The abort handler sends the terminal complete (aborted: true);
+            // flag the process so its close handler does not emit a second one.
+            geminiProc.aborted = true;
            geminiProc.kill('SIGTERM');
            setTimeout(() => {
                if (activeGeminiProcesses.has(processKey)) {
--- a/server/modules/websocket/README.md
+++ b/server/modules/websocket/README.md
@@ -133,9 +133,10 @@ flowchart TD

 ### Chat Notes

-1. `abort-session` returns a normalized `complete` message with `aborted: true`.
-2. `check-session-status` returns `{ type: "session-status", isProcessing }`.
-3. Claude status checks can reconnect output stream to the new socket via `reconnectSessionWriter`.
+1. **Unified terminal lifecycle**: every provider run ends with exactly one `complete` message built by `createCompleteMessage()` (`server/shared/utils.ts`), regardless of provider: `{ kind: "complete", sessionId, actualSessionId, exitCode, success, aborted }`. Failed runs emit an informational `error` message first, then the terminal `complete` with `success: false`. Mid-run `error` messages (e.g. stderr output) are non-terminal; the frontend only treats `complete` as end-of-run.
+2. `abort-session` sends the terminal `complete` (`aborted: true`) on behalf of the cancelled run; providers detect the abort and skip their own `complete` so the client sees exactly one.
+3. `check-session-status` returns `{ type: "session-status", isProcessing }`.
+4. Claude status checks can reconnect output stream to the new socket via `reconnectSessionWriter`.

 ## `/shell` Terminal Flow

--- a/server/modules/websocket/services/chat-websocket.service.ts
+++ b/server/modules/websocket/services/chat-websocket.service.ts
@@ -7,7 +7,7 @@ import type {
  AuthenticatedWebSocketRequest,
  LLMProvider,
 } from '@/shared/types.js';
-import { createNormalizedMessage, parseIncomingJsonObject } from '@/shared/utils.js';
+import { createCompleteMessage, parseIncomingJsonObject } from '@/shared/utils.js';

 type ChatIncomingMessage = AnyRecord & {
  type?: string;
@@ -173,14 +173,14 @@ export function handleChatConnection(
          success = await dependencies.abortClaudeSDKSession(sessionId);
        }

+        // Terminal complete on behalf of the cancelled run — providers skip
+        // their own complete for aborted runs so the client sees exactly one.
        writer.send(
-          createNormalizedMessage({
-            kind: 'complete',
+          createCompleteMessage({
+            provider,
+            sessionId,
            exitCode: success ? 0 : 1,
            aborted: true,
-            success,
-            sessionId,
-            provider,
          })
        );
        return;
@@ -202,13 +202,11 @@ export function handleChatConnection(
        const sessionId = typeof data.sessionId === 'string' ? data.sessionId : '';
        const success = dependencies.abortCursorSession(sessionId);
        writer.send(
-          createNormalizedMessage({
-            kind: 'complete',
+          createCompleteMessage({
+            provider: 'cursor',
+            sessionId,
            exitCode: success ? 0 : 1,
            aborted: true,
-            success,
-            sessionId,
-            provider: 'cursor',
          })
        );
        return;
--- a/server/openai-codex.js
+++ b/server/openai-codex.js
@@ -18,7 +18,7 @@ import { notifyRunFailed, notifyRunStopped } from './services/notification-orche
 import { sessionsService } from './modules/providers/services/sessions.service.js';
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { createNormalizedMessage } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage } from './shared/utils.js';

 // Track active sessions
 const activeCodexSessions = new Map();
@@ -352,21 +352,26 @@ export async function queryCodex(command, options = {}, ws) {
      }
    }

-    // Send completion event
-    if (!terminalFailure) {
-      sendMessage(ws, createNormalizedMessage({
-        kind: 'complete',
-        actualSessionId: capturedSessionId || thread.id || sessionId || null,
-        sessionId: capturedSessionId || sessionId || null,
-        provider: 'codex'
-      }));
-      notifyRunStopped({
-        userId: ws?.userId || null,
+    // Send the terminal completion event — skipped for aborted runs, whose
+    // terminal `complete` (aborted: true) was already sent by abort-session.
+    const runSession = capturedSessionId ? activeCodexSessions.get(capturedSessionId) : null;
+    const runAborted = runSession?.status === 'aborted' || abortController.signal.aborted;
+    if (!runAborted) {
+      sendMessage(ws, createCompleteMessage({
        provider: 'codex',
        sessionId: capturedSessionId || sessionId || null,
-        sessionName: sessionSummary,
-        stopReason: 'completed'
-      });
+        actualSessionId: capturedSessionId || thread.id || sessionId || null,
+        exitCode: terminalFailure ? 1 : 0,
+      }));
+      if (!terminalFailure) {
+        notifyRunStopped({
+          userId: ws?.userId || null,
+          provider: 'codex',
+          sessionId: capturedSessionId || sessionId || null,
+          sessionName: sessionSummary,
+          stopReason: 'completed'
+        });
+      }
    }

  } catch (error) {
@@ -386,6 +391,11 @@ export async function queryCodex(command, options = {}, ws) {
        : error.message;

      sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+      sendMessage(ws, createCompleteMessage({
+        provider: 'codex',
+        sessionId: capturedSessionId || sessionId || null,
+        exitCode: 1,
+      }));
      if (!terminalFailure) {
        notifyRunFailed({
          userId: ws?.userId || null,
--- a/server/opencode-cli.js
+++ b/server/opencode-cli.js
@@ -8,7 +8,7 @@ import { sessionsService } from './modules/providers/services/sessions.service.j
 import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
 import { providerModelsService } from './modules/providers/services/provider-models.service.js';
 import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
-import { createNormalizedMessage, getOpenCodeDatabasePath } from './shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage, getOpenCodeDatabasePath } from './shared/utils.js';

 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;

@@ -92,6 +92,9 @@ async function spawnOpenCode(command, options = {}, ws) {
    let stdoutLineBuffer = '';
    let terminalNotificationSent = false;
    let opencodeProcess = null;
+    // Unified lifecycle contract: exactly one terminal `complete` per run
+    // (close and error handlers can both fire for spawn failures).
+    let completeSent = false;

    const notifyTerminalState = ({ code = null, error = null } = {}) => {
      if (terminalNotificationSent) {
@@ -256,13 +259,12 @@ async function spawnOpenCode(command, options = {}, ws) {
          }));
        }

-        ws.send(createNormalizedMessage({
-          kind: 'complete',
-          exitCode: code,
-          isNewSession: !sessionId && !!command,
-          sessionId: finalSessionId,
-          provider: 'opencode',
-        }));
+        // Terminal complete — skipped for aborted runs (abort-session
+        // already sent the aborted complete on this run's behalf).
+        if (!completeSent && !opencodeProcess.aborted) {
+          completeSent = true;
+          ws.send(createCompleteMessage({ provider: 'opencode', sessionId: finalSessionId, exitCode: code }));
+        }

        if (code === 0) {
          notifyTerminalState({ code });
@@ -302,6 +304,10 @@ async function spawnOpenCode(command, options = {}, ws) {
          sessionId: finalSessionId,
          provider: 'opencode',
        }));
+        if (!completeSent && !opencodeProcess.aborted) {
+          completeSent = true;
+          ws.send(createCompleteMessage({ provider: 'opencode', sessionId: finalSessionId, exitCode: 1 }));
+        }
        notifyTerminalState({ error });
        reject(error);
      });
@@ -315,6 +321,9 @@ function abortOpenCodeSession(sessionId) {
    return false;
  }

+  // The abort handler sends the terminal complete (aborted: true); flag the
+  // process so its close handler does not emit a second one.
+  process.aborted = true;
  process.kill('SIGTERM');
  activeOpenCodeProcesses.delete(sessionId);
  return true;
--- a/server/shared/utils.ts
+++ b/server/shared/utils.ts
@@ -346,6 +346,43 @@ export function createNormalizedMessage(fields: NormalizedMessageInput): Normali
  };
 }

+/**
+ * Build the unified terminal `complete` lifecycle message.
+ *
+ * Contract: every provider run ends with exactly one `complete` (the
+ * abort-session handler emits it on behalf of cancelled runs, so aborted runs
+ * must NOT emit their own). The frontend treats `complete` as the only
+ * terminal signal and never needs provider-specific handling:
+ *
+ * - `sessionId`     — the id the client knows this run by ('' if never discovered)
+ * - `actualSessionId` — canonical id after the run; equals `sessionId` unless
+ *                       the provider rewrote it mid-run
+ * - `exitCode`      — 0 on success; a missing/null code (e.g. killed process)
+ *                     is reported as failure
+ * - `success`       — exitCode === 0 and not aborted
+ * - `aborted`       — run was cancelled by the user
+ */
+export function createCompleteMessage(opts: {
+  provider: NormalizedMessage['provider'];
+  sessionId?: string | null;
+  actualSessionId?: string | null;
+  exitCode?: number | null;
+  aborted?: boolean;
+}): NormalizedMessage {
+  const exitCode = typeof opts.exitCode === 'number' ? opts.exitCode : 1;
+  const aborted = Boolean(opts.aborted);
+
+  return createNormalizedMessage({
+    kind: 'complete',
+    provider: opts.provider,
+    sessionId: opts.sessionId || null,
+    actualSessionId: opts.actualSessionId || opts.sessionId || null,
+    exitCode,
+    success: exitCode === 0 && !aborted,
+    aborted,
+  });
+}
+
 // ---------------------------
 //----------------- MCP CONFIG PARSING UTILITIES ------------
 /**
--- a/src/components/app/AppContent.tsx
+++ b/src/components/app/AppContent.tsx
@@ -28,12 +28,9 @@ function AppContentInner() {
  const wasConnectedRef = useRef(false);

  const {
-    activeSessions,
    processingSessions,
-    markSessionAsActive,
-    markSessionAsInactive,
-    markSessionAsProcessing,
-    markSessionAsNotProcessing,
+    markSessionProcessing,
+    markSessionIdle,
  } = useSessionProtection();

  const {
@@ -57,7 +54,7 @@ function AppContentInner() {
    navigate,
    latestMessage,
    isMobile,
-    activeSessions,
+    activeSessions: processingSessions,
  });

  usePaletteOpsRegister({
@@ -185,10 +182,8 @@ function AppContentInner() {
          onMenuClick={() => setSidebarOpen(true)}
          isLoading={isLoadingProjects}
          onInputFocusChange={setIsInputFocused}
-          onSessionActive={markSessionAsActive}
-          onSessionInactive={markSessionAsInactive}
-          onSessionProcessing={markSessionAsProcessing}
-          onSessionNotProcessing={markSessionAsNotProcessing}
+          onSessionProcessing={markSessionProcessing}
+          onSessionIdle={markSessionIdle}
          processingSessions={processingSessions}
          onNavigateToSession={(targetSessionId: string, options) =>
            navigate(`/session/${targetSessionId}`, { replace: Boolean(options?.replace) })
--- a/src/components/chat/hooks/useChatComposerState.ts
+++ b/src/components/chat/hooks/useChatComposerState.ts
@@ -12,6 +12,8 @@ import type {
 import { useDropzone } from 'react-dropzone';

 import { authenticatedFetch } from '../../../utils/api';
+import { PENDING_SESSION_ID } from '../../../hooks/useSessionProtection';
+import type { MarkSessionProcessing } from '../../../hooks/useSessionProtection';
 import { grantClaudeToolPermission } from '../utils/chatPermissions';
 import { safeLocalStorage } from '../utils/chatStorage';
 import type {
@@ -25,10 +27,6 @@ import { escapeRegExp } from '../utils/chatFormatting';
 import { useFileMentions } from './useFileMentions';
 import { type SlashCommand, useSlashCommands } from './useSlashCommands';

-type PendingViewSession = {
-  startedAt: number;
-};
-
 interface UseChatComposerStateArgs {
  selectedProject: Project | null;
  selectedSession: ProjectSession | null;
@@ -46,17 +44,12 @@ interface UseChatComposerStateArgs {
  tokenBudget: Record<string, unknown> | null;
  sendMessage: (message: unknown) => void;
  sendByCtrlEnter?: boolean;
-  onSessionActive?: (sessionId?: string | null) => void;
-  onSessionProcessing?: (sessionId?: string | null) => void;
+  onSessionProcessing?: MarkSessionProcessing;
  onInputFocusChange?: (focused: boolean) => void;
  onFileOpen?: (filePath: string, diffInfo?: unknown) => void;
  onShowSettings?: () => void;
-  pendingViewSessionRef: { current: PendingViewSession | null };
  scrollToBottom: () => void;
  addMessage: (msg: ChatMessage) => void;
-  setIsLoading: (loading: boolean) => void;
-  setCanAbortSession: (canAbort: boolean) => void;
-  setClaudeStatus: (status: { text: string; tokens: number; can_interrupt: boolean } | null) => void;
  setIsUserScrolledUp: (isScrolledUp: boolean) => void;
  setPendingPermissionRequests: Dispatch<SetStateAction<PendingPermissionRequest[]>>;
 }
@@ -177,17 +170,12 @@ export function useChatComposerState({
  tokenBudget,
  sendMessage,
  sendByCtrlEnter,
-  onSessionActive,
  onSessionProcessing,
  onInputFocusChange,
  onFileOpen,
  onShowSettings,
-  pendingViewSessionRef,
  scrollToBottom,
  addMessage,
-  setIsLoading,
-  setCanAbortSession,
-  setClaudeStatus,
  setIsUserScrolledUp,
  setPendingPermissionRequests,
 }: UseChatComposerStateArgs) {
@@ -620,27 +608,18 @@ export function useChatComposerState({
      };

      addMessage(userMessage);
-      setIsLoading(true); // Processing banner starts
-      setCanAbortSession(true);
-      setClaudeStatus({
-        text: 'Processing',
-        tokens: 0,
-        can_interrupt: true,
+      // Mark this request as processing in the per-session activity map (the
+      // single source of truth the indicator derives from). A brand-new
+      // conversation has no session id yet, so it is tracked under the
+      // pending placeholder until `session_created` announces the real id.
+      onSessionProcessing?.(effectiveSessionId || PENDING_SESSION_ID, {
+        statusText: null,
+        canInterrupt: true,
      });

      setIsUserScrolledUp(false);
      setTimeout(() => scrollToBottom(), 100);

-      if (!effectiveSessionId && !selectedSession?.id) {
-        // This tracks only that a request is in flight before the provider has
-        // emitted its real session id; routing still waits for session_created.
-        pendingViewSessionRef.current = { startedAt: Date.now() };
-      }
-      if (effectiveSessionId) {
-        onSessionActive?.(effectiveSessionId);
-        onSessionProcessing?.(effectiveSessionId);
-      }
-
      const getToolsSettings = () => {
        try {
          const settingsKey =
@@ -776,19 +755,14 @@ export function useChatComposerState({
      geminiModel,
      opencodeModel,
      isLoading,
-      onSessionActive,
      onSessionProcessing,
-      pendingViewSessionRef,
      permissionMode,
      provider,
      resetCommandMenuState,
      scrollToBottom,
      selectedProject,
      sendMessage,
-      setCanAbortSession,
      addMessage,
-      setClaudeStatus,
-      setIsLoading,
      setIsUserScrolledUp,
      slashCommands,
    ],
@@ -1000,15 +974,11 @@ export function useChatComposerState({
        });
      });

-      setPendingPermissionRequests((previous) => {
-        const next = previous.filter((request) => !validIds.includes(request.requestId));
-        if (next.length === 0) {
-          setClaudeStatus(null);
-        }
-        return next;
-      });
+      setPendingPermissionRequests((previous) =>
+        previous.filter((request) => !validIds.includes(request.requestId)),
+      );
    },
-    [sendMessage, setClaudeStatus, setPendingPermissionRequests],
+    [sendMessage, setPendingPermissionRequests],
  );

  const [isInputFocused, setIsInputFocused] = useState(false);
--- a/src/components/chat/hooks/useChatRealtimeHandlers.ts
+++ b/src/components/chat/hooks/useChatRealtimeHandlers.ts
@@ -4,14 +4,12 @@ import type { Dispatch, MutableRefObject, SetStateAction } from 'react';
 import { usePaletteOps } from '../../../contexts/PaletteOpsContext';
 import { showCompletionTitleIndicator } from '../../../utils/pageTitleNotification';
 import { playChatCompletionSound } from '../../../utils/notificationSound';
+import { PENDING_SESSION_ID } from '../../../hooks/useSessionProtection';
+import type { MarkSessionIdle, MarkSessionProcessing } from '../../../hooks/useSessionProtection';
 import type { PendingPermissionRequest, SessionNavigationOptions } from '../types/types';
 import type { ProjectSession, LLMProvider } from '../../../types/app';
 import type { SessionStore, NormalizedMessage } from '../../../stores/useSessionStore';

-type PendingViewSession = {
-  startedAt: number;
-};
-
 type LatestChatMessage = {
  type?: string;
  kind?: string;
@@ -55,18 +53,14 @@ interface UseChatRealtimeHandlersArgs {
  selectedSession: ProjectSession | null;
  currentSessionId: string | null;
  setCurrentSessionId: (sessionId: string | null) => void;
-  setIsLoading: (loading: boolean) => void;
-  setCanAbortSession: (canAbort: boolean) => void;
-  setClaudeStatus: (status: { text: string; tokens: number; can_interrupt: boolean } | null) => void;
  setTokenBudget: (budget: Record<string, unknown> | null) => void;
  setPendingPermissionRequests: Dispatch<SetStateAction<PendingPermissionRequest[]>>;
-  pendingViewSessionRef: MutableRefObject<PendingViewSession | null>;
  streamTimerRef: MutableRefObject<number | null>;
  accumulatedStreamRef: MutableRefObject<string>;
-  onSessionInactive?: (sessionId?: string | null) => void;
-  onSessionActive?: (sessionId?: string | null) => void;
-  onSessionProcessing?: (sessionId?: string | null) => void;
-  onSessionNotProcessing?: (sessionId?: string | null) => void;
+  /** When each session's `check-session-status` was last sent; guards stale idle replies. */
+  statusCheckSentAtRef: MutableRefObject<Map<string, number>>;
+  onSessionProcessing?: MarkSessionProcessing;
+  onSessionIdle?: MarkSessionIdle;
  onNavigateToSession?: (sessionId: string, options?: SessionNavigationOptions) => void;
  onWebSocketReconnect?: () => void;
  sessionStore: SessionStore;
@@ -82,18 +76,13 @@ export function useChatRealtimeHandlers({
  selectedSession,
  currentSessionId,
  setCurrentSessionId,
-  setIsLoading,
-  setCanAbortSession,
-  setClaudeStatus,
  setTokenBudget,
  setPendingPermissionRequests,
-  pendingViewSessionRef,
  streamTimerRef,
  accumulatedStreamRef,
-  onSessionInactive,
-  onSessionActive,
+  statusCheckSentAtRef,
  onSessionProcessing,
-  onSessionNotProcessing,
+  onSessionIdle,
  onNavigateToSession,
  onWebSocketReconnect,
  sessionStore,
@@ -138,35 +127,24 @@ export function useChatRealtimeHandlers({

          const status = msg.status;
          if (status) {
-            const statusInfo = {
-              text: status.text || 'Working...',
-              tokens: status.tokens || 0,
-              can_interrupt: status.can_interrupt !== undefined ? status.can_interrupt : true,
-            };
-            setClaudeStatus(statusInfo);
-            setIsLoading(true);
-            setCanAbortSession(statusInfo.can_interrupt);
+            onSessionProcessing?.(statusSessionId, {
+              statusText: status.text || null,
+              canInterrupt: status.can_interrupt !== false,
+            });
            return;
          }

-          // Legacy isProcessing format from check-session-status
-          const isCurrentSession =
-            statusSessionId === currentSessionId || (selectedSession && statusSessionId === selectedSession.id);
-
+          // Reply to check-session-status (or unsolicited processing update)
          if (msg.isProcessing) {
-            onSessionActive?.(statusSessionId);
            onSessionProcessing?.(statusSessionId);
-            if (isCurrentSession) { setIsLoading(true); setCanAbortSession(true); }
            return;
          }

-          onSessionInactive?.(statusSessionId);
-          onSessionNotProcessing?.(statusSessionId);
-          if (isCurrentSession) {
-            setIsLoading(false);
-            setCanAbortSession(false);
-            setClaudeStatus(null);
-          }
+          // Idle reply: ignore it if a newer request started after the check
+          // was sent — the reply describes the older request.
+          onSessionIdle?.(statusSessionId, {
+            ifStartedBefore: statusCheckSentAtRef.current.get(statusSessionId),
+          });
          return;
        }

@@ -238,23 +216,15 @@ export function useChatRealtimeHandlers({
        // We no longer synthesize client-side placeholder IDs. Until the provider
        // announces `session_created`, the active id is expected to be null.
        if (!currentSessionId) {
-          console.log('Session created with ID:', newSessionId);
-          console.log('Existing session ID:', currentSessionId);
          setCurrentSessionId(newSessionId);
          setPendingPermissionRequests((prev) =>
            prev.map((r) => (r.sessionId ? r : { ...r, sessionId: newSessionId })),
          );
        }
-        pendingViewSessionRef.current = null;
-        onSessionActive?.(newSessionId);
+        // The in-flight request now has a concrete session id: migrate the
+        // processing entry from the pending placeholder.
+        onSessionIdle?.(PENDING_SESSION_ID);
        onSessionProcessing?.(newSessionId);
-        setIsLoading(true);
-        setCanAbortSession(true);
-        setClaudeStatus({
-          text: 'Processing',
-          tokens: 0,
-          can_interrupt: true,
-        });
        onNavigateToSession?.(newSessionId);
        break;
      }
@@ -271,24 +241,27 @@ export function useChatRealtimeHandlers({
        }
        accumulatedStreamRef.current = '';

-        setIsLoading(false);
-        setCanAbortSession(false);
-        setClaudeStatus(null);
+        // `complete` is the unified terminal event — every provider run ends
+        // with exactly one, regardless of success, failure, or abort. The
+        // indicator derives from the processing map, so deleting the entry
+        // hides it immediately and atomically.
+        onSessionIdle?.(sid);
+        onSessionIdle?.(PENDING_SESSION_ID);
        setPendingPermissionRequests([]);
-        onSessionInactive?.(sid);
-        onSessionNotProcessing?.(sid);
-        pendingViewSessionRef.current = null;

        // Handle aborted case
        if (msg.aborted) {
          // Abort was requested — the complete event confirms it
-          // No special UI action needed beyond clearing loading state above
+          // No special UI action needed beyond clearing the processing entry above
          // The backend already sent any abort-related messages
          break;
        }

-        showCompletionTitleIndicator();
-        void playChatCompletionSound();
+        // Celebrate only successful runs (failed runs end with success: false).
+        if (msg.success !== false) {
+          showCompletionTitleIndicator();
+          void playChatCompletionSound();
+        }

        const actualSessionId =
          typeof msg.actualSessionId === 'string' && msg.actualSessionId.trim().length > 0
@@ -302,6 +275,7 @@ export function useChatRealtimeHandlers({

        if (actualSessionId && sid && actualSessionId !== sid) {
          sessionStore.replaceSessionId(sid, actualSessionId);
+          onSessionIdle?.(actualSessionId);

          if (isVisibleSession) {
            setCurrentSessionId(actualSessionId);
@@ -317,15 +291,9 @@ export function useChatRealtimeHandlers({
        break;
      }

-      case 'error': {
-        setIsLoading(false);
-        setCanAbortSession(false);
-        setClaudeStatus(null);
-        onSessionInactive?.(sid);
-        onSessionNotProcessing?.(sid);
-        pendingViewSessionRef.current = null;
-        break;
-      }
+      // 'error' is an informational message row, not a terminal event —
+      // providers emit it for mid-run stderr output too. Run teardown is
+      // always signalled by the unified 'complete' that follows.

      case 'permission_request': {
        if (!msg.requestId) break;
@@ -340,9 +308,7 @@ export function useChatRealtimeHandlers({
            receivedAt: new Date(),
          }];
        });
-        setIsLoading(true);
-        setCanAbortSession(true);
-        setClaudeStatus({ text: 'Waiting for permission', tokens: 0, can_interrupt: true });
+        onSessionProcessing?.(sid || PENDING_SESSION_ID);
        break;
      }

@@ -357,13 +323,10 @@ export function useChatRealtimeHandlers({
        if (msg.text === 'token_budget' && msg.tokenBudget) {
          setTokenBudget(msg.tokenBudget as Record<string, unknown>);
        } else if (msg.text) {
-          setClaudeStatus({
-            text: msg.text,
-            tokens: msg.tokens || 0,
-            can_interrupt: msg.canInterrupt !== undefined ? msg.canInterrupt : true,
+          onSessionProcessing?.(sid || PENDING_SESSION_ID, {
+            statusText: msg.text,
+            canInterrupt: msg.canInterrupt !== false,
          });
-          setIsLoading(true);
-          setCanAbortSession(msg.canInterrupt !== false);
        }
        break;
      }
@@ -379,18 +342,13 @@ export function useChatRealtimeHandlers({
    selectedSession,
    currentSessionId,
    setCurrentSessionId,
-    setIsLoading,
-    setCanAbortSession,
-    setClaudeStatus,
    setTokenBudget,
    setPendingPermissionRequests,
-    pendingViewSessionRef,
    streamTimerRef,
    accumulatedStreamRef,
-    onSessionInactive,
-    onSessionActive,
+    statusCheckSentAtRef,
    onSessionProcessing,
-    onSessionNotProcessing,
+    onSessionIdle,
    onNavigateToSession,
    onWebSocketReconnect,
    sessionStore,
--- a/src/components/chat/hooks/useChatSessionState.ts
+++ b/src/components/chat/hooks/useChatSessionState.ts
@@ -2,6 +2,8 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 import type { MutableRefObject } from 'react';

 import { authenticatedFetch } from '../../../utils/api';
+import { PENDING_SESSION_ID } from '../../../hooks/useSessionProtection';
+import type { MarkSessionIdle, SessionActivityMap } from '../../../hooks/useSessionProtection';
 import type { Project, ProjectSession, LLMProvider } from '../../../types/app';
 import type { SessionStore, NormalizedMessage } from '../../../stores/useSessionStore';
 import type { ChatMessage, Provider } from '../types/types';
@@ -12,10 +14,6 @@ import { normalizedToChatMessages } from './useChatMessages';
 const MESSAGES_PER_PAGE = 20;
 const INITIAL_VISIBLE_MESSAGES = 100;

-type PendingViewSession = {
-  startedAt: number;
-};
-
 interface UseChatSessionStateArgs {
  selectedProject: Project | null;
  selectedSession: ProjectSession | null;
@@ -24,9 +22,11 @@ interface UseChatSessionStateArgs {
  autoScrollToBottom?: boolean;
  externalMessageUpdate?: number;
  newSessionTrigger?: number;
-  processingSessions?: Set<string>;
+  processingSessions?: SessionActivityMap;
+  onSessionIdle?: MarkSessionIdle;
  resetStreamingState: () => void;
-  pendingViewSessionRef: MutableRefObject<PendingViewSession | null>;
+  /** When each session's `check-session-status` was last sent; guards stale idle replies. */
+  statusCheckSentAtRef: MutableRefObject<Map<string, number>>;
  sessionStore: SessionStore;
 }

@@ -99,21 +99,19 @@ export function useChatSessionState({
  externalMessageUpdate,
  newSessionTrigger,
  processingSessions,
+  onSessionIdle,
  resetStreamingState,
-  pendingViewSessionRef,
+  statusCheckSentAtRef,
  sessionStore,
 }: UseChatSessionStateArgs) {
-  const [isLoading, setIsLoading] = useState(false);
  const [currentSessionId, setCurrentSessionId] = useState<string | null>(selectedSession?.id || null);
  const [isLoadingSessionMessages, setIsLoadingSessionMessages] = useState(false);
  const [isLoadingMoreMessages, setIsLoadingMoreMessages] = useState(false);
  const [hasMoreMessages, setHasMoreMessages] = useState(false);
  const [totalMessages, setTotalMessages] = useState(0);
-  const [canAbortSession, setCanAbortSession] = useState(false);
  const [isUserScrolledUp, setIsUserScrolledUp] = useState(false);
  const [tokenBudget, setTokenBudget] = useState<Record<string, unknown> | null>(null);
  const [visibleMessageCount, setVisibleMessageCount] = useState(INITIAL_VISIBLE_MESSAGES);
-  const [claudeStatus, setClaudeStatus] = useState<{ text: string; tokens: number; can_interrupt: boolean } | null>(null);
  const [allMessagesLoaded, setAllMessagesLoaded] = useState(false);
  const [isLoadingAllMessages, setIsLoadingAllMessages] = useState(false);
  const [loadAllJustFinished, setLoadAllJustFinished] = useState(false);
@@ -170,10 +168,7 @@ export function useChatSessionState({
     * - No coupling to unrelated external update signals.
     */
    resetStreamingState();
-    pendingViewSessionRef.current = null;
-    setClaudeStatus(null);
-    setCanAbortSession(false);
-    setIsLoading(false);
+    onSessionIdle?.(PENDING_SESSION_ID);
    setCurrentSessionId(null);
    setPendingUserMessage(null);
    sessionStorage.removeItem('cursorSessionId');
@@ -204,13 +199,29 @@ export function useChatSessionState({
      clearTimeout(loadAllFinishedTimerRef.current);
      loadAllFinishedTimerRef.current = null;
    }
-  }, [newSessionTrigger, pendingViewSessionRef, resetStreamingState]);
+  }, [newSessionTrigger, onSessionIdle, resetStreamingState]);
+
+  /* ---------------------------------------------------------------- */
+  /*  Derive processing state for the viewed session                  */
+  /* ---------------------------------------------------------------- */
+
+  const activeSessionId = selectedSession?.id || currentSessionId || null;
+
+  // The activity indicator always reflects the latest status of the session
+  // being viewed (or of the pending not-yet-created session on a fresh
+  // draft) — never stale local UI state from the last time it was open.
+  const sessionActivity = processingSessions?.get(activeSessionId ?? PENDING_SESSION_ID) ?? null;
+  const isProcessing = sessionActivity !== null;
+  const canAbortSession = isProcessing && sessionActivity.canInterrupt;
+
+  // Ref mirror so effects can read the latest map without re-running on
+  // every activity transition.
+  const processingSessionsRef = useRef(processingSessions);
+  processingSessionsRef.current = processingSessions;

  /* ---------------------------------------------------------------- */
  /*  Derive chatMessages from the store                              */
  /* ---------------------------------------------------------------- */
-
-  const activeSessionId = selectedSession?.id || currentSessionId || null;
  const [pendingUserMessage, setPendingUserMessage] = useState<ChatMessage | null>(null);
  const flushedPendingUserMessageRef = useRef<ChatMessage | null>(null);

@@ -430,16 +441,12 @@ export function useChatSessionState({
  useEffect(() => {
    if (!selectedSession || !selectedProject) {
      // A new provider run can be in flight before the router has a canonical
-      // selectedSession. Keep the processing banner alive until complete/error.
-      if (pendingViewSessionRef.current) {
+      // selectedSession. Keep the draft view intact until complete/error.
+      if (processingSessionsRef.current?.has(PENDING_SESSION_ID)) {
        return;
      }

      resetStreamingState();
-      pendingViewSessionRef.current = null;
-      setClaudeStatus(null);
-      setCanAbortSession(false);
-      setIsLoading(false);
      setCurrentSessionId(null);
      sessionStorage.removeItem('cursorSessionId');
      messagesOffsetRef.current = 0;
@@ -461,9 +468,6 @@ export function useChatSessionState({
    const sessionChanged = currentSessionId !== null && currentSessionId !== selectedSession.id;
    if (sessionChanged) {
      resetStreamingState();
-      pendingViewSessionRef.current = null;
-      setClaudeStatus(null);
-      setCanAbortSession(false);
    }

    // Reset pagination/scroll state
@@ -482,7 +486,6 @@ export function useChatSessionState({

    if (sessionChanged) {
      setTokenBudget(null);
-      setIsLoading(false);
    }

    setCurrentSessionId(selectedSession.id);
@@ -490,8 +493,11 @@ export function useChatSessionState({
      sessionStorage.setItem('cursorSessionId', selectedSession.id);
    }

-    // Check session status
+    // Reconcile processing state with the server. Recording the send time
+    // lets the reply handler discard idle replies that a newer request has
+    // since outdated.
    if (ws) {
+      statusCheckSentAtRef.current.set(selectedSession.id, Date.now());
      sendMessage({ type: 'check-session-status', sessionId: selectedSession.id, provider });
    }

@@ -516,11 +522,11 @@ export function useChatSessionState({
      setIsLoadingSessionMessages(false);
    });
  }, [
-    pendingViewSessionRef,
    resetStreamingState,
    selectedProject,
    selectedSession?.id,
    sendMessage,
+    statusCheckSentAtRef,
    ws,
    sessionStore,
  ]);
@@ -534,7 +540,7 @@ export function useChatSessionState({
        const provider = (localStorage.getItem('selected-provider') as Provider) || 'claude';

        // Skip store refresh during active streaming
-        if (!isLoading) {
+        if (!isProcessing) {
          await sessionStore.refreshFromServer(selectedSession.id, {
            provider: (selectedSession.__provider || provider) as LLMProvider,
            projectId: selectedProject.projectId,
@@ -559,7 +565,7 @@ export function useChatSessionState({
    selectedProject,
    selectedSession,
    sessionStore,
-    isLoading,
+    isProcessing,
  ]);

  // Search navigation target
@@ -726,16 +732,6 @@ export function useChatSessionState({
    return () => container.removeEventListener('scroll', handleScroll);
  }, [handleScroll]);

-  useEffect(() => {
-    const activeViewSessionId = selectedSession?.id || currentSessionId;
-    if (!activeViewSessionId || !processingSessions) return;
-    const shouldBeProcessing = processingSessions.has(activeViewSessionId);
-    if (shouldBeProcessing && !isLoading) {
-      setIsLoading(true);
-      setCanAbortSession(true);
-    }
-  }, [currentSessionId, isLoading, processingSessions, selectedSession?.id]);
-
  // "Load all" overlay
  const prevLoadingRef = useRef(false);
  useEffect(() => {
@@ -817,16 +813,15 @@ export function useChatSessionState({
    addMessage,
    clearMessages,
    rewindMessages,
-    isLoading,
-    setIsLoading,
+    sessionActivity,
+    isProcessing,
+    canAbortSession,
    currentSessionId,
    setCurrentSessionId,
    isLoadingSessionMessages,
    isLoadingMoreMessages,
    hasMoreMessages,
    totalMessages,
-    canAbortSession,
-    setCanAbortSession,
    isUserScrolledUp,
    setIsUserScrolledUp,
    tokenBudget,
@@ -839,8 +834,6 @@ export function useChatSessionState({
    isLoadingAllMessages,
    loadAllJustFinished,
    showLoadAllOverlay,
-    claudeStatus,
-    setClaudeStatus,
    createDiff,
    scrollContainerRef,
    scrollToBottom,
--- a/src/components/chat/types/types.ts
+++ b/src/components/chat/types/types.ts
@@ -1,4 +1,9 @@
 import type { Project, ProjectSession, LLMProvider } from '../../../types/app';
+import type {
+  MarkSessionIdle,
+  MarkSessionProcessing,
+  SessionActivityMap,
+} from '../../../hooks/useSessionProtection';

 export type Provider = LLMProvider;

@@ -110,11 +115,9 @@ export interface ChatInterfaceProps {
  latestMessage: any;
  onFileOpen?: (filePath: string, diffInfo?: any) => void;
  onInputFocusChange?: (focused: boolean) => void;
-  onSessionActive?: (sessionId?: string | null) => void;
-  onSessionInactive?: (sessionId?: string | null) => void;
-  onSessionProcessing?: (sessionId?: string | null) => void;
-  onSessionNotProcessing?: (sessionId?: string | null) => void;
-  processingSessions?: Set<string>;
+  onSessionProcessing?: MarkSessionProcessing;
+  onSessionIdle?: MarkSessionIdle;
+  processingSessions?: SessionActivityMap;
  onNavigateToSession?: (targetSessionId: string, options?: SessionNavigationOptions) => void;
  onShowSettings?: () => void;
  autoExpandTools?: boolean;
--- a/src/components/chat/view/ChatInterface.tsx
+++ b/src/components/chat/view/ChatInterface.tsx
@@ -17,10 +17,6 @@ import ChatComposer from './subcomponents/ChatComposer';
 import CommandResultModal from './subcomponents/CommandResultModal';


-type PendingViewSession = {
-  startedAt: number;
-};
-
 function ChatInterface({
  selectedProject,
  selectedSession,
@@ -29,10 +25,8 @@ function ChatInterface({
  latestMessage,
  onFileOpen,
  onInputFocusChange,
-  onSessionActive,
-  onSessionInactive,
  onSessionProcessing,
-  onSessionNotProcessing,
+  onSessionIdle,
  processingSessions,
  onNavigateToSession,
  onShowSettings,
@@ -51,7 +45,9 @@ function ChatInterface({
  const sessionStore = useSessionStore();
  const streamTimerRef = useRef<number | null>(null);
  const accumulatedStreamRef = useRef('');
-  const pendingViewSessionRef = useRef<PendingViewSession | null>(null);
+  // When each session's `check-session-status` was last sent; idle replies
+  // older than a later local request are discarded as stale.
+  const statusCheckSentAtRef = useRef(new Map<string, number>());

  const resetStreamingState = useCallback(() => {
    if (streamTimerRef.current) {
@@ -92,16 +88,15 @@ function ChatInterface({
  const {
    chatMessages,
    addMessage,
-    isLoading,
-    setIsLoading,
+    sessionActivity,
+    isProcessing,
+    canAbortSession,
    currentSessionId,
    setCurrentSessionId,
    isLoadingSessionMessages,
    isLoadingMoreMessages,
    hasMoreMessages,
    totalMessages,
-    canAbortSession,
-    setCanAbortSession,
    isUserScrolledUp,
    setIsUserScrolledUp,
    tokenBudget,
@@ -114,8 +109,6 @@ function ChatInterface({
    isLoadingAllMessages,
    loadAllJustFinished,
    showLoadAllOverlay,
-    claudeStatus,
-    setClaudeStatus,
    createDiff,
    scrollContainerRef,
    scrollToBottom,
@@ -130,8 +123,9 @@ function ChatInterface({
    externalMessageUpdate,
    newSessionTrigger,
    processingSessions,
+    onSessionIdle,
    resetStreamingState,
-    pendingViewSessionRef,
+    statusCheckSentAtRef,
    sessionStore,
  });

@@ -191,40 +185,40 @@ function ChatInterface({
    codexModel,
    geminiModel,
    opencodeModel,
-    isLoading,
+    isLoading: isProcessing,
    canAbortSession,
    tokenBudget,
    sendMessage,
    sendByCtrlEnter,
-    onSessionActive,
    onSessionProcessing,
    onInputFocusChange,
    onFileOpen,
    onShowSettings,
-    pendingViewSessionRef,
    scrollToBottom,
    addMessage,
-    setIsLoading,
-    setCanAbortSession,
-    setClaudeStatus,
    setIsUserScrolledUp,
    setPendingPermissionRequests,
  });

-  // On WebSocket reconnect, re-fetch the current session's messages from the server
-  // so missed streaming events are shown. Also reset isLoading.
+  // On WebSocket reconnect, re-fetch the current session's messages from the
+  // server so missed streaming events are shown, then re-check the session's
+  // processing status — the authoritative reply restores or clears the
+  // activity indicator depending on whether the run is still active.
  const handleWebSocketReconnect = useCallback(async () => {
    if (!selectedProject || !selectedSession) return;
-    const providerVal = (localStorage.getItem('selected-provider') as LLMProvider) || 'claude';
+    const providerVal =
+      selectedSession.__provider
+      || (localStorage.getItem('selected-provider') as LLMProvider)
+      || 'claude';
    await sessionStore.refreshFromServer(selectedSession.id, {
-      provider: (selectedSession.__provider || providerVal) as LLMProvider,
+      provider: providerVal as LLMProvider,
      // Use DB projectId; legacy folder-derived projectName is no longer accepted here.
      projectId: selectedProject.projectId,
      projectPath: selectedProject.fullPath || selectedProject.path || '',
    });
-    setIsLoading(false);
-    setCanAbortSession(false);
-  }, [selectedProject, selectedSession, sessionStore, setIsLoading, setCanAbortSession]);
+    statusCheckSentAtRef.current.set(selectedSession.id, Date.now());
+    sendMessage({ type: 'check-session-status', sessionId: selectedSession.id, provider: providerVal });
+  }, [selectedProject, selectedSession, sendMessage, sessionStore]);

  useChatRealtimeHandlers({
    latestMessage,
@@ -232,25 +226,20 @@ function ChatInterface({
    selectedSession,
    currentSessionId,
    setCurrentSessionId,
-    setIsLoading,
-    setCanAbortSession,
-    setClaudeStatus,
    setTokenBudget,
    setPendingPermissionRequests,
-    pendingViewSessionRef,
    streamTimerRef,
    accumulatedStreamRef,
-    onSessionInactive,
-    onSessionActive,
+    statusCheckSentAtRef,
    onSessionProcessing,
-    onSessionNotProcessing,
+    onSessionIdle,
    onNavigateToSession,
    onWebSocketReconnect: handleWebSocketReconnect,
    sessionStore,
  });

  useEffect(() => {
-    if (!isLoading || !canAbortSession) {
+    if (!canAbortSession) {
      return;
    }

@@ -267,7 +256,7 @@ function ChatInterface({
    return () => {
      document.removeEventListener('keydown', handleGlobalEscape, { capture: true });
    };
-  }, [canAbortSession, handleAbortSession, isLoading]);
+  }, [canAbortSession, handleAbortSession]);

  useEffect(() => {
    return () => {
@@ -362,10 +351,9 @@ function ChatInterface({
          pendingPermissionRequests={pendingPermissionRequests}
          handlePermissionDecision={handlePermissionDecision}
          handleGrantToolPermission={handleGrantToolPermission}
-          claudeStatus={claudeStatus}
-          isLoading={isLoading}
+          activity={sessionActivity}
+          isLoading={isProcessing}
          onAbortSession={handleAbortSession}
-          provider={provider}
          permissionMode={permissionMode}
          onModeSwitch={cyclePermissionMode}
          tokenBudget={tokenBudget}
--- a/src/components/chat/view/subcomponents/ActivityIndicator.tsx
+++ b/src/components/chat/view/subcomponents/ActivityIndicator.tsx
@@ -0,0 +1,80 @@
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { Shimmer } from '../../../../shared/view/ui';
+import type { SessionActivity } from '../../../../hooks/useSessionProtection';
+
+type ActivityIndicatorProps = {
+  activity: SessionActivity | null;
+  onAbort?: () => void;
+};
+
+const ACTION_KEYS = [
+  'claudeStatus.actions.thinking',
+  'claudeStatus.actions.processing',
+  'claudeStatus.actions.analyzing',
+  'claudeStatus.actions.working',
+  'claudeStatus.actions.computing',
+  'claudeStatus.actions.reasoning',
+];
+const DEFAULT_ACTION_WORDS = ['Thinking', 'Processing', 'Analyzing', 'Working', 'Computing', 'Reasoning'];
+
+/**
+ * Minimal response-in-progress indicator, in the spirit of the inline status
+ * lines in Claude Code / Codex / OpenCode: a shimmering activity label, the
+ * elapsed time, and an interrupt affordance. Rendered only while the viewed
+ * session has an entry in the processing map; it disappears the instant that
+ * entry is removed.
+ */
+export default function ActivityIndicator({ activity, onAbort }: ActivityIndicatorProps) {
+  const { t } = useTranslation('chat');
+  const startedAt = activity?.startedAt ?? null;
+  const [elapsedSeconds, setElapsedSeconds] = useState(0);
+
+  useEffect(() => {
+    if (startedAt === null) return;
+    const update = () => setElapsedSeconds(Math.max(0, Math.floor((Date.now() - startedAt) / 1000)));
+    update();
+    const timer = setInterval(update, 1000);
+    return () => clearInterval(timer);
+  }, [startedAt]);
+
+  if (!activity) return null;
+
+  const actionWords = ACTION_KEYS.map((key, i) => t(key, { defaultValue: DEFAULT_ACTION_WORDS[i] }));
+  const label = (activity.statusText || actionWords[Math.floor(elapsedSeconds / 4) % actionWords.length])
+    .replace(/\.+$/, '');
+
+  const minutes = Math.floor(elapsedSeconds / 60);
+  const seconds = elapsedSeconds % 60;
+  const elapsedLabel = minutes < 1
+    ? t('claudeStatus.elapsed.seconds', { count: seconds, defaultValue: '{{count}}s' })
+    : t('claudeStatus.elapsed.minutesSeconds', { minutes, seconds, defaultValue: '{{minutes}}m {{seconds}}s' });
+
+  return (
+    <div className="animate-in fade-in mb-2 w-full duration-300">
+      <div className="mx-auto flex max-w-4xl items-center gap-2 px-1">
+        <span className="h-1.5 w-1.5 shrink-0 animate-pulse rounded-full bg-primary" aria-hidden />
+        <Shimmer className="text-xs font-medium">{`${label}…`}</Shimmer>
+        <span className="text-xs tabular-nums text-muted-foreground/60">{elapsedLabel}</span>
+
+        {activity.canInterrupt && onAbort && (
+          <button
+            type="button"
+            onClick={onAbort}
+            className="ml-auto flex items-center gap-1.5 rounded-md px-2 py-0.5 text-xs text-muted-foreground transition-colors hover:bg-destructive/10 hover:text-destructive"
+            aria-label={t('claudeStatus.stop', { defaultValue: 'Stop' })}
+          >
+            <svg className="h-2.5 w-2.5 fill-current" viewBox="0 0 24 24" aria-hidden>
+              <rect x="5" y="5" width="14" height="14" rx="2" />
+            </svg>
+            <span>{t('claudeStatus.stop', { defaultValue: 'Stop' })}</span>
+            <kbd className="hidden rounded border border-border/60 px-1 text-[10px] text-muted-foreground/70 sm:inline-block">
+              esc
+            </kbd>
+          </button>
+        )}
+      </div>
+    </div>
+  );
+}
--- a/src/components/chat/view/subcomponents/ChatComposer.tsx
+++ b/src/components/chat/view/subcomponents/ChatComposer.tsx
@@ -11,7 +11,8 @@ import type {
 } from 'react';
 import { ImageIcon, MessageSquareIcon, XIcon, ArrowDownIcon } from 'lucide-react';

-import type { PendingPermissionRequest, PermissionMode, Provider } from '../../types/types';
+import type { SessionActivity } from '../../../../hooks/useSessionProtection';
+import type { PendingPermissionRequest, PermissionMode } from '../../types/types';
 import {
  PromptInput,
  PromptInputHeader,
@@ -24,7 +25,7 @@ import {
 } from '../../../../shared/view/ui';

 import CommandMenu from './CommandMenu';
-import ClaudeStatus from './ClaudeStatus';
+import ActivityIndicator from './ActivityIndicator';
 import ImageAttachment from './ImageAttachment';
 import PermissionRequestsBanner from './PermissionRequestsBanner';
 import TokenUsageSummary from './TokenUsageSummary';
@@ -51,10 +52,9 @@ interface ChatComposerProps {
    decision: { allow?: boolean; message?: string; rememberEntry?: string | null; updatedInput?: unknown },
  ) => void;
  handleGrantToolPermission: (suggestion: { entry: string; toolName: string }) => { success: boolean };
-  claudeStatus: { text: string; tokens: number; can_interrupt: boolean } | null;
+  activity: SessionActivity | null;
  isLoading: boolean;
  onAbortSession: () => void;
-  provider: Provider | string;
  permissionMode: PermissionMode | string;
  onModeSwitch: () => void;
  tokenBudget: Record<string, unknown> | null;
@@ -105,10 +105,9 @@ export default function ChatComposer({
  pendingPermissionRequests,
  handlePermissionDecision,
  handleGrantToolPermission,
-  claudeStatus,
+  activity,
  isLoading,
  onAbortSession,
-  provider,
  permissionMode,
  onModeSwitch,
  tokenBudget,
@@ -173,12 +172,7 @@ export default function ChatComposer({
  return (
    <div className="flex-shrink-0 p-2 pb-2 sm:p-4 sm:pb-4 md:p-4 md:pb-6">
      {!hasPendingPermissions && (
-        <ClaudeStatus
-          status={claudeStatus}
-          isLoading={isLoading}
-          onAbort={onAbortSession}
-          provider={provider}
-        />
+        <ActivityIndicator activity={activity} onAbort={onAbortSession} />
      )}

      {pendingPermissionRequests.length > 0 && (
--- a/src/components/chat/view/subcomponents/ClaudeStatus.tsx
+++ b/src/components/chat/view/subcomponents/ClaudeStatus.tsx
@@ -1,130 +0,0 @@
-import { useEffect, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { cn } from '../../../../lib/utils';
-import SessionProviderLogo from '../../../llm-logo-provider/SessionProviderLogo';
-
-type ClaudeStatusProps = {
-  status: {
-    text?: string;
-    tokens?: number;
-    can_interrupt?: boolean;
-  } | null;
-  onAbort?: () => void;
-  isLoading: boolean;
-  provider?: string;
-};
-
-const ACTION_KEYS = [
-  'claudeStatus.actions.thinking',
-  'claudeStatus.actions.processing',
-  'claudeStatus.actions.analyzing',
-  'claudeStatus.actions.working',
-  'claudeStatus.actions.computing',
-  'claudeStatus.actions.reasoning',
-];
-const DEFAULT_ACTION_WORDS = ['Thinking', 'Processing', 'Analyzing', 'Working', 'Computing', 'Reasoning'];
-
-const PROVIDER_LABEL_KEYS: Record<string, string> = {
-  claude: 'messageTypes.claude',
-  codex: 'messageTypes.codex',
-  cursor: 'messageTypes.cursor',
-  gemini: 'messageTypes.gemini',
-  opencode: 'messageTypes.opencode',
-};
-
-function formatElapsedTime(totalSeconds: number) {
-  const mins = Math.floor(totalSeconds / 60);
-  const secs = totalSeconds % 60;
-  return mins < 1 ? `${secs}s` : `${mins}m ${secs}s`;
-}
-
-export default function ClaudeStatus({
-  status,
-  onAbort,
-  isLoading,
-  provider = 'claude',
-}: ClaudeStatusProps) {
-  const { t } = useTranslation('chat');
-  const [elapsedTime, setElapsedTime] = useState(0);
-  const [dots, setDots] = useState('');
-
-  useEffect(() => {
-    if (!isLoading) {
-      setElapsedTime(0);
-      return;
-    }
-    const startTime = Date.now();
-    const timer = setInterval(() => {
-      setElapsedTime(Math.floor((Date.now() - startTime) / 1000));
-    }, 1000);
-    const dotTimer = setInterval(() => {
-      setDots((prev) => (prev.length >= 3 ? '' : prev + '.'));
-    }, 500);
-
-    return () => {
-      clearInterval(timer);
-      clearInterval(dotTimer);
-    };
-  }, [isLoading]);
-
-  if (!isLoading && !status) return null;
-
-  const actionWords = ACTION_KEYS.map((key, i) => t(key, { defaultValue: DEFAULT_ACTION_WORDS[i] }));
-  const statusText = (status?.text || actionWords[Math.floor(elapsedTime / 3) % actionWords.length]).replace(/[.]+$/, '');
-
-  const providerLabel = t(PROVIDER_LABEL_KEYS[provider] || 'claudeStatus.providers.assistant', { defaultValue: 'Assistant' });
-
-  return (
-    <div className="animate-in fade-in slide-in-from-bottom-2 mb-3 w-full duration-500">
-      <div className="mx-auto flex max-w-4xl items-center justify-between gap-3 overflow-hidden rounded-full border border-border/50 bg-slate-100 px-3 py-1.5 shadow-sm backdrop-blur-md dark:bg-slate-900">
-
-        {/* Left Side: Identity & Status */}
-        <div className="flex min-w-0 items-center gap-2.5">
-          <div className="relative flex h-6 w-6 shrink-0 items-center justify-center rounded-full bg-primary/20 ring-1 ring-primary/10">
-            <SessionProviderLogo provider={provider} className="h-3.5 w-3.5" />
-            {isLoading && (
-              <span className="absolute inset-0 animate-pulse rounded-full ring-2 ring-emerald-500/20" />
-            )}
-          </div>
-
-          <div className="flex min-w-0 flex-col sm:flex-row sm:items-center sm:gap-2">
-            <span className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground/70">
-              {providerLabel}
-            </span>
-            <div className="flex items-center gap-1.5">
-              <span className={cn("h-1.5 w-1.5 rounded-full", isLoading ? "bg-emerald-500 animate-pulse" : "bg-amber-500")} />
-              <p className="truncate text-xs font-medium text-foreground">
-                {statusText}<span className="inline-block w-4 text-primary">{isLoading ? dots : ''}</span>
-              </p>
-            </div>
-          </div>
-        </div>
-
-        {/* Right Side: Metrics & Actions */}
-        <div className="flex items-center gap-2">
-          {isLoading && status?.can_interrupt !== false && onAbort && (
-            <>
-              <div className="hidden items-center rounded-md bg-muted/50 px-2 py-0.5 text-[10px] font-medium tabular-nums text-muted-foreground sm:flex">
-                {formatElapsedTime(elapsedTime)}
-              </div>
-
-              <button
-                type="button"
-                onClick={onAbort}
-                className="group flex items-center gap-1.5 rounded-full bg-destructive/10 px-2.5 py-1 text-[10px] font-bold text-destructive transition-all hover:bg-destructive hover:text-destructive-foreground"
-              >
-                <svg className="h-3 w-3 fill-current" viewBox="0 0 24 24">
-                  <path d="M6 6h12v12H6z" />
-                </svg>
-                <span className="hidden sm:inline">STOP</span>
-                <kbd className="hidden rounded bg-black/10 px-1 text-[9px] group-hover:bg-white/20 sm:block">
-                  ESC
-                </kbd>
-              </button>
-            </>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}
--- a/src/components/main-content/types/types.ts
+++ b/src/components/main-content/types/types.ts
@@ -1,10 +1,13 @@
 import type { Dispatch, SetStateAction } from 'react';

 import type { AppTab, Project, ProjectSession } from '../../../types/app';
+import type {
+  MarkSessionIdle,
+  MarkSessionProcessing,
+  SessionActivityMap,
+} from '../../../hooks/useSessionProtection';
 import type { SessionNavigationOptions } from '../../chat/types/types';

-export type SessionLifecycleHandler = (sessionId?: string | null) => void;
-
 export type TaskMasterTask = {
  id: string | number;
  title?: string;
@@ -46,11 +49,9 @@ export type MainContentProps = {
  onMenuClick: () => void;
  isLoading: boolean;
  onInputFocusChange: (focused: boolean) => void;
-  onSessionActive: SessionLifecycleHandler;
-  onSessionInactive: SessionLifecycleHandler;
-  onSessionProcessing: SessionLifecycleHandler;
-  onSessionNotProcessing: SessionLifecycleHandler;
-  processingSessions: Set<string>;
+  onSessionProcessing: MarkSessionProcessing;
+  onSessionIdle: MarkSessionIdle;
+  processingSessions: SessionActivityMap;
  onNavigateToSession: (targetSessionId: string, options?: SessionNavigationOptions) => void;
  onShowSettings: () => void;
  externalMessageUpdate: number;
--- a/src/components/main-content/view/MainContent.tsx
+++ b/src/components/main-content/view/MainContent.tsx
@@ -42,10 +42,8 @@ function MainContent({
  onMenuClick,
  isLoading,
  onInputFocusChange,
-  onSessionActive,
-  onSessionInactive,
  onSessionProcessing,
-  onSessionNotProcessing,
+  onSessionIdle,
  processingSessions,
  onNavigateToSession,
  onShowSettings,
@@ -131,10 +129,8 @@ function MainContent({
                latestMessage={latestMessage}
                onFileOpen={handleFileOpen}
                onInputFocusChange={onInputFocusChange}
-                onSessionActive={onSessionActive}
-                onSessionInactive={onSessionInactive}
                onSessionProcessing={onSessionProcessing}
-                onSessionNotProcessing={onSessionNotProcessing}
+                onSessionIdle={onSessionIdle}
                processingSessions={processingSessions}
                onNavigateToSession={onNavigateToSession}
                onShowSettings={onShowSettings}
--- a/src/components/plugins/view/PluginSettingsTab.tsx
+++ b/src/components/plugins/view/PluginSettingsTab.tsx
@@ -4,14 +4,11 @@ import {
  Activity,
  BarChart3,
  BookOpen,
-  Calculator,
  Clock,
  Download,
  ExternalLink,
-  Github,
  GitBranch,
  Loader2,
-  ListTodo,
  RefreshCw,
  ServerCrash,
  ShieldAlert,
@@ -30,10 +27,6 @@ const TERMINAL_PLUGIN_URL = 'https://github.com/cloudcli-ai/cloudcli-plugin-term
 const SCHEDULED_PROMPT_PLUGIN_URL = 'https://github.com/grostim/cloudcli-cron';
 const CLAUDE_WATCH_PLUGIN_URL = 'https://github.com/satsuki19980613/cloudcli-claude-watch';
 const PRISM_CLOUDCLI_PLUGIN_URL = 'https://github.com/jakeefr/cloudcli-plugin-prism';
-const SESSION_MANAGER_PLUGIN_URL = 'https://github.com/strykereye2/cloudcli-plugin-session-manager';
-const TOKEN_COST_CALCULATOR_PLUGIN_URL = 'https://github.com/NightmareAway/cloudcli-plugin-token-cost-calculator';
-const TASK_QUEUE_PLUGIN_URL = 'https://github.com/TadMSTR/cloudcli-plugin-task-queue';
-const GITHUB_ISSUES_BOARD_PLUGIN_URL = 'https://github.com/szmidtpiotr/claude-github-issue';

 type PluginRecommendation = {
  id: string;
@@ -86,40 +79,8 @@ const UNOFFICIAL_PLUGIN_RECOMMENDATIONS: PluginRecommendation[] = [
    repoUrl: PRISM_CLOUDCLI_PLUGIN_URL,
    installedNames: ['prism'],
    icon: Activity,
-    source: 'unofficial',
-  },
-  {
-    id: 'session-manager',
-    translationKey: 'sessionManagerPlugin',
-    repoUrl: SESSION_MANAGER_PLUGIN_URL,
-    installedNames: ['session-manager'],
-    icon: Activity,
-    source: 'unofficial',
-  },
-  {
-    id: 'token-cost-calculator',
-    translationKey: 'tokenCostCalculatorPlugin',
-    repoUrl: TOKEN_COST_CALCULATOR_PLUGIN_URL,
-    installedNames: ['token-cost-calculator'],
-    icon: Calculator,
-    source: 'unofficial',
-  },
-  {
-    id: 'task-queue',
-    translationKey: 'taskQueuePlugin',
-    repoUrl: TASK_QUEUE_PLUGIN_URL,
-    installedNames: ['task-queue'],
-    icon: ListTodo,
-    source: 'unofficial',
-  },
-  {
-    id: 'claude-github-issue',
-    translationKey: 'githubIssuesBoardPlugin',
-    repoUrl: GITHUB_ISSUES_BOARD_PLUGIN_URL,
-    installedNames: ['claude-github-issue'],
-    icon: Github,
-    source: 'unofficial',
-  },
+    source: 'unofficial'
+  }
 ];

 function repoSlug(repoUrl: string) {
--- a/src/hooks/useProjectsState.ts
+++ b/src/hooks/useProjectsState.ts
@@ -12,12 +12,14 @@ import type {
  ProjectsUpdatedMessage,
 } from '../types/app';

+import type { SessionActivityMap } from './useSessionProtection';
+
 type UseProjectsStateArgs = {
  sessionId?: string;
  navigate: NavigateFunction;
  latestMessage: AppSocketMessage | null;
  isMobile: boolean;
-  activeSessions: Set<string>;
+  activeSessions: SessionActivityMap;
 };

 type FetchProjectsOptions = {
--- a/src/hooks/useSessionProtection.ts
+++ b/src/hooks/useSessionProtection.ts
@@ -1,55 +1,103 @@
 import { useCallback, useState } from 'react';

+/**
+ * Map key for a request that is in flight before the provider has announced
+ * its real session id (a brand-new conversation). `session_created` migrates
+ * the entry to the concrete session id.
+ */
+export const PENDING_SESSION_ID = '__pending_session__';
+
+export interface SessionActivity {
+  /** Provider-supplied status line; null renders the default activity label. */
+  statusText: string | null;
+  canInterrupt: boolean;
+  /**
+   * When this request was first marked as processing (client clock). Drives
+   * the elapsed-time display and the stale `session-status` reply guard.
+   */
+  startedAt: number;
+}
+
+export type SessionActivityMap = ReadonlyMap<string, SessionActivity>;
+
+export type MarkSessionProcessing = (
+  sessionId?: string | null,
+  activity?: { statusText?: string | null; canInterrupt?: boolean },
+) => void;
+
+export type MarkSessionIdle = (
+  sessionId?: string | null,
+  opts?: { ifStartedBefore?: number },
+) => void;
+
+/**
+ * Single source of truth for which sessions are actively processing a
+ * request. Everything the chat UI shows (activity indicator, abort
+ * availability, status text) is derived from this map; terminal events
+ * (`complete`, `error`, abort, an authoritative idle status reply) delete the
+ * entry atomically. The map also drives session protection: project refreshes
+ * are suppressed for sessions that have an entry here.
+ */
 export function useSessionProtection() {
-  const [activeSessions, setActiveSessions] = useState<Set<string>>(new Set());
-  const [processingSessions, setProcessingSessions] = useState<Set<string>>(new Set());
+  const [processingSessions, setProcessingSessions] = useState<Map<string, SessionActivity>>(
+    new Map(),
+  );

-  const markSessionAsActive = useCallback((sessionId?: string | null) => {
-    if (!sessionId) {
-      return;
-    }
-
-    setActiveSessions((prev) => new Set([...prev, sessionId]));
-  }, []);
-
-  const markSessionAsInactive = useCallback((sessionId?: string | null) => {
-    if (!sessionId) {
-      return;
-    }
-
-    setActiveSessions((prev) => {
-      const next = new Set(prev);
-      next.delete(sessionId);
-      return next;
-    });
-  }, []);
-
-  const markSessionAsProcessing = useCallback((sessionId?: string | null) => {
-    if (!sessionId) {
-      return;
-    }
-
-    setProcessingSessions((prev) => new Set([...prev, sessionId]));
-  }, []);
-
-  const markSessionAsNotProcessing = useCallback((sessionId?: string | null) => {
+  const markSessionProcessing = useCallback<MarkSessionProcessing>((sessionId, activity) => {
    if (!sessionId) {
      return;
    }

    setProcessingSessions((prev) => {
-      const next = new Set(prev);
-      next.delete(sessionId);
-      return next;
+      const existing = prev.get(sessionId);
+      const next: SessionActivity = {
+        statusText:
+          activity?.statusText !== undefined ? activity.statusText : existing?.statusText ?? null,
+        canInterrupt: activity?.canInterrupt ?? existing?.canInterrupt ?? true,
+        startedAt: existing?.startedAt ?? Date.now(),
+      };
+
+      if (
+        existing
+        && existing.statusText === next.statusText
+        && existing.canInterrupt === next.canInterrupt
+      ) {
+        return prev;
+      }
+
+      const updated = new Map(prev);
+      updated.set(sessionId, next);
+      return updated;
+    });
+  }, []);
+
+  const markSessionIdle = useCallback<MarkSessionIdle>((sessionId, opts) => {
+    if (!sessionId) {
+      return;
+    }
+
+    setProcessingSessions((prev) => {
+      const existing = prev.get(sessionId);
+      if (!existing) {
+        return prev;
+      }
+
+      // Guard against stale `check-session-status` replies: if a new request
+      // started after the check was sent, the idle reply describes the older
+      // request and must not clear the newer one.
+      if (opts?.ifStartedBefore !== undefined && existing.startedAt >= opts.ifStartedBefore) {
+        return prev;
+      }
+
+      const updated = new Map(prev);
+      updated.delete(sessionId);
+      return updated;
    });
  }, []);

  return {
-    activeSessions,
    processingSessions,
-    markSessionAsActive,
-    markSessionAsInactive,
-    markSessionAsProcessing,
-    markSessionAsNotProcessing,
+    markSessionProcessing,
+    markSessionIdle,
  };
 }
--- a/src/i18n/locales/en/chat.json
+++ b/src/i18n/locales/en/chat.json
@@ -224,6 +224,7 @@
      "label": "{{time}} elapsed",
      "startingNow": "Starting now"
    },
+    "stop": "Stop",
    "controls": {
      "stopGeneration": "Stop Generation",
      "pressEscToStop": "Press Esc anytime to stop"
--- a/src/i18n/locales/en/settings.json
+++ b/src/i18n/locales/en/settings.json
@@ -514,30 +514,6 @@
      "description": "Session intelligence for Claude Code, inside CloudCLI. See why your sessions are burning tokens without leaving the browser.",
      "install": "Install"
    },
-    "sessionManagerPlugin": {
-      "name": "Sessions",
-      "badge": "unofficial",
-      "description": "View, manage, and kill active Claude Code sessions.",
-      "install": "Install"
-    },
-    "tokenCostCalculatorPlugin": {
-      "name": "Token Cost Calculator",
-      "badge": "unofficial",
-      "description": "Calculate API costs from model prices and token usage, with preset model pricing support.",
-      "install": "Install"
-    },
-    "taskQueuePlugin": {
-      "name": "Task Queue",
-      "badge": "unofficial",
-      "description": "Task queue dashboard to view, filter, and launch agent tasks.",
-      "install": "Install"
-    },
-    "githubIssuesBoardPlugin": {
-      "name": "GitHub Issues Board",
-      "badge": "unofficial",
-      "description": "Kanban board for GitHub Issues with bidirectional TaskMaster sync and /github-task CLI skill auto-install",
-      "install": "Install"
-    },
    "morePlugins": "More",
    "enable": "Enable",
    "disable": "Disable",