Uh oh!
There was an error while loading. Please reload this page.
Enable terminals for local draft threads - #143
Closed
juliusmarminge wants to merge 4 commits into
Closed
Conversation
Important Review skippedAuto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the You can disable this status message by setting the Use the checkbox below for a quick retry:
✨ Finishing Touches🧪 Generate unit tests (beta)
Comment |
Contributor
There was a problem hiding this comment.
Cursor Bugbot has reviewed your changes and found 1 potential issue.
Autofix Details
Bugbot Autofix prepared a fix for the issue found in the latest run.
- ✅ Fixed: Close terminal selects next active terminal differently than store
- Added same-group preference logic (closedTerminalGroup lookup and remainingTerminalsInClosedGroup fallback) to closeDraftTerminal, matching the store's closeThreadTerminal 3-level fallback behavior.
Or push these changes by commenting:
@cursor push 5002774b80
Preview (5002774b80)
diff --git a/apps/web/src/draftThreadTerminalState.ts b/apps/web/src/draftThreadTerminalState.ts--- a/apps/web/src/draftThreadTerminalState.ts+++ b/apps/web/src/draftThreadTerminalState.ts@@ -161,9 +161,21 @@
}
const closedTerminalIndex = state.terminalIds.indexOf(terminalId);
+ const closedTerminalGroup = state.terminalGroups.find((group) =>+ group.terminalIds.includes(terminalId),+ );+ const closedTerminalGroupIndex = closedTerminalGroup+ ? closedTerminalGroup.terminalIds.indexOf(terminalId)+ : -1;+ const remainingTerminalsInClosedGroup = (closedTerminalGroup?.terminalIds ?? []).filter(+ (id) => id !== terminalId,+ );
const nextActiveTerminalId =
state.activeTerminalId === terminalId
- ? (remainingTerminalIds[Math.min(closedTerminalIndex, remainingTerminalIds.length - 1)] ??+ ? (remainingTerminalsInClosedGroup[+ Math.min(closedTerminalGroupIndex, remainingTerminalsInClosedGroup.length - 1)+ ] ??+ remainingTerminalIds[Math.min(closedTerminalIndex, remainingTerminalIds.length - 1)] ??
remainingTerminalIds[0] ??
DEFAULT_THREAD_TERMINAL_ID)
: state.activeTerminalId;Uh oh!
There was an error while loading. Please reload this page.
Comment on lines
+51
to
+53
| return [...new Set(runningTerminalIds)] | ||
| .map((id) => id.trim()) | ||
| .filter((id) => id.length > 0 && validTerminalIdSet.has(id)); |
Contributor
There was a problem hiding this comment.
🟢 Lowsrc/threadTerminalState.ts:51
Consider trimming before deduplicating—currently " term1 " and "term1" both survive the Set, then become identical after .trim(), producing duplicates.
Suggested change
| return[...newSet(runningTerminalIds)] | |
| .map((id)=>id.trim()) | |
| .filter((id)=>id.length>0&&validTerminalIdSet.has(id)); | |
| return[...newSet(runningTerminalIds.map((id)=>id.trim()))] | |
| .filter((id)=>id.length>0&&validTerminalIdSet.has(id)); |
🚀 Reply "fix it for me" or copy this AI Prompt for your agent:
In file apps/web/src/threadTerminalState.ts around lines 51-53:
Consider trimming before deduplicating—currently `" term1 "` and `"term1"` both survive the `Set`, then become identical after `.trim()`, producing duplicates.
Evidence trail:
File: apps/web/src/threadTerminalState.ts lines 51-53 at REVIEWED_COMMIT. The function `normalizeRunningTerminalIds` uses `[...new Set(runningTerminalIds)].map((id) => id.trim())`. The Set deduplicates before trim, so `" term1 "` and `"term1"` both survive the Set, then both become `"term1"` after trim, producing duplicates.
Uh oh!
There was an error while loading. Please reload this page.
Adds local terminal state management for draft threads before they're promoted to server threads. Terminal operations (open, split, create, close, activate, resize) now work on draft threads and hydrate into the server thread state when the draft is promoted. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
- Add shared threadTerminalState.ts: ThreadTerminalState type, default state, normalize helpers, and single reduceThreadTerminalState() used by both flows - Refactor store.ts to use shared terminal reducer and helpers; terminal actions map to reduceThreadTerminalState(threadTerminalSlice(thread), action) - Make draftThreadTerminalState.ts re-export shared module (same shape/actions) - Add terminalState to composer draft store: getDraftThreadTerminalState, setDraftThreadTerminalAction, clearDraftThreadTerminalState; draft thread shape matches Thread terminal slice - ChatView: move draft terminal from useState into composer draft store; use same actions for draft and persisted; hydrate then clear draft terminal when reconciling server state Made-with: Cursor
…irectly - Delete draftThreadTerminalState.ts (was only re-exporting shared module) - Replace draftThreadTerminalState.test.ts with threadTerminalState.test.ts using createDefaultThreadTerminalState and reduceThreadTerminalState - Draft threads are first-class: same helpers and types as persisted threads Made-with: Cursor
Comment on lines
+149
to
+151
| export function createDefaultThreadTerminalState(): ThreadTerminalState { | ||
| return { ...DEFAULT_THREAD_TERMINAL_STATE }; | ||
| } |
Contributor
There was a problem hiding this comment.
🟢 Lowsrc/threadTerminalState.ts:149
Defaults are shallow. Mutating nested arrays (e.g. terminalIds, terminalGroups) can leak into DEFAULT_THREAD_TERMINAL_STATE. Suggest deep-freezing the default and/or returning deep clones from createDefaultThreadTerminalState and getDefaultThreadTerminalState to avoid shared references.
-export function createDefaultThreadTerminalState(): ThreadTerminalState {- return { ...DEFAULT_THREAD_TERMINAL_STATE };+export function createDefaultThreadTerminalState(): ThreadTerminalState {+ return {+ ...DEFAULT_THREAD_TERMINAL_STATE,+ terminalIds: [...DEFAULT_THREAD_TERMINAL_STATE.terminalIds],+ runningTerminalIds: [...DEFAULT_THREAD_TERMINAL_STATE.runningTerminalIds],+ terminalGroups: DEFAULT_THREAD_TERMINAL_STATE.terminalGroups.map((g) => ({+ ...g,+ terminalIds: [...g.terminalIds],+ })),+ };
}🚀 Reply "fix it for me" or copy this AI Prompt for your agent:
In file apps/web/src/threadTerminalState.ts around lines 149-151:
Defaults are shallow. Mutating nested arrays (e.g. `terminalIds`, `terminalGroups`) can leak into `DEFAULT_THREAD_TERMINAL_STATE`. Suggest deep-freezing the default and/or returning deep clones from `createDefaultThreadTerminalState` and `getDefaultThreadTerminalState` to avoid shared references.
Evidence trail:
apps/web/src/threadTerminalState.ts lines 132-155: `DEFAULT_THREAD_TERMINAL_STATE` is defined with `Object.freeze()` containing nested arrays (`terminalIds`, `runningTerminalIds`, `terminalGroups`). `createDefaultThreadTerminalState()` returns `{ ...DEFAULT_THREAD_TERMINAL_STATE }` (shallow copy). `getDefaultThreadTerminalState()` returns the frozen object directly. JavaScript's `Object.freeze()` is documented as shallow-freezing only top-level properties (MDN documentation). Usage sites in `composerDraftStore.ts` lines 683-697 show these functions being called and their results potentially stored/used.
Contributor
There was a problem hiding this comment.
Cursor Bugbot has reviewed your changes and found 2 potential issues.
Autofix Details
Bugbot Autofix prepared fixes for both issues found in the latest run.
- ✅ Fixed: Close terminal lost group-aware active terminal selection
- Restored group-aware active terminal selection in closeTerminal by first looking for siblings in the same group (remainingTerminalsInClosedGroup) before falling back to the global remainingTerminalIds list, matching the old closeThreadTerminal behavior.
- ✅ Fixed: Dead reference equality check never short-circuits store updates
- Replaced the dead
next === currentreference equality check with a structural comparison via a new threadTerminalStateEquals helper, since reduceThreadTerminalState always returns a new object through normalizeThreadTerminalState.
- Replaced the dead
Or push these changes by commenting:
@cursor push a82c89a4f7
Preview (a82c89a4f7)
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts--- a/apps/web/src/composerDraftStore.ts+++ b/apps/web/src/composerDraftStore.ts@@ -10,6 +10,7 @@
createDefaultThreadTerminalState,
getDefaultThreadTerminalState,
reduceThreadTerminalState,
+ threadTerminalStateEquals,
type ThreadTerminalAction,
type ThreadTerminalState,
} from "./threadTerminalState";
@@ -696,7 +697,7 @@
}
const current = existing.terminalState ?? createDefaultThreadTerminalState();
const next = reduceThreadTerminalState(current, action);
- if (next === current) {+ if (threadTerminalStateEquals(next, current)) {
return state;
}
return {
diff --git a/apps/web/src/threadTerminalState.ts b/apps/web/src/threadTerminalState.ts--- a/apps/web/src/threadTerminalState.ts+++ b/apps/web/src/threadTerminalState.ts@@ -205,9 +205,21 @@
}
const closedTerminalIndex = state.terminalIds.indexOf(terminalId);
+ const closedTerminalGroup = state.terminalGroups.find((group) =>+ group.terminalIds.includes(terminalId),+ );+ const closedTerminalGroupIndex = closedTerminalGroup+ ? closedTerminalGroup.terminalIds.indexOf(terminalId)+ : -1;+ const remainingTerminalsInClosedGroup = (closedTerminalGroup?.terminalIds ?? []).filter(+ (id) => id !== terminalId,+ );
const nextActiveTerminalId =
state.activeTerminalId === terminalId
- ? (remainingTerminalIds[Math.min(closedTerminalIndex, remainingTerminalIds.length - 1)] ??+ ? (remainingTerminalsInClosedGroup[+ Math.min(closedTerminalGroupIndex, remainingTerminalsInClosedGroup.length - 1)+ ] ??+ remainingTerminalIds[Math.min(closedTerminalIndex, remainingTerminalIds.length - 1)] ??
remainingTerminalIds[0] ??
DEFAULT_THREAD_TERMINAL_ID)
: state.activeTerminalId;
@@ -242,6 +254,36 @@
}));
}
+export function threadTerminalStateEquals(a: ThreadTerminalState, b: ThreadTerminalState): boolean {+ if (a === b) return true;+ if (+ a.terminalOpen !== b.terminalOpen ||+ a.terminalHeight !== b.terminalHeight ||+ a.activeTerminalId !== b.activeTerminalId ||+ a.activeTerminalGroupId !== b.activeTerminalGroupId ||+ a.terminalIds.length !== b.terminalIds.length ||+ a.runningTerminalIds.length !== b.runningTerminalIds.length ||+ a.terminalGroups.length !== b.terminalGroups.length+ ) {+ return false;+ }+ for (let i = 0; i < a.terminalIds.length; i++) {+ if (a.terminalIds[i] !== b.terminalIds[i]) return false;+ }+ for (let i = 0; i < a.runningTerminalIds.length; i++) {+ if (a.runningTerminalIds[i] !== b.runningTerminalIds[i]) return false;+ }+ for (let i = 0; i < a.terminalGroups.length; i++) {+ const ga = a.terminalGroups[i]!;+ const gb = b.terminalGroups[i]!;+ if (ga.id !== gb.id || ga.terminalIds.length !== gb.terminalIds.length) return false;+ for (let j = 0; j < ga.terminalIds.length; j++) {+ if (ga.terminalIds[j] !== gb.terminalIds[j]) return false;+ }+ }+ return true;+}+
// ─── Single reducer for both draft and persisted thread ────────────────────
export function reduceThreadTerminalState(Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
- Main store: replace useReducer with Zustand; pure state transition functions (syncServerReadModel, markThreadVisited, setError, etc.) called via store methods. Persist via subscribe. - Terminal store: single store keyed by threadId; replace dispatchTerminalAction with direct methods (setTerminalOpen, setTerminalHeight, splitTerminal, newTerminal, setActiveTerminal, closeTerminal, setTerminalActivity). Pure reduceThreadTerminalState used internally. - Update all consumers to call dispatch.method(...) and terminal store methods. Fix store tests to use markThreadUnread pure fn. - Fix Fragment import in store.ts; fix unused get param for lint. Made-with: Cursor
juliusmarmingeforce-pushed
the
t3code/enable-draft-thread-terminals
branch
from
March 2, 2026 18:24
eef2781 to
c283d2aCompare| if (!thread.latestTurn?.completedAt) return thread; | ||
| const latestTurnCompletedAtMs = Date.parse(thread.latestTurn.completedAt); | ||
| if (Number.isNaN(latestTurnCompletedAtMs)) return thread; | ||
| const unreadVisitedAt = new Date(latestTurnCompletedAtMs - 1).toISOString(); |
Contributor
There was a problem hiding this comment.
🟢 Lowsrc/store.ts:303
If latestTurn.completedAt is in the future (clock skew), unreadVisitedAt will also be in the future, preventing markThreadVisited from updating lastVisitedAt until client time catches up. Consider using Math.min(latestTurnCompletedAtMs - 1, Date.now()) to cap the timestamp.
Suggested change
| constunreadVisitedAt=newDate(latestTurnCompletedAtMs-1).toISOString(); | |
| constunreadVisitedAt=newDate(Math.min(latestTurnCompletedAtMs-1,Date.now())).toISOString(); |
🚀 Reply "fix it for me" or copy this AI Prompt for your agent:
In file apps/web/src/store.ts around line 303:
If `latestTurn.completedAt` is in the future (clock skew), `unreadVisitedAt` will also be in the future, preventing `markThreadVisited` from updating `lastVisitedAt` until client time catches up. Consider using `Math.min(latestTurnCompletedAtMs - 1, Date.now())` to cap the timestamp.
Evidence trail:
apps/web/src/store.ts lines 296-306 (markThreadUnread function, line 303 sets unreadVisitedAt from latestTurn.completedAt - 1); apps/web/src/store.ts lines 273-291 (markThreadVisited function, line 278 defaults to Date.now(), lines 284-287 comparison that prevents update if previousVisitedAtMs >= visitedAtMs)
| (store) => store.getDraftThreadByProjectId, | ||
| ); | ||
| const getDraftThread = useComposerDraftStore((store) => store.getDraftThread); | ||
| const getTerminalState = useTerminalStateStore((s) => s.getTerminalState); |
Contributor
There was a problem hiding this comment.
🟡 Mediumcomponents/Sidebar.tsx:240
The component subscribes to getTerminalState (a stable function reference), not the underlying terminalStateByThreadId data. When terminal state changes, this component won't re-render, causing stale terminalStatus display. Consider subscribing to the data directly, e.g., useTerminalStateStore((s) => s.terminalStateByThreadId), then access state in the render loop.
🚀 Reply "fix it for me" or copy this AI Prompt for your agent:
In file apps/web/src/components/Sidebar.tsx around line 240:
The component subscribes to `getTerminalState` (a stable function reference), not the underlying `terminalStateByThreadId` data. When terminal state changes, this component won't re-render, causing stale `terminalStatus` display. Consider subscribing to the data directly, e.g., `useTerminalStateStore((s) => s.terminalStateByThreadId)`, then access state in the render loop.
Evidence trail:
apps/web/src/components/Sidebar.tsx line 240: `const getTerminalState = useTerminalStateStore((s) => s.getTerminalState);` - subscribes to function reference
apps/web/src/components/Sidebar.tsx lines 818-820: `const terminalStatus = terminalStatusFromRunningIds(getTerminalState(thread.id).runningTerminalIds);` - uses function to get data during render
apps/web/src/terminalStateStore.ts lines 51-66: Shows `getTerminalState` is a stable function that calls `get().terminalStateByThreadId[threadId]` - the function reference doesn't change when the data it accesses changes
juliusmarminge added a commit
that referenced
this pull request
Mar 2, 2026
Integrate the draft and persisted terminal-state flow from #143 (shared thread terminal reducer plus dedicated terminal store), while preserving selector compatibility and runtime-mode switch robustness on this branch. Made-with: Cursor
juliusmarminge
commented
Mar 2, 2026
MemberAuthor
Superseded by #141. I merged the terminal-store work into that branch/PR so the three-store architecture now lives there (composer draft store + app state store + terminal store). |
Contributor
There was a problem hiding this comment.
Cursor Bugbot has reviewed your changes and found 3 potential issues.
Bugbot Autofix prepared fixes for all 3 issues found in the latest run.
- ✅ Fixed: Unstable
dispatchreference causes infinite effect loop- Wrapped dispatch action functions in useMemo with empty deps so the dispatch object is referentially stable across renders, breaking the infinite re-render/effect cycle.
- ✅ Fixed: Sidebar terminal status indicator not reactive to changes
- Changed the Sidebar's terminal store subscription from the stable getTerminalState function reference to the terminalStateByThreadId data object, so changes to terminal running state trigger re-renders.
- ✅ Fixed: No-op terminal actions always trigger store updates
- Changed all no-op early-return paths in reduceThreadTerminalState to return the original state parameter instead of the normalized copy, allowing the reference equality check in applyTerminalAction to succeed and skip unnecessary store updates.
Or push these changes by commenting:
@cursor push 004658797e
Preview (004658797e)
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx--- a/apps/web/src/components/Sidebar.tsx+++ b/apps/web/src/components/Sidebar.tsx@@ -237,7 +237,7 @@
(store) => store.getDraftThreadByProjectId,
);
const getDraftThread = useComposerDraftStore((store) => store.getDraftThread);
- const getTerminalState = useTerminalStateStore((s) => s.getTerminalState);+ const terminalStateByThreadId = useTerminalStateStore((s) => s.terminalStateByThreadId);
const setProjectDraftThreadId = useComposerDraftStore((store) => store.setProjectDraftThreadId);
const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
const clearProjectDraftThreadId = useComposerDraftStore(
@@ -816,7 +816,7 @@
);
const prStatus = prStatusIndicator(prByThreadId.get(thread.id) ?? null);
const terminalStatus = terminalStatusFromRunningIds(
- getTerminalState(thread.id).runningTerminalIds,+ terminalStateByThreadId[thread.id]?.runningTerminalIds ?? [],
);
return (
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts--- a/apps/web/src/store.ts+++ b/apps/web/src/store.ts@@ -1,4 +1,4 @@-import { Fragment, type ReactNode, createElement, useEffect } from "react";+import { Fragment, type ReactNode, createElement, useEffect, useMemo } from "react";
import {
DEFAULT_MODEL,
ProviderSessionId,
@@ -416,8 +416,18 @@
threadsHydrated: s.threadsHydrated,
runtimeMode: s.runtimeMode,
}));
- return {- state,- dispatch: useAppStore.getState(),- };+ const dispatch = useMemo(() => {+ const s = useAppStore.getState();+ return {+ syncServerReadModel: s.syncServerReadModel,+ markThreadVisited: s.markThreadVisited,+ markThreadUnread: s.markThreadUnread,+ toggleProject: s.toggleProject,+ setProjectExpanded: s.setProjectExpanded,+ setError: s.setError,+ setThreadBranch: s.setThreadBranch,+ setRuntimeMode: s.setRuntimeMode,+ };+ }, []);+ return { state, dispatch };
}
diff --git a/apps/web/src/threadTerminalState.ts b/apps/web/src/threadTerminalState.ts--- a/apps/web/src/threadTerminalState.ts+++ b/apps/web/src/threadTerminalState.ts@@ -251,7 +251,7 @@
const normalized = normalizeThreadTerminalState(state);
if (action.type === "set-open") {
- if (normalized.terminalOpen === action.open) return normalized;+ if (normalized.terminalOpen === action.open) return state;
return { ...normalized, terminalOpen: action.open };
}
@@ -261,14 +261,14 @@
action.height <= 0 ||
normalized.terminalHeight === action.height
) {
- return normalized;+ return state;
}
return { ...normalized, terminalHeight: action.height };
}
if (action.type === "set-active") {
if (!normalized.terminalIds.includes(action.terminalId)) {
- return normalized;+ return state;
}
const activeTerminalGroupId =
normalized.terminalGroups.find((group) => group.terminalIds.includes(action.terminalId))?.id ??
@@ -286,7 +286,7 @@
if (action.type === "set-activity") {
if (!normalized.terminalIds.includes(action.terminalId)) {
- return normalized;+ return state;
}
const runningTerminalIds = new Set(normalized.runningTerminalIds);
if (action.hasRunningSubprocess) {
@@ -298,12 +298,12 @@
}
if (!action.terminalId || action.terminalId.trim().length === 0) {
- return normalized;+ return state;
}
const isNewTerminal = !normalized.terminalIds.includes(action.terminalId);
if (isNewTerminal && normalized.terminalIds.length >= MAX_THREAD_TERMINAL_COUNT) {
- return normalized;+ return state;
}
const terminalIds = isNewTerminal| function setThreadTerminalActivity( | ||
| thread: Thread, | ||
| terminalId: string, |
Contributor
There was a problem hiding this comment.
Unstable dispatch reference causes infinite effect loop
High Severity
useStore() returns dispatch: useAppStore.getState(), which produces a new object reference after every store update. The selector also creates a new inline object on every call, so every store change triggers a re-render. In EventRouter, this dispatch is in the useEffect dependency array. Each effect run calls syncSnapshot(), which calls dispatch.syncServerReadModel(snapshot), which updates the store, which triggers a re-render, which changes dispatch, which re-runs the effect — creating an infinite loop of network requests and event re-subscriptions.
Additional Locations (1)
| (store) => store.getDraftThreadByProjectId, | ||
| ); | ||
| const getDraftThread = useComposerDraftStore((store) => store.getDraftThread); | ||
| const getTerminalState = useTerminalStateStore((s) => s.getTerminalState); |
Contributor
There was a problem hiding this comment.
Sidebar terminal status indicator not reactive to changes
Medium Severity
The Sidebar subscribes to useTerminalStateStore((s) => s.getTerminalState), which returns the getTerminalState function reference — a stable closure that never changes. This means the Sidebar never re-renders when terminal state (like runningTerminalIds) changes in the terminal store. The terminal running indicator in the sidebar will be stale until the component re-renders for an unrelated reason.
Additional Locations (1)
| ...state, | ||
| [threadId]: next, | ||
| }; | ||
| } |
Contributor
There was a problem hiding this comment.
No-op terminal actions always trigger store updates
Low Severity
applyTerminalAction checks if (next === current) to avoid unnecessary updates, but this never succeeds. reduceThreadTerminalState always calls normalizeThreadTerminalState first, which creates a new object. So even for no-op actions (e.g., setting terminalOpen to its current value), next is a different reference than current, and the store always updates. The intended optimization is defeated.
Additional Locations (1)
logancsack added a commit
to logancsack/t3code
that referenced
this pull request
Aug 4, 2026
Aldo Review lost 27% of its lead reviewers in the field (12 of 44 slots across remote-dev PRs pingdotgg#135-pingdotgg#143): 8 Grok Build structured-output rejections and 4 timeouts. Nothing retried, so one transient blip deleted a whole reviewer for the entire run. Retry every failure a fresh sample could plausibly fix, against a new subprocess. Output that overflows the collection limit stays terminal because it recurs identically. Give the swarm one wall-clock budget split into stage deadlines, so a retrying lead can never starve the verification that produces the report. The worst-case serial path was already 12 minutes against a 10-minute service cap. Delegation, the only optional stage, is skipped and reported rather than started with too little time to finish. Carry the Grok Build error cause into reviewer diagnostics so the next failure is diagnosable.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
HYDRATE_THREAD_TERMINALSactiondraftThreadTerminalState.tsmodule with reducer pattern for managing draft terminal stateTest plan
bun testto verify new unit tests pass🤖 Generated with Claude Code
Note
Medium Risk
Moderate risk because this refactors core client state management (React reducer/context → Zustand) and moves terminal UI state out of
Threadinto a new persisted store, which could cause state sync/persistence regressions across threads and drafts.Overview
Moves app state from a reducer/context to a Zustand store.
store.tsnow exposes pure transition helpers (e.g.markThreadUnread,setThreadBranch,setRuntimeMode) plus a Zustand-backeduseStore()whosedispatchis a method API (dispatch.setError(...),dispatch.toggleProject(...), etc.).Decouples terminal UI state from
Threadand persists it separately. Terminal fields are removed fromThread(types.ts), and a newterminalStateStore.tspersists per-threadIdterminal state in localStorage using a shared reducer inthreadTerminalState.ts.Updates UI to use the new dispatch API and terminal store.
ChatViewandSidebarswitch terminal open/height/tab/group/active/running indicators touseTerminalStateStore, while other actions are updated to call the newdispatch.*methods; root websocket terminal activity events now write directly to the terminal store. Tests are adjusted accordingly, with new unit coverage forthreadTerminalStatebehavior.Written by Cursor Bugbot for commit c283d2a. This will update automatically on new commits. Configure here.
Note
Move terminal UI state for local draft threads to a dedicated Zustand store and update
ChatViewandSidebarto read/write viauseTerminalStateStorewithMAX_THREAD_TERMINAL_COUNTenforcementIntroduce
useTerminalStateStorefor per-thread terminal state and refactor app state to a single Zustand store; updateChatViewandSidebarto consume terminal state from the new store and remove terminal fields fromThread. Core terminal logic lives inreduceThreadTerminalStatewith normalization helpers.📍Where to Start
Start with the terminal reducer and helpers in apps/web/src/threadTerminalState.ts, then see the store wiring in apps/web/src/terminalStateStore.ts and usage in apps/web/src/components/ChatView.tsx.
Macroscope summarized c283d2a.