fix(web): hide ineffective mark unread actions during active runs

apps/web/src/components/Sidebar.logic.test.ts

@@ -6,6 +6,8 @@ import { describe, expect, it } from "vite-plus/test";
 import * as Cause from "effect/Cause";
 import { AsyncResult } from "effect/reactivity";
 import {
+  buildBulkMarkUnreadContextMenuItem,
+  canMarkThreadUnread,
   shouldCreateNewThreadInCurrentProject,
   deleteSelectedThreadEntries,
   getFallbackThreadIdAfterDelete,
@@ -135,6 +137,34 @@ describe("deleteSelectedThreadEntries", () => {
   });
 });
 
+describe("bulk mark unread", () => {
+  const runtimeWith = (status: "idle" | "running" | "waiting" | "completed") => ({
+    status,
+    activeRunId: null,
+    providerInstanceId: ProviderInstanceId.make("codex"),
+    providerName: "Codex",
+    lastError: null,
+  });
+  const menuItemFor = (threads: readonly Parameters<typeof canMarkThreadUnread>[0][]) =>
+    buildBulkMarkUnreadContextMenuItem({
+      eligibleCount: threads.filter(canMarkThreadUnread).length,
+    });
+
+  it("counts only threads without an active run", () => {
+    expect(
+      menuItemFor([
+        { runtime: runtimeWith("running") },
+        { runtime: runtimeWith("idle") },
+        { runtime: runtimeWith("completed") },
+        { runtime: null },
+      ]),
+    ).toEqual({ id: "mark-unread", label: "Mark unread (3)" });
+    expect(
+      menuItemFor([{ runtime: runtimeWith("running") }, { runtime: runtimeWith("waiting") }]),
+    ).toBe(null);
+  });
+});
+
 describe("sidebar thread lineage helpers", () => {
   it("maps an open subagent to its nearest visible ancestor's sidebar row", () => {
     const environmentId = EnvironmentId.make("environment-row");

apps/web/src/components/Sidebar.logic.ts

@@ -1,6 +1,10 @@
 import type { EnvironmentServerConfig } from "@t3tools/client-runtime/connection";
 import { scopeThreadRef, scopedThreadKey } from "@t3tools/client-runtime/environment";
-import { resolveThreadWorkingStartedAt } from "@t3tools/client-runtime/state/models";
+import {
+  resolveThreadWorkingStartedAt,
+  threadRuntimeIsActive,
+  type ThreadStructureRuntime,
+} from "@t3tools/client-runtime/state/models";
 import { isShownUnderParent } from "@t3tools/client-runtime/state/threads";
 import { backgroundWorkHoldsCompletion } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import { threadPullRequestSearchTerms } from "@t3tools/shared/threadPullRequests";
@@ -567,6 +571,20 @@ export function isSidebarHiddenThread(thread: Pick<SidebarThreadSummary, "lineag
   return !isListedThreadLineage(thread.lineage);
 }
 
+// Unread only surfaces as a completion pill, which an active run hides.
+export function canMarkThreadUnread(thread: {
+  readonly runtime: ThreadStructureRuntime | null | undefined;
+}): boolean {
+  return !threadRuntimeIsActive(thread.runtime);
+}
+
+export function buildBulkMarkUnreadContextMenuItem(input: {
+  eligibleCount: number;
+}): ContextMenuItem<"mark-unread"> | null {
+  if (input.eligibleCount === 0) return null;
+  return { id: "mark-unread", label: `Mark unread (${input.eligibleCount})` };
+}
+
 // Subagent and side-chat threads have no sidebar row, so an open one is represented by
 // its nearest listed ancestor. A broken chain (missing parent, cycle,
 // other environment) resolves to the thread itself, which then matches no row.

apps/web/src/components/Sidebar.tsx

@@ -44,6 +44,7 @@ import { foldSearchQuery, rankMessageMatches } from "@t3tools/shared/paletteSear
 import { findForMessageMatch, openThreadFindOnQuery } from "./chat/threadFindStore";
 import {
   threadRuntimeCanArchive,
+  threadRuntimeIsActive,
   type EnvironmentThreadShell,
 } from "@t3tools/client-runtime/state/models";
 import {
@@ -184,7 +185,9 @@ import {
   groupSidebarThreadsByProject,
   sidebarFolderExpansionKeys,
   buildBulkTitleRegenerationContextMenuItem,
+  buildBulkMarkUnreadContextMenuItem,
   buildBulkUnpinContextMenuItem,
+  canMarkThreadUnread,
   deleteSelectedThreadEntries,
   filterSidebarProjectScopeItems,
   firstValidTimestampMs,
@@ -2312,6 +2315,10 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
       const unpinMenuItem = buildBulkUnpinContextMenuItem({
         pinnedCount: pinnedSelectedThreads.length,
       });
+      const markUnreadThreads = selectedThreads.filter(canMarkThreadUnread);
+      const markUnreadMenuItem = buildBulkMarkUnreadContextMenuItem({
+        eligibleCount: markUnreadThreads.length,
+      });
       // Presets sync across environments, so the first selected thread's stand for all.
       const menuOpenedAt = new Date();
       const snoozePresets = resolveSnoozePresets(
@@ -2362,7 +2369,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
                   },
                 ]
               : []),
-            { id: "mark-unread", label: `Mark unread (${count})` },
+            ...(markUnreadMenuItem ? [markUnreadMenuItem] : []),
             {
               id: "delete",
               label: `Delete (${count})`,
@@ -2472,9 +2479,8 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
         return;
       }
       if (clicked.value === "mark-unread") {
-        for (const threadKey of threadKeys) {
-          const thread = threadByKeyRef.current.get(threadKey);
-          if (thread) markThreadUnread(scopeThreadRef(thread.environmentId, thread.id));
+        for (const thread of markUnreadThreads) {
+          markThreadUnread(scopeThreadRef(thread.environmentId, thread.id));
         }
         clearSelection();
         return;
@@ -2642,6 +2648,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
               canSnoozeNow: canSnooze(thread, { now: new Date().toISOString() }),
               isRegeneratingTitle,
               isRunning: !threadRuntimeCanArchive(thread.runtime),
+              hasActiveRun: threadRuntimeIsActive(thread.runtime),
               canShareWithGuest: appAtomRegistry.get(
                 canShareWithGuestAtom(threadRef.environmentId),
               ),

apps/web/src/components/threadActionMenu.logic.test.ts

@@ -13,6 +13,7 @@ const baseState: ThreadActionMenuState = {
   canSnoozeNow: true,
   isRegeneratingTitle: false,
   isRunning: false,
+  hasActiveRun: false,
   supports: {
     settlement: true,
     autoSettleOptOut: true,
@@ -74,4 +75,11 @@ describe("buildThreadActionMenuItems", () => {
     expect(items.find((item) => item.id === "archive")?.disabled).toBe(true);
     expect(items.find((item) => item.id === "turn-into-project")?.disabled).toBe(true);
   });
+
+  it("omits mark unread while the thread is running", () => {
+    const ids = (hasActiveRun: boolean) =>
+      buildThreadActionMenuItems({ ...baseState, hasActiveRun }).map((item) => item.id);
+    expect(ids(false)).toContain("mark-unread");
+    expect(ids(true)).not.toContain("mark-unread");
+  });
 });

apps/web/src/components/threadActionMenu.logic.ts

@@ -83,6 +83,8 @@ export interface ThreadActionMenuState {
   readonly isRegeneratingTitle: boolean;
   /** Archive rejects attached providers, so disable it while running. */
   readonly isRunning: boolean;
+  /** Unread only surfaces as a completion pill, which an active run hides. */
+  readonly hasActiveRun: boolean;
   readonly supports: {
     readonly settlement: boolean;
     readonly autoSettleOptOut: boolean;
@@ -177,7 +179,9 @@ export function buildThreadActionMenuItems(
           },
         ]
       : []),
-    { id: "mark-unread", label: "Mark unread", icon: "mail-open" },
+    ...(state.hasActiveRun
+      ? []
+      : [{ id: "mark-unread" as const, label: "Mark unread", icon: "mail-open" }]),
     ...(state.canShareWithGuest
       ? [{ id: "share-guest" as const, label: "Share with guest", icon: "user-plus" }]
       : []),

apps/web/src/hooks/useThreadActionMenu.ts

@@ -42,7 +42,10 @@ import {
   selectProjectGroupingSettings,
 } from "@t3tools/client-runtime/state/project-grouping";
 import { buildPhysicalToLogicalProjectKeyMap } from "../sidebarProjectGrouping";
-import { threadRuntimeCanArchive } from "@t3tools/client-runtime/state/models";
+import {
+  threadRuntimeCanArchive,
+  threadRuntimeIsActive,
+} from "@t3tools/client-runtime/state/models";
 import { useCopyToClipboard } from "./useCopyToClipboard";
 import { useNewThreadHandler } from "./useHandleNewThread";
 import { useClientSettings } from "./useSettings";
@@ -148,6 +151,7 @@ export function useThreadActionMenu(input: {
         canSnoozeNow: canSnooze(thread, { now: now.toISOString() }),
         isRegeneratingTitle,
         isRunning: !threadRuntimeCanArchive(thread.runtime),
+        hasActiveRun: threadRuntimeIsActive(thread.runtime),
         supports,
         snoozePresets,
         canShareWithGuest,