[saphid]

Problem

If you drag a thread to a spot in the Active list, settle it, and then press Undo, the thread comes back at the top of Active instead of where you put it.

Settling clears the thread's manual Active position (activeOrderKey), and un-settling doesn't restore it. Undo already restores the pin order and the snooze that settling clears. The Active position was the one placement it missed, on both web and mobile.

Real-client proof

With Settings → General → Working section off, drag Alpha between Beta and Gamma, settle it, then click the sidebar footer Undo control (⌘Z to undo). On this revision Undo is in the sidebar footer, not a toast. Base returns Alpha to the top; candidate restores the chosen position. Both results survive a full reload.

Before (base)

After (candidate)

Captured in the real web client with disposable Alpha/Beta/Gamma threads created through normal app commands; no model turns or projection writes. Same light theme, 800×480 viewport, initial selection and order. GIFs retain the complete sidebar and footer Undo, sample the recordings at 10 fps at original speed, and omit only the first 0.5 seconds of recorder startup. They make no timing or smoothness claim.

Baseline uses the exact c6ca6056 versions of threadUndo.ts, web useThreadActions.ts, and mobile useThreadListActions.ts overlaid on dbc60262; the rest of the isolated app is candidate. Candidate capture followed exact restoration of all three files and a clean worktree check.

Full-context recordings and reload screenshots

Before recording · After recording

Before after reload:

After after reload:

Change

The shared settle Undo plan (planThreadUndo in client-runtime) now restores the saved Active position right after un-settling, when the thread wasn't pinned. Pinned threads are still restored by their pin. The web and mobile Undo handlers send that step as thread.active.reorder. The server already accepts that command once the thread is un-settled.

Scope and approval

Very small, focused fix for an obvious bug, so no prior issue: Undo should put the thread back where it was, and it already does that for pinned threads. One shared plan step, plus the matching case in each client's Undo handler.

Overlap: I searched open and closed PRs and issues for settle Undo position or order, planThreadUndo, and reorderActive Undo, and found nothing. The open PRs that touch the same Undo code (#18170, #24917, #29628) don't change settle placement.

Verification

Current recovery merges main f2551583. The single conflict keeps main's silent sendPin path and the PR's reorderActive step. The four-file net contribution remains +39/-1.

• Focused web Undo and mobile action suites: 74 passed (30 web, 44 mobile).
• CI=true vp run check:changed in Boat passed: 113 tests across four files, seven package typechecks, format, lint, knip, and React compiler checks (seven assertions).
• Fresh independent Claude Opus 5.5/high read-only review completed without actionable findings on tree 467e22b1983597fe4474dd8428d97f9d8098b859 (T3 task d6194fc5-2b4f-4350-984d-4ae7c9162d8d). The reviewer inspected source/logs and did not rerun tests.
• The failing-first test, orchestrator transcript, and real-client media above are from the original contribution. The media was captured on dbc60262 and has not been recaptured after this merge. It shows drag → settle → Undo restoring the saved position, including after reload. Maria separately verified the original head through real browser commands and reload.
• Native mobile, Electron-specific behavior, and remote/tunnel connections were not exercised in this recovery. Current-head hosted CI is pending publication.

Reviewed with sol-loop: 1 round with GPT-6.1 Sol on high. Sol verdict: approved.

Real-client visual verification and evidence publication: GPT-6 Astra through Codex in T3 Code.

Created with Claude Opus 5.5 in Claude Code (T3 Code).

🤖 Generated with Claude Code

Conflict recovery by GPT-6.1 Sol/high in Codex through T3 Code; fresh independent review by Claude Opus 5.5.

[macroscopeapp]

Approvability

Verdict: Approved at 201f7e8

Macroscope's review found this PR approvable — Undoing settle restores the thread's previous Active-list placement instead of moving it to the top. The change is limited to reversible placement metadata, while ordinary unsettle behavior remains unchanged.

^{You can add or adjust custom eligibility rules. Learn more.}

[coderabbitai]

No actionable comments were generated in the recent review.

Walkthrough

Settle undo now restores the prior unsettled timestamp and, when available, the thread’s active order. Client command handling, server orchestration, and mobile and web undo handlers support these restoration steps.

Changes: Settle undo

Layer / File(s)	Summary
Plan settle undo restoration packages/client-runtime/src/state/threadUndo.ts, packages/contracts/src/orchestrationV2.ts	The undo plan includes the saved unsettled timestamp and active order key when available. The command contract accepts an optional nullable timestamp.
Pass and apply the restored timestamp packages/client-runtime/src/operations/commands.ts, packages/client-runtime/src/state/threadCommands.ts, apps/server/src/orchestration-v2/Orchestrator.ts, apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts	The client forwards the timestamp, optimistic state applies it, and orchestration validates and applies it. Server tests cover restoring a timestamp and clearing it with null.
Execute and verify settle undo apps/mobile/src/features/home/useThreadListActions.ts, apps/web/src/hooks/useThreadActions.ts, apps/web/src/hooks/useThreadActions.undo.test.ts	Mobile and web handlers forward the timestamp and execute active-order restoration steps. Web tests check the execution order and timestamp restoration behavior.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Change: Bug fix

Sequence Diagram(s)

sequenceDiagram
  participant UndoPlan as planThreadUndo
  participant WebAction as Web thread actions
  participant Runtime as Client runtime
  participant Orchestrator
  UndoPlan->>WebAction: unsettled timestamp and active order steps
  WebAction->>Runtime: unsettle with restoreUnsettledAt
  Runtime->>Orchestrator: thread.unsettle command
  Orchestrator-->>Runtime: updated thread state
  WebAction->>Runtime: reorderActive with orderKey

Loading

Suggested reviewers: juliusmarminge

Merge Risk: Minimal · up to 201f7

Undoing a settle now restores the thread's prior position and unsettled timestamp. The reported tests and manual verification support this, and no concrete merge-blocking risk was found.

Pre-merge checks: 4

Check name	Status	Explanation
Title check		The title names the main change: undoing a settle restores the thread to the position the user set. The changeset adds restoration of the saved Active order key (via a reorderActive undo step) and the…
Description check		The description follows the template closely. It has Problem, Change, Scope, and Verification sections. The Problem section states the bug and expected behavior, and the Change section explains the fi…
Linked Issues check		Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check		Check skipped because no linked issues were found for this pull request.

Full details: Title check

Explanation

The title names the main change: undoing a settle restores the thread to the position the user set. The changeset adds restoration of the saved Active order key (via a reorderActive undo step) and the unsettledAt timestamp on settle undo, which matches the title. It follows the conventional commit format used in the repository template.

Full details: Description check

Explanation

The description follows the template closely. It has Problem, Change, Scope, and Verification sections. The Problem section states the bug and expected behavior, and the Change section explains the fix across the shared plan and the web and mobile handlers. Scope explains why no issue is linked and states the overlap search. Verification lists focused test counts, a CI check run, a review, and media, and it states what was not exercised (native mobile, Electron, remote connections). The description is long and includes some process detail, but the required information is present.

Finishing Touches

Generate unit tests (beta)

• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Recent review info

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: main
• File: .coderabbit.config.ts
• Commit: 0487654
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Advanced
• Run ID: 5db5fd6b-f8cc-493d-b949-d1fb38f6d63c

Commits

Reviewing files that changed from the base of the PR and between c3862f5 and 201f7e8.

Files selected for processing: 9

• apps/mobile/src/features/home/useThreadListActions.ts
• apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts
• apps/server/src/orchestration-v2/Orchestrator.ts
• apps/web/src/hooks/useThreadActions.ts
• apps/web/src/hooks/useThreadActions.undo.test.ts
• packages/client-runtime/src/operations/commands.ts
• packages/client-runtime/src/state/threadCommands.ts
• packages/client-runtime/src/state/threadUndo.ts
• packages/contracts/src/orchestrationV2.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 1 remain after this review.

Dismissing prior approval to re-evaluate dbc6026

[maria-rcks]

Note

Written by gpt-6.1-sol on behalf of Maria

Verified in a real dev environment

verified as-is at dbc60262e576d31e55b2a8c9defb07c063dfb551 on a disposable linux vm.

• reproduced on exact github/main (e89abadaee70), in a separate worktree: drag alpha between beta and gamma, settle alpha, click the sidebar footer undo. alpha jumps to the top and stays there after reload.
• on the exact pr head, the same interaction restores beta / alpha / gamma and survives reload.
• used the real dev web app with the repository's playwright and /usr/bin/google-chrome. added a project pointing at a real git checkout through the ui, then created alpha, beta, and gamma with real codex gpt-6.1-sol turns. copied that app-created disposable state with both servers stopped. another real codex turn completed on the pr head. no mocks, fixtures, projection writes, or source overlays.
• nearby behavior: pinned placement and a one-hour snooze both restore after settle / undo and survive reload. unpin and wake also work afterward.
• vp i completed on both revisions. vp run check:changed FETCH_HEAD passed through blacksmith after fetching main and the candidate ancestry: format, lint, knip, typecheck (7 packages), tests (4 files), and react compiler (2 files).

actual browser websocket command sequence during the recorded interaction:

thread.active.reorder orderKey=k
thread.settle
thread.unsettle reason=user
thread.active.reorder orderKey=k

before, on main after undo and reload (crop of the three matching thread rows):

after, on the pr after undo and reload (same three thread records):

full-client gif recording of drag, settle, and footer undo, trimmed to the interaction at original speed. inspected the capture and checked this gif in the rendered comment:

runtime transcript

Not verified

native ios/android clients, electron shell/IPC, macos/windows-specific behavior, other providers, and remote/relay/tunnel connections were not exercised on this linux vm. no source changes were needed.

Dismissing prior approval to re-evaluate 201f7e8

[juliusmarminge]

Evidence

Real app, fresh synthetic Replay data on each commit. Web: Chromium, 1280×800, light theme. Working section off. Drag Alpha into Beta / Alpha / Gamma, Settle, immediately use footer Undo, reload. Repeat without a manual key using Zeta / Epsilon / Delta. Also verify pin restoration, snooze restoration, and the saved Active position after waking the restored snooze.

Native: iPhone 18 Pro simulator, iOS 27.2, light theme, 402×874 points; captures exclude the 62-point animated status bar. Start Gamma / Beta / Alpha; swipe Beta left to Settle, immediately Undo. Create fresh Delta/Epsilon/Zeta; long-press Zeta → More → Arrange → Move down to Epsilon / Zeta / Delta; Settle and Undo Zeta. Finally pin Zeta, Settle and Undo. Native stills matched another capture 500 ms later.

Base loses both manual and automatic placement in web and iOS. Head preserves both. Pin restoration works in both clients; web also demonstrates snooze restoration and preserved placement after waking. The stills below show post-Undo results; recordings show the actual interactions. Web recordings and snooze/wake stills use a 256×800 sidebar crop.

Capture	Before — 0487654fc8	After — 201f7e8bcb
Web manual position after Undo and reload
Web automatic order after Undo and reload
Web pin restored
Web snooze restored
Web placement after waking restored snooze
iOS automatic order after Undo
iOS manual position after Undo
iOS pin restored
Web manual and automatic recordings	Before recording	After recording
Web pin and snooze recordings	Before recording	After recording
iOS automatic, manual and pin recordings	Before recording	After recording

Web scenario · Pin/snooze scenario · Native driver and seed bundle · Native driver · Native instructions · Redacted run logs and web proof records