diff --git a/apps/web/src/App.tsx b/apps/web/src/App.tsx
index a982c1fc6e85868b132d93e392cc640433b485d9..41c7ff36fc482abec692acf944ed13e9ee998623 100644
--- a/apps/web/src/App.tsx
+++ b/apps/web/src/App.tsx
@@ -27,6 +27,16 @@ function EventRouter() {
     });
   }, [api, dispatch]);
 
+  useEffect(() => {
+    if (!api) return;
+    return api.terminal.onEvent((event) => {
+      dispatch({
+        type: "APPLY_TERMINAL_EVENT",
+        event,
+      });
+    });
+  }, [api, dispatch]);
+
   return null;
 }
 
@@ -82,6 +92,7 @@ function AutoProjectBootstrap() {
           terminalOpen: false,
           terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
           terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+          runningTerminalIds: [],
           activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
           terminalGroups: [
             {
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 32a832a491a6160dcb9b219cc52c49af6be1de61..858e438b503086b1afa14af6f663178dc714cf60 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -32,7 +32,7 @@ function inferProjectName(cwd: string): string {
 }
 
 interface ThreadStatusPill {
-  label: "Working" | "Connecting" | "Completed" | "Awaiting response";
+  label: "Working" | "Connecting" | "Completed" | "Awaiting response" | "Terminal";
   colorClass: string;
   dotClass: string;
   pulse: boolean;
@@ -89,6 +89,18 @@ function threadStatusPill(thread: Thread, hasPendingApprovals: boolean): ThreadS
   return null;
 }
 
+function terminalStatusPill(thread: Thread): ThreadStatusPill | null {
+  if (thread.runningTerminalIds.length === 0) {
+    return null;
+  }
+  return {
+    label: "Terminal",
+    colorClass: "text-teal-600 dark:text-teal-300/90",
+    dotClass: "bg-teal-500 dark:bg-teal-300/90",
+    pulse: true,
+  };
+}
+
 export default function Sidebar() {
   const { state, dispatch } = useStore();
   const api = useNativeApi();
@@ -118,6 +130,7 @@ export default function Sidebar() {
           terminalOpen: false,
           terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
           terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+          runningTerminalIds: [],
           activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
           terminalGroups: [
             {
@@ -388,6 +401,7 @@ export default function Sidebar() {
                       thread,
                       pendingApprovalByThreadId.get(thread.id) === true,
                     );
+                    const terminalStatus = terminalStatusPill(thread);
                     return (
                       <button
                         key={thread.id}
@@ -412,6 +426,18 @@ export default function Sidebar() {
                         }}
                       >
                         <div className="flex min-w-0 flex-1 items-center gap-1.5">
+                          {terminalStatus && (
+                            <span
+                              className={`inline-flex items-center gap-1 text-[10px] ${terminalStatus.colorClass}`}
+                            >
+                              <span
+                                className={`h-1.5 w-1.5 rounded-full ${terminalStatus.dotClass} ${
+                                  terminalStatus.pulse ? "animate-pulse" : ""
+                                }`}
+                              />
+                              <span className="hidden md:inline">{terminalStatus.label}</span>
+                            </span>
+                          )}
                           {threadStatus && (
                             <span
                               className={`inline-flex items-center gap-1 text-[10px] ${threadStatus.colorClass}`}
diff --git a/apps/web/src/persistenceSchema.test.ts b/apps/web/src/persistenceSchema.test.ts
index b05fbf352ae88aa351131352d8ae423a3325dafe..277d86ab26091cd91aa722d7b154ca549c45e871 100644
--- a/apps/web/src/persistenceSchema.test.ts
+++ b/apps/web/src/persistenceSchema.test.ts
@@ -278,6 +278,7 @@ describe("toPersistedState", () => {
       terminalOpen: true,
       terminalHeight: 320,
       terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+      runningTerminalIds: [],
       activeTerminalId: "term-2",
       terminalGroups: [
         { id: `group-${DEFAULT_THREAD_TERMINAL_ID}`, terminalIds: [DEFAULT_THREAD_TERMINAL_ID] },
diff --git a/apps/web/src/persistenceSchema.ts b/apps/web/src/persistenceSchema.ts
index 5738107c3ca77a0723f6d9fdf07118d25824427f..aaf10de75c5642b15e40b20572cbe351910f05cb 100644
--- a/apps/web/src/persistenceSchema.ts
+++ b/apps/web/src/persistenceSchema.ts
@@ -243,6 +243,7 @@ function hydrateThread(
     terminalOpen: thread.terminalOpen ?? false,
     terminalHeight: thread.terminalHeight ?? DEFAULT_THREAD_TERMINAL_HEIGHT,
     terminalIds: safeTerminalIds,
+    runningTerminalIds: [],
     activeTerminalId,
     terminalGroups: normalizedGroups,
     activeTerminalGroupId,
diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.ts
index 4a5dd0e099e008b6b36802f9acf7a971cb41c177..3e157b1b25bb4b3c249d043ac1ff78e2a779c8f2 100644
--- a/apps/web/src/store.test.ts
+++ b/apps/web/src/store.test.ts
@@ -1,4 +1,4 @@
-import type { ProviderEvent, ProviderSession } from "@t3tools/contracts";
+import type { ProviderEvent, ProviderSession, TerminalEvent } from "@t3tools/contracts";
 import { describe, expect, it } from "vitest";
 
 import { type AppState, reducer } from "./store";
@@ -38,6 +38,7 @@ function makeThread(overrides: Partial<Thread> = {}): Thread {
     terminalOpen: false,
     terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
     terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+    runningTerminalIds: [],
     activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
     terminalGroups: [
       {
@@ -75,6 +76,27 @@ function makeState(thread: Thread): AppState {
   };
 }
 
+function makeTerminalStartedEvent(overrides: Partial<TerminalEvent> = {}): TerminalEvent {
+  return {
+    type: "started",
+    threadId: "thread-local-1",
+    terminalId: DEFAULT_THREAD_TERMINAL_ID,
+    createdAt: "2026-02-09T00:00:01.000Z",
+    snapshot: {
+      threadId: "thread-local-1",
+      terminalId: DEFAULT_THREAD_TERMINAL_ID,
+      cwd: "/tmp/project",
+      status: "running",
+      pid: 1234,
+      history: "",
+      exitCode: null,
+      exitSignal: null,
+      updatedAt: "2026-02-09T00:00:01.000Z",
+    },
+    ...overrides,
+  };
+}
+
 describe("store reducer thread continuity", () => {
   it("stores codexThreadId from UPDATE_SESSION", () => {
     const state = makeState(
@@ -255,6 +277,7 @@ describe("store reducer thread continuity", () => {
     const state = makeState(
       makeThread({
         terminalOpen: true,
+        runningTerminalIds: [DEFAULT_THREAD_TERMINAL_ID],
       }),
     );
     const next = reducer(state, {
@@ -265,6 +288,7 @@ describe("store reducer thread continuity", () => {
 
     expect(next.threads[0]?.terminalOpen).toBe(false);
     expect(next.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
+    expect(next.threads[0]?.runningTerminalIds).toEqual([]);
     expect(next.threads[0]?.activeTerminalId).toBe(DEFAULT_THREAD_TERMINAL_ID);
     expect(next.threads[0]?.terminalGroups).toEqual([
       {
@@ -274,6 +298,59 @@ describe("store reducer thread continuity", () => {
     ]);
   });
 
+  it("tracks running terminals from terminal lifecycle events", () => {
+    const state = makeState(makeThread());
+    const started = reducer(state, {
+      type: "APPLY_TERMINAL_EVENT",
+      event: makeTerminalStartedEvent(),
+    });
+    expect(started.threads[0]?.runningTerminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
+
+    const exited = reducer(started, {
+      type: "APPLY_TERMINAL_EVENT",
+      event: {
+        type: "exited",
+        threadId: "thread-local-1",
+        terminalId: DEFAULT_THREAD_TERMINAL_ID,
+        createdAt: "2026-02-09T00:00:05.000Z",
+        exitCode: 0,
+        exitSignal: null,
+      },
+    });
+    expect(exited.threads[0]?.runningTerminalIds).toEqual([]);
+  });
+
+  it("keeps running status when another terminal in the thread is still running", () => {
+    const state = makeState(
+      makeThread({
+        terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+        runningTerminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+        activeTerminalId: "term-2",
+        terminalGroups: [
+          {
+            id: `group-${DEFAULT_THREAD_TERMINAL_ID}`,
+            terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+          },
+        ],
+        activeTerminalGroupId: `group-${DEFAULT_THREAD_TERMINAL_ID}`,
+      }),
+    );
+
+    const next = reducer(state, {
+      type: "APPLY_TERMINAL_EVENT",
+      event: {
+        type: "exited",
+        threadId: "thread-local-1",
+        terminalId: DEFAULT_THREAD_TERMINAL_ID,
+        createdAt: "2026-02-09T00:00:07.000Z",
+        exitCode: 0,
+        exitSignal: null,
+      },
+    });
+
+    expect(next.threads[0]?.runningTerminalIds).toEqual(["term-2"]);
+  });
+
   it("backfills codexThreadId from routed provider events", () => {
     const state = makeState(makeThread({ codexThreadId: null }));
     const next = reducer(state, {
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index 3527d46b0fc1a848793e9c14f383554ff40c6ac8..e7937f4d3b4ee2bd3d6d891a27d0b59f0e012cd5 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -8,7 +8,7 @@ import {
   useReducer,
 } from "react";
 
-import type { ProviderEvent, ProviderSession } from "@t3tools/contracts";
+import type { ProviderEvent, ProviderSession, TerminalEvent } from "@t3tools/contracts";
 import { resolveModelSlug } from "./model-logic";
 import { hydratePersistedState, toPersistedState } from "./persistenceSchema";
 import { applyEventToMessages, asObject, asString, evolveSession } from "./session-logic";
@@ -43,6 +43,7 @@ type Action =
       event: ProviderEvent;
       activeAssistantItemRef: { current: string | null };
     }
+  | { type: "APPLY_TERMINAL_EVENT"; event: TerminalEvent }
   | { type: "UPDATE_SESSION"; threadId: string; session: ProviderSession }
   | {
       type: "PUSH_USER_MESSAGE";
@@ -149,6 +150,17 @@ function normalizeTerminalIds(terminalIds: string[]): string[] {
   return [DEFAULT_THREAD_TERMINAL_ID];
 }
 
+function normalizeRunningTerminalIds(
+  runningTerminalIds: string[],
+  terminalIds: string[],
+): string[] {
+  if (runningTerminalIds.length === 0) return [];
+  const validTerminalIdSet = new Set(terminalIds);
+  return [...new Set(runningTerminalIds)]
+    .map((id) => id.trim())
+    .filter((id) => id.length > 0 && validTerminalIdSet.has(id));
+}
+
 function normalizeTerminalGroupIds(terminalIds: string[]): string[] {
   return [...new Set(terminalIds.map((id) => id.trim()).filter((id) => id.length > 0))];
 }
@@ -252,6 +264,7 @@ function normalizeThreadTerminals(thread: Thread): Thread {
   return {
     ...thread,
     terminalIds,
+    runningTerminalIds: normalizeRunningTerminalIds(thread.runningTerminalIds, terminalIds),
     activeTerminalId,
     terminalGroups,
     activeTerminalGroupId,
@@ -269,6 +282,7 @@ function closeThreadTerminal(thread: Thread, terminalId: string): Thread {
       ...thread,
       terminalOpen: false,
       terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+      runningTerminalIds: [],
       activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
       terminalGroups: [
         {
@@ -309,6 +323,7 @@ function closeThreadTerminal(thread: Thread, terminalId: string): Thread {
   return normalizeThreadTerminals({
     ...thread,
     terminalIds: remainingTerminalIds,
+    runningTerminalIds: thread.runningTerminalIds.filter((id) => id !== terminalId),
     activeTerminalId: nextActiveTerminalId,
     terminalGroups: nextTerminalGroups,
   });
@@ -650,6 +665,35 @@ export function reducer(state: AppState, action: Action): AppState {
     case "TOGGLE_DIFF":
       return { ...state, diffOpen: !state.diffOpen };
 
+    case "APPLY_TERMINAL_EVENT":
+      if (!state.threads.some((thread) => thread.id === action.event.threadId)) {
+        return state;
+      }
+      return {
+        ...state,
+        threads: updateThread(state.threads, action.event.threadId, (thread) => {
+          const normalizedThread = normalizeThreadTerminals(thread);
+          const runningTerminalIdSet = new Set(normalizedThread.runningTerminalIds);
+          if (
+            action.event.type === "started" ||
+            action.event.type === "restarted"
+          ) {
+            if (action.event.snapshot.status === "running") {
+              runningTerminalIdSet.add(action.event.terminalId);
+            } else {
+              runningTerminalIdSet.delete(action.event.terminalId);
+            }
+          } else if (action.event.type === "exited" || action.event.type === "error") {
+            runningTerminalIdSet.delete(action.event.terminalId);
+          }
+
+          return normalizeThreadTerminals({
+            ...normalizedThread,
+            runningTerminalIds: [...runningTerminalIdSet],
+          });
+        }),
+      };
+
     case "APPLY_EVENT": {
       const { event, activeAssistantItemRef } = action;
       const target = findThreadBySessionId(state.threads, event.sessionId);
diff --git a/apps/web/src/types.ts b/apps/web/src/types.ts
index 56343f128e9b1eb2e262eb5ea592973c9a53cc50..d662997231ec3da0be7e9f0fce787d2a04682d2b 100644
--- a/apps/web/src/types.ts
+++ b/apps/web/src/types.ts
@@ -48,6 +48,7 @@ export interface Thread {
   terminalOpen: boolean;
   terminalHeight: number;
   terminalIds: string[];
+  runningTerminalIds: string[];
   activeTerminalId: string;
   terminalGroups: ThreadTerminalGroup[];
   activeTerminalGroupId: string;