Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(web): sidebar v2 polish — jump hints, working duration, in-flight fade, settled sort (#4274)
Theo Browneddd5a46f3942
diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.tsindex 084cf0956..65424b830 100644--- a/apps/web/src/components/Sidebar.logic.test.ts+++ b/apps/web/src/components/Sidebar.logic.test.ts@@ -20,9 +20,12 @@ import {resolveThreadRowClassName,resolveSidebarV2Status,resolveThreadStatusPill,+ resolveWorkingStartedAt,+ formatWorkingDurationLabel,shouldNavigateAfterProjectRemoval,shouldClearThreadSelectionOnMouseDown,sortLogicalProjectsForSidebar,+ sortSettledThreadsForSidebarV2,sortThreadsForSidebarV2,sortProjectsForSidebar,sortScopedProjectsForSidebar,@@ -209,8 +212,10 @@ function makeLatestTurn(overrides?: {state: "completed",assistantMessageId: null,requestedAt: "2026-03-09T10:00:00.000Z",- startedAt: overrides?.startedAt ?? "2026-03-09T10:00:00.000Z",- completedAt: overrides?.completedAt ?? "2026-03-09T10:05:00.000Z",+ startedAt:+ overrides?.startedAt !== undefined ? overrides.startedAt : "2026-03-09T10:00:00.000Z",+ completedAt:+ overrides?.completedAt !== undefined ? overrides.completedAt : "2026-03-09T10:05:00.000Z",};}@@ -783,6 +788,141 @@ describe("sortThreadsForSidebarV2", () => {});});+describe("sortSettledThreadsForSidebarV2", () => {+ const settled = (input: {+ id: string;+ settledAt?: string | null;+ latestUserMessageAt?: string | null;+ latestTurn?: OrchestrationLatestTurn | null;+ updatedAt?: string;+ }) => ({+ id: input.id,+ settledAt: input.settledAt ?? null,+ latestUserMessageAt: input.latestUserMessageAt ?? null,+ latestTurn: input.latestTurn ?? null,+ updatedAt: input.updatedAt ?? "2026-03-09T09:00:00.000Z",+ });++ it("orders by settle time, most recently settled first", () => {+ const sorted = sortSettledThreadsForSidebarV2([+ settled({+ id: "settled-first",+ settledAt: "2026-03-09T10:00:00.000Z",+ // Created/active later than the other thread: settle time must win.+ latestUserMessageAt: "2026-03-09T09:59:00.000Z",+ }),+ settled({+ id: "settled-last",+ settledAt: "2026-03-09T12:00:00.000Z",+ latestUserMessageAt: "2026-03-09T08:00:00.000Z",+ }),+ ]);++ expect(sorted.map((thread) => thread.id)).toEqual(["settled-last", "settled-first"]);+ });++ it("falls back to last activity for auto-settled threads without a settledAt stamp", () => {+ const sorted = sortSettledThreadsForSidebarV2([+ settled({ id: "auto-old", latestUserMessageAt: "2026-03-09T08:00:00.000Z" }),+ settled({ id: "explicit", settledAt: "2026-03-09T10:00:00.000Z" }),+ settled({ id: "auto-recent", latestUserMessageAt: "2026-03-09T11:00:00.000Z" }),+ ]);++ expect(sorted.map((thread) => thread.id)).toEqual(["auto-recent", "explicit", "auto-old"]);+ });++ it("counts a turn completion as activity for auto-settled threads", () => {+ // The message came in before the other thread's, but its turn finished+ // after: completion time is the real "work ended" moment.+ const sorted = sortSettledThreadsForSidebarV2([+ settled({ id: "message-only", latestUserMessageAt: "2026-03-09T10:04:00.000Z" }),+ settled({+ id: "completed-later",+ latestUserMessageAt: "2026-03-09T10:00:00.000Z",+ latestTurn: makeLatestTurn({ completedAt: "2026-03-09T10:30:00.000Z" }),+ }),+ ]);++ expect(sorted.map((thread) => thread.id)).toEqual(["completed-later", "message-only"]);+ });++ it("breaks timestamp ties by id so the order is stable", () => {+ const sorted = sortSettledThreadsForSidebarV2([+ settled({ id: "b", settledAt: "2026-03-09T10:00:00.000Z" }),+ settled({ id: "a", settledAt: "2026-03-09T10:00:00.000Z" }),+ ]);++ expect(sorted.map((thread) => thread.id)).toEqual(["a", "b"]);+ });+});++describe("resolveWorkingStartedAt", () => {+ const session = {+ threadId: ThreadId.make("thread-1"),+ status: "running" as const,+ providerName: "Codex",+ providerInstanceId: ProviderInstanceId.make("codex"),+ runtimeMode: DEFAULT_RUNTIME_MODE,+ activeTurnId: "turn-1" as never,+ lastError: null,+ updatedAt: "2026-03-09T10:02:00.000Z",+ };++ it("uses the running turn's start time", () => {+ expect(+ resolveWorkingStartedAt({+ latestTurn: makeLatestTurn({ completedAt: null }),+ session,+ }),+ ).toBe("2026-03-09T10:00:00.000Z");+ });++ it("uses the request time while a turn awaits adoption", () => {+ expect(+ resolveWorkingStartedAt({+ latestTurn: makeLatestTurn({ startedAt: null, completedAt: null }),+ session,+ }),+ ).toBe("2026-03-09T10:00:00.000Z");+ });++ it("falls back to the session transition when the latest turn already completed", () => {+ expect(+ resolveWorkingStartedAt({+ latestTurn: makeLatestTurn(),+ session,+ }),+ ).toBe("2026-03-09T10:02:00.000Z");+ });++ it("skips a malformed startedAt instead of returning it", () => {+ expect(+ resolveWorkingStartedAt({+ latestTurn: makeLatestTurn({ startedAt: "not-a-date", completedAt: null }),+ session,+ }),+ ).toBe("2026-03-09T10:00:00.000Z");+ });++ it("returns null with neither a running turn nor a session", () => {+ expect(resolveWorkingStartedAt({ latestTurn: null, session: null })).toBeNull();+ });+});++describe("formatWorkingDurationLabel", () => {+ it("formats seconds, minutes, and hours", () => {+ expect(formatWorkingDurationLabel(0)).toBe("0s");+ expect(formatWorkingDurationLabel(42_000)).toBe("42s");+ expect(formatWorkingDurationLabel(5 * 60_000)).toBe("5m");+ expect(formatWorkingDurationLabel(90 * 60_000)).toBe("1h 30m");+ });++ it("clamps negative and non-finite elapsed values to zero", () => {+ expect(formatWorkingDurationLabel(-5_000)).toBe("0s");+ expect(formatWorkingDurationLabel(Number.NaN)).toBe("0s");+ });+});+describe("resolveThreadStatusPill", () => {const baseThread = {hasActionableProposedPlan: false,diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.tsindex 04124feb5..e7082ca8a 100644--- a/apps/web/src/components/Sidebar.logic.ts+++ b/apps/web/src/components/Sidebar.logic.ts@@ -502,6 +502,18 @@ export function firstValidTimestampMs(return 0;}+/** String twin of firstValidTimestampMs for callers that need the ISO string+ (display labels, tick anchors) rather than epoch ms. */+export function firstValidTimestamp(+ ...candidates: ReadonlyArray<string | null | undefined>+): string | null {+ for (const candidate of candidates) {+ if (candidate == null) continue;+ if (!Number.isNaN(Date.parse(candidate))) return candidate;+ }+ return null;+}+// v2 sort: static creation order, newest thread on top. Activity NEVER// reorders the list — a row holds its position from open until settled, so// the screen only moves at lifecycle transitions. Status (including pending@@ -516,6 +528,73 @@ export function sortThreadsForSidebarV2<);}+type SettledTimestampInput = Pick<+ SidebarThreadSummary,+ "settledAt" | "latestUserMessageAt" | "latestTurn" | "updatedAt"+>;++/** The timestamp a settled row sorts and labels by: settledAt when stamped+ (explicit settles), otherwise last activity — the same candidates+ threadLastActivityAt feeds the auto-settle window (user message plus all+ latestTurn stamps), so a thread whose last activity was a turn completion+ doesn't sort by an older message time. updatedAt is the final net. */+export function resolveSettledTimestamp(thread: SettledTimestampInput): string | null {+ const settledAt = firstValidTimestamp(thread.settledAt);+ if (settledAt !== null) return settledAt;+ let latest: string | null = null;+ let latestMs = Number.NEGATIVE_INFINITY;+ for (const candidate of [+ thread.latestUserMessageAt,+ thread.latestTurn?.requestedAt,+ thread.latestTurn?.startedAt,+ thread.latestTurn?.completedAt,+ ]) {+ if (candidate == null) continue;+ const parsed = Date.parse(candidate);+ if (!Number.isNaN(parsed) && parsed > latestMs) {+ latest = candidate;+ latestMs = parsed;+ }+ }+ return latest ?? firstValidTimestamp(thread.updatedAt);+}++// Settled rows are history, so they order by when the work ENDED, not when+// the thread was created or last touched.+export function sortSettledThreadsForSidebarV2<+ T extends SettledTimestampInput & { readonly id: string },+>(threads: readonly T[]): T[] {+ const timestampMs = (thread: T) => {+ const timestamp = resolveSettledTimestamp(thread);+ return timestamp === null ? 0 : Date.parse(timestamp);+ };+ return [...threads].toSorted(+ (left, right) => timestampMs(right) - timestampMs(left) || left.id.localeCompare(right.id),+ );+}++/** The timestamp a working thread's elapsed label counts from: the running+ turn's start (request time until adoption), falling back to the session's+ last transition when the turn projection lags behind. Malformed+ timestamps fall through to the next candidate, not just missing ones. */+export function resolveWorkingStartedAt(+ thread: Pick<SidebarThreadSummary, "latestTurn" | "session">,+): string | null {+ const turn = thread.latestTurn;+ if (turn && turn.completedAt === null) {+ return firstValidTimestamp(turn.startedAt, turn.requestedAt, thread.session?.updatedAt);+ }+ return firstValidTimestamp(thread.session?.updatedAt);+}++export function formatWorkingDurationLabel(elapsedMs: number): string {+ const seconds = Number.isFinite(elapsedMs) ? Math.max(0, Math.floor(elapsedMs / 1000)) : 0;+ if (seconds < 60) return `${seconds}s`;+ const minutes = Math.floor(seconds / 60);+ if (minutes < 60) return `${minutes}m`;+ return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;+}+export function resolveThreadStatusPill(input: {thread: ThreadStatusInput;}): ThreadStatusPill | null {diff --git a/apps/web/src/components/SidebarV2.tsx b/apps/web/src/components/SidebarV2.tsxindex 1563c3d01..361c3460b 100644--- a/apps/web/src/components/SidebarV2.tsx+++ b/apps/web/src/components/SidebarV2.tsx@@ -91,14 +91,17 @@ import { formatRelativeTimeLabel } from "../timestampFormat";import type { SidebarThreadSummary } from "../types";import { cn } from "~/lib/utils";import {- firstValidTimestampMs,+ formatWorkingDurationLabel,hasUnseenCompletion,isTrailingDoubleClick,orderItemsByPreferredIds,resolveAdjacentThreadId,+ resolveSettledTimestamp,resolveSidebarV2Status,+ resolveWorkingStartedAt,shouldNavigateAfterProjectRemoval,sortLogicalProjectsForSidebar,+ sortSettledThreadsForSidebarV2,sortThreadsForSidebarV2,} from "./Sidebar.logic";import { resolveLocalCheckoutBranchMismatch } from "./BranchToolbar.logic";@@ -149,6 +152,44 @@ function threadTimeLabel(thread: SidebarThreadSummary): string {return compactSidebarTimeLabel(formatRelativeTimeLabel(timestamp));}+// Settled rows read "how long ago did this wrap up", matching their sort+// key: both go through resolveSettledTimestamp so label and order can't+// disagree.+function settledTimeLabel(thread: SidebarThreadSummary): string {+ const timestamp = resolveSettledTimestamp(thread);+ return timestamp === null ? "" : compactSidebarTimeLabel(formatRelativeTimeLabel(timestamp));+}++// Floats at the row's right edge, vertically centered, while the jump+// modifier is held. An overlay pill instead of an inline slot: the hint+// must neither displace the status/time label (holding ⌘ used to blank+// out "Working") nor shift any layout when it appears. pointer-events-none+// so it never swallows clicks meant for the settle/un-settle buttons it+// can overlap.+function JumpHintBadge(props: { label: string }) {+ return (+ <span+ aria-hidden+ className="pointer-events-none absolute right-1.5 top-1/2 z-10 inline-flex h-5 -translate-y-1/2 items-center rounded-full border border-border/80 bg-background/95 px-1.5 font-mono text-[10px] font-medium tracking-tight text-foreground shadow-sm"+ >+ {props.label}+ </span>+ );+}++// Self-ticking so only this span re-renders each second, not the whole row.+function WorkingDuration(props: { startedAt: string | null }) {+ const startedMs = props.startedAt !== null ? Date.parse(props.startedAt) : Number.NaN;+ const [, setTick] = useState(0);+ useEffect(() => {+ if (Number.isNaN(startedMs)) return;+ const id = window.setInterval(() => setTick((tick) => tick + 1), 1_000);+ return () => window.clearInterval(id);+ }, [startedMs]);+ if (Number.isNaN(startedMs)) return null;+ return <span className="tabular-nums">{formatWorkingDurationLabel(Date.now() - startedMs)}</span>;+}+function SidebarV2ThreadTooltip({thread,projectTitle,@@ -292,7 +333,15 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {// flag must not light up every historical thread as unread.const isUnread = hasUnseenCompletion({ ...thread, lastVisitedAt });const status = resolveSidebarV2Status(thread);- const shouldRecede = status === "ready" && !isUnread && !props.isActive && !isSelected;+ // In-flight rows (working, or waiting on approval/input) fade as a whole:+ // there is nothing for the user to do yet, so prominence is reserved for+ // rows that need a human — done (unread), read-but-unsettled, and failed.+ // The status label keeps its hue, so waiting rows stay findable. In-flight+ // rows recede the same as read-ready ones (inbox-zero: working threads+ // aren't your problem yet) — only the colored status label stands out.+ const isInFlight = status === "working" || status === "approval" || status === "input";+ const shouldRecede =+ (status === "ready" || isInFlight) && !isUnread && !props.isActive && !isSelected;// Status hues follow the system-wide convention set by sidebar v1 and the// mobile Live Activity/widgets (amber approval, indigo input, sky working)// so a thread reads the same color everywhere it surfaces.@@ -478,6 +527,10 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {: shouldRecede? "text-sidebar-muted-foreground/75 hover:bg-sidebar-row-hover hover:text-sidebar-foreground": "bg-transparent text-sidebar-foreground hover:bg-sidebar-row-hover",+ isInFlight &&+ !props.isActive &&+ !isSelected &&+ "opacity-70 transition-opacity hover:opacity-100",);const title = isRenaming ? (@@ -503,10 +556,10 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {"truncate",isUnread? "text-foreground"- : status !== "ready"- ? "text-foreground/95"- : shouldRecede- ? "text-muted-foreground/80"+ : shouldRecede+ ? "text-muted-foreground/80"+ : status === "failed"+ ? "text-foreground/95": "text-foreground/90",): cn(@@ -587,10 +640,9 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {<span className="relative ml-auto flex h-6 min-w-8 shrink-0 items-center justify-end"><span className="inline-flex justify-end tabular-nums text-muted-foreground/55 transition-opacity group-hover/v2-row:opacity-0"><span className="text-xs">- {props.jumpLabel ??- compactSidebarTimeLabel(- formatRelativeTimeLabel(thread.latestUserMessageAt ?? thread.updatedAt),- )}+ {variantAction === "unsettle"+ ? settledTimeLabel(thread)+ : threadTimeLabel(thread)}</span></span>{!props.settlementSupported ? null : variantAction === "unsettle" ? (@@ -613,6 +665,7 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {</button>)}</span>+ {props.jumpLabel ? <JumpHintBadge label={props.jumpLabel} /> : null}</TooltipTrigger>{detailsTooltip}</Tooltip>@@ -650,7 +703,12 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {className="size-4 shrink-0"/>{props.projectTitle ? (- <span className="min-w-0 flex-1 truncate text-xs font-medium text-muted-foreground/85">+ <span+ className={cn(+ "min-w-0 flex-1 truncate text-xs text-muted-foreground/85",+ shouldRecede ? "font-normal" : "font-medium",+ )}+ >{props.projectTitle}</span>) : (@@ -658,11 +716,8 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {)}<span className="relative ml-auto flex h-5 min-w-8 shrink-0 items-center justify-end pl-1 text-xs"><span className="tabular-nums text-muted-foreground/65 transition-opacity group-hover/v2-row:opacity-0">- {props.jumpLabel ? (- props.jumpLabel- ) : topStatus ? (+ {topStatus ? (<span- role="status"className={cn("inline-flex items-center gap-1 font-medium",topStatus.className,@@ -673,7 +728,15 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {) : topStatus.icon === "done" ? (<CircleCheckIcon aria-hidden className="size-4 shrink-0" />) : null}- {topStatus.label}+ {/* The label alone is the live region: a role="status"+ wrapper around the ticking duration would make+ screen readers announce every second. */}+ <span role="status">{topStatus.label}</span>+ {status === "working" ? (+ <span aria-hidden>+ <WorkingDuration startedAt={resolveWorkingStartedAt(thread)} />+ </span>+ ) : null}</span>) : (threadTimeLabel(thread)@@ -727,6 +790,7 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {</span></div></div>+ {props.jumpLabel ? <JumpHintBadge label={props.jumpLabel} /> : null}</TooltipTrigger>{detailsTooltip}</Tooltip>@@ -1137,11 +1201,7 @@ export default function SidebarV2() {}return {activeThreads: sortThreadsForSidebarV2(active),- settledThreads: settled.toSorted(- (left, right) =>- firstValidTimestampMs(right.latestUserMessageAt, right.updatedAt) -- firstValidTimestampMs(left.latestUserMessageAt, left.updatedAt),- ),+ settledThreads: sortSettledThreadsForSidebarV2(settled),};}, [autoSettleAfterDays,