feat(sidebar): sync pinned thread order

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581

[f-trycua]

Pinned threads are global, but their order was fixed by creation time. This adds manual ordering that is stored by the server and follows the user across connected clients.

What changed

• add a version-skew-safe thread.pin.reorder command and thread.pin-reordered event
• persist an exact rational order so moving one thread only updates that thread
• add drag handles and keyboard drag support on web/desktop
• add Move up / Move down actions on web and mobile
• keep legacy clients and servers working through optional fields and a separate capability flag
• document the sidebar behavior and cover contracts, ordering, projections, persistence, web logic, and mobile rendering with focused tests

Screenshots

Before	After

The integrated browser pass moved “Review API changes” from third to first with the keyboard-accessible drag control, confirmed that only the moved thread received a persisted order, and verified the same order after a full reload.

Verification

• 254 focused tests across 11 files
• focused typechecks for contracts, client runtime, server, web, and mobile
• targeted lint and formatting checks for all changed files
• Cua Driver pass in standalone Chrome against isolated synthetic state

Related to #698.

Built with GPT-5 Codex in the Codex desktop harness.

---

Note

Medium Risk
Touches orchestration commands, persistence, and multi-client sync with optimistic UI and multi-thread compaction when rational gaps run out; gated by capability but mixed server versions can block reorder until updated.

Overview
Pinned threads used to sort by creation time only. This PR adds server-backed manual order that syncs across web, desktop, and mobile.

Backend: New PinnedThreadOrder rational positions, thread.pin.reorder / thread.pin-reordered, pinned_order on projections (migration 038), and a separate threadPinReordering capability so older pinning servers are not sent reorder commands. Unpin clears pinnedOrder. Client-runtime adds sortPinnedThreads and move helpers (mediant between neighbors, full-list compaction when gaps are exhausted).

Web: Sidebar v2 uses @dnd-kit drag on pinned rows (grip handle), context-menu move up/down, optimistic pending orders, parallel commands with rollback, and toasts when compaction needs all servers updated.

Mobile:Move up / Move down in the pinned thread overflow menu with the same ordering logic, in-flight guard, sequential apply/rollback, and alerts for unsupported environments.

Docs: New user guide for organizing threads; list rendering switches from creation-order sort to synced pinned order (with compatibility fallback).

^{Reviewed by Cursor Bugbot for commit 138c1d8. Bugbot is set up for automated code reviews on this repo. Configure here.}

Note

Add synced pinned thread reordering via drag-and-drop and context menu

• Introduces a PinnedThreadOrder rational-fraction type (e.g. 3/7) stored in the projection_threads table and carried through contracts, projections, and client state to represent an explicit server-synced pin position.
• Adds sortPinnedThreads, pinnedThreadOrderForMove, and pinnedThreadOrderUpdatesForMove utilities in threadSort.ts to compute new orders using mediants, with full-list compaction as a fallback when no representable value fits.
• Web sidebar (SidebarV2.tsx) gains drag-and-drop reordering via dnd-kit and context-menu 'Move up/down' actions; mobile (HomeScreen.tsx, ThreadNavigationSidebar.tsx) gains equivalent context-menu actions.
• Reordering is gated on the new threadPinReordering server capability flag; mixed-capability environments show an alert and unsupported environments return a typed ThreadPinReorderingUnsupportedError.
• Optimistic UI updates are applied immediately and rolled back on failure; compaction-required scenarios prompt a user alert before proceeding.
• Migration 038 adds the pinned_order column to projection_threads.

^{Macroscope summarized 138c1d8.}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 56403cff-effa-4cdc-a733-301b3a024692

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[macroscopeapp]

One finding: the new web reorder path reuses ThreadPinningUnsupportedError, whose caller-visible message describes pinning rather than pin reordering. Everything else (namespace subpath imports in the new migration, decider/projector event handling, contracts schema additions) follows the service conventions.

^{Posted via Macroscope — Effect Service Conventions}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR introduces a new feature (synced pinned thread order) with schema changes, new API commands/events, complex sorting algorithms, and cross-platform UI additions. An unresolved review comment also identifies a concurrency bug in the web implementation. New features of this scope warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[cursor]

Web reorder lacks in-flight lock

Medium Severity

movePinnedThread never guards against overlapping reorders. Mobile blocks with pinnedReorderInFlightRef, but web can start another drag or move-up/down while prior reorderPinnedThread calls and pendingPinnedOrderByKey updates are still in flight, so concurrent moves can compute ranks from a stale list and leave the synced order wrong.

^{Reviewed by Cursor Bugbot for commit 138c1d8. Configure here.}

[maria-rcks]

superseded by #5581