[teamleaderleo]

This is slice S4 of Leo's sidebar-organization ask (item A, the "Done (N)" fold).

What changes

Workspaces you marked Done (Mark as Done, Set Workspace Status → Done) leave their place and list behind one "Done (N)" row at the end of their group, or at the end of the loose rows. Click the row to show them below it; click again to fold them.

• Order: nothing reorders the model. The other rows keep their manual order, and the Done ones keep theirs behind the fold.
• Kept in place: the active workspace, even when it is Done. While filtering, every match shows where it is. With the session tree on, nothing folds (the tree nests rows under others).
• What redraws: marking a workspace Done (or not) is now a structural change, so the list lays out again instead of patching the row (SidebarModel.movesRows). A group holding Done workspaces folds and opens by a full layout instead of the splice.
• The row: a chevron and "Done (N)" in the folder header's quiet style, one line high, indented with the group's members. It is no drop target, has no rename, and right-click shows its group's or section's menu. VoiceOver reads it as a disclosure triangle.
• While a drag runs, every Done workspace shows in its place (drops resolve by the drawn rows), and the fold comes back after the drop.
• Selected from elsewhere: a Done workspace chosen from the palette, Cmd-number or the socket shows in its place (the selection patch hands over to a layout). After you leave a Done workspace by a click, it stays drawn until the next layout, as a collapsed group keeps the member you left, so nothing moves under the pointer.
• State: which Done rows are open is view state of the list (SidebarListView.openDoneFolds), not saved.
• Toggle: Debug toggle sidebar.doneFold, on by default.
• Strings: one new string, "Done (%lld)", in all 21 locales.
• Size: SidebarLayout.swift shrinks (474 → 461 lines): its row helpers visible, listsTabs and disclosure moved onto SidebarLayoutOptions, and the filter's path-to-match onto a static helper.

Tests

Tests/CmuxNextAppTests/SidebarDoneFoldTests.swift (committed first):

• Done workspaces fold into one row at the end, in a group and in the loose rows;
• the row counts its workspaces;
• an open fold lists them in their order;
• the active workspace keeps its place;
• off, and while filtering, every row is in place;
• a group with Done workspaces is not spliced;
• marking Done is a structural change;
• the string carries the count;
• a Done workspace selected elsewhere shows.

Capture

Three workspaces marked Done (with the app's Mark as Done action) fold into one closed "Done (3)" row under the others.

Capture steps-386849ff85 at 7c19da8f8742 (fleet build, capture mini, text checked for private data)

Light	Dark

Review

• BLOCK at d5b9dd3: drops near a closed Done row, the drop gap, and a Done workspace selected elsewhere. Fixed in 87531eb, with a test.
• SHIP at 87531eb. Follow-ups from it: the first event of a drag from outside the sidebar can name the wrong row until the next move; rows jump when a drag starts while Done rows are folded; a dragged group's slot is taller than its card.
• After it: the chevron sat over the count (moved before it), and turning sidebar.doneFold on or off now lays the list out again. Fleet compile passed at 7c19da8.

Changelog

• Added: Workspaces marked Done fold into one "Done (N)" row at the end of their group or list.
  Agent session: cosmic-gray

🤖 Generated with Claude Code

[github-actions]

cmux status _{(one comment, edited in place; each line is updated by the job that owns it)}

Review 1a7130a: HQ feed card · gallery before/after runs · checks

App of this head (app.zip, kept 1 day)

gh workflow run reload-build.yml -R manaflow-ai/cmux --ref feat-cmux-next -f tag=pr23633 -f ref=leo/sidebar-done-fold -f platform=macos -f backend_mode=local

Not verified: macOS jobs did not run: compile and app tests were skipped on 1a7130aef1; ci-status is green without them.

CI passes on 1a7130aef1 (run 39674440777 attempt 1).
macOS jobs did not run: compile and app tests were skipped: Fast static checks skipped (the macos job needs both to succeed). Re-run CI once they pass, before merging.

Written by scripts/ci/classify_failures.py (ci-failure-attribution.yml); signatures are its SIGNATURES table. A machine verdict is the runner's fault, not this PR's; yours means the failing file is one this PR changes, also red on main that main's latest full suite fails the same way, seen on other PRs that it failed on another pull request's run lately.

red: cmux-next checks (god files, concurrency, crash safety, l10n); base red: the same failure on the base cb27a38; does not block

[teamleaderleo]

Owned by chief-sidebar on cosmic-gray · session

[teamleaderleo]

Bead cx-ddt3z created for this PR by the cmux coordinator.

[teamleaderleo]

Review (claude-review-subagent): BLOCK at d5b9dd3

I read the full diff against merge-base 7771639, plus the drop resolver (cmux-tui/crates/cmux-layout-reducer/src/sidebar_drop.rs), SidebarListView+SelectionPatch.swift, SidebarView+Observation.swift and SidebarEmptyArea.swift. I didn't build or run anything.

Blocking

1. Drops near a folded "Done (N)" row land in the wrong place, and you can no longer drop below a group's end.
RustRow.resolvable leaves out .doneFold rows. The resolver's hit() picks the last resolvable row whose y <= pointer and clamps the fraction to 1.0, so a pointer over a Done row resolves against the visible row above it.

• Group fold: the group's last visible member (g2 in the test fixture) now has isLastInGroup == false, because the fold row is last. The group_exit_fraction branch in workspace_target never fires. A drop on the lower part of g2, on the group's Done row, or in the group's bottom padding stays inside the group at g2.siblingIndex + 1. Before this change, the bottom edge of the last member moved the drop out of the group to parent_index + 1.
• Section-level fold placed after a group (the fixture's order: … g, g2, Done(g), Done(loose)): a drop over the loose "Done (N)" row also resolves to g2, so the workspace goes into group G between g2 and the hidden g3. The person dropped on a row in the loose list and the workspace ended up inside the group. When the group is the section's last node, no position remains that drops after the group at section level.
• Suggested fix: make the fold row resolvable as the end of its list. For a group, map it to its last member, or send it as a member row with isLastInGroup and siblingIndex = members.count - 1 so the exit fraction still works. For the loose list, map it to nodes.count. Alternatively, give the last shown member isLastInGroup = true when the fold row is closed. Add a resolver test for both rows.

2. A drop gap never opens when the target index belongs to a hidden Done member.
openGapIfNeeded matches on the exact model index. With the fold closed, the resolver's usual target "after the visible row X" is X.siblingIndex + 1. In the fixture that is b, d or g3, which are hidden, so gapY stays nil. This affects internal drags (o.gap = position) and external new-workspace proposals. Dragging below a or c in the loose list, or below g2 in the group, shows no gap at all, even though the drop still commits. Open the gap at the first drawn entry whose model index is >= gap.index (or before the fold row) instead of requiring an exact match.

3. Selecting a hidden Done workspace from somewhere other than the list leaves it undrawn.
Cmd-1…9 use itemOrder, which is model order and still includes the folded workspaces. The palette and the socket can also select them. The resulting selection change, with no row change, goes through patchSelection. Its only "needs layout" check is model.isInCollapsedGroup(id) && displayed.row(for:) == nil. A folded Done workspace isn't in a collapsed group, so newKey becomes nil, the patch returns true and nothing reloads. The active workspace isn't drawn or revealed, which breaks the PR's "the active workspace keeps its place" contract until some unrelated reload runs. Make the guard also return false when the new active workspace is a Done workspace with no displayed row (or, more generally, any listed workspace with no row while not filtering), and add a test next to the collapsed-group one.

Checked and fine

• visible, listsTabs and disclosure moved onto SidebarLayoutOptions unchanged. pathToMatch is the same algorithm, only computed while filtering, as before.
• foldingDone doesn't run while filtering, with the session tree, with the toggle off, or when nothing is Done. Order is kept: shown entries, then the fold, then the Done entries when the fold is open. isLastInGroup is right for the last Done row after an open fold.
• SidebarLayout+Fold: refusing to splice a group with Done members (falling back to the full layout) is safe. listOptions() never sets sessionTree, so with the tree on the splice is just refused more often than needed: conservative, not wrong. Groups without Done members splice exactly as before.
• movesRows returning true on a Done flip (when the toggle is on) makes patchWorkspaces lay out again, and markingDoneMovesTheRow covers it.
• All updated switch sites are exhaustive. SidebarDocDrag skips the fold row. The context menu targets the fold row's group or section. Drag start and rename ignore the fold row. Clicking it toggles openDoneFolds and reloads.
• SidebarDoneFoldRowView: DecorativeImageView chevron, disclosure-triangle role with label and expanded state, Palette colours under performWithTheme, iconRowSize exists. Fine.
• sidebar.doneFold.title: 21 locales, all %lld, all translated.

Nits

• appendDoneFold gives the fold row siblingIndex: 0. It is never resolved today, but any future consumer that reads siblingIndex from rows that have a group would treat it as member 0. Use the end index (or -1) instead.
• The SidebarDoneFoldTests.markingDoneMovesTheRow test changes the shared TunableStore without restoring the store's activation state. The suite is .serialized, but the global can still leak into other suites.
• When the person clicks another workspace, the previously active Done workspace stays drawn in place until the next reload. That's intentional calm movement, but the description should say so.

[teamleaderleo]

cmux-next crash-class rules / cmux-next crash-class rules is red on 9 of 9 fresh feat-cmux-next PR heads in the last 2:00:00, so it is most likely a base red, not this PR's. The base-reds lane has it; a base merge picks up the fix once it lands.

[cursor]

Bugbot needs on-demand usage enabled

Bugbot uses usage-based billing for this team and requires on-demand usage to be enabled.

A team admin can enable on-demand usage in the Cursor dashboard.

[teamleaderleo]

Review (claude-review-subagent): SHIP at 87531eb

All three findings from the earlier BLOCK are fixed. Read with local git only (incremental diff d5b9dd3..87531eb, plus the drag, tab-drop, settle and selection paths). Nothing was built or run.

Drag layouts. Every list layout built during a drag goes through options(includeGap:):

• internal drag: displayLayout and its reorder branch, updateDrag base, updateDocDrag geometry base
• tab drop: externalDragMoved and externalDragRefusal bases
• settle: shownDrag covers settling?.drag

So the resolver, the gap and the displayed rows all see the unfolded layout while drag, settling or external is set. With the Done rows back in their places, the BLOCK's (1) and (2) no longer apply. The list folds again on the first reload after the drag ends:

• plain drop and cancel: self.drag = nil, then reload
• document drop: settleDrop() clears settling before displayLayout() in the same reload
• external drag: endExternalDrag sets external = nil, then reload

The model-level layouts (VisibleRows, ItemOrder) stay folded, which is correct because they are not drag geometry.

Drag start. beginDrag reads the folded displayed (rowFrame, lift content, restFrame, grabOffset), then showDragLayout() switches to the unfolded layout before any updateDrag. After that, every hit test uses the new displayed/base pair. Values kept from the folded layout are used only for size, x and grab offset, not as y positions, so nothing resolves against stale frames. land takes its destination from the live row views or dropped(). If the dropped item folds away, the card finishes where it is.

Selection patch. The new early-out returns false only when the new active workspace is listed but not drawn. lists() is O(1) through rowIndex. Hidden-workspace mode already returned false via displayed.rows.isEmpty. The only other new reloads come from selecting into a collapsed section or a leaving row: these are rare, happen once per selection change, and an extra reload there is harmless. The fold keeps the active workspace in place (foldingDone), so the reload shows it.

Test. aDoneWorkspaceSelectedElsewhereShows is sound:

• the TunableStore activate, register and set pattern matches CompactTabStripTests
• the defer resets the override
• with external/drag/settling/landing all nil, patchSelection reaches the new check, and the test then reloads and checks the row

Optional: #require that the set returned .bool(true). The tunable already defaults to true.

Non-blocking notes:

1. externalDragMoved, first event: the code sets self.external and then, before any reload, maps point.y through the folded displayed but resolves it against an unfolded base. For that one event, the proposal and highlight can name the wrong row. A nil proposal also triggers no reload, so the mismatch lasts until the first non-nil proposal. It corrects itself on the next draggingUpdated. A simple fix: reload(animated: true) when external is first set and the fold hides rows.
2. Every drag start now unfolds every Done list. The fold defaults to on, so rows below jump at lift and fold back at drop. That is a lot of movement under "calm sidebar movement"; consider unfolding only while the pointer is near a fold, or mapping hidden indexes. This is a design choice, so it does not block.
3. A group drag: the card is the folded block (header plus non-Done members), but the slot from displayLayout holds every member. The slot is N rows taller than the card. This is cosmetic.

[teamleaderleo]

cmux-next guards / cmux-next localization debt ratchet is red on 13 of 15 fresh feat-cmux-next PR heads in the last 2:00:00, so it is most likely a base red, not this PR's. The base-reds lane has it; a base merge picks up the fix once it lands.

[teamleaderleo]

Review (claude-review-subagent): SHIP at 7c19da8

Scope: git diff 87531ebf0ef1..7c19da8f8742 (two commits since the last SHIP).

• Observation: foldsDone = SidebarTunables.doneFold.value is read in RenderState.init, which runs inside the ObservationStream { ObservationTrigger(RenderState(model, design)) } closure, so changing the tunable fires a new state. This is the same wiring as workspacesAsTabs. render counts a foldsDone change as rowsChanged, and the layout pass reads SidebarTunables.doneFold.value into SidebarLayoutOptions.foldsDone (SidebarModel.swift:526), so the list is laid out again with the new value.
• Layout: the chevron sits at titleLeading - labelCellPadding and the count starts at chevron.maxX + space1, so they no longer overlap. The name width is clamped with max(0, …), so it never goes negative. The old max(0, x - icon.width - space1) clamp is no longer needed because start doesn't depend on the icon width.
• Isolation: nothing new. The read happens in the same place, under the same isolation as the existing workspacesAsTabs read.

No blocking findings. Not built or run, per the review scope.

[blacksmith-sh]

Found 9 test failures on Blacksmith runners:

Failures

Test	View Logs
/tmp/tmp2m5pe5dy/summary-fail.json (live):/summary-fail.json (live):	View Logs
/tmp/tmpx7ityqkw/summary-missing.json (live):/summary-missing.json (live):	View Logs
[new_workspaces] debug.new_workspace timed 0 of 50 new workspace rows/ [new_workspaces] debug.new_workspace timed 0 of 50 new workspace rows	View Logs
[new_workspaces] the window draws no frames/[new_workspaces] the window draws no frames	View Logs
[tabs] debug.tab_switch timed 0 of 40 switches/ [tabs] debug.tab_switch timed 0 of 40 switches	View Logs
[tabs] the window draws no frames/[tabs] the window draws no frames	View Logs
convention violations found (ERROR lines above)./ convention violations found (ERROR lines above).	View Logs
test_a_file_a_test_reads_selects_that_test (main.PullRequestTiers.test_a_file_a_tes t_reads_selects_that_test)/ test_a_file_a_test_reads_selects_that_test (main.PullRequestTiers.test_a_file_a_tes t_reads_selects_that_test)	View Logs
test_a_shared_module_selects_its_dependents (main.PullRequestTiers.test_a_shared_mo dule_selects_its_dependents)/ test_a_shared_module_selects_its_dependents (main.PullRequestTiers.test_a_shared_mo dule_selects_its_dependents)	View Logs

^{Need help on this PR? Tag @codesmith-bot with what you need.}

[teamleaderleo]

Review (claude-review-subagent): SHIP at 1a7130a

Scope: only the new commit since the last SHIP (d77cefa..1a7130a). Read with local git and a Python json comparison; nothing built.

• git diff d77cefa..1a7130a touches only CmuxNextSidebar/Resources/Localizable.xcstrings (842/842 lines, a reorder).
• The parsed catalog at 1a7130a equals the one at d77cefa: same keys, same values, same top-level fields. Only key order changed.
• Against the merge base cb27a38 (git diff --numstat origin/feat-cmux-next...1a7130a): 131 additions, 0 deletions, one hunk. The only new key is sidebar.doneFold.title (21 localizations, en "Done (%lld)"). No base key was removed or changed, and base key order is kept.
• The file parses as JSON and ends with a newline, like base.

No findings.

[github-actions]

Shipped in:

• cmux NEXT nightly 1.0.0-nightly.3970568398401 (79dca53e69)