diff --git a/.agents/skills/test-t3-mobile/SKILL.md b/.agents/skills/test-t3-mobile/SKILL.md
index 66be80cd12312..f48bb0377ad94 100644
--- a/.agents/skills/test-t3-mobile/SKILL.md
+++ b/.agents/skills/test-t3-mobile/SKILL.md
@@ -38,8 +38,8 @@ This installs the dev client for the checkout's native fingerprint: from the
 device, the local cache, or the shared cache in seconds, building once only
 when no machine has that fingerprint yet (5-15 minutes, logged to the file it
 names). The device id may be omitted when exactly one device is booted. It
-prints one JSON line; on failure it names the next command. Authorized mobile
-verification includes that step unless the user prohibits it.
+prints one JSON line; on failure it names the next command. Mobile verification
+includes that step unless the user prohibits it.
 
 For a device you opened in an agent-device session elsewhere (a device pool,
 cloud, or remote host), run `vp run mobile:install <ios|android> --session <s>`
diff --git a/.github/VOUCHED.td b/.github/VOUCHED.td
index 353a1f41a2616..1c4ae817060a9 100644
--- a/.github/VOUCHED.td
+++ b/.github/VOUCHED.td
@@ -59,6 +59,7 @@ github:myacoub91
 github:naMqe-h
 github:nateEc
 github:naveed949
+github:nexxeln
 github:nmggithub
 github:Noojuno
 github:notkainoa
diff --git a/.github/workflows/agent-context-budget.yml b/.github/workflows/agent-context-budget.yml
index 9396d8e3e7a63..41efb7b69a5a2 100644
--- a/.github/workflows/agent-context-budget.yml
+++ b/.github/workflows/agent-context-budget.yml
@@ -51,5 +51,5 @@ jobs:
             echo "Accepted by the agent-context-increase label."
             exit 0
           fi
-          echo "::error file=$BUDGET::Agent context grew compared to main. Cut the added text, or ask a maintainer to add the agent-context-increase label."
+          echo "::error file=$BUDGET::Agent context grew compared to main. Cut the added text and rerun the evals that cover it (evals/README.md), or ask a maintainer to add the agent-context-increase label."
           exit 1
diff --git a/.github/workflows/mobile-fingerprint-label.yml b/.github/workflows/mobile-fingerprint-label.yml
new file mode 100644
index 0000000000000..45e4c9f2ad42d
--- /dev/null
+++ b/.github/workflows/mobile-fingerprint-label.yml
@@ -0,0 +1,189 @@
+name: Mobile Fingerprint Label
+
+# Trusted half of mobile-fingerprint-check.yml. That workflow runs PR code
+# (fork PRs included) with a read-only token and records which platforms'
+# fingerprints changed. This one runs from main with a write token and syncs
+# the "📱 Native Change" label. It never checks out or runs PR code.
+#
+# A PR can edit the check workflow it runs under, so the recorded result is
+# untrusted data: it is validated, and at worst a PR mislabels itself.
+
+on:
+  workflow_run:
+    workflows: [Mobile Fingerprint Check]
+    types: [completed]
+
+permissions:
+  contents: read
+
+jobs:
+  label:
+    name: Sync native change label
+    # A cancelled run was superseded by a newer push, whose run labels instead.
+    if: >-
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    permissions:
+      actions: read
+      contents: read
+      issues: write
+      pull-requests: write
+    steps:
+      - id: pr
+        name: Resolve the pull request behind the check
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const run = context.payload.workflow_run;
+            const { owner, repo } = context.repo;
+
+            const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {
+              owner,
+              repo,
+              run_id: run.id,
+              per_page: 100,
+            });
+            const results = artifacts.filter(
+              (artifact) => artifact.name === "fingerprint-result" && !artifact.expired,
+            );
+            if (results.length !== 1) {
+              core.info(`Expected one fingerprint-result artifact; found ${results.length}. Skipping.`);
+              return;
+            }
+
+            // workflow_run.pull_requests and the commit-to-PR lookup are both
+            // empty for fork PRs, so list open PRs by head owner and branch.
+            // Requiring the PR's current head to be the checked commit keeps a
+            // slow run for an older push from overwriting a newer result.
+            const open = await github.paginate(github.rest.pulls.list, {
+              owner,
+              repo,
+              state: "open",
+              head: `${run.head_repository?.owner?.login}:${run.head_branch}`,
+              per_page: 100,
+            });
+            const matching = open.filter(
+              (candidate) =>
+                candidate.state === "open" &&
+                candidate.head.sha === run.head_sha &&
+                candidate.head.ref === run.head_branch &&
+                candidate.head.repo?.full_name === run.head_repository?.full_name,
+            );
+            if (matching.length !== 1) {
+              core.info(`Expected one open PR at ${run.head_sha}; found ${matching.length}. Skipping.`);
+              return;
+            }
+
+            core.setOutput("artifact_id", String(results[0].id));
+            core.setOutput("pr_number", String(matching[0].number));
+
+      # Read the archive as bytes; never extract PR-produced files into a
+      # workspace this job runs code from.
+      - id: result
+        name: Read changed platforms
+        if: steps.pr.outputs.pr_number != ''
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+          ARTIFACT_ID: ${{ steps.pr.outputs.artifact_id }}
+        run: |
+          set -euo pipefail
+          gh api "repos/${GITHUB_REPOSITORY}/actions/artifacts/${ARTIFACT_ID}/zip" > "$RUNNER_TEMP/fingerprint-result.zip"
+          changed="$(unzip -p "$RUNNER_TEMP/fingerprint-result.zip" changed-platforms)"
+          if [[ ! "$changed" =~ ^((ios|android)( (ios|android))?)?$ ]]; then
+            echo "Unexpected changed-platforms value '$changed'." >&2
+            exit 1
+          fi
+          echo "changed_platforms=$changed" >> "$GITHUB_OUTPUT"
+
+      - name: Sync native change label
+        if: steps.pr.outputs.pr_number != ''
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.pr_number }}
+          CHANGED_PLATFORMS: ${{ steps.result.outputs.changed_platforms }}
+        with:
+          script: |
+            const managedLabel = {
+              name: "📱 Native Change",
+              color: "d93f0b",
+              description:
+                "Changes the native fingerprint; merging blocks production OTAs until a new store build ships.",
+            };
+            const nativeChanged = (process.env.CHANGED_PLATFORMS ?? "").trim() !== "";
+            const issueNumber = Number(process.env.PR_NUMBER);
+
+            try {
+              const { data: existing } = await github.rest.issues.getLabel({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                name: managedLabel.name,
+              });
+
+              if (
+                existing.color !== managedLabel.color ||
+                (existing.description ?? "") !== managedLabel.description
+              ) {
+                await github.rest.issues.updateLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: managedLabel.name,
+                  color: managedLabel.color,
+                  description: managedLabel.description,
+                });
+              }
+            } catch (error) {
+              if (error.status !== 404) {
+                throw error;
+              }
+
+              try {
+                await github.rest.issues.createLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: managedLabel.name,
+                  color: managedLabel.color,
+                  description: managedLabel.description,
+                });
+              } catch (createError) {
+                if (createError.status !== 422) {
+                  throw createError;
+                }
+              }
+            }
+
+            const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber,
+              per_page: 100,
+            });
+            const hasLabel = currentLabels.some((label) => label.name === managedLabel.name);
+
+            if (nativeChanged && !hasLabel) {
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                labels: [managedLabel.name],
+              });
+            } else if (!nativeChanged && hasLabel) {
+              try {
+                await github.rest.issues.removeLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber,
+                  name: managedLabel.name,
+                });
+              } catch (removeError) {
+                if (removeError.status !== 404) {
+                  throw removeError;
+                }
+              }
+            }
+
+            core.info(
+              `PR #${issueNumber}: native fingerprint ${nativeChanged ? `changed (${process.env.CHANGED_PLATFORMS})` : "unchanged"}`,
+            );
diff --git a/AGENTS.md b/AGENTS.md
index cff91bdc1d2be..27b3f5221458a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -98,7 +98,7 @@ An empty database is a bad test. Seed your worktree's `.t3` with a copy of real
 
 ## Verifying
 
-- Before you push, run `vp run check:changed`. It runs CI's fast checks for changed files: format, lint, knip, typecheck of affected packages and dependents, and tests beside changes. CI still runs the full test suites.
+- Before you push, run `vp run check:changed`. It runs CI's fast checks for changed files: format, lint, knip, typecheck of affected packages and dependents, tests beside changes, and the cross-file checks those miss. CI still runs the full test suites.
 - While you iterate, run `vp test run <files>`. For big files, add `-t "<name>"`.
 - Use `vp run typecheck`, not `npx tsc`; it caches per package. Both run tsc-rs (`typescript` is the `@tsc-rs/typescript` drop-in).
 - Run `node -e` snippets from `apps/server` or the owning package. `effect` does not resolve from the repo root.
@@ -135,11 +135,11 @@ An empty database is a bad test. Seed your worktree's `.t3` with a copy of real
   });
   ```
 
-- Upon request, user-visible frontend changes should get one integrated pass in a real client: `test-t3-app` for web, `test-t3-mobile` for mobile. The primary agent does this once after integrating. Subagents do not launch their own dev servers. Ask permission before doing computer use or spinning up browsers.
+- User-visible frontend changes should get one integrated pass in a real client: `test-t3-app` for web, `test-t3-mobile` for mobile. The primary agent does this once after integrating. Subagents do not launch their own dev servers.
 
 - Real agent turns cost money. To watch a turn stream through the pipeline and UI, use the free `Replay (dev)` provider that `vp run dev` registers; [test-t3-app](.agents/skills/test-t3-app/SKILL.md) shows how to start one. Use a real provider only when the change depends on that provider's behavior, and then pick its cheapest model, such as Haiku for Claude or Luna for Codex.
 
-For authorized mobile verification, a missing or outdated native client is an install step, not a blocker. Run `vp run mobile:install <ios|android> [device-id]` on the device host before starting Metro; it targets the only booted simulator or connected Android device when the id is omitted. It installs the dev client for this checkout's native fingerprint from the shared cache in seconds and builds only when no machine has built it yet, so prefer it over `expo run:*`, `xcodebuild`, or `gradlew`, which rebuild from scratch. Its stdout is one JSON line; build output goes to the log it names. See `test-t3-mobile` for the full workflow.
+For mobile verification, a missing or outdated native client is an install step, not a blocker. Run `vp run mobile:install <ios|android> [device-id]` on the device host before starting Metro; it targets the only booted simulator or connected Android device when the id is omitted. It installs the dev client for this checkout's native fingerprint from the shared cache in seconds and builds only when no machine has built it yet, so prefer it over `expo run:*`, `xcodebuild`, or `gradlew`, which rebuild from scratch. Its stdout is one JSON line; build output goes to the log it names. See `test-t3-mobile` for the full workflow.
 
 ## Evals
 
@@ -215,5 +215,4 @@ Architecture and its constraints: `docs/internals/overview.md`. Glossary: `docs/
 
 ## Additional tips
 
-- Don't verify with browsers or computer use unless the user explicitly agrees or requests it.
 - Security is important, but should not be over-indexed on, especially for dev mode/maintainer-only features.
diff --git a/README.md b/README.md
index 36f558a79dc60..6f6dab985e154 100644
--- a/README.md
+++ b/README.md
@@ -84,6 +84,16 @@ yay -S t3code-nightly-bin
 
 The AUR packaging is maintained in this repository under [`packaging/aur`](./packaging/aur).
 
+#### Nix (nixpkgs)
+
+```bash
+nix profile add github:NixOS/nixpkgs/nixos-unstable#t3code
+```
+
+The package is maintained in [nixpkgs](https://github.com/NixOS/nixpkgs/tree/nixos-unstable/pkgs/by-name/t3/t3code)
+and includes the desktop app (`t3code-desktop`) and the `t3` command.
+See [Nix installation](./docs/user/install.md#nix-nixpkgs) for NixOS configuration and updates.
+
 ## Some notes
 
 We are very very early in this project. Expect bugs.
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 728ab36f7fcb2..886ccf3cd798f 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@t3tools/desktop",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": true,
   "type": "module",
   "main": "dist-electron/boot.cjs",
@@ -22,7 +22,7 @@
     "@t3tools/tailscale": "workspace:*",
     "dbus-next": "0.10.2",
     "effect": "catalog:",
-    "electron": "44.9.3",
+    "electron": "44.10.0",
     "electron-store": "^8.2.0",
     "electron-updater": "^6.8.9",
     "electron-webauthn": "catalog:",
diff --git a/apps/desktop/src/coil/updateDelivery/UpdateDelivery.ts b/apps/desktop/src/coil/updateDelivery/UpdateDelivery.ts
index 24b4a206e86fb..ea1ec4df4a184 100644
--- a/apps/desktop/src/coil/updateDelivery/UpdateDelivery.ts
+++ b/apps/desktop/src/coil/updateDelivery/UpdateDelivery.ts
@@ -93,7 +93,7 @@ type DeliveryServices =
   | FileSystem.FileSystem
   | HttpClient.HttpClient;
 
-export const make = Effect.gen(function* () {
+const make = Effect.gen(function* () {
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
   const fileSystem = yield* FileSystem.FileSystem;
   const electronWindow = yield* ElectronWindow.ElectronWindow;
diff --git a/apps/desktop/src/coil/updateDelivery/connectionHealth.ts b/apps/desktop/src/coil/updateDelivery/connectionHealth.ts
index a51d0b44506b6..2e150093ce780 100644
--- a/apps/desktop/src/coil/updateDelivery/connectionHealth.ts
+++ b/apps/desktop/src/coil/updateDelivery/connectionHealth.ts
@@ -26,7 +26,7 @@ export const WATCHDOG_TIMEOUT_MS = SERVER_HEARTBEAT_INTERVAL_MS * 2.5;
 export const FLOOR_POLL_INTERVAL_MS = 15 * 60_000;
 
 /** Reconnect backoff. Capped low because the relay closes streams every 15 min by design. */
-export const RECONNECT_BASE_DELAY_MS = 1_000;
+const RECONNECT_BASE_DELAY_MS = 1_000;
 export const RECONNECT_MAX_DELAY_MS = 60_000;
 
 export type ConnectionVerdict =
diff --git a/apps/desktop/src/coil/updateDelivery/decision.ts b/apps/desktop/src/coil/updateDelivery/decision.ts
index c6748a130dd40..2076498fd760c 100644
--- a/apps/desktop/src/coil/updateDelivery/decision.ts
+++ b/apps/desktop/src/coil/updateDelivery/decision.ts
@@ -19,7 +19,7 @@ import {
  * fails during a build. It must never be treated as a commit hash — an app that believes its own
  * commit is "unknown" differs from every real manifest and would update on every payload, forever.
  */
-export const UNKNOWN_COMMIT_HASH = "unknown";
+const UNKNOWN_COMMIT_HASH = "unknown";
 
 export interface InstalledBuild {
   /** From `DesktopAppIdentity`. Absent for any build that has no embedded hash. */
diff --git a/apps/desktop/src/coil/updateDelivery/manifest.ts b/apps/desktop/src/coil/updateDelivery/manifest.ts
index c68922f9c6122..dc44e03abac46 100644
--- a/apps/desktop/src/coil/updateDelivery/manifest.ts
+++ b/apps/desktop/src/coil/updateDelivery/manifest.ts
@@ -57,7 +57,6 @@ export const UpdateManifest = Schema.Struct({
 });
 export type UpdateManifest = typeof UpdateManifest.Type;
 
-export const decodeUpdateManifest = Schema.decodeUnknownEffect(UpdateManifest);
 export const decodeUpdateManifestJson = Schema.decodeEffect(Schema.fromJsonString(UpdateManifest));
 
 export function findAssetForPlatform(
diff --git a/apps/desktop/src/coil/updateDelivery/restart.ts b/apps/desktop/src/coil/updateDelivery/restart.ts
index c15b1337ed058..a5ffb73b27604 100644
--- a/apps/desktop/src/coil/updateDelivery/restart.ts
+++ b/apps/desktop/src/coil/updateDelivery/restart.ts
@@ -18,7 +18,7 @@ import * as DesktopShutdown from "../../app/DesktopShutdown.ts";
  * enough that a hung one costs the user ten seconds rather than their whole session. The relaunch
  * is armed before the timer starts, so a forced exit still comes back up.
  */
-export const SHUTDOWN_GRACE = Duration.seconds(10);
+const SHUTDOWN_GRACE = Duration.seconds(10);
 
 export type RestartOutcome = "graceful" | "forced-after-timeout";
 
diff --git a/apps/desktop/src/ipc/methods/updates.ts b/apps/desktop/src/ipc/methods/updates.ts
index b2212609030d1..ca85ee8b0c417 100644
--- a/apps/desktop/src/ipc/methods/updates.ts
+++ b/apps/desktop/src/ipc/methods/updates.ts
@@ -23,11 +23,14 @@ export const getUpdateState = DesktopIpc.makeIpcMethod({
 
 export const setUpdateChannel = DesktopIpc.makeIpcMethod({
   channel: IpcChannels.UPDATE_SET_CHANNEL_CHANNEL,
-  payload: DesktopUpdateChannelSchema,
+  payload: Schema.Struct({
+    channel: DesktopUpdateChannelSchema,
+    minimumVersion: Schema.optional(Schema.String),
+  }),
   result: DesktopUpdateStateSchema,
-  handler: Effect.fn("desktop.ipc.updates.setChannel")(function* (channel) {
+  handler: Effect.fn("desktop.ipc.updates.setChannel")(function* ({ channel, minimumVersion }) {
     const updates = yield* DesktopUpdates.DesktopUpdates;
-    return yield* updates.setChannel(channel);
+    return yield* updates.setChannel(channel, { minimumVersion });
   }),
 });
 
@@ -43,11 +46,14 @@ export const downloadUpdate = DesktopIpc.makeIpcMethod({
 
 export const installUpdate = DesktopIpc.makeIpcMethod({
   channel: IpcChannels.UPDATE_INSTALL_CHANNEL,
-  payload: Schema.Void,
+  /** A version installs only that downloaded build, never one that replaced it. */
+  payload: Schema.UndefinedOr(Schema.String),
   result: DesktopUpdateActionResultSchema,
-  handler: Effect.fn("desktop.ipc.updates.install")(function* () {
+  handler: Effect.fn("desktop.ipc.updates.install")(function* (expectedVersion) {
     const updates = yield* DesktopUpdates.DesktopUpdates;
-    return yield* updates.install;
+    if (expectedVersion === undefined) return yield* updates.install;
+    const { accepted, completed, state } = yield* updates.installPrepared(expectedVersion);
+    return { accepted, completed, state };
   }),
 });
 
diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts
index d4e64148bb69e..571fb32dff636 100644
--- a/apps/desktop/src/preload.ts
+++ b/apps/desktop/src/preload.ts
@@ -278,11 +278,12 @@ contextBridge.exposeInMainWorld("desktopBridge", {
     };
   },
   getUpdateState: () => ipcRenderer.invoke(IpcChannels.UPDATE_GET_STATE_CHANNEL),
-  setUpdateChannel: (channel) =>
-    ipcRenderer.invoke(IpcChannels.UPDATE_SET_CHANNEL_CHANNEL, channel),
+  setUpdateChannel: (channel, minimumVersion) =>
+    ipcRenderer.invoke(IpcChannels.UPDATE_SET_CHANNEL_CHANNEL, { channel, minimumVersion }),
   checkForUpdate: () => ipcRenderer.invoke(IpcChannels.UPDATE_CHECK_CHANNEL),
   downloadUpdate: () => ipcRenderer.invoke(IpcChannels.UPDATE_DOWNLOAD_CHANNEL),
-  installUpdate: () => ipcRenderer.invoke(IpcChannels.UPDATE_INSTALL_CHANNEL),
+  installUpdate: (expectedVersion) =>
+    ipcRenderer.invoke(IpcChannels.UPDATE_INSTALL_CHANNEL, expectedVersion),
   cliCommand: {
     getState: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_GET_STATE_CHANNEL),
     install: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_INSTALL_CHANNEL),
diff --git a/apps/desktop/src/settings/DesktopAppSettings.ts b/apps/desktop/src/settings/DesktopAppSettings.ts
index 5767057b4a35d..a0624ced669ea 100644
--- a/apps/desktop/src/settings/DesktopAppSettings.ts
+++ b/apps/desktop/src/settings/DesktopAppSettings.ts
@@ -22,7 +22,7 @@ import {
   normalizeLinuxPasswordStorePreference,
   type LinuxPasswordStorePreference,
 } from "../linuxSecretStorage.ts";
-import { resolveDefaultDesktopUpdateChannel } from "../updates/updateChannels.ts";
+import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
 import { isValidDistroName } from "../wsl/wslPathParsing.ts";
 
 export interface DesktopSettings {
@@ -180,7 +180,7 @@ export class DesktopAppSettings extends Context.Service<
 export function resolveDefaultDesktopSettings(appVersion: string): DesktopSettings {
   return {
     ...DEFAULT_DESKTOP_SETTINGS,
-    updateChannel: resolveDefaultDesktopUpdateChannel(appVersion),
+    updateChannel: desktopUpdateChannelOf(appVersion),
   };
 }
 
diff --git a/apps/desktop/src/settings/DesktopClientSettings.test.ts b/apps/desktop/src/settings/DesktopClientSettings.test.ts
index ea351b6ceb2f4..ec5062f9105bf 100644
--- a/apps/desktop/src/settings/DesktopClientSettings.test.ts
+++ b/apps/desktop/src/settings/DesktopClientSettings.test.ts
@@ -64,6 +64,8 @@ const clientSettings: ClientSettings = {
   sidebarThreadSortOrder: "created_at",
   boringSidebarEnabled: false,
   boringSidebarMultilineRows: false,
+  threadDetailsUsageEnabled: false,
+  threadDetailsItems: {},
   legacySidebarEnabled: false,
   sidebarWorkingShelfEnabled: false,
   loadBalancingEnabled: false,
diff --git a/apps/desktop/src/updates/DesktopRemoteUpdates.test.ts b/apps/desktop/src/updates/DesktopRemoteUpdates.test.ts
index 253a015d8ec9e..1f5321148b77b 100644
--- a/apps/desktop/src/updates/DesktopRemoteUpdates.test.ts
+++ b/apps/desktop/src/updates/DesktopRemoteUpdates.test.ts
@@ -119,6 +119,239 @@ describe("DesktopRemoteUpdates", () => {
     );
   });
 
+  it.effect("switches to the requested track before preparing its release", () => {
+    // In-memory settings keep the channel write off real disk I/O.
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* Queue.offer(requests, {
+          ...request("req-switch"),
+          channel: "nightly",
+          targetVersion: "1.2.4-nightly.20261027.1",
+        });
+        yield* settle;
+        assert.equal((yield* updates.getState).channel, "nightly");
+
+        harness.emit("update-available", { version: "1.2.4-nightly.20261027.1" });
+        yield* settle;
+        harness.emit("update-downloaded", { version: "1.2.4-nightly.20261027.1" });
+        yield* settle;
+
+        const terminals = terminalReports(reports);
+        assert.deepEqual(
+          terminals.map((report) => [report.requestId, report.outcome]),
+          [["req-switch", "ready-to-install"]],
+        );
+        assert.equal(terminals[0]?.state.downloadedVersion, "1.2.4-nightly.20261027.1");
+      }),
+    );
+  });
+
+  it.effect(
+    "refuses a crossing whose feed has only an older build, and never offers it later",
+    () => {
+      const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+      return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+        Effect.gen(function* () {
+          const updates = yield* DesktopUpdates.DesktopUpdates;
+          const older = "1.2.4-nightly.20261020.1";
+          yield* Queue.offer(requests, {
+            ...request("req-older"),
+            channel: "nightly",
+            targetVersion: "1.2.4-nightly.20261027.1",
+          });
+          yield* settle;
+          // Answers the track change's check, then the request's own check.
+          harness.emit("update-available", { version: older });
+          yield* settle;
+          harness.emit("update-available", { version: older });
+          yield* settle;
+
+          assert.deepEqual(
+            terminalReports(reports).map((report) => [report.outcome, report.reason]),
+            [["failed", "The desktop app found no build of 1.2.4-nightly.20261027.1."]],
+          );
+          // The saved track is the user's intent; a retry picks it up from here.
+          assert.equal((yield* updates.getState).channel, "nightly");
+
+          // A plain update afterwards cannot reach the build the switch refused.
+          yield* Queue.offer(requests, request("req-plain"));
+          yield* settle;
+          harness.emit("update-available", { version: older });
+          yield* settle;
+          assert.isNull((yield* updates.getState).availableVersion);
+          assert.equal(harness.downloadCount(), 0);
+        }),
+      );
+    },
+  );
+
+  it.effect("only saves the track on a host already running the release", () => {
+    const harness = makeHarness({ savedChannel: "nightly" });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* Queue.offer(requests, {
+          ...request("req-track-only"),
+          channel: "latest",
+          targetVersion: "1.2.3",
+        });
+        yield* settle;
+        // Even with a newer build on the feed, the host only saves its track.
+        harness.emit("update-available", { version: "1.2.4" });
+        yield* settle;
+
+        assert.deepEqual(
+          terminalReports(reports).map((report) => report.outcome),
+          ["up-to-date"],
+        );
+        assert.equal((yield* updates.getState).channel, "latest");
+        assert.equal(harness.downloadCount(), 0);
+      }),
+    );
+  });
+
+  it.effect("drops a retained download below the switch's checked release", () => {
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        // Downloaded earlier on this Stable host, before the switch checked 1.2.5.
+        harness.emit("update-downloaded", { version: "1.2.4" });
+        yield* settle;
+        assert.equal((yield* updates.getState).downloadedVersion, "1.2.4");
+
+        yield* Queue.offer(requests, {
+          ...request("req-floor"),
+          channel: "latest",
+          targetVersion: "1.2.5",
+        });
+        yield* settle;
+        harness.emit("update-available", { version: "1.2.5" });
+        yield* settle;
+        harness.emit("update-downloaded", { version: "1.2.5" });
+        yield* settle;
+
+        assert.deepEqual(
+          terminalReports(reports).map((report) => [
+            report.outcome,
+            report.state.downloadedVersion,
+          ]),
+          [["ready-to-install", "1.2.5"]],
+        );
+      }),
+    );
+  });
+
+  it.effect("refuses to cross tracks remotely while WSL backends need their own checks", () => {
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void, wslBackend: true });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* Queue.offer(requests, {
+          ...request("req-wsl"),
+          channel: "nightly",
+          targetVersion: "1.2.4-nightly.20261027.1",
+        });
+        yield* settle;
+
+        assert.deepEqual(
+          terminalReports(reports).map((report) => report.outcome),
+          ["failed"],
+        );
+        assert.include(terminalReports(reports)[0]?.reason ?? "", "Switch it on that machine");
+        assert.equal((yield* updates.getState).channel, "latest");
+      }),
+    );
+  });
+
+  it.effect("fails a switch that leaves a same-track host below the checked release", () => {
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        yield* Queue.offer(requests, {
+          ...request("req-behind"),
+          channel: "latest",
+          targetVersion: "1.2.5",
+        });
+        yield* settle;
+        // The feed lags npm and has nothing newer than this host's 1.2.3.
+        harness.emit("update-not-available");
+        yield* settle;
+        harness.emit("update-not-available");
+        yield* settle;
+
+        assert.deepEqual(
+          terminalReports(reports).map((report) => [report.outcome, report.reason]),
+          [["failed", "The desktop app found no build of 1.2.5."]],
+        );
+      }),
+    );
+  });
+
+  it.effect("fails a crossing to an older-numbered Stable that the feed does not offer", () => {
+    const harness = makeHarness({
+      appVersion: "1.2.4-nightly.20261027.1",
+      beforeSetUpdateChannel: Effect.void,
+    });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        yield* Queue.offer(requests, {
+          ...request("req-to-stable"),
+          channel: "latest",
+          targetVersion: "1.2.3",
+        });
+        yield* settle;
+        harness.emit("update-not-available");
+        yield* settle;
+        harness.emit("update-not-available");
+        yield* settle;
+
+        // Still on Nightly, though the target is numbered below this build.
+        assert.deepEqual(
+          terminalReports(reports).map((report) => [report.outcome, report.reason]),
+          [["failed", "The desktop app found no build of 1.2.3."]],
+        );
+      }),
+    );
+  });
+
+  it.effect("accepts a newer build than the checked release on the requested track", () => {
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+    return runRemoteUpdatesTest(harness, ({ reports, requests }) =>
+      Effect.gen(function* () {
+        const newer = "1.2.4-nightly.20261028.2";
+        yield* Queue.offer(requests, {
+          ...request("req-newer"),
+          channel: "nightly",
+          targetVersion: "1.2.4-nightly.20261027.1",
+        });
+        yield* settle;
+        harness.emit("update-available", { version: newer });
+        yield* settle;
+        harness.emit("update-downloaded", { version: newer });
+        yield* settle;
+
+        assert.deepEqual(
+          terminalReports(reports).map((report) => [
+            report.outcome,
+            report.state.downloadedVersion,
+          ]),
+          [["ready-to-install", newer]],
+        );
+      }),
+    );
+  });
+
   it.effect("reports a failed outcome when quitAndInstall fails", () => {
     const harness = makeHarness({
       quitAndInstall: Effect.fail(
@@ -525,6 +758,42 @@ describe("DesktopRemoteUpdates", () => {
     );
   });
 
+  it.effect("cancels a track switch while its own feed check is still running", () => {
+    const releaseCheck = Deferred.makeUnsafe<void>();
+    const harness = makeHarness({
+      beforeSetUpdateChannel: Effect.void,
+      checkForUpdates: Deferred.await(releaseCheck),
+    });
+
+    return runRemoteUpdatesTest(harness, ({ requests, cancellations }) =>
+      Effect.gen(function* () {
+        yield* Queue.offer(requests, {
+          ...request("req-switch-cancel"),
+          channel: "nightly",
+          targetVersion: "1.2.4-nightly.20261027.1",
+        });
+        yield* settle;
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* Queue.offer(cancellations, {
+          version: 1,
+          type: "cancelDesktopUpdate",
+          requestId: "req-switch-cancel",
+        });
+        yield* settle;
+        // The next request starts without waiting for the cancelled switch's feed check.
+        yield* Queue.offer(requests, {
+          ...request("req-switch-back"),
+          channel: "latest",
+          targetVersion: "1.2.3",
+        });
+        yield* settle;
+
+        assert.equal((yield* updates.getState).channel, "latest");
+        yield* Deferred.succeed(releaseCheck, undefined);
+      }),
+    );
+  });
+
   it.effect("cancels an active preparation so the next request can run", () => {
     const releaseCheck = Deferred.makeUnsafe<void>();
     const harness = makeHarness({ checkForUpdates: Deferred.await(releaseCheck) });
diff --git a/apps/desktop/src/updates/DesktopRemoteUpdates.ts b/apps/desktop/src/updates/DesktopRemoteUpdates.ts
index cb606d8fbd253..560e2e78d4bb1 100644
--- a/apps/desktop/src/updates/DesktopRemoteUpdates.ts
+++ b/apps/desktop/src/updates/DesktopRemoteUpdates.ts
@@ -10,10 +10,13 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Queue from "effect/Queue";
 import * as Ref from "effect/Ref";
+import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
+import { compareSemverVersions } from "@t3tools/shared/semver";
 import type * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 
 import * as DesktopObservability from "../app/DesktopObservability.ts";
+import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
 import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts";
 import * as DesktopUpdates from "./DesktopUpdates.ts";
 import {
@@ -44,9 +47,13 @@ type CommitClaim =
 export const listen: Effect.Effect<
   void,
   never,
-  DesktopUpdates.DesktopUpdates | DesktopTelemetryPublisher.DesktopTelemetryPublisher | Scope.Scope
+  | DesktopUpdates.DesktopUpdates
+  | DesktopTelemetryPublisher.DesktopTelemetryPublisher
+  | DesktopBackendPool.DesktopBackendPool
+  | Scope.Scope
 > = Effect.gen(function* () {
   const updates = yield* DesktopUpdates.DesktopUpdates;
+  const backends = yield* DesktopBackendPool.DesktopBackendPool;
   const publisher = yield* DesktopTelemetryPublisher.DesktopTelemetryPublisher;
   const activeRequestIdRef = yield* Ref.make(Option.none<string>());
   const requestControlRef = yield* Ref.make<{
@@ -171,7 +178,59 @@ export const listen: Effect.Effect<
           return;
         }
         yield* Ref.set(activeRequestIdRef, Option.some(request.requestId));
-        yield* logInfo("remote update requested", { requestId: request.requestId });
+        yield* logInfo("remote update requested", {
+          requestId: request.requestId,
+          channel: request.channel,
+        });
+        // A switch saves its track first, so the step machine never sees the old track's offer.
+        // The saved track is the user's intent and stays even if this request fails: a track saved
+        // toward Stable never offers an older build outside a guarded switch.
+        if (request.channel !== undefined) {
+          // A reinstall restarts every backend, but the requesting server checked only its own
+          // database. A WSL backend keeps its own, so cross tracks only where all can be checked.
+          const current = yield* updates.getState;
+          if (
+            desktopUpdateChannelOf(current.currentVersion) !== request.channel &&
+            (yield* backends.list).length > 1
+          ) {
+            yield* publishReport(
+              current,
+              {
+                outcome: "failed",
+                reason:
+                  "This desktop app also runs WSL backends, whose databases a remote switch cannot check. Switch it on that machine.",
+              },
+              request.requestId,
+            );
+            return;
+          }
+          const switched = yield* Effect.raceFirst(
+            updates.setChannel(request.channel, { minimumVersion: request.targetVersion }).pipe(
+              Effect.as(true),
+              Effect.catch((error) =>
+                updates.getState.pipe(
+                  Effect.flatMap((state) =>
+                    publishReport(
+                      state,
+                      { outcome: "failed", reason: error.message },
+                      request.requestId,
+                    ),
+                  ),
+                  Effect.as(false),
+                ),
+              ),
+            ),
+            Deferred.await(cancellation).pipe(Effect.as(false)),
+          );
+          if (!switched) return;
+          // A host already running the target only needed its track saved; installing a newer
+          // build here would restart it without the dialog having said so.
+          const state = yield* updates.getState;
+          if (request.targetVersion === state.currentVersion) {
+            yield* publishReport(state, { outcome: "up-to-date" }, request.requestId);
+            return;
+          }
+        }
         const { latest, changes } = yield* updates.subscribe;
         const disabledReason = Option.getOrNull(yield* updates.disabledReason);
         let attempts: RemoteDesktopUpdateAttempts = { checks: 0, downloads: 0 };
@@ -184,6 +243,12 @@ export const listen: Effect.Effect<
             Effect.forkScoped,
           );
 
+        // A host leaving its build's track may need an older build, down to the checked release;
+        // the updater offers nothing below it.
+        const crossing = (state: DesktopUpdateState) =>
+          request.channel !== undefined &&
+          request.targetVersion !== undefined &&
+          desktopUpdateChannelOf(state.currentVersion) !== request.channel;
         const step = Effect.fn("DesktopRemoteUpdates.step")(function* (
           state: DesktopUpdateState,
         ): Effect.fn.Return<boolean, never, Scope.Scope> {
@@ -193,7 +258,7 @@ export const listen: Effect.Effect<
               return false;
             case "check":
               attempts = { ...attempts, checks: attempts.checks + 1 };
-              yield* updates.check("remote-update").pipe(
+              yield* updates.check("remote-update", { allowDowngrade: crossing(state) }).pipe(
                 Effect.flatMap((result) => {
                   if (result.checked) return Effect.void;
                   attempts = { ...attempts, checks: attempts.checks - 1 };
@@ -246,21 +311,34 @@ export const listen: Effect.Effect<
               yield* logInfo("remote update prepared", { requestId: request.requestId });
               return true;
             }
-            case "done":
+            case "done": {
+              // A switch that leaves the host on its old track, or below its checked release, did
+              // not reach it; a track-only host already at the release is done.
+              const done =
+                request.targetVersion !== undefined &&
+                next.outcome === "up-to-date" &&
+                (crossing(state) ||
+                  compareSemverVersions(state.currentVersion, request.targetVersion) < 0)
+                  ? {
+                      outcome: "failed" as const,
+                      reason: `The desktop app found no build of ${request.targetVersion}.`,
+                    }
+                  : next;
               yield* publishReport(
                 state,
                 {
-                  outcome: next.outcome,
-                  ...(next.reason === undefined ? {} : { reason: next.reason }),
+                  outcome: done.outcome,
+                  ...(done.reason === undefined ? {} : { reason: done.reason }),
                 },
                 request.requestId,
               );
               yield* logInfo("remote update finished", {
                 requestId: request.requestId,
-                outcome: next.outcome,
-                reason: next.reason ?? null,
+                outcome: done.outcome,
+                reason: done.reason ?? null,
               });
               return true;
+            }
           }
         });
 
diff --git a/apps/desktop/src/updates/DesktopUpdates.test.ts b/apps/desktop/src/updates/DesktopUpdates.test.ts
index d2f24143fc209..c6bcd46b8c206 100644
--- a/apps/desktop/src/updates/DesktopUpdates.test.ts
+++ b/apps/desktop/src/updates/DesktopUpdates.test.ts
@@ -2,6 +2,7 @@ import { assert, describe, it } from "@effect/vitest";
 import { DESKTOP_UPDATE_RESTART_MARKER_FILE } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
@@ -694,6 +695,65 @@ describe("DesktopUpdates", () => {
     ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
   });
 
+  it.effect("ignores a finished download from a track it no longer follows", () => {
+    const harness = makeHarness();
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        // A backed-out switch's download keeps reporting progress until it finishes.
+        harness.emit("download-progress", { percent: 40 });
+        yield* flushCallbacks;
+        harness.emit("update-downloaded", { version: "1.2.4-nightly.20261027.1" });
+        yield* flushCallbacks;
+
+        const state = yield* updates.getState;
+        assert.equal(state.downloadedVersion, null);
+        assert.notEqual(state.status, "downloading");
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("offers older releases only to checks that leave the running build's track", () => {
+    const harness = makeHarness({ beforeSetUpdateChannel: Effect.void });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        const before = harness.checkAllowedDowngrade.length;
+        yield* updates.setChannel("nightly");
+        yield* updates.setChannel("latest");
+        yield* updates.check("remote-update", { allowDowngrade: true });
+
+        // Back on its own Stable track the build never needs an older release.
+        assert.deepEqual(harness.checkAllowedDowngrade.slice(before), [true, false, true]);
+        assert.isFalse(harness.allowDowngrade());
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("re-checks a saved track that differs from the running build's track", () => {
+    const harness = makeHarness({
+      appVersion: "1.2.4-nightly.20261027.1",
+      beforeSetUpdateChannel: Effect.void,
+    });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        yield* updates.setChannel("latest");
+        const checks = harness.checkCount();
+
+        yield* updates.setChannel("latest");
+
+        assert.equal(harness.checkCount(), checks + 1);
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
   it.effect("does not persist an unchanged update channel as a user preference", () => {
     const harness = makeHarness();
 
@@ -713,6 +773,116 @@ describe("DesktopUpdates", () => {
     ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
   });
 
+  it.effect("offers nothing below a track switch's checked release", () => {
+    const harness = makeHarness({
+      appVersion: "1.2.4-nightly.20261027.1",
+      beforeSetUpdateChannel: Effect.void,
+    });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        yield* updates.setChannel("latest", { minimumVersion: "1.2.3" });
+
+        harness.emit("update-available", { version: "1.2.2" });
+        yield* flushCallbacks;
+        assert.isNull((yield* updates.getState).availableVersion);
+        harness.emit("update-downloaded", { version: "1.2.2" });
+        yield* flushCallbacks;
+        assert.isNull((yield* updates.getState).downloadedVersion);
+
+        harness.emit("update-available", { version: "1.2.3" });
+        yield* flushCallbacks;
+        assert.equal((yield* updates.getState).availableVersion, "1.2.3");
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("keeps a saved Stable track across a restart without offering an older release", () => {
+    // A Nightly build whose switch to Stable did not finish before the app quit.
+    const harness = makeHarness({ appVersion: "1.2.4-nightly.20261027.1", savedChannel: "latest" });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        yield* updates.check("startup");
+
+        assert.equal((yield* updates.getState).channel, "latest");
+        assert.deepEqual(harness.checkAllowedDowngrade, [false]);
+        // Semver ranks Stable 1.2.4 above this Nightly, but a Nightly built before the release's
+        // version bump can hold migrations 1.2.4 lacks. Crossing needs a guarded switch.
+        harness.emit("update-available", { version: "1.2.4" });
+        yield* flushCallbacks;
+        assert.isNull((yield* updates.getState).availableVersion);
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("keeps a saved Nightly track across a restart without crossing on its own", () => {
+    // A Stable build whose switch to Nightly was refused before the app quit; its floor is gone.
+    const harness = makeHarness({ savedChannel: "nightly" });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        yield* updates.check("startup");
+        harness.emit("update-available", { version: "1.2.4-nightly.20261027.1" });
+        yield* flushCallbacks;
+
+        assert.equal((yield* updates.getState).channel, "nightly");
+        assert.isNull((yield* updates.getState).availableVersion);
+        assert.deepEqual(harness.checkAllowedDowngrade, [false]);
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("never offers an older Nightly to a Nightly build's own checks", () => {
+    const harness = makeHarness({ appVersion: "1.2.4-nightly.20261027.1" });
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const updates = yield* DesktopUpdates.DesktopUpdates;
+        yield* updates.configure;
+        yield* updates.check("poll");
+
+        assert.equal((yield* updates.getState).channel, "nightly");
+        assert.deepEqual(harness.checkAllowedDowngrade, [false]);
+      }),
+    ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+  });
+
+  it.effect("waits out a background check instead of refusing a track change", () =>
+    Effect.gen(function* () {
+      const checkStarted = yield* Deferred.make<void>();
+      const releaseCheck = yield* Deferred.make<void>();
+      const harness = makeHarness({
+        beforeSetUpdateChannel: Effect.void,
+        checkForUpdates: Deferred.succeed(checkStarted, undefined).pipe(
+          Effect.andThen(Deferred.await(releaseCheck)),
+        ),
+      });
+
+      yield* Effect.scoped(
+        Effect.gen(function* () {
+          const updates = yield* DesktopUpdates.DesktopUpdates;
+          yield* updates.configure;
+          yield* updates.check("poll").pipe(Effect.forkScoped);
+          yield* Deferred.await(checkStarted);
+
+          const channelFiber = yield* updates.setChannel("nightly").pipe(Effect.forkScoped);
+          yield* Deferred.succeed(releaseCheck, undefined);
+          yield* TestClock.adjust(Duration.seconds(2));
+          const state = yield* Fiber.join(channelFiber);
+
+          assert.equal(state.channel, "nightly");
+        }),
+      ).pipe(Effect.provide(Layer.merge(TestClock.layer(), harness.layer)));
+    }),
+  );
+
   it.effect("rejects checks while an update channel change is being persisted", () =>
     Effect.gen(function* () {
       const channelChangeStarted = yield* Deferred.make<void>();
diff --git a/apps/desktop/src/updates/DesktopUpdates.ts b/apps/desktop/src/updates/DesktopUpdates.ts
index aeda73f2bfad3..3a0b41cd9e369 100644
--- a/apps/desktop/src/updates/DesktopUpdates.ts
+++ b/apps/desktop/src/updates/DesktopUpdates.ts
@@ -19,6 +19,7 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as PubSub from "effect/PubSub";
 import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
@@ -34,7 +35,8 @@ import * as ElectronWindow from "../electron/ElectronWindow.ts";
 import * as IpcChannels from "../ipc/channels.ts";
 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
 import { normalizeDesktopUpdateReleaseNotes } from "./releaseNotes.ts";
-import { resolveDefaultDesktopUpdateChannel } from "./updateChannels.ts";
+import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
+import { compareSemverVersions } from "@t3tools/shared/semver";
 import {
   createInitialDesktopUpdateState,
   reduceDesktopUpdateStateOnCheckFailure,
@@ -49,6 +51,8 @@ import {
   resolveNotAppliedInstallVersion,
 } from "./updateMachine.ts";
 
+const CHANNEL_CHANGE_RETRY_DELAY = Duration.seconds(1);
+const CHANNEL_CHANGE_RETRIES = 30;
 const AUTO_UPDATE_STARTUP_DELAY = "15 seconds";
 const AUTO_UPDATE_POLL_INTERVAL = "4 minutes";
 const PREPARED_INSTALL_CHECK_WAIT = Duration.seconds(90);
@@ -66,6 +70,7 @@ const UpdateInfo = Schema.Struct({
   version: Schema.String,
   // Malformed notes must not block update-state decoding; normalizeDesktopUpdateReleaseNotes validates separately.
   releaseNotes: Schema.optional(Schema.Unknown),
+  releaseDate: Schema.optional(Schema.String),
 });
 
 const DownloadProgressInfo = Schema.Struct({
@@ -179,10 +184,16 @@ export class DesktopUpdates extends Context.Service<
     readonly emitState: Effect.Effect<void>;
     readonly disabledReason: Effect.Effect<Option.Option<string>>;
     readonly configure: Effect.Effect<void, never, Scope.Scope>;
+    /** `minimumVersion` is a track switch's checked release; nothing older is offered after. */
     readonly setChannel: (
       channel: DesktopUpdateChannel,
+      options?: { readonly minimumVersion?: string | undefined },
     ) => Effect.Effect<DesktopUpdateState, DesktopUpdateSetChannelError>;
-    readonly check: (reason: string) => Effect.Effect<DesktopUpdateCheckResult>;
+    /** `allowDowngrade` is for a guarded track switch, which checked that older release. */
+    readonly check: (
+      reason: string,
+      options?: { readonly allowDowngrade?: boolean },
+    ) => Effect.Effect<DesktopUpdateCheckResult>;
     readonly download: Effect.Effect<DesktopUpdateActionResult>;
     readonly install: Effect.Effect<DesktopUpdateActionResult>;
     readonly installPrepared: (
@@ -351,6 +362,20 @@ export const make = Effect.gen(function* () {
   const updaterConfiguredRef = yield* Ref.make(false);
   const lastLoggedDownloadMilestoneRef = yield* Ref.make(-1);
   const notAppliedVersionRef = yield* Ref.make(Option.none<string>());
+  // The release a track switch's database check cleared. A build crosses to another track only
+  // through such a switch, and never below that release: version order alone cannot tell whether
+  // a Stable knows a Nightly's migrations.
+  const releaseFloorRef = yield* Ref.make(Option.none<string>());
+  const offerable = (version: string, state: DesktopUpdateState) =>
+    Ref.get(releaseFloorRef).pipe(
+      Effect.map(
+        (floor) =>
+          desktopUpdateChannelOf(version) === state.channel &&
+          (Option.isSome(floor)
+            ? compareSemverVersions(version, floor.value) >= 0
+            : desktopUpdateChannelOf(environment.appVersion) === state.channel),
+      ),
+    );
   const updateStateRef = yield* Ref.make<DesktopUpdateState>(
     createInitialDesktopUpdateState(
       environment.appVersion,
@@ -454,12 +479,13 @@ export const make = Effect.gen(function* () {
     const allowsPrerelease = channel === "nightly";
     yield* electronUpdater.setChannel(channel);
     yield* electronUpdater.setAllowPrerelease(allowsPrerelease);
-    yield* electronUpdater.setAllowDowngrade(allowsPrerelease);
+    // An older build can lack migrations this one ran. Only a guarded track switch's own check
+    // may offer one.
+    yield* electronUpdater.setAllowDowngrade(false);
     yield* electronUpdater.setFullChangelog(allowsPrerelease);
     yield* logUpdaterInfo("using update channel", {
       channel,
       allowPrerelease: allowsPrerelease,
-      allowDowngrade: allowsPrerelease,
       fullChangelog: allowsPrerelease,
     });
   });
@@ -467,6 +493,7 @@ export const make = Effect.gen(function* () {
   const checkForUpdates = Effect.fn("desktop.updates.checkForUpdates")(function* (
     reason: string,
     actionReservation: "acquire" | "held" = "acquire",
+    allowDowngrade = false,
   ) {
     yield* Effect.annotateCurrentSpan({ reason });
     if (yield* Ref.get(desktopState.quitting)) return false;
@@ -488,7 +515,11 @@ export const make = Effect.gen(function* () {
       yield* setState(reduceDesktopUpdateStateOnCheckStart(state, checkedAt));
       yield* logUpdaterInfo("checking for updates", { reason });
 
+      // The flag is shared updater state, so it flips only while this check holds the reservation.
+      const restoreDowngrade = yield* electronUpdater.allowDowngrade;
+      if (allowDowngrade) yield* electronUpdater.setAllowDowngrade(true);
       return yield* electronUpdater.checkForUpdates.pipe(
+        Effect.ensuring(electronUpdater.setAllowDowngrade(restoreDowngrade).pipe(Effect.ignore)),
         Effect.as(true),
         Effect.catchTags({
           ElectronUpdaterCheckForUpdatesError: Effect.fn(
@@ -849,8 +880,8 @@ export const make = Effect.gen(function* () {
       Effect.flatMap(
         Effect.fn("desktop.updates.applyUpdateAvailable")(function* (info) {
           const state = yield* Ref.get(updateStateRef);
-          if (resolveDefaultDesktopUpdateChannel(info.version) !== state.channel) {
-            yield* logUpdaterInfo("ignoring update that does not match selected channel", {
+          if (!(yield* offerable(info.version, state))) {
+            yield* logUpdaterInfo("ignoring update outside the selected channel or its floor", {
               version: info.version,
               channel: state.channel,
             });
@@ -865,6 +896,7 @@ export const make = Effect.gen(function* () {
             info.releaseNotes,
             info.version,
             state.channel,
+            info.releaseDate,
           );
           yield* setState(
             reduceDesktopUpdateStateOnUpdateAvailable(
@@ -986,6 +1018,20 @@ export const make = Effect.gen(function* () {
       Effect.flatMap(
         Effect.fn("desktop.updates.applyUpdateDownloaded")(function* (info) {
           const state = yield* Ref.get(updateStateRef);
+          // A download can finish after its track switch moved on; never offer that build.
+          if (!(yield* offerable(info.version, state))) {
+            yield* logUpdaterInfo("ignoring download outside the selected channel or its floor", {
+              version: info.version,
+              channel: state.channel,
+            });
+            // Its progress events left the updater "downloading", which would block every check.
+            if (state.status === "downloading") {
+              yield* setState(
+                reduceDesktopUpdateStateOnNoUpdate(state, yield* currentIsoTimestamp),
+              );
+            }
+            return;
+          }
           yield* setState(reduceDesktopUpdateStateOnDownloadComplete(state, info.version));
           yield* logUpdaterInfo("update downloaded", { version: info.version });
         }),
@@ -1092,9 +1138,17 @@ export const make = Effect.gen(function* () {
     }).pipe(Effect.withSpan("desktop.updates.configure")),
     setChannel: Effect.fn("desktop.updates.setChannel")(function* (
       nextChannel: DesktopUpdateChannel,
+      options?: { readonly minimumVersion?: string | undefined },
     ) {
       yield* Effect.annotateCurrentSpan({ channel: nextChannel });
-      const activeAction = yield* tryStartChannelChange;
+      // A background check holds the updater only briefly, so wait it out instead of refusing.
+      const activeAction = yield* tryStartChannelChange.pipe(
+        Effect.repeat({
+          while: (active) => Option.isSome(active) && active.value === "check",
+          schedule: Schedule.spaced(CHANNEL_CHANGE_RETRY_DELAY),
+          times: CHANNEL_CHANGE_RETRIES,
+        }),
+      );
       if (Option.isSome(activeAction)) {
         return yield* new DesktopUpdateActionInProgressError({
           action: activeAction.value === "install-recovery" ? "install" : activeAction.value,
@@ -1103,8 +1157,16 @@ export const make = Effect.gen(function* () {
       }
 
       return yield* Effect.gen(function* () {
+        yield* Ref.set(releaseFloorRef, Option.fromNullishOr(options?.minimumVersion));
         const state = yield* Ref.get(updateStateRef);
-        if (nextChannel === state.channel) {
+        const retained = state.downloadedVersion ?? state.availableVersion;
+        // A build from another track re-checks, so retrying a track switch finds an older release.
+        // So does a retained offer below the new floor, which must not install.
+        if (
+          nextChannel === state.channel &&
+          nextChannel === desktopUpdateChannelOf(environment.appVersion) &&
+          (retained === null || (yield* offerable(retained, state)))
+        ) {
           return state;
         }
 
@@ -1124,15 +1186,19 @@ export const make = Effect.gen(function* () {
         }
 
         yield* applyAutoUpdaterChannel(nextChannel);
-        const allowDowngrade = yield* electronUpdater.allowDowngrade;
-        yield* electronUpdater.setAllowDowngrade(true);
-        yield* checkForUpdates("channel-change", "held").pipe(
-          Effect.ensuring(electronUpdater.setAllowDowngrade(allowDowngrade).pipe(Effect.ignore)),
+        // Only leaving the running build's track can need an older release.
+        yield* checkForUpdates(
+          "channel-change",
+          "held",
+          nextChannel !== desktopUpdateChannelOf(environment.appVersion),
         );
         return yield* Ref.get(updateStateRef);
       }).pipe(Effect.ensuring(finishUpdateAction("channel")));
     }),
-    check: Effect.fn("desktop.updates.check")(function* (reason: string) {
+    check: Effect.fn("desktop.updates.check")(function* (
+      reason: string,
+      options?: { readonly allowDowngrade?: boolean },
+    ) {
       yield* Effect.annotateCurrentSpan({ reason });
       if (!(yield* Ref.get(updaterConfiguredRef))) {
         return {
@@ -1140,7 +1206,7 @@ export const make = Effect.gen(function* () {
           state: yield* Ref.get(updateStateRef),
         };
       }
-      const checked = yield* checkForUpdates(reason);
+      const checked = yield* checkForUpdates(reason, "acquire", options?.allowDowngrade === true);
       return {
         checked,
         state: yield* Ref.get(updateStateRef),
diff --git a/apps/desktop/src/updates/releaseNotes.test.ts b/apps/desktop/src/updates/releaseNotes.test.ts
index 028e42fa6e3b7..d88838439dba7 100644
--- a/apps/desktop/src/updates/releaseNotes.test.ts
+++ b/apps/desktop/src/updates/releaseNotes.test.ts
@@ -28,6 +28,7 @@ describe("normalizeDesktopUpdateReleaseNotes", () => {
       releaseNotes: [
         {
           version: "0.0.36-nightly.20260828.1213",
+          releasedAt: "2026-08-28",
           items: [
             "fix(opencode): handle child approvals, stops, and model catalogs by @human in #8480",
             "fix(web): keep long task drawers usable on small screens by @human in #8313",
@@ -60,6 +61,37 @@ describe("normalizeDesktopUpdateReleaseNotes", () => {
     });
   });
 
+  it("reads a generated summary as a note and skips the folded full list", () => {
+    const fixes = Array.from({ length: 9 }, (_, index) => `- Fix ${index + 1} (#${index + 1})`);
+    const result = normalizeDesktopUpdateReleaseNotes(
+      [
+        "**v1.2.4** · 12 changes from 3 contributors",
+        "## Highlights",
+        "Link machines (beta).",
+        "## Fixes",
+        ...fixes,
+        "<details>",
+        "<summary>Full changelog</summary>",
+        "* fix: raw entry by @human in https://github.com/pingdotgg/t3code/pull/1",
+        "</details>",
+      ].join("\n"),
+      "1.2.4",
+      "latest",
+      "2026-10-29T10:00:00.000Z",
+    );
+
+    expect(result.releaseNotes).toEqual([
+      {
+        version: "1.2.4",
+        releasedAt: "2026-10-29T10:00:00.000Z",
+        stats: "12 changes from 3 contributors",
+        intro: "Link machines (beta).",
+        items: fixes.map((_, index) => `Fix ${index + 1}`),
+        totalItems: 10,
+      },
+    ]);
+  });
+
   it("does not count Markdown or HTML section headings as changes", () => {
     const changes = Array.from({ length: 8 }, (_, index) => `Change ${index + 1}`);
     const result = normalizeDesktopUpdateReleaseNotes(
@@ -80,6 +112,35 @@ describe("normalizeDesktopUpdateReleaseNotes", () => {
     ]);
   });
 
+  it("reads handwritten notes with their own <details> as a list", () => {
+    const result = normalizeDesktopUpdateReleaseNotes(
+      "- Older fix\n- Newer fix\n<details><summary>Logs</summary>\n- hidden\n</details>",
+      "1.2.3",
+      "latest",
+    );
+
+    expect(result.releaseNotes).toEqual([
+      { version: "1.2.3", items: ["hidden", "Logs", "Newer fix", "Older fix"], totalItems: 4 },
+    ]);
+  });
+
+  it("dates the offered release from the feed and older nightlies by their build day", () => {
+    const result = normalizeDesktopUpdateReleaseNotes(
+      [
+        { version: "0.0.41-nightly.20260914.1707", note: "- Nightly change 2" },
+        { version: "0.0.41-nightly.20260913.1700", note: "- Nightly change 1" },
+      ],
+      "0.0.41-nightly.20260914.1707",
+      "nightly",
+      "2026-09-14T18:30:00.000Z",
+    );
+
+    expect(result.releaseNotes.map(({ releasedAt }) => releasedAt)).toEqual([
+      "2026-09-14T18:30:00.000Z",
+      "2026-09-13",
+    ]);
+  });
+
   it("drops releases from other trains before grouping on nightly", () => {
     const releaseNotes = [
       { version: "0.0.41-preview.20260914.1683", note: "- Maintainer test build" },
diff --git a/apps/desktop/src/updates/releaseNotes.ts b/apps/desktop/src/updates/releaseNotes.ts
index 69d710ff7b269..2704563cfc0b8 100644
--- a/apps/desktop/src/updates/releaseNotes.ts
+++ b/apps/desktop/src/updates/releaseNotes.ts
@@ -1,6 +1,6 @@
 import type { DesktopUpdateChannel, DesktopUpdateReleaseNote } from "@t3tools/contracts";
 
-import { resolveDefaultDesktopUpdateChannel } from "./updateChannels.ts";
+import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
 
 interface ElectronReleaseNoteInfo {
   readonly version: string;
@@ -93,11 +93,46 @@ function isIgnoredReleaseNoteLine(line: string): boolean {
 interface ExtractedReleaseNoteItems {
   readonly items: ReadonlyArray<string>;
   readonly totalItems: number;
+  readonly intro?: string;
+  readonly stats?: string;
+}
+
+/**
+ * Reads a generated summary (`scripts/generate-release-notes.ts`): a `v1.2.3 · N changes…`
+ * header, a highlights paragraph, and fix bullets. PR numbers are left to the GitHub page.
+ */
+function extractReleaseNoteSummary(summary: string): ExtractedReleaseNoteItems {
+  let stats: string | undefined;
+  const intro: string[] = [];
+  const items: string[] = [];
+  for (const rawLine of stripMarkup(summary).split("\n")) {
+    const line = rawLine.trim().replace(/\s+/g, " ");
+    if (line === "" || /^#{1,6}\s+/.test(line)) continue;
+    if (stats === undefined && /^v\S+ · /.test(line)) {
+      stats = line.slice(line.indexOf(" · ") + 3);
+      continue;
+    }
+    const text = line
+      .replace(/^[-*]\s+/, "")
+      .replace(/\s*\((?:#\d+(?:,\s*)?)+\)\.?$/, "")
+      .trim();
+    if (/^[-*]\s+/.test(line)) items.push(text);
+    else intro.push(text);
+  }
+  return {
+    items,
+    totalItems: items.length + intro.length,
+    ...(intro.length > 0 ? { intro: intro.join(" ") } : {}),
+    ...(stats ? { stats } : {}),
+  };
 }
 
 function extractReleaseNoteItems(note: string | null | undefined): ExtractedReleaseNoteItems {
   if (!note) return { items: [], totalItems: 0 };
 
+  // Generated summaries fold GitHub's full list under this exact <details> block.
+  const summaryEnd = note.search(/<details>\s*<summary>\s*Full changelog\s*<\/summary>/i);
+  if (summaryEnd >= 0) return extractReleaseNoteSummary(note.slice(0, summaryEnd));
   const items: string[] = [];
   let totalItems = 0;
   for (const rawLine of stripMarkup(note).split("\n")) {
@@ -117,6 +152,15 @@ function extractReleaseNoteItems(note: string | null | undefined): ExtractedRele
   return { items: items.toReversed(), totalItems };
 }
 
+// The update feed dates only the offered version; prerelease versions carry their UTC build day.
+const PRERELEASE_BUILD_DAY = /-(?:nightly|preview)\.(\d{4})(\d{2})(\d{2})\.\d+$/;
+
+function resolveReleasedAt(version: string, offeredVersion: string, releaseDate?: string) {
+  if (version === offeredVersion && releaseDate) return releaseDate;
+  const day = PRERELEASE_BUILD_DAY.exec(version);
+  return day ? `${day[1]}-${day[2]}-${day[3]}` : undefined;
+}
+
 interface NormalizedDesktopUpdateReleaseNotes {
   readonly releaseNotes: ReadonlyArray<DesktopUpdateReleaseNote>;
   readonly omittedReleaseCount: number;
@@ -127,6 +171,7 @@ export function normalizeDesktopUpdateReleaseNotes(
   releaseNotes: unknown,
   fallbackVersion: string,
   channel: DesktopUpdateChannel,
+  releaseDate?: string,
 ): NormalizedDesktopUpdateReleaseNotes {
   const rawNotes = (
     typeof releaseNotes === "string"
@@ -134,16 +179,20 @@ export function normalizeDesktopUpdateReleaseNotes(
       : Array.isArray(releaseNotes)
         ? releaseNotes.filter(isElectronReleaseNoteInfo)
         : []
-  ).filter((entry) => resolveDefaultDesktopUpdateChannel(entry.version) === channel);
+  ).filter((entry) => desktopUpdateChannelOf(entry.version) === channel);
 
   const normalizedNotes = rawNotes.flatMap((entry) => {
-    const { items, totalItems } = extractReleaseNoteItems(entry.note);
+    const { items, totalItems, intro, stats } = extractReleaseNoteItems(entry.note);
     if (totalItems === 0) return [];
+    const releasedAt = resolveReleasedAt(entry.version, fallbackVersion, releaseDate);
     return [
       {
         version: entry.version,
         items,
         totalItems,
+        ...(intro ? { intro } : {}),
+        ...(stats ? { stats } : {}),
+        ...(releasedAt ? { releasedAt } : {}),
       },
     ];
   });
diff --git a/apps/desktop/src/updates/updateChannels.ts b/apps/desktop/src/updates/updateChannels.ts
index d79a374a668a5..b07735ceb7a29 100644
--- a/apps/desktop/src/updates/updateChannels.ts
+++ b/apps/desktop/src/updates/updateChannels.ts
@@ -1,13 +1,6 @@
-import type { DesktopUpdateChannel } from "@t3tools/contracts";
-
-const NIGHTLY_VERSION_PATTERN = /^[^-+]+-nightly\.\d{8}\.\d+$/;
 // Preview builds share nightly branding but ship without an update feed.
 const PRERELEASE_VERSION_PATTERN = /^[^-+]+-(?:nightly|preview)\.\d{8}\.\d+$/;
 
 export function isNightlyDesktopVersion(version: string): boolean {
   return PRERELEASE_VERSION_PATTERN.test(version);
 }
-
-export function resolveDefaultDesktopUpdateChannel(appVersion: string): DesktopUpdateChannel {
-  return NIGHTLY_VERSION_PATTERN.test(appVersion) ? "nightly" : "latest";
-}
diff --git a/apps/desktop/src/updates/updatesTestHarness.ts b/apps/desktop/src/updates/updatesTestHarness.ts
index 1d8c21a42dfe5..d8d16b7dbfd62 100644
--- a/apps/desktop/src/updates/updatesTestHarness.ts
+++ b/apps/desktop/src/updates/updatesTestHarness.ts
@@ -35,6 +35,11 @@ export interface UpdatesHarnessOptions {
   readonly platform?: NodeJS.Platform;
   readonly packageType?: string | undefined;
   readonly installRecord?: string | undefined;
+  readonly appVersion?: string;
+  /** Starts from in-memory settings with this track saved, as after a restart. */
+  readonly savedChannel?: DesktopAppSettings.DesktopSettings["updateChannel"];
+  /** Adds a WSL backend beside the primary, as on a Windows host with WSL enabled. */
+  readonly wslBackend?: boolean;
 }
 
 export function makeHarness(options: UpdatesHarnessOptions = {}) {
@@ -42,6 +47,7 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
   let quitAndInstallCount = 0;
   let downloadCount = 0;
   let allowDowngrade = false;
+  const checkAllowedDowngrade: boolean[] = [];
   let fullChangelog = false;
   const feedUrls: ElectronUpdater.ElectronUpdaterFeedUrl[] = [];
   const listeners = new Map<string, Set<(...args: readonly unknown[]) => void>>();
@@ -86,6 +92,7 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
     setDisableDifferentialDownload: () => options.setDisableDifferentialDownload ?? Effect.void,
     checkForUpdates: Effect.sync(() => {
       checkCount += 1;
+      checkAllowedDowngrade.push(allowDowngrade);
     }).pipe(Effect.andThen(options.checkForUpdates ?? Effect.void)),
     downloadUpdate: Effect.sync(() => {
       downloadCount += 1;
@@ -149,7 +156,17 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
     waitForReady: () => Effect.succeed(true),
   };
   const layerBackend = DesktopBackendPool.layerTest(
-    options.backendInstances ?? [stubBackendInstance],
+    options.backendInstances ??
+      (options.wslBackend
+        ? [
+            stubBackendInstance,
+            {
+              ...stubBackendInstance,
+              id: DesktopBackendPool.BackendInstanceId("wsl:Ubuntu"),
+              label: Effect.succeed("Ubuntu"),
+            },
+          ]
+        : [stubBackendInstance]),
   );
 
   const layerEnvironment = DesktopEnvironment.layer({
@@ -157,7 +174,7 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
     homeDirectory: `/tmp/t3-desktop-updates-home-${process.pid}`,
     platform: options.platform ?? "darwin",
     processArch: "x64",
-    appVersion: "1.2.3",
+    appVersion: options.appVersion ?? "1.2.3",
     appPath: "/repo",
     isPackaged: true,
     resourcesPath: "/missing/resources",
@@ -178,10 +195,13 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
 
   let testSettings: DesktopAppSettings.DesktopSettings = {
     ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
+    ...(options.savedChannel === undefined
+      ? {}
+      : { updateChannel: options.savedChannel, updateChannelConfiguredByUser: true }),
   };
   const setUpdateChannelError = options.setUpdateChannelError;
   const layerSettings =
-    setUpdateChannelError || options.beforeSetUpdateChannel
+    setUpdateChannelError || options.beforeSetUpdateChannel || options.savedChannel
       ? Layer.succeed(DesktopAppSettings.DesktopAppSettings, {
           get: Effect.sync(() => testSettings),
           load: Effect.sync(() => testSettings),
@@ -279,6 +299,9 @@ export function makeHarness(options: UpdatesHarnessOptions = {}) {
     downloadCount: () => downloadCount,
     feedUrls: (): ElectronUpdater.ElectronUpdaterFeedUrl[] => feedUrls,
     fullChangelog: () => fullChangelog,
+    /** Whether each feed check could offer an older release, and the flag now. */
+    checkAllowedDowngrade,
+    allowDowngrade: () => allowDowngrade,
     listenerCount: () =>
       Array.from(listeners.values()).reduce(
         (total, eventListeners) => total + eventListeners.size,
diff --git a/apps/marketing/package.json b/apps/marketing/package.json
index 36dc282e89b47..e37dd8fb7a894 100644
--- a/apps/marketing/package.json
+++ b/apps/marketing/package.json
@@ -10,6 +10,7 @@
     "preview": "astro preview"
   },
   "dependencies": {
+    "@fontsource-variable/inter": "^5.3.0",
     "@t3tools/shared": "workspace:*",
     "astro": "^7.3.5",
     "sharp": "0.35.4"
diff --git a/apps/marketing/public/fonts/dm-sans-OFL.txt b/apps/marketing/public/fonts/dm-sans-OFL.txt
deleted file mode 100644
index a0eedfbf0df0e..0000000000000
--- a/apps/marketing/public/fonts/dm-sans-OFL.txt
+++ /dev/null
@@ -1,93 +0,0 @@
-Copyright 2014 The DM Sans Project Authors (https://github.com/googlefonts/dm-fonts)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-https://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded,
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/apps/marketing/public/fonts/jetbrains-mono-OFL.txt b/apps/marketing/public/fonts/jetbrains-mono-OFL.txt
deleted file mode 100644
index 821a3dac22aff..0000000000000
--- a/apps/marketing/public/fonts/jetbrains-mono-OFL.txt
+++ /dev/null
@@ -1,93 +0,0 @@
-Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-
-This license is copied below, and is also available with a FAQ at: https://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded,
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/apps/marketing/src/assets/app-desktop.webp b/apps/marketing/src/assets/app-desktop.webp
index 11b51331eef34..48c0c3e9abc50 100644
Binary files a/apps/marketing/src/assets/app-desktop.webp and b/apps/marketing/src/assets/app-desktop.webp differ
diff --git a/apps/marketing/src/assets/fonts/dm-sans-latin-ext.woff2 b/apps/marketing/src/assets/fonts/dm-sans-latin-ext.woff2
deleted file mode 100644
index 6e84cba1949cd..0000000000000
Binary files a/apps/marketing/src/assets/fonts/dm-sans-latin-ext.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/dm-sans-latin.woff2 b/apps/marketing/src/assets/fonts/dm-sans-latin.woff2
deleted file mode 100644
index c75f7bf1b4656..0000000000000
Binary files a/apps/marketing/src/assets/fonts/dm-sans-latin.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic-ext.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic-ext.woff2
deleted file mode 100644
index 289de93149abe..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic-ext.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic.woff2
deleted file mode 100644
index de39acbc40690..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-cyrillic.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-greek.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-greek.woff2
deleted file mode 100644
index a53d52d6d02cb..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-greek.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-latin-ext.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-latin-ext.woff2
deleted file mode 100644
index 82f96681c0762..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-latin-ext.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-latin.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-latin.woff2
deleted file mode 100644
index 4d09cda4a4c3f..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-latin.woff2 and /dev/null differ
diff --git a/apps/marketing/src/assets/fonts/jetbrains-mono-vietnamese.woff2 b/apps/marketing/src/assets/fonts/jetbrains-mono-vietnamese.woff2
deleted file mode 100644
index e38f5538f84e9..0000000000000
Binary files a/apps/marketing/src/assets/fonts/jetbrains-mono-vietnamese.woff2 and /dev/null differ
diff --git a/apps/marketing/src/layouts/Layout.astro b/apps/marketing/src/layouts/Layout.astro
index 6b4bf819e2d12..d1aea12f09bc9 100644
--- a/apps/marketing/src/layouts/Layout.astro
+++ b/apps/marketing/src/layouts/Layout.astro
@@ -2,8 +2,7 @@
 import { getImage, Image } from "astro:assets";
 import appIcon from "../assets/icon.webp";
 import socialCard from "../assets/social-card.webp";
-import dmSansLatinUrl from "../assets/fonts/dm-sans-latin.woff2?url";
-import "../styles/fonts.css";
+import "@fontsource-variable/inter";
 import {
   ANDROID_PLAY_STORE_URL,
   GITHUB_REPOSITORY_URL,
@@ -58,13 +57,6 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
     <meta name="twitter:description" content={description} />
     <meta name="twitter:image" content={socialImageUrl} />
     <meta name="twitter:image:alt" content={socialImageAlt} />
-    <link
-      rel="preload"
-      href={dmSansLatinUrl}
-      as="font"
-      type="font/woff2"
-      crossorigin="anonymous"
-    />
     <link rel="icon" href="/favicon.ico" sizes="48x48" />
     <link rel="icon" type="image/png" href="/favicon-32x32.png" sizes="32x32" />
     <link rel="icon" type="image/png" href="/favicon-16x16.png" sizes="16x16" />
@@ -153,22 +145,21 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
 
 <style is:global>
   :root {
-    --bg: #09090b;
-    --bg-elev: #0c0c0e;
-    --bg-card: #111113;
-    --fg: #fafafa;
-    --fg-muted: #a1a1aa;
-    --fg-dim: #71717a;
-    --fg-faint: #52525b;
+    --bg: #000;
+    --bg-elev: #0a0a0a;
+    --bg-card: #0d0d0d;
+    --fg: #f5f5f5;
+    --fg-muted: #a3a3a3;
+    --fg-dim: #737373;
+    --fg-faint: #525252;
     --border: rgba(255, 255, 255, 0.08);
     --border-strong: rgba(255, 255, 255, 0.14);
-    --accent-h: 250;
+    --accent-h: 264;
     --accent: oklch(0.68 0.17 var(--accent-h));
-    --accent-dim: oklch(0.68 0.17 var(--accent-h) / 0.15);
     --ok: oklch(0.72 0.16 150);
     --warn: oklch(0.76 0.15 75);
-    --font-sans: "DM Sans", -apple-system, BlinkMacSystemFont, system-ui, sans-serif;
-    --font-mono: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, monospace;
+    --font-sans: -apple-system, BlinkMacSystemFont, "Inter Variable", "Segoe UI", system-ui, sans-serif;
+    --font-mono: ui-monospace, "SF Mono", "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace;
     --radius: 12px;
     --radius-sm: 8px;
     --radius-lg: 16px;
@@ -189,7 +180,6 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
     background: var(--bg);
     color: var(--fg);
     font-family: var(--font-sans);
-    font-feature-settings: "ss01", "ss02";
     -webkit-font-smoothing: antialiased;
     -moz-osx-font-smoothing: grayscale;
     min-height: 100vh;
@@ -197,17 +187,6 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
     line-height: 1.5;
   }
 
-  body::after {
-    content: "";
-    position: fixed;
-    inset: 0;
-    pointer-events: none;
-    opacity: 0.035;
-    background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 256 256' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
-    background-repeat: repeat;
-    background-size: 256px 256px;
-    z-index: 9999;
-  }
 
   a {
     color: inherit;
@@ -238,8 +217,8 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
   }
 
   .display {
-    font-weight: 500;
-    letter-spacing: -0.035em;
+    font-weight: 600;
+    letter-spacing: -0.03em;
     line-height: 1.05;
   }
 
@@ -265,14 +244,14 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
   }
 
   .btn-primary {
-    background: var(--fg);
-    color: #09090b;
+    background: oklch(0.571 0.21 264);
+    color: #fff;
     font-weight: 600;
   }
 
   .btn-primary:hover {
     transform: translateY(-1px);
-    background: #fff;
+    background: oklch(0.62 0.2 264);
   }
 
   .btn-primary:active {
@@ -301,7 +280,7 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
     position: relative;
     border: 1px solid var(--border);
     border-radius: var(--radius);
-    background: linear-gradient(180deg, rgba(255, 255, 255, 0.015), rgba(255, 255, 255, 0));
+    background: var(--bg-card);
     overflow: hidden;
   }
 
@@ -419,21 +398,16 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
     align-items: center;
     gap: 7px;
     height: 36px;
-    padding: 0 14px;
-    border: 1px solid var(--border);
-    border-radius: 999px;
-    background: rgba(255, 255, 255, 0.02);
+    padding: 0 10px;
     color: var(--fg-muted);
     font-size: 13px;
     letter-spacing: -0.01em;
     white-space: nowrap;
-    transition: color 0.18s ease, border-color 0.18s ease, background 0.18s ease;
+    transition: color 0.18s ease;
   }
 
   .nav-stars:hover {
     color: var(--fg);
-    border-color: var(--border-strong);
-    background: rgba(255, 255, 255, 0.04);
   }
 
   .nav-stars strong {
@@ -492,7 +466,7 @@ const canonicalUrl = new URL(Astro.url.pathname, Astro.site);
 
   .footer-links a {
     font-size: 13px;
-    color: var(--fg-dim);
+    color: var(--fg-muted);
     transition: color 0.2s ease;
   }
 
diff --git a/apps/marketing/src/lib/site.ts b/apps/marketing/src/lib/site.ts
index 99cc56191659c..5cd1337d141f4 100644
--- a/apps/marketing/src/lib/site.ts
+++ b/apps/marketing/src/lib/site.ts
@@ -7,6 +7,6 @@ export const ANDROID_PLAY_STORE_URL =
   "https://play.google.com/store/apps/details?id=com.t3tools.t3code";
 
 export const MARKETING_STATS = {
-  githubStars: "24k+",
+  githubStars: "31k+",
   users: "500,000",
 } as const;
diff --git a/apps/marketing/src/pages/index.astro b/apps/marketing/src/pages/index.astro
index a4767e7bb4bca..d3f12d8541946 100644
--- a/apps/marketing/src/pages/index.astro
+++ b/apps/marketing/src/pages/index.astro
@@ -89,16 +89,11 @@ const mobileEndorsementRows = [
         <div class="hero-preview">
           <figure class="hero-screenshot-frame">
             <picture>
-              <!-- Match the hidden mobile layout without requesting a screenshot. -->
-              <source
-                media="(max-width: 820px)"
-                srcset="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
-              />
               <img
                 src={desktopScreenshot.src}
                 srcset={`${screenshot.srcSet.attribute}, ${desktopScreenshot.src} ${desktopScreenshot.width}w`}
                 sizes="(max-width: 960px) min(864px, calc(100vw - 20px)), min(1180px, calc(100vw - 60px))"
-                alt="T3 Code with a settled thread beside its pull request diff"
+                alt="T3 Code running Claude, Codex, Muse, and Gemini subagents in one thread"
                 width={desktopScreenshot.width}
                 height={desktopScreenshot.height}
                 loading="eager"
@@ -285,7 +280,7 @@ const mobileEndorsementRows = [
           </div>
           <div class="pr-foot">
             <span class="btn btn-ghost" style="font-size:12px;padding:6px 10px">View diff</span>
-            <span class="btn btn-primary" style="font-size:12px;padding:6px 12px">
+            <span class="btn btn-ghost" style="font-size:12px;padding:6px 12px">
               <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M12 .5C5.65.5.5 5.65.5 12a11.5 11.5 0 007.86 10.93c.58.1.79-.25.79-.56v-2c-3.2.69-3.88-1.37-3.88-1.37-.52-1.33-1.27-1.69-1.27-1.69-1.04-.71.08-.7.08-.7 1.15.08 1.76 1.18 1.76 1.18 1.02 1.76 2.68 1.25 3.33.96.1-.75.4-1.25.72-1.54-2.55-.29-5.24-1.27-5.24-5.67 0-1.25.45-2.28 1.18-3.08-.12-.29-.51-1.45.11-3.02 0 0 .96-.31 3.15 1.18a10.96 10.96 0 015.74 0c2.19-1.49 3.15-1.18 3.15-1.18.62 1.57.23 2.73.11 3.02.74.8 1.18 1.83 1.18 3.08 0 4.41-2.7 5.38-5.27 5.66.41.36.78 1.06.78 2.13v3.16c0 .31.21.67.8.56A11.5 11.5 0 0023.5 12C23.5 5.65 18.35.5 12 .5z"/></svg>
               Open pull request
             </span>
@@ -327,7 +322,6 @@ const mobileEndorsementRows = [
   <section id="open" class="sec-open">
     <div class="container">
       <div class="section-head open-head">
-        <div class="eyebrow">Open source</div>
         <h2>If you don't like something, fork it.</h2>
       </div>
 
@@ -406,7 +400,7 @@ const mobileEndorsementRows = [
 
           <span id="cta-download-label">Download for macOS</span>
         </a>
-        <a class="btn btn-ghost btn-lg" href="/download">Windows · Linux · other</a>
+        <a class="btn btn-ghost btn-lg" href="/download">Other platforms</a>
       </div>
     </div>
   </section>
@@ -489,12 +483,12 @@ const mobileEndorsementRows = [
 <style>
   section {
     position: relative;
-    padding: 96px 0;
+    padding: 80px 0;
     border-top: 1px solid var(--border);
   }
 
   .section-head {
-    margin-bottom: 56px;
+    margin-bottom: 40px;
     max-width: 720px;
   }
 
@@ -505,8 +499,8 @@ const mobileEndorsementRows = [
 
   .section-head h2 {
     font-size: clamp(32px, 4vw, 48px);
-    font-weight: 500;
-    letter-spacing: -0.035em;
+    font-weight: 600;
+    letter-spacing: -0.03em;
     line-height: 1.05;
     margin-bottom: 18px;
   }
@@ -550,8 +544,8 @@ const mobileEndorsementRows = [
     inset: 0;
     pointer-events: none;
     background-image:
-      linear-gradient(to right, rgba(255, 255, 255, 0.035) 1px, transparent 1px),
-      linear-gradient(to bottom, rgba(255, 255, 255, 0.035) 1px, transparent 1px);
+      linear-gradient(to right, rgba(255, 255, 255, 0.018) 1px, transparent 1px),
+      linear-gradient(to bottom, rgba(255, 255, 255, 0.018) 1px, transparent 1px);
     background-size: 48px 48px;
     mask-image: radial-gradient(ellipse 80% 60% at 50% 40%, black 40%, transparent 100%);
     -webkit-mask-image: radial-gradient(ellipse 80% 60% at 50% 40%, black 40%, transparent 100%);
@@ -574,10 +568,11 @@ const mobileEndorsementRows = [
   .hero-sub {
     color: var(--fg-muted);
     font-size: clamp(16px, 1.4vw, 19px);
-    max-width: 640px;
+    max-width: 720px;
     margin: 0 auto 36px;
     letter-spacing: -0.005em;
     line-height: 1.55;
+    text-wrap: balance;
   }
 
   .hero-actions {
@@ -622,7 +617,7 @@ const mobileEndorsementRows = [
     display: inline-flex;
     align-items: center;
     gap: 6px;
-    color: var(--fg-dim);
+    color: var(--fg-muted);
     font-size: 13px;
     letter-spacing: -0.005em;
   }
@@ -630,7 +625,7 @@ const mobileEndorsementRows = [
   .hero-mobile-line a {
     color: var(--fg-muted);
     text-decoration: underline;
-    text-decoration-color: rgba(161, 161, 170, 0.4);
+    text-decoration-color: rgba(163, 163, 163, 0.4);
     text-underline-offset: 3px;
     transition: color 0.18s ease, text-decoration-color 0.18s ease;
   }
@@ -679,15 +674,10 @@ const mobileEndorsementRows = [
     width: 100%;
     height: 100%;
     border-radius: 25%;
-    background: radial-gradient(circle at 30% 25%, var(--tint, rgba(255, 255, 255, 0.08)), rgba(20, 20, 24, 0.92) 65%);
+    background: var(--bg-card);
     border: 1px solid var(--border);
-    box-shadow:
-      0 20px 48px -16px rgba(0, 0, 0, 0.65),
-      0 2px 0 0 rgba(255, 255, 255, 0.04) inset;
-    animation:
-      mark-in 1s cubic-bezier(0.2, 0.7, 0.2, 1) var(--d) both,
-      mark-drift var(--dur) ease-in-out calc(var(--d) + 1s) infinite;
-    animation-play-state: running, var(--home-motion-state, paused);
+    box-shadow: 0 12px 32px -16px rgba(0, 0, 0, 0.65);
+    animation: mark-in 1s cubic-bezier(0.2, 0.7, 0.2, 1) var(--d) both;
   }
 
   .hero-float-card img {
@@ -701,17 +691,13 @@ const mobileEndorsementRows = [
     from { opacity: 0; transform: translate(var(--fx), var(--fy)) rotate(calc(var(--rot) + 24deg)) scale(0.6); }
     to { opacity: 1; transform: translate(0, 0) rotate(var(--rot)) scale(1); }
   }
-  @keyframes mark-drift {
-    0%, 100% { transform: translate(0, 0) rotate(var(--rot)); }
-    50% { transform: translate(var(--dx), var(--dy)) rotate(calc(var(--rot) + var(--wob))); }
-  }
 
-  .hf-opencode    { --x: max(-300px, -19vw); --y: 20px; --s: 64px; --rot: 6deg; --depth: 0.6; --d: 620ms; --dur: 8.5s; --dx: 2px; --dy: -8px; --wob: 3deg; --fx: -40px; --fy: -80px; }
-  .hf-antigravity { --x: min(300px, 19vw); --y: 20px; --s: 64px; --rot: -5deg; --depth: 0.6; --d: 580ms; --dur: 9.8s; --dx: -2px; --dy: -9px; --wob: -3deg; --fx: 40px; --fy: -80px; }
-  .hf-claude   { --x: max(-560px, -38vw); --y: 128px; --s: 96px; --rot: -8deg; --depth: 1.2; --d: 380ms; --dur: 10.5s; --dx: 4px; --dy: -12px; --wob: -2deg; --fx: -160px; --fy: -40px; --tint: rgba(217, 119, 87, 0.22); }
-  .hf-codex    { --x: min(560px, 38vw); --y: 128px; --s: 96px; --rot: 7deg; --depth: 1.2; --d: 460ms; --dur: 9.2s; --dx: -4px; --dy: -10px; --wob: 2deg; --fx: 160px; --fy: -40px; }
-  .hf-grok     { --x: max(-440px, -30vw); --y: 440px; --s: 80px; --rot: 4deg; --depth: 0.9; --d: 540ms; --dur: 11.5s; --dx: 3px; --dy: -9px; --wob: -3deg; --fx: -120px; --fy: 80px; }
-  .hf-cursor   { --x: min(440px, 30vw); --y: 440px; --s: 80px; --rot: -5deg; --depth: 0.9; --d: 700ms; --dur: 7.8s; --dx: -3px; --dy: -11px; --wob: 3deg; --fx: 120px; --fy: 80px; }
+  .hf-opencode    { --x: max(-300px, -19vw); --y: 20px; --s: 64px; --rot: 6deg; --depth: 0.6; --d: 620ms; --fx: -40px; --fy: -80px; }
+  .hf-antigravity { --x: min(300px, 19vw); --y: 20px; --s: 64px; --rot: -5deg; --depth: 0.6; --d: 580ms; --fx: 40px; --fy: -80px; }
+  .hf-claude   { --x: max(-560px, -38vw); --y: 128px; --s: 96px; --rot: -8deg; --depth: 1.2; --d: 380ms; --fx: -160px; --fy: -40px; }
+  .hf-codex    { --x: min(560px, 38vw); --y: 128px; --s: 96px; --rot: 7deg; --depth: 1.2; --d: 460ms; --fx: 160px; --fy: -40px; }
+  .hf-grok     { --x: max(-440px, -30vw); --y: 440px; --s: 80px; --rot: 4deg; --depth: 0.9; --d: 540ms; --fx: -120px; --fy: 80px; }
+  .hf-cursor   { --x: min(440px, 30vw); --y: 440px; --s: 80px; --rot: -5deg; --depth: 0.9; --d: 700ms; --fx: 120px; --fy: 80px; }
 
   @media (prefers-reduced-motion: reduce) {
     .hero-float-card { animation: none; transform: rotate(var(--rot)); }
@@ -726,15 +712,16 @@ const mobileEndorsementRows = [
   @media (max-width: 820px) {
     .hero {
       padding-top: 132px;
+      padding-bottom: 32px;
     }
 
     .hero-title {
-      font-size: clamp(40px, 11vw, 56px);
+      font-size: clamp(32px, 9.2vw, 56px);
       margin-top: 14px;
     }
 
     .hero-actions {
-      margin-bottom: 96px;
+      margin-bottom: 40px;
     }
 
     /* Four above the headline, two beside the CTA. Keeps the copy clear. */
@@ -754,21 +741,16 @@ const mobileEndorsementRows = [
   .hero-preview {
     max-width: 1180px;
     margin: 0 auto;
-    transform: perspective(2000px) rotateX(2deg);
-    transition: transform 0.6s ease;
-  }
-
-  .hero-preview:hover {
-    transform: perspective(2000px) rotateX(0deg);
   }
 
   .hero-screenshot-frame {
     position: relative;
     overflow: hidden;
     aspect-ratio: 2880 / 1800;
-    border-radius: 14px;
-    background: #0a0a0c;
-    box-shadow: 0 28px 64px -28px rgba(0, 0, 0, 0.75);
+    border-radius: 12px;
+    background: #000;
+    /* The screenshot is true black like the page, so this edge defines the window. */
+    box-shadow: 0 0 0 1px var(--border-strong);
   }
 
   .hero-screenshot-frame picture {
@@ -785,8 +767,6 @@ const mobileEndorsementRows = [
     object-position: center top;
   }
 
-  .sec-harness { background: #09090b; }
-
   .harness-grid {
     display: grid;
     grid-template-columns: repeat(6, 1fr);
@@ -800,7 +780,6 @@ const mobileEndorsementRows = [
     padding: 22px 20px;
     display: flex; align-items: center; gap: 14px;
     border-right: 1px solid var(--border);
-    background: linear-gradient(180deg, rgba(255, 255, 255, 0.015), transparent);
     transition: background 0.2s ease;
   }
   .harness:last-child { border-right: 0; }
@@ -820,13 +799,14 @@ const mobileEndorsementRows = [
   }
   .harness-tag {
     font-family: var(--font-mono);
-    font-size: 11px; color: var(--fg-dim);
+    font-size: 11px; color: var(--fg-muted);
+    white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
   }
 
   .harness-footer {
     display: flex; gap: 24px; flex-wrap: wrap;
     margin-top: 28px; padding-top: 24px;
-    border-top: 1px dashed var(--border);
+    border-top: 1px solid var(--border);
     font-size: 13px; color: var(--fg-muted);
   }
   .harness-footer-item {
@@ -841,13 +821,13 @@ const mobileEndorsementRows = [
 
   .endorsements-head {
     max-width: 720px;
-    margin-bottom: 56px;
+    margin-bottom: 40px;
   }
 
   .endorsements-head h2 {
     font-size: clamp(32px, 4vw, 48px);
-    font-weight: 500;
-    letter-spacing: -0.035em;
+    font-weight: 600;
+    letter-spacing: -0.03em;
     line-height: 1.05;
     margin-bottom: 18px;
   }
@@ -946,7 +926,7 @@ const mobileEndorsementRows = [
     gap: 10px;
     border: 1px solid var(--border);
     border-radius: 10px;
-    background: rgba(255, 255, 255, 0.012);
+    background: var(--bg-elev);
     transition:
       border-color 0.18s ease,
       background 0.18s ease;
@@ -1017,16 +997,11 @@ const mobileEndorsementRows = [
   }
   .pr-head svg { color: var(--ok); }
   .pr-title { font-weight: 500; font-size: 15px; flex: 1; }
-  .pr-status {
-    font-family: var(--font-mono); font-size: 10px;
-    color: var(--ok); padding: 2px 8px;
-    border: 1px solid var(--ok); border-radius: 999px;
-    letter-spacing: 0.08em; text-transform: uppercase;
-  }
+  .pr-status { font-size: 12px; font-weight: 500; color: var(--ok); }
   .pr-meta {
     display: flex; gap: 14px;
     font-family: var(--font-mono); font-size: 11px;
-    color: var(--fg-dim); margin-bottom: 14px; flex-wrap: wrap;
+    color: var(--fg-muted); margin-bottom: 14px; flex-wrap: wrap;
   }
   .pr-meta span { display: inline-flex; align-items: center; gap: 5px; }
   .pr-files {
@@ -1034,13 +1009,14 @@ const mobileEndorsementRows = [
     overflow: hidden; margin-bottom: 16px;
   }
   .pr-files > div {
-    display: flex; justify-content: space-between;
+    display: flex; justify-content: space-between; gap: 12px;
     padding: 8px 12px; font-family: var(--font-mono);
     font-size: 11px; border-top: 1px solid var(--border);
     color: var(--fg-muted);
   }
   .pr-files > div:first-child { border-top: 0; }
-  .pr-files span { color: var(--fg-dim); }
+  .pr-files code { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .pr-files span { flex: none; color: var(--fg-dim); }
   .pr-foot { display: flex; justify-content: flex-end; gap: 8px; }
 
   .pr-trail {
@@ -1054,18 +1030,17 @@ const mobileEndorsementRows = [
   }
   .pr-trail-line {
     width: 1px; height: 28px;
-    background: linear-gradient(180deg, var(--border-strong), var(--accent));
+    background: var(--border-strong);
   }
 
   .pr-button-shell { display: flex; justify-content: center; }
   .pr-button {
     display: inline-flex; align-items: center; gap: 10px;
     padding: 12px 20px;
-    background: var(--fg); color: #09090b;
+    background: var(--fg); color: #000;
     font-weight: 600; font-size: 13px;
     line-height: normal;
     border-radius: 10px;
-    box-shadow: 0 8px 24px -8px rgba(255, 255, 255, 0.2);
   }
   .pr-button-kbd {
     font-family: var(--font-mono); font-size: 10px;
@@ -1075,7 +1050,7 @@ const mobileEndorsementRows = [
 
   .open-head {
     text-align: center;
-    margin: 0 auto 56px;
+    margin: 0 auto 40px;
   }
 
   .open-grid {
@@ -1088,11 +1063,10 @@ const mobileEndorsementRows = [
   .open-term-head {
     display: flex; align-items: center; gap: 6px;
     padding: 10px 14px; border-bottom: 1px solid var(--border);
-    background: rgba(255, 255, 255, 0.02);
   }
   .open-term-head span {
     width: 10px; height: 10px; border-radius: 999px;
-    background: #2a2a30; display: block;
+    background: #262626; display: block;
   }
   .open-term-title {
     margin-left: 10px;
@@ -1138,9 +1112,6 @@ const mobileEndorsementRows = [
     flex-direction: column;
     justify-content: center;
     gap: 32px;
-    background:
-      radial-gradient(110% 75% at 100% 0%, var(--accent-dim), transparent 60%),
-      linear-gradient(180deg, rgba(255, 255, 255, 0.02), transparent);
   }
 
   .open-pitch-list {
@@ -1166,15 +1137,8 @@ const mobileEndorsementRows = [
 
   .open-pitch-mark {
     flex: none;
-    display: grid;
-    place-items: center;
-    width: 22px;
-    height: 22px;
-    margin-top: 1px;
-    border-radius: 7px;
-    color: var(--accent);
-    background: var(--accent-dim);
-    border: 1px solid color-mix(in srgb, var(--accent) 28%, transparent);
+    margin-top: 5px;
+    color: var(--ok);
   }
 
   .open-pitch-footer {
@@ -1187,7 +1151,7 @@ const mobileEndorsementRows = [
     display: flex;
     align-items: center;
     gap: 8px;
-    color: var(--fg-dim);
+    color: var(--fg-muted);
     font-family: var(--font-mono);
     font-size: 11px;
   }
@@ -1215,19 +1179,10 @@ const mobileEndorsementRows = [
 
   .sec-cta {
     text-align: center;
-    padding: 120px 0;
+    padding: 96px 0;
     position: relative;
     overflow: hidden;
   }
-  .sec-cta::before {
-    content: "";
-    position: absolute;
-    inset: auto 0 -50% 0;
-    height: 60%;
-    background: radial-gradient(ellipse at center, var(--accent-dim) 0%, transparent 60%);
-    pointer-events: none;
-    opacity: 0.6;
-  }
   .cta-inner { position: relative; }
   .cta-title {
     font-size: clamp(40px, 6vw, 72px);
@@ -1250,10 +1205,7 @@ const mobileEndorsementRows = [
     .hero-preview {
       width: min(860px, calc(100vw - 24px));
       margin-left: 50%;
-      transform: translateX(-50%) perspective(1600px) rotateX(1.5deg);
-    }
-    .hero-preview:hover {
-      transform: translateX(-50%) perspective(1600px) rotateX(0deg);
+      transform: translateX(-50%);
     }
     .harness-grid { grid-template-columns: 1fr 1fr; }
     .harness { border-right: 0; border-bottom: 1px solid var(--border); }
@@ -1264,10 +1216,9 @@ const mobileEndorsementRows = [
   }
 
   @media (max-width: 820px) {
-    section { padding: 64px 0; }
-    .sec-cta { padding: 96px 0; }
+    section { padding: 56px 0; }
+    .sec-cta { padding: 80px 0; }
     .container { padding-left: 20px; padding-right: 20px; }
-    .hero-preview { display: none; }
     .endorsements-head {
       margin-bottom: 40px;
     }
@@ -1294,5 +1245,9 @@ const mobileEndorsementRows = [
     .endorsement-card p {
       font-size: 13px;
     }
+    .open-term-body {
+      padding: 16px;
+      font-size: 11px;
+    }
   }
 </style>
diff --git a/apps/marketing/src/styles/fonts.css b/apps/marketing/src/styles/fonts.css
deleted file mode 100644
index 2f3933d61239c..0000000000000
--- a/apps/marketing/src/styles/fonts.css
+++ /dev/null
@@ -1,193 +0,0 @@
-/*! DM Sans v17 and JetBrains Mono v24. Licenses: /fonts/dm-sans-OFL.txt and /fonts/jetbrains-mono-OFL.txt. */
-/* Keep subset bytes out of the stylesheet so unused glyph ranges do not add transfer size. */
-/* latin-ext */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin-ext.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329,
-    U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F,
-    U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329,
-    U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
-}
-/* latin-ext */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin-ext.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329,
-    U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F,
-    U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329,
-    U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
-}
-/* latin-ext */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 600;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin-ext.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329,
-    U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F,
-    U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: "DM Sans";
-  font-style: normal;
-  font-weight: 600;
-  font-display: swap;
-  src: url(../assets/fonts/dm-sans-latin.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329,
-    U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
-}
-/* cyrillic-ext */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-cyrillic-ext.woff2?no-inline) format("woff2");
-  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
-}
-/* cyrillic */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-cyrillic.woff2?no-inline) format("woff2");
-  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
-}
-/* greek */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-greek.woff2?no-inline) format("woff2");
-  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
-}
-/* vietnamese */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-vietnamese.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301,
-    U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
-}
-/* latin-ext */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-latin-ext.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329,
-    U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F,
-    U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 400;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-latin.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329,
-    U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
-}
-/* cyrillic-ext */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-cyrillic-ext.woff2?no-inline) format("woff2");
-  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
-}
-/* cyrillic */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-cyrillic.woff2?no-inline) format("woff2");
-  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
-}
-/* greek */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-greek.woff2?no-inline) format("woff2");
-  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
-}
-/* vietnamese */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-vietnamese.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301,
-    U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
-}
-/* latin-ext */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-latin-ext.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329,
-    U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F,
-    U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: "JetBrains Mono";
-  font-style: normal;
-  font-weight: 500;
-  font-display: swap;
-  src: url(../assets/fonts/jetbrains-mono-latin.woff2?no-inline) format("woff2");
-  unicode-range:
-    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329,
-    U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
-}
diff --git a/apps/mobile/assets/icons/chevron-down.xml b/apps/mobile/assets/icons/chevron-down.xml
new file mode 100644
index 0000000000000..285eda9c1b463
--- /dev/null
+++ b/apps/mobile/assets/icons/chevron-down.xml
@@ -0,0 +1,4 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp" android:height="24dp" android:viewportWidth="24" android:viewportHeight="24">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M7.41,8.59L12,13.17l4.59,-4.58L18,10l-6,6 -6,-6z" />
+</vector>
diff --git a/apps/mobile/src/components/ui/AndroidScreenHeader.tsx b/apps/mobile/src/components/ui/AndroidScreenHeader.tsx
index 7931717682fa1..3d7605b71b5fb 100644
--- a/apps/mobile/src/components/ui/AndroidScreenHeader.tsx
+++ b/apps/mobile/src/components/ui/AndroidScreenHeader.tsx
@@ -21,6 +21,7 @@ export interface AndroidHeaderAction {
   readonly disabled?: boolean;
   readonly loading?: boolean;
   readonly selected?: boolean;
+  readonly subtitle?: string;
   readonly destructive?: boolean;
   readonly overflowOnly?: boolean;
 }
@@ -178,10 +179,11 @@ export function AndroidScreenHeader(props: {
                   actions={overflowActions.map((action, index) => ({
                     id: String(index),
                     title: action.accessibilityLabel,
+                    subtitle: action.subtitle,
+                    state: action.selected ? "on" : undefined,
                     attributes: {
                       disabled: Boolean(action.disabled),
                       destructive: action.destructive,
-                      state: action.selected ? "on" : undefined,
                     },
                   }))}
                   onPressAction={({ nativeEvent }) =>
diff --git a/apps/mobile/src/components/ui/MenuPopup.android.tsx b/apps/mobile/src/components/ui/MenuPopup.android.tsx
index b5af18cd2bcbb..dd6ef2b046566 100644
--- a/apps/mobile/src/components/ui/MenuPopup.android.tsx
+++ b/apps/mobile/src/components/ui/MenuPopup.android.tsx
@@ -55,7 +55,9 @@ function MenuIcon(props: {
   );
 }
 
-export function MenuPopup(props: MenuPopupProps) {
+export function MenuPopupItems(
+  props: Pick<MenuPopupProps, "menuWidth" | "actions" | "title" | "parent" | "onPress" | "onBack">,
+) {
   const { appearance, themeVariables: colors } = useAppearancePreferences();
   const { scale, menuItemHeight } = useAndroidControlSizing();
   const body = resolveScaledTextRole("body", appearance.baseFontSize);
@@ -64,7 +66,7 @@ export function MenuPopup(props: MenuPopupProps) {
   const muted = colors["--color-foreground-muted"];
   // A fixed native item height clips wrapped labels; a minimum lets each row grow.
   const itemModifiers = [width(props.menuWidth), defaultMinSize({ minHeight: menuItemHeight })];
-  const items = (
+  return (
     <>
       {props.parent ? (
         <DropdownMenuItem onClick={props.onBack} modifiers={itemModifiers}>
@@ -146,6 +148,11 @@ export function MenuPopup(props: MenuPopupProps) {
       ))}
     </>
   );
+}
+
+export function MenuPopup(props: MenuPopupProps) {
+  const { themeVariables: colors } = useAppearancePreferences();
+  const items = <MenuPopupItems {...props} />;
   if (props.inline) {
     return (
       <NativeThemeHost
diff --git a/apps/mobile/src/components/ui/SplitButton.android.tsx b/apps/mobile/src/components/ui/SplitButton.android.tsx
new file mode 100644
index 0000000000000..6f183ede86481
--- /dev/null
+++ b/apps/mobile/src/components/ui/SplitButton.android.tsx
@@ -0,0 +1,145 @@
+import {
+  Box,
+  DropdownMenu,
+  Icon,
+  LoadingIndicator,
+  RNHostView,
+  Row,
+  SplitButtonLayout,
+  Text,
+} from "@expo/ui/jetpack-compose";
+import {
+  defaultMinSize,
+  fillMaxWidth,
+  rotate,
+  semantics,
+  size,
+} from "@expo/ui/jetpack-compose/modifiers";
+import { useState } from "react";
+import { Pressable } from "react-native";
+
+import { useScaledTextRole } from "../../features/settings/appearance/useScaledTextRole";
+import { SymbolView } from "./AppSymbol";
+import { Button } from "./Button";
+import { MenuPopupItems } from "./MenuPopup.android";
+import { NativeThemeHost } from "./NativeThemeHost.android";
+import type { SplitButtonProps } from "./SplitButton.types";
+import { useAndroidControlSizing } from "./useAndroidControlSizing";
+import { useControlTheme } from "./useControlTheme";
+
+export function SplitButton(props: SplitButtonProps) {
+  const { colors } = useControlTheme();
+  const typography = useScaledTextRole("footnote");
+  const { scale, iconSize, mediumIconSize, menuWidth } = useAndroidControlSizing();
+  const [expanded, setExpanded] = useState(false);
+  if (props.actions.length === 0) return <Button {...props} tone="primary" fullWidth />;
+  const enabled = !props.disabled && !props.loading;
+  const menuEnabled = props.actions.some((action) => !action.attributes?.disabled);
+  const buttonColors = {
+    containerColor: colors["--color-primary"],
+    contentColor: colors["--color-primary-foreground"],
+    disabledContainerColor: colors["--color-subtle-strong"],
+    disabledContentColor: colors["--color-foreground-muted"],
+  };
+  // A usable menu beside a disabled action still takes the disabled palette, so the pair reads as one control.
+  const trailingColors = enabled
+    ? buttonColors
+    : {
+        ...buttonColors,
+        containerColor: buttonColors.disabledContainerColor,
+        contentColor: buttonColors.disabledContentColor,
+      };
+  const label = (
+    <Row verticalAlignment="center">
+      {props.loading ? (
+        <>
+          <LoadingIndicator
+            modifiers={[size(mediumIconSize, mediumIconSize)]}
+            color={colors["--color-foreground-muted"]}
+          />
+          <Box modifiers={[size(8 * scale, 1)]} />
+        </>
+      ) : props.icon ? (
+        <>
+          {/* The glyph host consumes touches, so it runs the action itself. */}
+          <RNHostView matchContents modifiers={[size(mediumIconSize, mediumIconSize)]}>
+            <Pressable
+              accessible={false}
+              disabled={!enabled}
+              onPress={props.onPress}
+              importantForAccessibility="no-hide-descendants"
+              style={{ width: mediumIconSize, height: mediumIconSize }}
+            >
+              <SymbolView
+                name={props.icon}
+                size={mediumIconSize}
+                tintColor={enabled ? buttonColors.contentColor : buttonColors.disabledContentColor}
+              />
+            </Pressable>
+          </RNHostView>
+          <Box modifiers={[size(8 * scale, 1)]} />
+        </>
+      ) : null}
+      <Text style={{ ...typography, fontWeight: "500" }}>{props.label}</Text>
+    </Row>
+  );
+  return (
+    <NativeThemeHost
+      matchContents={{ vertical: true }}
+      ignoreSafeAreaKeyboardInsets
+      style={{ width: "100%" }}
+    >
+      <SplitButtonLayout modifiers={[fillMaxWidth()]}>
+        <SplitButtonLayout.LeadingButton
+          enabled={enabled}
+          onClick={props.onPress}
+          colors={buttonColors}
+          modifiers={[
+            fillMaxWidth(),
+            defaultMinSize({ minHeight: 48 }),
+            semantics({ contentDescription: props.accessibilityLabel ?? props.label }),
+          ]}
+        >
+          {label}
+        </SplitButtonLayout.LeadingButton>
+        <SplitButtonLayout.TrailingButton
+          checked={expanded}
+          onCheckedChange={setExpanded}
+          enabled={menuEnabled}
+          colors={trailingColors}
+          modifiers={[
+            defaultMinSize({ minWidth: 48, minHeight: 48 }),
+            semantics({ contentDescription: props.menuTitle }),
+          ]}
+        >
+          <DropdownMenu
+            expanded={expanded && menuEnabled}
+            onDismissRequest={() => setExpanded(false)}
+            color={colors["--color-card-alt"]}
+          >
+            <DropdownMenu.Trigger>
+              <Icon
+                source={require("../../../assets/icons/chevron-down.xml")}
+                size={iconSize}
+                modifiers={[rotate(expanded ? 180 : 0)]}
+              />
+            </DropdownMenu.Trigger>
+            <DropdownMenu.Items>
+              <MenuPopupItems
+                menuWidth={menuWidth}
+                actions={props.actions}
+                title={props.menuTitle}
+                parent={null}
+                onPress={(action) => {
+                  setExpanded(false);
+                  if (action.id !== undefined) props.onPressAction(action.id);
+                }}
+                onBack={() => {}}
+              />
+            </DropdownMenu.Items>
+          </DropdownMenu>
+        </SplitButtonLayout.TrailingButton>
+      </SplitButtonLayout>
+    </NativeThemeHost>
+  );
+}
diff --git a/apps/mobile/src/components/ui/SplitButton.tsx b/apps/mobile/src/components/ui/SplitButton.tsx
new file mode 100644
index 0000000000000..511c3a5b7c29f
--- /dev/null
+++ b/apps/mobile/src/components/ui/SplitButton.tsx
@@ -0,0 +1,65 @@
+import { Pressable, View } from "react-native";
+import { AppActivityIndicator } from "./AppActivityIndicator";
+import { AppText } from "./AppText";
+import { SymbolView } from "./AppSymbol";
+import { Menu } from "./Menu";
+import type { SplitButtonProps } from "./SplitButton.types";
+
+export function SplitButton(props: SplitButtonProps) {
+  const active = !props.disabled;
+  const menuEnabled = props.actions.some((action) => !action.attributes?.disabled);
+  return (
+    <View
+      className={`flex-row overflow-hidden rounded-xl border-continuous ${active ? "bg-prominent-action" : "bg-subtle-strong"}`}
+    >
+      <Pressable
+        accessibilityRole="button"
+        accessibilityLabel={props.accessibilityLabel ?? props.label}
+        accessibilityState={{ disabled: Boolean(props.disabled), busy: Boolean(props.loading) }}
+        disabled={props.disabled}
+        onPress={props.onPress}
+        className="min-h-11 min-w-0 flex-1 flex-row items-center justify-center gap-2 px-3 py-2 active:opacity-70"
+      >
+        {props.loading ? (
+          <AppActivityIndicator size="small" colorClassName="accent-icon-muted" />
+        ) : props.icon ? (
+          <SymbolView
+            name={props.icon}
+            size={16}
+            tintColorClassName={active ? "accent-prominent-action-foreground" : "accent-icon-muted"}
+          />
+        ) : null}
+        <AppText
+          className={`shrink text-center text-sm font-t3-semibold ${active ? "text-prominent-action-foreground" : "text-foreground-muted"}`}
+        >
+          {props.label}
+        </AppText>
+      </Pressable>
+      {props.actions.length > 0 ? (
+        <View pointerEvents={menuEnabled ? "auto" : "none"}>
+          <Menu
+            title={props.menuTitle}
+            actions={props.actions}
+            onPressAction={({ nativeEvent }) => props.onPressAction(nativeEvent.event)}
+          >
+            <Pressable
+              accessibilityRole="button"
+              accessibilityLabel={props.menuTitle}
+              accessibilityState={{ disabled: !menuEnabled }}
+              disabled={!menuEnabled}
+              className="min-h-11 w-11 items-center justify-center border-l border-border-subtle"
+            >
+              <SymbolView
+                name="chevron.down"
+                size={13}
+                tintColorClassName={
+                  active ? "accent-prominent-action-foreground" : "accent-icon-muted"
+                }
+              />
+            </Pressable>
+          </Menu>
+        </View>
+      ) : null}
+    </View>
+  );
+}
diff --git a/apps/mobile/src/components/ui/SplitButton.types.ts b/apps/mobile/src/components/ui/SplitButton.types.ts
new file mode 100644
index 0000000000000..73d0b36f2ce20
--- /dev/null
+++ b/apps/mobile/src/components/ui/SplitButton.types.ts
@@ -0,0 +1,14 @@
+import type { MenuAction } from "@react-native-menu/menu";
+import type { AppSymbolName } from "./AppSymbol";
+
+export interface SplitButtonProps {
+  readonly label: string;
+  readonly accessibilityLabel?: string;
+  readonly icon?: AppSymbolName;
+  readonly disabled?: boolean;
+  readonly loading?: boolean;
+  readonly onPress: () => void;
+  readonly menuTitle: string;
+  readonly actions: MenuAction[];
+  readonly onPressAction: (id: string) => void;
+}
diff --git a/apps/mobile/src/features/devices/DevicePreviewRouteScreen.tsx b/apps/mobile/src/features/devices/DevicePreviewRouteScreen.tsx
index 65aaee6f0d479..99aed81cf2b82 100644
--- a/apps/mobile/src/features/devices/DevicePreviewRouteScreen.tsx
+++ b/apps/mobile/src/features/devices/DevicePreviewRouteScreen.tsx
@@ -411,6 +411,7 @@ function OpenDevicePreview({
       access={access}
       platform={session.platform}
       deviceId={session.deviceId}
+      serveSimOnly={preview.serveSimOnly}
       colors={{
         background: themeVariables["--color-sheet-solid"],
         foreground: themeVariables["--color-foreground"],
diff --git a/apps/mobile/src/features/devices/DeviceStreamWebView.tsx b/apps/mobile/src/features/devices/DeviceStreamWebView.tsx
index 798e650b73e26..94db8527c5d67 100644
--- a/apps/mobile/src/features/devices/DeviceStreamWebView.tsx
+++ b/apps/mobile/src/features/devices/DeviceStreamWebView.tsx
@@ -45,6 +45,7 @@ export function DeviceStreamWebView({
     access: props.access,
     platform: props.platform,
     deviceId: props.deviceId,
+    ...(props.serveSimOnly ? { serveSimOnly: true } : {}),
     colors: props.colors,
   });
   return (
diff --git a/apps/mobile/src/features/devices/device-stream-document.ts b/apps/mobile/src/features/devices/device-stream-document.ts
index 07a699567b6ea..abf045cdd172c 100644
--- a/apps/mobile/src/features/devices/device-stream-document.ts
+++ b/apps/mobile/src/features/devices/device-stream-document.ts
@@ -6,6 +6,8 @@ export interface DeviceStreamConfiguration {
   readonly access: DeviceHubAccess;
   readonly platform: DevicePlatform;
   readonly deviceId: string;
+  /** See `DeviceStreamTarget.serveSimOnly`. */
+  readonly serveSimOnly?: boolean;
   readonly colors: {
     readonly background: string;
     readonly foreground: string;
diff --git a/apps/mobile/src/features/devices/threadDevicePreviews.ts b/apps/mobile/src/features/devices/threadDevicePreviews.ts
index aaf87ca9784e1..5ec92e113b8c2 100644
--- a/apps/mobile/src/features/devices/threadDevicePreviews.ts
+++ b/apps/mobile/src/features/devices/threadDevicePreviews.ts
@@ -14,6 +14,7 @@ export function threadDevicePreviews(state: DeviceServiceState | null, threadId:
         session,
         name: device?.name ?? (session.platform === "ios" ? "iOS Simulator" : "Android Emulator"),
         description: [device?.version, host?.label].filter(Boolean).join(" · "),
+        serveSimOnly: host?.kind === "simlock",
       };
     });
 }
diff --git a/apps/mobile/src/features/pull-requests/PullRequestMergeControls.tsx b/apps/mobile/src/features/pull-requests/PullRequestMergeControls.tsx
index b784bdb4eb427..8ba68d2a2bfa9 100644
--- a/apps/mobile/src/features/pull-requests/PullRequestMergeControls.tsx
+++ b/apps/mobile/src/features/pull-requests/PullRequestMergeControls.tsx
@@ -1,4 +1,3 @@
-import { AppActivityIndicator } from "../../components/ui/AppActivityIndicator";
 import * as Dialog from "../../components/ui/Dialog";
 import { useAtomRefresh, useAtomSet, useAtomValue } from "@effect/atom-react";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
@@ -6,12 +5,10 @@ import { sourceControlClients } from "@t3tools/client-runtime/source-control-cli
 import type { PullRequestDetail, PullRequestMergeMethod } from "@t3tools/contracts";
 import { AsyncResult } from "effect/reactivity";
 import { useRef, useState } from "react";
-import { Platform, Pressable, View } from "react-native";
+import { View } from "react-native";
 import { AppText as Text } from "../../components/ui/AppText";
-import { SymbolView } from "../../components/ui/AppSymbol";
-import { Menu } from "../../components/ui/Menu";
 import { Button } from "../../components/ui/Button";
-import { IconButton } from "../../components/ui/IconButton";
+import { SplitButton } from "../../components/ui/SplitButton";
 import { mobilePreferencesAtom, updateMobilePreferencesAtom } from "../../state/preferences";
 import { composerPullRequests } from "../../state/pull-requests";
 import { useAtomCommand } from "../../state/use-atom-command";
@@ -26,8 +23,8 @@ import {
 import { pullRequestStackMerge, singlePullRequestMergeAllowed } from "./pullRequestStack";
 import { pullRequestTarget, type PullRequestParams } from "./usePullRequestDiff";
 import { usePullRequestPermissions } from "./usePullRequestPermissions";
-import type { PullRequestStackState } from "./usePullRequestStack";
 import { PullRequestGlyph } from "./pullRequestGlyphs";
+import type { PullRequestStackState } from "./usePullRequestStack";
 
 export function PullRequestMergeControls(props: {
   readonly pr: PullRequestDetail;
@@ -169,107 +166,41 @@ export function PullRequestMergeControls(props: {
   };
   return (
     <View className="gap-2 border-t border-border-subtle p-3">
-      <View
-        className={
-          Platform.OS === "android"
-            ? "flex-row items-center gap-2"
-            : `flex-row overflow-hidden rounded-xl border-continuous ${canMerge ? "bg-prominent-action" : "bg-subtle-strong"}`
+      <SplitButton
+        label={busy ? "Working…" : !permissions.connected ? "Reconnect to merge" : label}
+        accessibilityLabel={
+          scope ? `${label}, ${scope.layers.length} stack layers through #${pr.number}` : label
         }
-      >
-        {Platform.OS === "android" ? (
-          <View className="min-w-0 flex-1">
-            <Button
-              label={busy ? "Working…" : !permissions.connected ? "Reconnect to merge" : label}
-              tone="primary"
-              fullWidth
-              disabled={!canMerge}
-              loading={busy || checkingStack}
-              onPress={() => confirm("merge")}
-            />
-          </View>
-        ) : (
-          <Pressable
-            accessibilityRole="button"
-            accessibilityLabel={
-              scope ? `${label}, ${scope.layers.length} stack layers through #${pr.number}` : label
-            }
-            accessibilityState={{ disabled: !canMerge, busy: busy || checkingStack }}
-            disabled={!canMerge}
-            onPress={() => confirm("merge")}
-            className="min-h-11 min-w-0 flex-1 flex-row items-center justify-center gap-2 px-3 py-2 active:opacity-70"
-          >
-            {busy || checkingStack ? (
-              <AppActivityIndicator size="small" colorClassName="accent-icon-muted" />
-            ) : (
-              <SymbolView
-                name={PullRequestGlyph.merged}
-                size={16}
-                tintColorClassName={
-                  canMerge ? "accent-prominent-action-foreground" : "accent-icon-muted"
-                }
-              />
-            )}
-            <Text
-              className={`shrink text-center text-sm font-t3-semibold ${canMerge ? "text-prominent-action-foreground" : "text-foreground-muted"}`}
-            >
-              {busy ? "Working…" : !permissions.connected ? "Reconnect to merge" : label}
-            </Text>
-          </Pressable>
-        )}
-        {methods.length > 0 || canAutoMerge ? (
-          <Menu
-            title="Merge options"
-            actions={[
-              ...methods.map((id) => ({
-                id,
-                title: MERGE_METHODS[id].title,
-                state: id === method ? ("on" as const) : ("off" as const),
-                attributes: { disabled: busy },
-              })),
-              ...(canAutoMerge
-                ? [
-                    {
-                      id: autoAction,
-                      title: pr.autoMergeEnabled ? "Disable auto-merge" : "Enable auto-merge",
-                      image: "clock",
-                    },
-                  ]
-                : []),
-            ]}
-            onPressAction={({ nativeEvent }) => {
-              const selected = methods.find((id) => id === nativeEvent.event);
-              if (selected) {
-                setSelectedMethod(selected);
-                savePreferences({ pullRequestMergeMethod: selected });
-              } else if (nativeEvent.event === autoAction && canAutoMerge) confirm(autoAction);
-            }}
-          >
-            {Platform.OS === "android" ? (
-              <View pointerEvents="none">
-                <IconButton
-                  accessibilityLabel="Merge options"
-                  icon="chevron.down"
-                  variant="tonal"
-                />
-              </View>
-            ) : (
-              <Pressable
-                accessibilityRole="button"
-                accessibilityLabel="Merge options"
-                className="min-h-11 w-11 items-center justify-center border-l border-border-subtle"
-              >
-                <SymbolView
-                  name="chevron.down"
-                  size={13}
-                  tintColorClassName={
-                    canMerge ? "accent-prominent-action-foreground" : "accent-icon-muted"
-                  }
-                />
-              </Pressable>
-            )}
-          </Menu>
-        ) : null}
-      </View>
+        icon={PullRequestGlyph.merged}
+        disabled={!canMerge}
+        loading={busy || checkingStack}
+        onPress={() => confirm("merge")}
+        menuTitle="Merge options"
+        actions={[
+          ...methods.map((id) => ({
+            id,
+            title: MERGE_METHODS[id].title,
+            state: id === method ? ("on" as const) : ("off" as const),
+            attributes: { disabled: !canMerge && !canAutoMerge },
+          })),
+          ...(canAutoMerge
+            ? [
+                {
+                  id: autoAction,
+                  title: pr.autoMergeEnabled ? "Disable auto-merge" : "Enable auto-merge",
+                  image: "clock",
+                },
+              ]
+            : []),
+        ]}
+        onPressAction={(id) => {
+          const selected = methods.find((method) => method === id);
+          if (selected) {
+            setSelectedMethod(selected);
+            savePreferences({ pullRequestMergeMethod: selected });
+          } else if (id === autoAction && canAutoMerge) confirm(autoAction);
+        }}
+      />
       {permissions.connected &&
       reason &&
       reason !== MERGE_CONFLICT_REASON &&
diff --git a/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx b/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
index e0ad9c76e9bb4..446794800eadb 100644
--- a/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
+++ b/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
@@ -41,7 +41,7 @@ import {
   pullRequestDiffInitialPosition,
 } from "./pullRequestDiffDebug";
 import { usePullRequestDiffHighlightFiles } from "./usePullRequestDiffHighlightFiles";
-import { isPullRequestTestFile } from "./pullRequestFileFilters";
+import { isTestChangedFile } from "@t3tools/shared/changedFileKind";
 import { useFocusEffect, useNavigation, type StaticScreenProps } from "@react-navigation/native";
 import type { NativeStackNavigationProp } from "@react-navigation/native-stack";
 import { RegistryContext, useAtomRefresh, useAtomValue } from "@effect/atom-react";
@@ -111,6 +111,7 @@ import {
   PullRequestReadStatus,
 } from "./PullRequestPresentation";
 import { usePullRequestFilesSection } from "./PullRequestFiles";
+import { usePullRequestMaintainerEdits } from "./usePullRequestMaintainerEdits";
 import { PullRequestDescription } from "./PullRequestDescription";
 import { PullRequestMediaVisibleContext } from "./PullRequestMedia";
 import { PullRequestMarkdownRepository } from "./PullRequestMarkdown";
@@ -416,6 +417,11 @@ export function PullRequestRouteScreen({ route }: StaticScreenProps<PullRequestP
   const terminology = sourceControlClients.get(identity?.provider).changeRequest;
   const permissions = usePullRequestPermissions(params, pr);
   const action = usePullRequestAction(params, pr);
+  const maintainerEdits = usePullRequestMaintainerEdits(
+    params,
+    pr,
+    permissions.canEditMaintainerEdits,
+  );
   const showsDeleteBranch = pr !== null && canPerformPullRequestAction(pr, "delete-branch");
   const confirmDeleteBranch = () =>
     pr &&
@@ -517,6 +523,19 @@ export function PullRequestRouteScreen({ route }: StaticScreenProps<PullRequestP
                     },
                   ]
                 : []),
+              ...(maintainerEdits.visible
+                ? [
+                    {
+                      accessibilityLabel: "Allow edits from maintainers",
+                      icon: "pencil" as const,
+                      selected: maintainerEdits.value,
+                      disabled: maintainerEdits.saving,
+                      subtitle: maintainerEdits.subtitle,
+                      overflowOnly: true,
+                      onPress: maintainerEdits.toggle,
+                    },
+                  ]
+                : []),
               ...(identity
                 ? [
                     {
@@ -597,6 +616,17 @@ export function PullRequestRouteScreen({ route }: StaticScreenProps<PullRequestP
                 <Toolbar.Label>Edit description</Toolbar.Label>
               </Toolbar.MenuAction>
             ) : null}
+            {maintainerEdits.visible ? (
+              <Toolbar.MenuAction
+                icon="pencil"
+                isOn={maintainerEdits.value}
+                disabled={maintainerEdits.saving}
+                subtitle={maintainerEdits.subtitle}
+                onPress={maintainerEdits.toggle}
+              >
+                <Toolbar.Label>Allow edits from maintainers</Toolbar.Label>
+              </Toolbar.MenuAction>
+            ) : null}
             {identity ? (
               <Toolbar.MenuAction
                 icon="arrow.up.right"
@@ -1005,7 +1035,7 @@ function PullRequestFileRouteContent({ route }: PullRequestFileRouteProps) {
   const jumpedUnder = useRef<boolean | null>(filter.hideTestFiles);
   const hasTestFiles =
     result.parsed.kind === "files" &&
-    result.parsed.files.some((file) => isPullRequestTestFile(file.path));
+    result.parsed.files.some((file) => isTestChangedFile(file.path));
   const jumpStarted = () =>
     jumpedUnder.current !== null && (!hasTestFiles || jumpedUnder.current === filter.hideTestFiles);
   const scrollToFile = (fileId: string) => {
diff --git a/apps/mobile/src/features/pull-requests/pullRequestFileFilters.ts b/apps/mobile/src/features/pull-requests/pullRequestFileFilters.ts
index 2d8e3a94fe4be..2e0424ddbbaed 100644
--- a/apps/mobile/src/features/pull-requests/pullRequestFileFilters.ts
+++ b/apps/mobile/src/features/pull-requests/pullRequestFileFilters.ts
@@ -1,12 +1,6 @@
-import { classifyChangedFile } from "@t3tools/shared/changedFileKind";
+import { isTestChangedFile } from "@t3tools/shared/changedFileKind";
 import type { ReviewParsedDiff } from "../review/reviewModel";
 
-/** Test support such as fixtures and snapshots is hidden along with the tests. */
-export function isPullRequestTestFile(path: string): boolean {
-  const kind = classifyChangedFile(path);
-  return kind === "tests" || kind === "mocks";
-}
-
 export function filterPullRequestTestFiles(
   parsed: ReviewParsedDiff,
   hideTestFiles: boolean,
@@ -14,7 +8,7 @@ export function filterPullRequestTestFiles(
 ): ReviewParsedDiff {
   if (!hideTestFiles || parsed.kind !== "files") return parsed;
   const files = parsed.files.filter(
-    (file) => file.path === includePath || !isPullRequestTestFile(file.path),
+    (file) => file.path === includePath || !isTestChangedFile(file.path),
   );
   if (files.length === parsed.files.length) return parsed;
   return {
diff --git a/apps/mobile/src/features/pull-requests/usePullRequestMaintainerEdits.ts b/apps/mobile/src/features/pull-requests/usePullRequestMaintainerEdits.ts
new file mode 100644
index 0000000000000..d474b8e5d5462
--- /dev/null
+++ b/apps/mobile/src/features/pull-requests/usePullRequestMaintainerEdits.ts
@@ -0,0 +1,63 @@
+import { useAtomRefresh } from "@effect/atom-react";
+import {
+  maintainerEditsChoiceInForce,
+  type MaintainerEditsChoice,
+} from "@t3tools/client-runtime/pull-request-editing";
+import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
+import type { PullRequestDetail } from "@t3tools/contracts";
+import { AsyncResult } from "effect/reactivity";
+import { useRef, useState } from "react";
+import * as Dialog from "../../components/ui/Dialog";
+import { composerPullRequests } from "../../state/pull-requests";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { pullRequestTarget, type PullRequestParams } from "./usePullRequestDiff";
+
+export function usePullRequestMaintainerEdits(
+  params: PullRequestParams,
+  pr: PullRequestDetail | null,
+  canEdit: boolean,
+) {
+  const target = pullRequestTarget(params);
+  const update = useAtomCommand(composerPullRequests.update, { reportFailure: false });
+  const refreshDetail = useAtomRefresh(composerPullRequests.detail(target));
+  const pending = useRef(false);
+  const [saving, setSaving] = useState(false);
+  const [choice, setChoice] = useState<MaintainerEditsChoice | null>(null);
+  const kept = maintainerEditsChoiceInForce(choice, pr?.url ?? "", pr?.observedAt, saving);
+  if (kept !== choice) {
+    setChoice(kept);
+  }
+  const value = kept?.value ?? pr?.maintainerCanModify === true;
+  const save = async (next: boolean) => {
+    if (pending.current || pr === null || !canEdit) return;
+    pending.current = true;
+    const previousChoice = choice;
+    setSaving(true);
+    setChoice({ key: pr.url, observedAt: pr.observedAt, value: next });
+    const response = await update({
+      ...target,
+      input: { ...target.input, maintainerCanModify: next },
+    });
+    pending.current = false;
+    setSaving(false);
+    if (AsyncResult.isFailure(response)) {
+      setChoice(previousChoice);
+      const cause = squashAtomCommandFailure(response);
+      Dialog.alert(
+        "Could not save maintainer access",
+        cause instanceof Error ? cause.message : "Try again.",
+      );
+      return;
+    }
+    refreshDetail();
+  };
+  return {
+    visible: canEdit,
+    value,
+    saving,
+    subtitle: saving
+      ? "Saving…"
+      : "Maintainers can push to this branch. If your fork has workflows, this can also give access to its secrets.",
+    toggle: () => void save(!value),
+  };
+}
diff --git a/apps/mobile/src/features/pull-requests/usePullRequestPermissions.ts b/apps/mobile/src/features/pull-requests/usePullRequestPermissions.ts
index 741b9c2ad0828..28a2bbb04cc97 100644
--- a/apps/mobile/src/features/pull-requests/usePullRequestPermissions.ts
+++ b/apps/mobile/src/features/pull-requests/usePullRequestPermissions.ts
@@ -2,6 +2,7 @@ import { useAtomValue } from "@effect/atom-react";
 import {
   canEditPullRequestChangeRequest,
   canEditPullRequestComment,
+  canEditPullRequestMaintainerEdits,
 } from "@t3tools/client-runtime/pull-request-editing";
 import type { PullRequestComment, PullRequestDetail } from "@t3tools/contracts";
 import { usePullRequestConnected } from "./usePullRequestConnected";
@@ -49,6 +50,8 @@ export function usePullRequestPermissions(params: PullRequestParams, pr: PullReq
     canWrite: connected && canWrite,
     canEditChangeRequest:
       connected && canUpdate && pr !== null && canEditPullRequestChangeRequest(pr),
+    canEditMaintainerEdits:
+      connected && canUpdate && pr !== null && canEditPullRequestMaintainerEdits(pr),
     canEditComment: (comment: Pick<PullRequestComment, "author" | "canEdit" | "kind">) =>
       connected && canUpdateComment && pr !== null && canEditPullRequestComment(pr, comment),
     canReact: connected && canSetReaction && pr?.capabilities.reactions === true,
diff --git a/apps/mobile/src/features/threads/PendingUserInputCard.tsx b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
index d097416b2ef20..9ecbbb70f1d8e 100644
--- a/apps/mobile/src/features/threads/PendingUserInputCard.tsx
+++ b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
@@ -26,9 +26,9 @@ import { useMarkdownPreviewStyles } from "../files/FileMarkdownPreview";
 import { useLiveThreadLinkLabels } from "../../state/entities";
 import {
   isPendingUserInputOptionSelected,
-  type PendingUserInput,
   type PendingUserInputDraftAnswer,
-} from "../../lib/threadActivity";
+} from "@t3tools/client-runtime/state/pending-user-input";
+import type { PendingUserInput } from "../../lib/threadActivity";
 
 export interface PendingUserInputCardProps {
   readonly environmentId: EnvironmentId;
diff --git a/apps/mobile/src/features/threads/SubagentStopButton.tsx b/apps/mobile/src/features/threads/SubagentStopButton.tsx
new file mode 100644
index 0000000000000..8cd7b89701ca9
--- /dev/null
+++ b/apps/mobile/src/features/threads/SubagentStopButton.tsx
@@ -0,0 +1,65 @@
+import { useAtomValue } from "@effect/atom-react";
+import type { EnvironmentId, OrchestrationV2Subagent } from "@t3tools/contracts";
+import { useState } from "react";
+import { View } from "react-native";
+
+import * as Dialog from "../../components/ui/Dialog";
+import { IconButton } from "../../components/ui/IconButton";
+import { orchestrationEnvironment } from "../../state/orchestration";
+import { threadEnvironment } from "../../state/threads";
+import { useAtomCommand } from "../../state/use-atom-command";
+import {
+  resolveSubagentRowPresentation,
+  resolveSubagentStopTarget,
+} from "./threadAgentsPresentation";
+
+export function SubagentStopButton(props: {
+  readonly environmentId: EnvironmentId;
+  readonly subagent: OrchestrationV2Subagent;
+  readonly className?: string;
+}) {
+  const target = resolveSubagentStopTarget(props.subagent);
+  const canStop = useAtomValue(
+    orchestrationEnvironment.stopWorkflow.permissionAtom(props.environmentId),
+  );
+  const stopWorkflow = useAtomCommand(orchestrationEnvironment.stopWorkflow);
+  const interruptTurn = useAtomCommand(threadEnvironment.interruptTurn);
+  const [stopping, setStopping] = useState(false);
+
+  if (target === null || !canStop) return null;
+
+  const workflow = target.kind === "workflow";
+  const label =
+    props.subagent.workflow?.name ?? resolveSubagentRowPresentation(props.subagent).title;
+  const stop = async () => {
+    setStopping(true);
+    const result = await (
+      target.kind === "workflow"
+        ? stopWorkflow({ environmentId: props.environmentId, input: target.input })
+        : interruptTurn({ environmentId: props.environmentId, input: target.input })
+    ).finally(() => setStopping(false));
+    if (result._tag === "Failure") {
+      Dialog.alert(workflow ? "Could not stop workflow" : "Could not stop agent");
+    }
+  };
+
+  return (
+    <View className={props.className}>
+      <IconButton
+        icon="stop.fill"
+        variant="danger"
+        accessibilityLabel={`${stopping ? "Stopping" : "Stop"} ${workflow ? "workflow" : "agent"} ${label}`}
+        disabled={stopping}
+        onPress={() =>
+          Dialog.confirm({
+            title: workflow ? "Stop workflow?" : "Stop agent?",
+            message: workflow ? `Every running agent in ${label} stops.` : `Stop ${label}?`,
+            confirmText: "Stop",
+            destructive: true,
+            onConfirm: () => void stop(),
+          })
+        }
+      />
+    </View>
+  );
+}
diff --git a/apps/mobile/src/features/threads/ThreadAgentsSheet.tsx b/apps/mobile/src/features/threads/ThreadAgentsSheet.tsx
index 5c0a4d53b6a79..03915d47bc23b 100644
--- a/apps/mobile/src/features/threads/ThreadAgentsSheet.tsx
+++ b/apps/mobile/src/features/threads/ThreadAgentsSheet.tsx
@@ -1,4 +1,8 @@
 import { useAtomValue } from "@effect/atom-react";
+import {
+  deriveWorkflowGroups,
+  projectedSubagentsToRuntime,
+} from "@t3tools/client-runtime/state/subagentRuntime";
 import type { ThreadTurnSubagents } from "@t3tools/client-runtime/state/thread-subagents";
 import {
   isOrchestrationV2WorkActive,
@@ -11,6 +15,7 @@ import { StackActions, useNavigation, type StaticScreenProps } from "@react-navi
 import * as DateTime from "effect/DateTime";
 import { Atom } from "effect/reactivity";
 import * as Haptics from "expo-haptics";
+import { useMemo } from "react";
 import { Platform, Pressable, ScrollView, View } from "react-native";
 import { ScreenStack } from "react-native-screens";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
@@ -23,6 +28,8 @@ import { NativeHeader, NativeScreen } from "../../native/ThemedScreenStack";
 import { useEnvironments } from "../../state/environments";
 import { SubagentRow } from "./SubagentRow";
 import { useVisibleSecondClock } from "./use-visible-second-clock";
+import { SubagentStopButton } from "./SubagentStopButton";
+import { ThreadWorkflowGroup } from "./ThreadWorkflowGroup";
 import { ScreenContent } from "../../components/ui/ScreenContent";
 import { useAdaptiveWorkspaceLayout } from "../layout/AdaptiveWorkspaceLayout";
 import { subagentThreadTarget } from "./threadAgentsPresentation";
@@ -54,6 +61,16 @@ export function ThreadAgentsSheet({ route }: StaticScreenProps<AgentsTarget>) {
   const turn = useThreadTurnSubagents(target);
   const subagents = turn?.subagents ?? [];
   const hasLiveAgent = (turn?.liveCount ?? 0) > 0;
+  const workflowGroups = useMemo(
+    () =>
+      new Map(
+        deriveWorkflowGroups(projectedSubagentsToRuntime(subagents)).map((group) => [
+          group.workflow.id,
+          group,
+        ]),
+      ),
+    [subagents],
+  );
 
   const openChildThread = (child: { environmentId: EnvironmentId; threadId: ThreadId }) => {
     void Haptics.selectionAsync();
@@ -88,15 +105,29 @@ export function ThreadAgentsSheet({ route }: StaticScreenProps<AgentsTarget>) {
           No agents in this turn.
         </Text>
       ) : (
-        subagents.map((subagent) => (
-          <AgentRow
-            key={subagent.id}
-            subagent={subagent}
-            environmentId={target.environmentId}
-            tickSeconds={hasLiveAgent}
-            onOpen={openChildThread}
-          />
-        ))
+        subagents.map((subagent) => {
+          const group = workflowGroups.get(subagent.id);
+          return group === undefined ? (
+            <View key={subagent.id} className="border-b border-border">
+              <AgentRow
+                subagent={subagent}
+                environmentId={target.environmentId}
+                tickSeconds={hasLiveAgent}
+                onOpen={openChildThread}
+              />
+            </View>
+          ) : (
+            <ThreadWorkflowGroup
+              key={subagent.id}
+              environmentId={target.environmentId}
+              subagent={subagent}
+              group={group}
+              onOpen={(threadId) =>
+                openChildThread({ environmentId: target.environmentId, threadId })
+              }
+            />
+          );
+        })
       )}
     </ScrollView>
   );
@@ -154,7 +185,7 @@ function AgentRow(props: {
   );
 
   const row = (
-    <View className="border-b border-border py-3.5">
+    <View className="py-3.5">
       <SubagentRow
         environmentId={props.environmentId}
         subagent={subagent}
@@ -164,10 +195,11 @@ function AgentRow(props: {
     </View>
   );
 
-  if (target === null) {
-    return (
+  const content =
+    target === null ? (
       <View
         accessible
+        className="min-w-0 flex-1"
         accessibilityHint={
           subagent.remoteChild === undefined
             ? "Provider-managed agent. Its work appears in the transcript."
@@ -176,18 +208,22 @@ function AgentRow(props: {
       >
         {row}
       </View>
+    ) : (
+      <Pressable
+        accessibilityRole="link"
+        accessibilityHint="Opens this agent's thread"
+        onPress={() => props.onOpen(target)}
+        className="min-w-0 flex-1 active:opacity-70"
+      >
+        {row}
+      </Pressable>
     );
-  }
 
   return (
-    <Pressable
-      accessibilityRole="link"
-      accessibilityHint="Opens this agent's thread"
-      onPress={() => props.onOpen(target)}
-      className="active:opacity-70"
-    >
-      {row}
-    </Pressable>
+    <View className="flex-row items-center">
+      {content}
+      <SubagentStopButton environmentId={props.environmentId} subagent={subagent} />
+    </View>
   );
 }
 
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index a23f06abef24b..27655f503bd65 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -157,10 +157,10 @@ import { appAtomRegistry } from "../../state/atom-registry";
 import { threadStreamHaptics } from "./threadStreamHaptics";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { useDelayedStatus } from "../../lib/useDelayedStatus";
+import type { PendingUserInputDraftAnswer } from "@t3tools/client-runtime/state/pending-user-input";
 import type {
   PendingApproval,
   PendingUserInput,
-  PendingUserInputDraftAnswer,
   ThreadFeedEntry,
   ThreadFeedLatestRun,
 } from "../../lib/threadActivity";
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index ce352bf17eb33..737e1aff90ada 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -95,7 +95,11 @@ import {
   ThreadInspectorContentStack,
   type ThreadInspectorMode,
 } from "./thread-inspector-content-stack";
-import { threadRouteIsHydrating } from "./thread-route-hydration";
+import {
+  threadDetailErrorIsCurrent,
+  threadRouteIsHydrating,
+  threadRouteOpensDraft,
+} from "./thread-route-hydration";
 import { ThreadHeader } from "./ThreadHeader";
 import {
   useAndroidWorkspaceBack,
@@ -265,6 +269,13 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
       ? null
       : scopedThreadKey(selectedThread.environmentId, selectedThread.id);
   const selectedThreadDetailState = useSelectedThreadDetailState();
+  const detailError = selectedThreadDetailState.error;
+  const [errorBeforeConnected, setErrorBeforeConnected] = useState(() =>
+    routeConnectionState === "connected" ? Option.none<string>() : detailError,
+  );
+  if (routeConnectionState !== "connected" && errorBeforeConnected !== detailError) {
+    setErrorBeforeConnected(detailError);
+  }
   const withInspectorHeader = (content: ReactNode) => (
     <>
       {props.inspectorPresentation ? (
@@ -297,14 +308,25 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
     shellStatus: routeEnvironmentShellState.status,
     shellHasError: routeEnvironmentShellState.hasError,
     detailStatus: selectedThreadDetailState.status,
-    detailHasError: Option.isSome(selectedThreadDetailState.error),
+    detailHasError: threadDetailErrorIsCurrent({
+      connectionState: routeConnectionState,
+      error: detailError,
+      errorBeforeConnected,
+    }),
   });
 
   if (stillHydrating) {
     return withInspectorHeader(<OpeningThreadLoadingScreen />);
   }
 
-  if (routeName === "Thread" && !props.inspectorPresentation) {
+  if (
+    routeName === "Thread" &&
+    !props.inspectorPresentation &&
+    threadRouteOpensDraft({
+      connectionState: routeConnectionState,
+      detailStatus: selectedThreadDetailState.status,
+    })
+  ) {
     return <UnavailableThreadDraftRedirect environmentId={environmentId} />;
   }
 
diff --git a/apps/mobile/src/features/threads/ThreadWorkflowGroup.tsx b/apps/mobile/src/features/threads/ThreadWorkflowGroup.tsx
new file mode 100644
index 0000000000000..df67df16cf581
--- /dev/null
+++ b/apps/mobile/src/features/threads/ThreadWorkflowGroup.tsx
@@ -0,0 +1,288 @@
+import { scopeThreadRef } from "@t3tools/client-runtime/environment";
+import {
+  isActiveSubagentStatus,
+  type RuntimeSubagent,
+  type SubagentWorkflowGroup,
+} from "@t3tools/client-runtime/state/subagentRuntime";
+import {
+  ThreadId,
+  type EnvironmentId,
+  type OrchestrationV2Subagent,
+  type ServerProvider,
+} from "@t3tools/contracts";
+import { deriveSubagentElapsedMs, formatDuration } from "@t3tools/shared/orchestrationTiming";
+import { useState, type ReactNode } from "react";
+import { ScrollView, View } from "react-native";
+
+import { AppText as Text } from "../../components/ui/AppText";
+import { SymbolView, type AppSymbolName } from "../../components/ui/AppSymbol";
+import { Chip } from "../../components/ui/Chip";
+import { ListRowLayout } from "../../components/ui/ListRowLayout";
+import { ListSection } from "../../components/ui/ListSection";
+import { RowPressable } from "../../components/ui/RowPressable";
+import { cn } from "../../lib/cn";
+import { useEnvironmentServerConfig, useThreadShell } from "../../state/entities";
+import { SUBAGENT_TONE_TEXT_CLASS, SubagentStatusDot } from "./SubagentStatusDot";
+import { SubagentStopButton } from "./SubagentStopButton";
+import {
+  nextWorkflowSelection,
+  resolveSubagentRowPresentation,
+  workflowMemberDetail,
+  workflowMemberMetadata,
+  workflowRail,
+  type WorkflowRailTone,
+} from "./threadAgentsPresentation";
+import { useVisibleSecondClock } from "./use-visible-second-clock";
+
+const RAIL_ICON = {
+  working: "circle.inset.filled",
+  completed: "checkmark.circle.fill",
+  failed: "xmark.circle.fill",
+  stopped: "circle",
+  queued: "circle.dashed",
+} as const satisfies Record<WorkflowRailTone, AppSymbolName>;
+
+export function ThreadWorkflowGroup(props: {
+  readonly environmentId: EnvironmentId;
+  readonly subagent: OrchestrationV2Subagent;
+  readonly group: SubagentWorkflowGroup;
+  readonly onOpen: (threadId: ThreadId) => void;
+}) {
+  const { group } = props;
+  const provider = useEnvironmentServerConfig(props.environmentId)?.providers.find(
+    (candidate) => candidate.instanceId === props.subagent.providerInstanceId,
+  );
+  const [selected, setSelected] = useState<string | null>(null);
+  const rail = workflowRail(group);
+  const open = rail.find((item) => item.key === selected);
+  const label = group.workflow.workflowName ?? group.workflow.title;
+  const statusLabel = resolveSubagentRowPresentation(props.subagent).statusLabel;
+
+  return (
+    <View className="my-2">
+      <ListSection>
+        <View className="flex-row items-center">
+          <RowPressable
+            accessibilityRole="button"
+            accessibilityLabel={`${label} workflow, ${statusLabel}`}
+            accessibilityHint={open ? "Collapses the workflow" : "Opens the current phase"}
+            accessibilityState={{ expanded: open !== undefined }}
+            disabled={rail.length === 0}
+            onPress={() => setSelected(nextWorkflowSelection(rail, selected))}
+            className="min-w-0 flex-1 active:opacity-70"
+          >
+            <WorkflowHeaderLayout
+              label={label}
+              statusLabel={statusLabel}
+              timing={group.workflow}
+              accessory={
+                rail.length > 0 ? (
+                  <SymbolView
+                    name={open ? "chevron.up" : "chevron.down"}
+                    size={12}
+                    tintColorClassName="accent-icon-subtle"
+                  />
+                ) : null
+              }
+            />
+          </RowPressable>
+          <SubagentStopButton
+            environmentId={props.environmentId}
+            subagent={props.subagent}
+            className="mr-2"
+          />
+        </View>
+        {rail.length > 0 ? (
+          <ScrollView
+            horizontal
+            showsHorizontalScrollIndicator={false}
+            contentContainerClassName="gap-2 px-4 pb-3"
+          >
+            {rail.map((item) => {
+              const count =
+                item.tone === "working" || item.tone === "failed"
+                  ? `${item.completedCount}/${item.members.length}`
+                  : null;
+              return (
+                <Chip
+                  key={item.key}
+                  icon={RAIL_ICON[item.tone]}
+                  label={count ? `${count} ${item.title}` : item.title}
+                  selected={item.key === selected}
+                  accessibilityLabel={`${item.title} phase, ${item.tone}${count ? `, ${count} completed` : ""}`}
+                  onPress={() => setSelected(nextWorkflowSelection(rail, selected, item.key))}
+                />
+              );
+            })}
+          </ScrollView>
+        ) : null}
+        {open === undefined ? null : open.members.length === 0 ? (
+          <Text
+            textRole="footnote"
+            className="border-t border-border-subtle px-4 py-3 text-foreground-muted"
+          >
+            No agents yet
+          </Text>
+        ) : (
+          open.members.map((member) => (
+            <WorkflowMemberRow
+              key={member.id}
+              environmentId={props.environmentId}
+              member={member}
+              provider={provider}
+              onOpen={props.onOpen}
+            />
+          ))
+        )}
+      </ListSection>
+    </View>
+  );
+}
+
+function WorkflowMemberRow(props: {
+  readonly environmentId: EnvironmentId;
+  readonly member: RuntimeSubagent;
+  readonly provider: ServerProvider | undefined;
+  readonly onOpen: (threadId: ThreadId) => void;
+}) {
+  const { member } = props;
+  const threadId = member.childThreadId === null ? null : ThreadId.make(member.childThreadId);
+  const shell = useThreadShell(
+    threadId === null ? null : scopeThreadRef(props.environmentId, threadId),
+  );
+  const canOpen = threadId !== null && shell !== null;
+  const presentation = resolveSubagentRowPresentation({
+    title: member.title,
+    prompt: "",
+    status: member.status,
+    result: null,
+    childThreadId: threadId,
+  });
+  const { detail, error } = workflowMemberDetail(member);
+  const metadata = workflowMemberMetadata(member, props.provider);
+  const labels = [metadata.model, metadata.effort].filter((value) => value !== null);
+  return (
+    <RowPressable
+      accessibilityRole={canOpen ? "link" : undefined}
+      accessibilityLabel={[
+        presentation.title,
+        presentation.statusLabel,
+        ...labels,
+        ...(metadata.speed === null ? [] : [metadata.speed]),
+        ...(error === null ? [] : [error]),
+      ].join(", ")}
+      accessibilityHint={canOpen ? "Opens this agent's thread" : "Its thread is not available yet"}
+      disabled={!canOpen}
+      onPress={() => threadId !== null && props.onOpen(threadId)}
+      className="min-h-11 flex-row gap-3 border-t border-border-subtle px-4 py-3 active:opacity-70"
+    >
+      <View className="h-5 justify-center">
+        <SubagentStatusDot tone={presentation.tone} placement="sheet" />
+      </View>
+      <View className="min-w-0 flex-1 gap-1">
+        <View className="min-h-5 flex-row items-center gap-2">
+          <View className="min-w-0 flex-1 flex-row items-baseline gap-1.5">
+            <Text
+              textRole="footnote"
+              numberOfLines={1}
+              className="min-w-0 shrink font-t3-medium text-foreground"
+            >
+              {presentation.title}
+            </Text>
+            <Text
+              accessibilityElementsHidden
+              importantForAccessibility="no"
+              textRole="label"
+              className="shrink-0 text-foreground-muted"
+            >
+              ·
+            </Text>
+            <Text
+              textRole="label"
+              className={cn("shrink-0 font-t3-medium", SUBAGENT_TONE_TEXT_CLASS[presentation.tone])}
+            >
+              {presentation.statusLabel}
+            </Text>
+          </View>
+          <WorkflowElapsed timing={member} />
+          {canOpen ? (
+            <SymbolView name="chevron.right" size={12} tintColorClassName="accent-icon-subtle" />
+          ) : null}
+        </View>
+        {labels.length > 0 || metadata.speed !== null ? (
+          <View className="min-w-0 flex-row items-center">
+            <Text
+              textRole="label"
+              numberOfLines={1}
+              className="min-w-0 shrink text-foreground-muted"
+            >
+              {labels.join(" · ")}
+              {labels.length > 0 && metadata.speed !== null ? " · " : ""}
+            </Text>
+            {metadata.fast ? (
+              <View className="shrink-0 flex-row items-center gap-0.5">
+                <SymbolView
+                  name={{ ios: "bolt.fill", android: "bolt" }}
+                  size={11}
+                  tintColorClassName="accent-adaptive-amber-700-300"
+                />
+                <Text textRole="label" className="text-adaptive-amber-700-300">
+                  {metadata.speed}
+                </Text>
+              </View>
+            ) : metadata.speed !== null ? (
+              <Text textRole="label" className="shrink-0 text-foreground-muted">
+                {metadata.speed}
+              </Text>
+            ) : null}
+          </View>
+        ) : null}
+        {detail ? (
+          <Text textRole="label" numberOfLines={1} className="text-foreground-muted">
+            {detail}
+          </Text>
+        ) : null}
+        {error ? (
+          <Text textRole="label" numberOfLines={1} className={SUBAGENT_TONE_TEXT_CLASS.failed}>
+            {error}
+          </Text>
+        ) : null}
+      </View>
+    </RowPressable>
+  );
+}
+
+function WorkflowHeaderLayout(props: {
+  readonly label: string;
+  readonly statusLabel: string;
+  readonly timing: ElapsedTiming;
+  readonly accessory: ReactNode;
+}) {
+  const elapsed = useElapsedLabel(props.timing);
+  return (
+    <ListRowLayout
+      icon="point.3.connected.trianglepath.dotted"
+      label={props.label}
+      description={props.statusLabel}
+      detail={elapsed ?? undefined}
+      accessory={props.accessory}
+    />
+  );
+}
+
+function WorkflowElapsed(props: { readonly timing: ElapsedTiming }) {
+  const elapsed = useElapsedLabel(props.timing);
+  return elapsed === null ? null : (
+    <Text textRole="label" className="shrink-0 tabular-nums text-foreground-muted">
+      {elapsed}
+    </Text>
+  );
+}
+
+type ElapsedTiming = Parameters<typeof deriveSubagentElapsedMs>[0];
+
+function useElapsedLabel(timing: ElapsedTiming): string | null {
+  const nowMs = useVisibleSecondClock(isActiveSubagentStatus(timing.status));
+  const elapsedMs = deriveSubagentElapsedMs(timing, nowMs);
+  return elapsedMs === null || elapsedMs === 0 ? null : formatDuration(elapsedMs);
+}
diff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
index b2159706abeee..14a9720cb4e96 100644
--- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx
+++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
@@ -1,4 +1,6 @@
 import { ActiveNewTaskContext } from "../../state/active-new-task";
+import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
+import { useNowMinuteMs } from "../../lib/clock";
 import * as Dialog from "../../components/ui/Dialog";
 import React, { useEffect, useRef, useState } from "react";
 
@@ -483,6 +485,7 @@ export function NewTaskFlowProvider(
     selectedProjectDraft.modelSelection ?? null,
     selectedProject?.id ?? null,
   );
+  const modelSelectionNow = useNowMinuteMs();
   const projectDefaultModelSelection = resolveDefaultableModelSelection(
     selectedEnvironmentServerConfig,
     projectSettings.settings.defaultModelSelection,
@@ -501,12 +504,24 @@ export function NewTaskFlowProvider(
     selectedProject?.id ?? null,
   );
 
-  const selectedModel = resolveNewTaskModelSelection({
+  const selectedDefaultModel = resolveNewTaskModelSelection({
     draftSelection: draftModelSelection,
     projectDefaultSelection: projectDefaultModelSelection,
     stickySelection: stickyModelSelection,
     modelOptions,
   });
+  const selectedModel = resolveNewThreadModelSelection({
+    defaultSelection: selectedDefaultModel,
+    explicitSelection:
+      draftModelSelection ?? (projectDefaultModelSelection ? null : stickyModelSelection),
+    fallbackSelection: selectedEnvironmentServerConfig?.settings.fallbackModelSelection ?? null,
+    providers: selectedEnvironmentServerConfig?.providers ?? [],
+    ...(selectedEnvironmentServerConfig
+      ? { settings: selectedEnvironmentServerConfig.settings }
+      : {}),
+    projectId: selectedProject?.id ?? null,
+    now: modelSelectionNow,
+  }).selection;
   const selectedModelKey = selectedModel
     ? `${selectedModel.instanceId}:${selectedModel.model}`
     : null;
diff --git a/apps/mobile/src/features/threads/pending-thread-feed.test.ts b/apps/mobile/src/features/threads/pending-thread-feed.test.ts
index 314dc1aa477b5..3d9463c79bd06 100644
--- a/apps/mobile/src/features/threads/pending-thread-feed.test.ts
+++ b/apps/mobile/src/features/threads/pending-thread-feed.test.ts
@@ -114,14 +114,17 @@ describe("pending timeline messages", () => {
     expect(appendPendingThreadMessages([], [delivered], [queued])).toEqual([]);
   });
 
-  it("stops showing an acknowledged message once the projection holds it, even when the feed hides it", () => {
+  it("stops showing an acknowledged message once the thread catches up, even when the feed hides it", () => {
     // A rolled-back or cancelled queued run keeps its message in projection.messages
     // while its user_message item leaves the visible feed.
     const echoed = pending("rolled-back");
-    const waiting = pending("waiting");
-    const shown = selectPendingAcknowledgedMessages([echoed, waiting], {
+    // A bounded projection pages an applied message out; it must not come back as pending.
+    const pagedOut = { ...pending("paged-out"), sequence: 40 };
+    const waiting = { ...pending("waiting"), sequence: 50 };
+    const shown = selectPendingAcknowledgedMessages([echoed, pagedOut, waiting], {
       threadKey: "env:thread",
       queuedMessages: [],
+      sequence: 45,
       projectedMessages: [{ id: echoed.messageId }],
     });
     expect(shown).toEqual([waiting]);
diff --git a/apps/mobile/src/features/threads/pending-thread-feed.ts b/apps/mobile/src/features/threads/pending-thread-feed.ts
index 9eaf42dcee81b..d38cc026fdd62 100644
--- a/apps/mobile/src/features/threads/pending-thread-feed.ts
+++ b/apps/mobile/src/features/threads/pending-thread-feed.ts
@@ -5,7 +5,11 @@ import {
 } from "@t3tools/contracts";
 import type { ThreadFeedEntry } from "../../lib/threadActivity";
 import { scopedThreadKey } from "../../lib/scopedEntities";
-import type { QueuedThreadMessage } from "../../state/thread-outbox-model";
+import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/threads";
+import type {
+  AcknowledgedThreadMessage,
+  QueuedThreadMessage,
+} from "../../state/thread-outbox-model";
 
 /**
  * A guest's message waiting for the owner's Send or Dismiss. It is a feed row, not the list
@@ -24,21 +28,25 @@ export type PendingThreadFeedEntry = ThreadFeedEntry & {
   readonly acknowledged?: boolean;
 };
 
-// An acknowledged row stops being pending once the projection holds its message,
+// An acknowledged row stops being pending once the thread catches up to it,
 // even when the feed hides that message (a rolled-back or cancelled run).
 export function selectPendingAcknowledgedMessages(
-  acknowledged: ReadonlyArray<QueuedThreadMessage>,
+  acknowledged: ReadonlyArray<AcknowledgedThreadMessage>,
   thread: {
     readonly threadKey: string | null;
     readonly queuedMessages: ReadonlyArray<QueuedThreadMessage>;
+    readonly sequence: number;
     readonly projectedMessages: ReadonlyArray<{ readonly id: string }> | undefined;
   },
-): ReadonlyArray<QueuedThreadMessage> {
+): ReadonlyArray<AcknowledgedThreadMessage> {
   return acknowledged.filter(
     (message) =>
       scopedThreadKey(message.environmentId, message.threadId) === thread.threadKey &&
       !thread.queuedMessages.some((queued) => queued.messageId === message.messageId) &&
-      !thread.projectedMessages?.some((projected) => projected.id === message.messageId),
+      !threadHasCaughtUpTo(message, {
+        sequence: thread.sequence,
+        messages: thread.projectedMessages,
+      }),
   );
 }
 
diff --git a/apps/mobile/src/features/threads/thread-list-v2-items.tsx b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
index b519cd7227612..5b0c1fd2f5284 100644
--- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx
+++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx
@@ -62,6 +62,8 @@ import { useThreadPr } from "../../state/use-thread-pr";
 import { useSwipeRowDormant } from "../home/swipe-row-activation";
 import { ThreadSwipeable } from "../home/thread-swipe-actions";
 import { buildThreadTitleRegenerationMenuItems } from "./thread-title-regeneration-menu";
+import { canTurnThreadIntoProject, turnThreadIntoProject } from "./turnThreadIntoProject";
+import { threadCanArchive } from "../home/threadArchive";
 import {
   THREAD_LIST_V2_SETTLED_PAGE_COUNT,
   resolveThreadListV2SnoozeGateExpiryMs,
@@ -837,6 +839,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         : [],
     [props.autoSettleOptOutSupported, thread.autoSettleDisabledAt],
   );
+  const canTurnIntoProject = canTurnThreadIntoProject(thread);
   const titleMenuItems = useMemo<MenuAction[]>(
     () => [
       { id: "rename", title: "Rename", image: "square.and.pencil" },
@@ -844,8 +847,23 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
         supported: props.titleRegenerationSupported,
         isRegenerating: thread.titleRegeneration != null,
       }),
+      ...(canTurnIntoProject
+        ? [
+            {
+              id: "turn-into-project",
+              title: "Turn into project",
+              image: "folder.badge.plus",
+              attributes: { disabled: !threadCanArchive(thread.runtime) },
+            } satisfies MenuAction,
+          ]
+        : []),
+    ],
+    [
+      canTurnIntoProject,
+      props.titleRegenerationSupported,
+      thread.runtime,
+      thread.titleRegeneration,
     ],
-    [props.titleRegenerationSupported, thread.titleRegeneration],
   );
   const snoozableCardMenuActions = useMemo<MenuAction[]>(
     () => [
@@ -923,6 +941,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
       if (nativeEvent.event === "archive") handleArchive();
       if (nativeEvent.event === "rename") handleRename();
       if (nativeEvent.event === "regenerate-title") handleRegenerateTitle();
+      if (nativeEvent.event === "turn-into-project") void turnThreadIntoProject(thread);
       if (nativeEvent.event === "copy-thread") {
         const target = threadChipCopyTarget(
           { environmentId: thread.environmentId, threadId: thread.id },
@@ -1327,8 +1346,9 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
       >
         <View
           className={cn(
-            "min-h-[44px] flex-row items-center gap-2.5 py-2",
-            sidebarPane ? "px-3" : "px-5",
+            THREAD_LIST_V2_ROW_CONTENT_CLASS_NAME,
+            "min-h-[44px] flex-row items-center gap-2 py-2",
+            sidebarPane && "px-3",
           )}
         >
           {props.project ? (
diff --git a/apps/mobile/src/features/threads/thread-route-hydration.test.ts b/apps/mobile/src/features/threads/thread-route-hydration.test.ts
index 9d8ce88506fd5..9a7f1043609df 100644
--- a/apps/mobile/src/features/threads/thread-route-hydration.test.ts
+++ b/apps/mobile/src/features/threads/thread-route-hydration.test.ts
@@ -1,6 +1,11 @@
+import * as Option from "effect/Option";
 import { describe, expect, it } from "vite-plus/test";
 
-import { threadRouteIsHydrating } from "./thread-route-hydration";
+import {
+  threadDetailErrorIsCurrent,
+  threadRouteIsHydrating,
+  threadRouteOpensDraft,
+} from "./thread-route-hydration";
 
 const settled = {
   isLoadingConnections: false,
@@ -89,3 +94,62 @@ describe("threadRouteIsHydrating", () => {
     ).toBe(false);
   });
 });
+
+describe("threadRouteOpensDraft", () => {
+  it("keeps the route while a reconnecting environment may still deliver the thread", () => {
+    expect(threadRouteOpensDraft({ connectionState: "reconnecting", detailStatus: "empty" })).toBe(
+      false,
+    );
+  });
+
+  it("keeps the route while Reconnect retries a thread that failed to sync", () => {
+    const failedDetail = {
+      ...settled,
+      connectionState: "connecting" as const,
+      detailStatus: "empty" as const,
+      detailHasError: true,
+    };
+    expect(threadRouteIsHydrating(failedDetail)).toBe(false);
+    expect(threadRouteOpensDraft(failedDetail)).toBe(false);
+  });
+
+  it("opens a draft once the thread can't arrive", () => {
+    expect(
+      threadRouteOpensDraft({ connectionState: "reconnecting", detailStatus: "deleted" }),
+    ).toBe(true);
+    expect(threadRouteOpensDraft({ connectionState: "offline", detailStatus: "empty" })).toBe(true);
+  });
+});
+
+describe("threadDetailErrorIsCurrent", () => {
+  const oldError = Option.some("Could not synchronize the thread.");
+
+  it("ignores the error a thread kept from before the connection came back", () => {
+    const detailHasError = threadDetailErrorIsCurrent({
+      connectionState: "connected",
+      error: oldError,
+      errorBeforeConnected: oldError,
+    });
+    expect(detailHasError).toBe(false);
+    expect(threadRouteIsHydrating({ ...settled, detailStatus: "empty", detailHasError })).toBe(
+      true,
+    );
+  });
+
+  it("counts an error the live connection reported", () => {
+    expect(
+      threadDetailErrorIsCurrent({
+        connectionState: "connected",
+        error: Option.some("Could not synchronize the thread."),
+        errorBeforeConnected: oldError,
+      }),
+    ).toBe(true);
+    expect(
+      threadDetailErrorIsCurrent({
+        connectionState: "reconnecting",
+        error: oldError,
+        errorBeforeConnected: oldError,
+      }),
+    ).toBe(true);
+  });
+});
diff --git a/apps/mobile/src/features/threads/thread-route-hydration.ts b/apps/mobile/src/features/threads/thread-route-hydration.ts
index 626e34cd7bb28..a6e3454d47659 100644
--- a/apps/mobile/src/features/threads/thread-route-hydration.ts
+++ b/apps/mobile/src/features/threads/thread-route-hydration.ts
@@ -1,6 +1,7 @@
 import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
 import type { EnvironmentShellStatus } from "@t3tools/client-runtime/state/shell";
 import type { EnvironmentThreadStatus } from "@t3tools/client-runtime/state/threads";
+import * as Option from "effect/Option";
 
 export function threadRouteIsHydrating(input: {
   readonly isLoadingConnections: boolean;
@@ -41,3 +42,34 @@ export function threadRouteIsHydrating(input: {
     (input.connectionState === "connected" && input.detailStatus === "empty")
   );
 }
+
+/**
+ * Replacing the route with a draft can't be undone, so a thread that may still arrive keeps its
+ * route: a reconnecting environment often delivers it moments later, and Reconnect starts a
+ * fresh connecting attempt.
+ */
+export function threadRouteOpensDraft(input: {
+  readonly connectionState: EnvironmentConnectionPhase;
+  readonly detailStatus: EnvironmentThreadStatus;
+}): boolean {
+  if (input.detailStatus === "deleted") {
+    return true;
+  }
+  return input.connectionState !== "reconnecting" && input.connectionState !== "connecting";
+}
+
+/**
+ * A thread keeps its sync error until the new connection resubscribes, so the first renders after
+ * a reconnect still show the old connection's error. Only an error the live connection reported
+ * counts.
+ */
+export function threadDetailErrorIsCurrent<E>(input: {
+  readonly connectionState: EnvironmentConnectionPhase;
+  readonly error: Option.Option<E>;
+  readonly errorBeforeConnected: Option.Option<E>;
+}): boolean {
+  return (
+    Option.isSome(input.error) &&
+    !(input.connectionState === "connected" && input.error === input.errorBeforeConnected)
+  );
+}
diff --git a/apps/mobile/src/features/threads/threadAgentsPresentation.test.ts b/apps/mobile/src/features/threads/threadAgentsPresentation.test.ts
new file mode 100644
index 0000000000000..171d73a148597
--- /dev/null
+++ b/apps/mobile/src/features/threads/threadAgentsPresentation.test.ts
@@ -0,0 +1,352 @@
+import { describe, expect, it } from "vite-plus/test";
+import {
+  deriveWorkflowGroups,
+  projectedSubagentsToRuntime,
+} from "@t3tools/client-runtime/state/subagentRuntime";
+import {
+  NodeId,
+  ProviderDriverKind,
+  RunId,
+  ThreadId,
+  type OrchestrationV2SubagentWorkflow,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+
+import {
+  nextWorkflowSelection,
+  resolveSubagentRowPresentation,
+  resolveSubagentStopTarget,
+  workflowMemberDetail,
+  workflowMemberMetadata,
+  workflowRail,
+} from "./threadAgentsPresentation";
+
+const base = {
+  title: null,
+  prompt: "Audit the timestamps",
+  status: "running" as const,
+  result: null,
+  childThreadId: "thread-child" as never,
+};
+
+describe("resolveSubagentRowPresentation", () => {
+  it("leads with progress while the agent is working", () => {
+    const row = resolveSubagentRowPresentation({
+      ...base,
+      progress: "Reading files",
+      result: "stale result",
+    });
+
+    expect(row.detail).toBe("Reading files");
+    expect(row.tone).toBe("working");
+    expect(row.live).toBe(true);
+  });
+
+  it("leads with the result once the agent has settled", () => {
+    const row = resolveSubagentRowPresentation({
+      ...base,
+      status: "completed",
+      progress: "Reading files",
+      result: "Found two\n  problems",
+    });
+
+    expect(row.detail).toBe("Found two problems");
+    expect(row.tone).toBe("completed");
+    expect(row.statusLabel).toBe("Completed");
+  });
+
+  it("shows a failure's text, since that is where the error lands", () => {
+    const row = resolveSubagentRowPresentation({ ...base, status: "failed", result: "Timed out" });
+
+    expect(row.detail).toBe("Timed out");
+    expect(row.tone).toBe("failed");
+  });
+
+  it("falls back to a trimmed prompt when the agent has no title", () => {
+    const long = resolveSubagentRowPresentation({ ...base, prompt: "x".repeat(200) });
+    const titled = resolveSubagentRowPresentation({ ...base, title: "Subagent: /root/my_worker" });
+
+    expect(long.title).toHaveLength(80);
+    expect(long.title.endsWith("...")).toBe(true);
+    expect(titled.title).toBe("My Worker");
+  });
+
+  it("only offers a thread to open when the agent has one", () => {
+    expect(resolveSubagentRowPresentation(base).canOpenThread).toBe(true);
+    expect(resolveSubagentRowPresentation({ ...base, childThreadId: null }).canOpenThread).toBe(
+      false,
+    );
+  });
+
+  it("uses the status label when there is nothing to report yet", () => {
+    const row = resolveSubagentRowPresentation({ ...base, status: "pending" });
+
+    expect(row.detail).toBeNull();
+    expect(row.statusLabel).toBe("Working");
+  });
+
+  it("bounds long result previews without dropping the agent's status", () => {
+    const row = resolveSubagentRowPresentation({
+      ...base,
+      status: "failed",
+      result: "x".repeat(400),
+    });
+    expect(row.detail).toBe(`${"x".repeat(280)}…`);
+    expect(row.statusLabel).toBe("Failed");
+  });
+});
+
+type WorkflowAgent = OrchestrationV2SubagentWorkflow["agents"][number];
+
+const workflowRailOf = (
+  agents: ReadonlyArray<WorkflowAgent>,
+  status: "running" | "completed" = "running",
+) =>
+  workflowRail(
+    deriveWorkflowGroups(
+      projectedSubagentsToRuntime([
+        {
+          id: "workflow",
+          title: "Mobile Stop review",
+          prompt: "",
+          model: null,
+          status,
+          result: null,
+          startedAt: DateTime.makeUnsafe("2026-08-01T10:00:00.000Z"),
+          completedAt: null,
+          updatedAt: DateTime.makeUnsafe("2026-08-01T10:00:05.000Z"),
+          workflow: {
+            phases: [
+              { index: 0, title: "Inspect" },
+              { index: 1, title: "Verify" },
+              { index: 2, title: "Report" },
+            ],
+            agents,
+          },
+        },
+      ]),
+    )[0]!,
+  );
+
+const agent = (
+  index: number,
+  phaseIndex: number | undefined,
+  state: WorkflowAgent["state"],
+  overrides: Partial<WorkflowAgent> = {},
+): WorkflowAgent => ({
+  index,
+  label: `agent ${index}`,
+  state,
+  ...(phaseIndex === undefined ? {} : { phaseIndex }),
+  ...overrides,
+});
+
+describe("workflowRail", () => {
+  it("keeps declared phases without agents and gives unphased agents a stop", () => {
+    const rail = workflowRailOf([
+      agent(1, 0, "completed"),
+      agent(2, 1, "running"),
+      agent(3, undefined, "queued"),
+    ]);
+
+    expect(rail.map((item) => [item.title, item.tone, item.members.length])).toEqual([
+      ["Inspect", "completed", 1],
+      ["Verify", "working", 1],
+      ["Report", "queued", 0],
+      ["Other", "queued", 1],
+    ]);
+  });
+
+  it("counts only completed agents toward a failed phase's progress", () => {
+    const [phase] = workflowRailOf([agent(1, 0, "failed"), agent(2, 0, "completed")], "completed");
+
+    expect([phase!.tone, phase!.completedCount, phase!.members.length]).toEqual(["failed", 1, 2]);
+  });
+});
+
+describe("nextWorkflowSelection", () => {
+  const running = workflowRailOf([agent(1, 0, "completed"), agent(2, 1, "running")]);
+
+  it("opens the running phase from the collapsed title, then collapses", () => {
+    expect(nextWorkflowSelection(running, null)).toBe("1");
+    expect(nextWorkflowSelection(running, "1")).toBeNull();
+  });
+
+  it("prefers the failed phase, then the latest phase with agents", () => {
+    const failed = workflowRailOf([agent(1, 0, "failed"), agent(2, 1, "completed")], "completed");
+    const done = workflowRailOf([agent(1, 0, "completed"), agent(2, 1, "completed")], "completed");
+
+    expect(nextWorkflowSelection(failed, null)).toBe("0");
+    expect(nextWorkflowSelection(done, null)).toBe("1");
+    expect(nextWorkflowSelection(workflowRailOf([]), null)).toBeNull();
+  });
+
+  it("keeps one phase open: another replaces it and the open one collapses the card", () => {
+    expect(nextWorkflowSelection(running, null, "0")).toBe("0");
+    expect(nextWorkflowSelection(running, "1", "0")).toBe("0");
+    expect(nextWorkflowSelection(running, "0", "0")).toBeNull();
+  });
+});
+
+describe("workflow member rows", () => {
+  it("keeps reported model, effort, and speed once an agent completes", () => {
+    const [completed] = workflowRailOf(
+      [
+        agent(1, 0, "completed", {
+          model: "claude-opus-5-5",
+          effort: "high",
+          speed: "fast",
+          result: "Checked controls",
+        }),
+      ],
+      "completed",
+    )[0]!.members;
+
+    expect(workflowMemberMetadata(completed!, undefined)).toEqual({
+      model: "Claude Opus 5.5",
+      effort: "High",
+      speed: "Fast",
+      fast: true,
+    });
+    expect(workflowMemberDetail(completed!)).toEqual({ detail: "Checked controls", error: null });
+  });
+
+  it("reports nothing the provider did not send", () => {
+    expect(workflowMemberMetadata({ model: null, effort: null }, undefined)).toEqual({
+      model: null,
+      effort: null,
+      speed: null,
+      fast: false,
+    });
+  });
+
+  it("labels effort from the catalog model a reported alias resolves to", () => {
+    expect(
+      workflowMemberMetadata(
+        { model: "opus", effort: "xhigh" },
+        {
+          driver: ProviderDriverKind.make("claudeAgent"),
+          models: [
+            {
+              slug: "claude-opus-5-5",
+              name: "Claude Opus 5.5",
+              shortName: "Opus 5.5",
+              aliases: ["opus"],
+              isCustom: false,
+              capabilities: {
+                optionDescriptors: [
+                  {
+                    id: "effort",
+                    label: "Reasoning",
+                    type: "select",
+                    options: [{ id: "xhigh", label: "Extra High" }],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ),
+    ).toMatchObject({ model: "Opus 5.5", effort: "Extra High" });
+  });
+
+  it("shows a failed agent's error under its prompt", () => {
+    const [failed] = workflowRailOf([
+      agent(1, 0, "failed", { prompt: "Update session store", result: "Type error" }),
+    ])[0]!.members;
+
+    expect(workflowMemberDetail(failed!)).toEqual({
+      detail: "Update session store",
+      error: "Type error",
+    });
+  });
+});
+
+const stopAgent = {
+  id: NodeId.make("agent"),
+  threadId: ThreadId.make("parent"),
+  childThreadId: ThreadId.make("child"),
+  status: "running" as const,
+  origin: "app_owned" as const,
+  driver: ProviderDriverKind.make("codex"),
+  runId: RunId.make("run"),
+  nativeTaskRef: null,
+};
+
+describe("resolveSubagentStopTarget", () => {
+  it.each(["pending", "running", "waiting"] as const)(
+    "stops the parent task and child of an app-owned %s agent",
+    (status) => {
+      expect(resolveSubagentStopTarget({ ...stopAgent, status })).toEqual({
+        kind: "subagent",
+        input: { threadId: stopAgent.threadId, subagentId: stopAgent.id },
+      });
+      expect(resolveSubagentStopTarget({ ...stopAgent, status, childThreadId: null })).toBeNull();
+    },
+  );
+
+  it.each(["idle", "completed", "failed", "cancelled", "interrupted"] as const)(
+    "offers no Stop for a %s agent",
+    (status) => {
+      expect(resolveSubagentStopTarget({ ...stopAgent, status })).toBeNull();
+    },
+  );
+
+  const native = {
+    ...stopAgent,
+    origin: "provider_native" as const,
+    driver: ProviderDriverKind.make("claudeAgent"),
+    childThreadId: null,
+    nativeTaskRef: {
+      driver: ProviderDriverKind.make("claudeAgent"),
+      strength: "strong" as const,
+      nativeId: "native-task",
+    },
+  };
+
+  it("targets a supported native task without interrupting its parent run", () => {
+    expect(resolveSubagentStopTarget(native)).toEqual({
+      kind: "subagent",
+      input: { threadId: native.threadId, subagentId: native.id },
+    });
+  });
+
+  it("hides native Stop when the task cannot be identified or stopped", () => {
+    expect(resolveSubagentStopTarget({ ...native, nativeTaskRef: null })).toBeNull();
+    expect(
+      resolveSubagentStopTarget({
+        ...native,
+        nativeTaskRef: { ...native.nativeTaskRef, strength: "weak" },
+      }),
+    ).toBeNull();
+    expect(
+      resolveSubagentStopTarget({
+        ...native,
+        nativeTaskRef: { ...native.nativeTaskRef, nativeId: null },
+      }),
+    ).toBeNull();
+    expect(resolveSubagentStopTarget({ ...native, runId: null })).toBeNull();
+    expect(resolveSubagentStopTarget({ ...native, status: "completed" })).toBeNull();
+    expect(
+      resolveSubagentStopTarget({ ...native, driver: ProviderDriverKind.make("codex") }),
+    ).toBeNull();
+  });
+
+  it("stops the whole workflow through its own command", () => {
+    const workflow = { name: "Review", phases: [], agents: [] };
+    expect(resolveSubagentStopTarget({ ...native, workflow })).toEqual({
+      kind: "workflow",
+      input: { threadId: native.threadId, subagentId: native.id },
+    });
+    expect(resolveSubagentStopTarget({ ...native, workflow, status: "waiting" })).toBeNull();
+    expect(resolveSubagentStopTarget({ ...stopAgent, workflow })).toBeNull();
+    expect(resolveSubagentStopTarget({ ...native, workflow, nativeTaskRef: null })).toBeNull();
+    expect(
+      resolveSubagentStopTarget({
+        ...native,
+        workflow,
+        nativeTaskRef: { ...native.nativeTaskRef, nativeId: "" },
+      }),
+    ).toBeNull();
+  });
+});
diff --git a/apps/mobile/src/features/threads/threadAgentsPresentation.ts b/apps/mobile/src/features/threads/threadAgentsPresentation.ts
index 3bf82e35c403a..7f560497da254 100644
--- a/apps/mobile/src/features/threads/threadAgentsPresentation.ts
+++ b/apps/mobile/src/features/threads/threadAgentsPresentation.ts
@@ -1,9 +1,23 @@
 import {
   formatSubagentDisplayTitle,
+  resolveSubagentMetadata,
   subagentDetailPreview,
 } from "@t3tools/client-runtime/state/subagent-display";
-import { isActiveSubagentStatus } from "@t3tools/client-runtime/state/subagentRuntime";
-import type { EnvironmentId, OrchestrationV2Subagent, ThreadId } from "@t3tools/contracts";
+import {
+  isActiveSubagentStatus,
+  type RuntimeSubagent,
+  type SubagentWorkflowGroup,
+} from "@t3tools/client-runtime/state/subagentRuntime";
+import { REASONING_EFFORT_OPTION_IDS } from "@t3tools/client-runtime/state/thread-execution";
+import type {
+  EnvironmentId,
+  OrchestrationV2Subagent,
+  ServerProvider,
+  ThreadId,
+} from "@t3tools/contracts";
+import { resolveSelectableModel } from "@t3tools/shared/model";
+
+import { subagentCardDetail } from "./subagent-card-presentation";
 
 const PROMPT_TITLE_LIMIT = 80;
 
@@ -95,3 +109,146 @@ export function resolveSubagentRowPresentation(
     runsOn: subagent.remoteChild?.label ?? null,
   };
 }
+
+export type WorkflowRailTone = SubagentRowTone | "queued";
+
+export interface WorkflowRailItem {
+  readonly key: string;
+  readonly title: string;
+  readonly members: ReadonlyArray<RuntimeSubagent>;
+  readonly completedCount: number;
+  readonly tone: WorkflowRailTone;
+}
+
+function railTone(members: ReadonlyArray<RuntimeSubagent>): WorkflowRailTone {
+  if (members.every((member) => member.status === "pending")) return "queued";
+  if (members.some((member) => isActiveSubagentStatus(member.status) || member.status === "idle")) {
+    return "working";
+  }
+  if (members.some((member) => member.status === "failed")) return "failed";
+  return members.every((member) => member.status === "completed") ? "completed" : "stopped";
+}
+
+export function workflowRail(group: SubagentWorkflowGroup): ReadonlyArray<WorkflowRailItem> {
+  const items = group.phases.map((phase) => ({
+    key: String(phase.index),
+    title: phase.title,
+    members: phase.members,
+  }));
+  if (group.unphasedMembers.length > 0) {
+    items.push({
+      key: "unphased",
+      title: items.length === 0 ? "Agents" : "Other",
+      members: group.unphasedMembers,
+    });
+  }
+  return items.map((item) => ({
+    ...item,
+    completedCount: item.members.filter((member) => member.status === "completed").length,
+    tone: railTone(item.members),
+  }));
+}
+
+export function nextWorkflowSelection(
+  rail: ReadonlyArray<WorkflowRailItem>,
+  selected: string | null,
+  tapped?: string,
+): string | null {
+  const open = rail.some((item) => item.key === selected) ? selected : null;
+  if (tapped !== undefined) return tapped === open ? null : tapped;
+  if (open !== null) return null;
+  const filled = rail.filter((item) => item.members.length > 0);
+  return (
+    (
+      filled.find((item) => item.tone === "working") ??
+      filled.find((item) => item.tone === "failed") ??
+      filled.at(-1)
+    )?.key ?? null
+  );
+}
+
+function capitalize(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export function workflowMemberMetadata(
+  member: Pick<RuntimeSubagent, "model" | "effort" | "speed">,
+  provider: Pick<ServerProvider, "driver" | "models"> | undefined,
+) {
+  const model = member.model?.trim()
+    ? resolveSubagentMetadata({ model: member.model, provider }).modelLabel
+    : null;
+  const slug = provider
+    ? resolveSelectableModel(provider.driver, member.model, provider.models)
+    : null;
+  const effortChoice = provider?.models
+    .find((candidate) => candidate.slug === slug)
+    ?.capabilities?.optionDescriptors?.flatMap((descriptor) =>
+      descriptor.type === "select" && REASONING_EFFORT_OPTION_IDS.includes(descriptor.id)
+        ? descriptor.options
+        : [],
+    )
+    .find((option) => option.id === member.effort);
+  return {
+    model,
+    effort: member.effort ? (effortChoice?.label ?? capitalize(member.effort)) : null,
+    speed: member.speed ? capitalize(member.speed) : null,
+    fast: member.speed === "fast",
+  };
+}
+
+export function workflowMemberDetail(
+  member: Pick<RuntimeSubagent, "status" | "progress" | "result" | "error">,
+) {
+  return {
+    detail: subagentCardDetail(subagentDetailPreview(member)),
+    error: member.status === "failed" ? subagentCardDetail(member.error) : null,
+  };
+}
+
+export function resolveSubagentStopTarget(
+  subagent: Pick<
+    OrchestrationV2Subagent,
+    | "id"
+    | "threadId"
+    | "childThreadId"
+    | "status"
+    | "origin"
+    | "driver"
+    | "runId"
+    | "nativeTaskRef"
+    | "workflow"
+  >,
+) {
+  if (!isActiveSubagentStatus(subagent.status)) return null;
+  if (subagent.workflow !== undefined) {
+    return subagent.status === "running" &&
+      subagent.origin === "provider_native" &&
+      subagent.driver === "claudeAgent" &&
+      Boolean(subagent.nativeTaskRef?.nativeId)
+      ? {
+          kind: "workflow" as const,
+          input: { threadId: subagent.threadId, subagentId: subagent.id },
+        }
+      : null;
+  }
+  if (subagent.origin === "app_owned" && subagent.childThreadId !== null) {
+    return {
+      kind: "subagent" as const,
+      input: { threadId: subagent.threadId, subagentId: subagent.id },
+    };
+  }
+  if (
+    subagent.origin === "provider_native" &&
+    subagent.driver === "claudeAgent" &&
+    subagent.runId !== null &&
+    subagent.nativeTaskRef?.strength === "strong" &&
+    subagent.nativeTaskRef.nativeId !== null
+  ) {
+    return {
+      kind: "subagent" as const,
+      input: { threadId: subagent.threadId, subagentId: subagent.id },
+    };
+  }
+  return null;
+}
diff --git a/apps/mobile/src/features/threads/turnThreadIntoProject.ts b/apps/mobile/src/features/threads/turnThreadIntoProject.ts
new file mode 100644
index 0000000000000..44e6e03fe0d9b
--- /dev/null
+++ b/apps/mobile/src/features/threads/turnThreadIntoProject.ts
@@ -0,0 +1,47 @@
+import {
+  isAtomCommandInterrupted,
+  runAtomCommand,
+  squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
+import { AuthOrchestrationOperateScope } from "@t3tools/contracts";
+import * as Haptics from "expo-haptics";
+
+import * as Dialog from "../../components/ui/Dialog";
+import { appAtomRegistry } from "../../state/atom-registry";
+import { environmentProjects, projectEnvironment } from "../../state/projects";
+import { environmentServerConfigsAtom } from "../../state/server";
+import { readEnvironmentScope } from "../../state/session";
+
+/** A No project thread that already has its own folder, on a server that can promote it. */
+export function canTurnThreadIntoProject(thread: EnvironmentThreadShell): boolean {
+  if (thread.worktreePath === null) return false;
+  const config = appAtomRegistry.get(environmentServerConfigsAtom).get(thread.environmentId);
+  if (config?.environment.capabilities.threadProjectFromScratch !== true) return false;
+  const project = appAtomRegistry.get(
+    environmentProjects.projectAtom({
+      environmentId: thread.environmentId,
+      projectId: thread.projectId,
+    }),
+  );
+  return project?.isScratch === true;
+}
+
+export async function turnThreadIntoProject(thread: EnvironmentThreadShell): Promise<void> {
+  const title = "Could not turn thread into a project";
+  if (!readEnvironmentScope(thread.environmentId, AuthOrchestrationOperateScope)) {
+    Dialog.alert(title, "This connection cannot change threads.");
+    return;
+  }
+  void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light);
+  const result = await runAtomCommand(
+    appAtomRegistry,
+    projectEnvironment.createFromThread,
+    { environmentId: thread.environmentId, input: { threadId: thread.id } },
+    { reportFailure: false },
+  );
+  if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+    const error = squashAtomCommandFailure(result);
+    Dialog.alert(title, error instanceof Error ? error.message : "Try again.");
+  }
+}
diff --git a/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx b/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
index dedfed547c8e0..f38c4f05825a5 100644
--- a/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
+++ b/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
@@ -282,7 +282,8 @@ function VoiceActionButton(props: {
       style={{
         opacity: props.disabled && !props.loading ? 0.4 : 1,
         // Matches ComposerActionButton so the circle stays concentric with the large composer corner.
-        width: variant === "primary" && large ? 62 : undefined,
+        // An undefined width would still override the class's 44px width.
+        ...(variant === "primary" && large ? { width: 62 } : null),
       }}
     >
       <View
diff --git a/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx b/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
index 5f78aba083201..b9f497cae5608 100644
--- a/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
+++ b/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
@@ -128,10 +128,7 @@ function WorkspaceRootContent() {
 
   return (
     <WorkspaceTabsContext value={context}>
-      <View
-        className={`flex-1 ${sidebarPicker ? "bg-drawer" : surface.className}`}
-        style={sidebarPicker ? { paddingTop: insets.top } : undefined}
-      >
+      <View className={`flex-1 ${sidebarPicker ? "bg-drawer" : surface.className}`}>
         {Platform.OS === "ios" ? (
           <NativeStackScreenOptions
             optionsVersion={[
@@ -191,11 +188,7 @@ function WorkspaceRootContent() {
             ]}
           />
         )}
-        <SafeAreaInsetsContext
-          value={
-            sidebarPicker ? { ...insets, top: 0 } : compactTabs ? { ...insets, bottom: 0 } : insets
-          }
-        >
+        <SafeAreaInsetsContext value={compactTabs ? { ...insets, bottom: 0 } : insets}>
           {settingsOpen ? (
             <SettingsRouteScreen />
           ) : enabled.length === 0 ? (
diff --git a/apps/mobile/src/lib/composerFiles.test.ts b/apps/mobile/src/lib/composerFiles.test.ts
index 546c28f408f78..bdcd35c36ff75 100644
--- a/apps/mobile/src/lib/composerFiles.test.ts
+++ b/apps/mobile/src/lib/composerFiles.test.ts
@@ -124,28 +124,35 @@ describe("composer file attachments", () => {
       width: 4032,
       height: 3024,
     };
+    type Size = { width: number; height: number };
     const native = {
-      size: { width: 1, height: 1 },
-      resizes: [] as Array<{ width?: number | null; height?: number | null }>,
+      size: { width: 1, height: 1 } as Size,
+      resizes: [] as Size[],
       saved: rendered as { uri: string; base64?: string },
+      encode: null as ((size: Size, format: string) => { uri: string; base64?: string }) | null,
     };
 
     beforeEach(() => {
       native.size = { width: 1, height: 1 };
       native.resizes = [];
       native.saved = rendered;
+      native.encode = null;
       mocks.manipulate.mockReset();
       mocks.release.mockReset();
-      mocks.manipulate.mockImplementation(() => {
+      mocks.manipulate.mockImplementation((source: string | Size) => {
+        let size = typeof source === "string" ? native.size : source;
         const context = {
-          resize(size: { width?: number | null; height?: number | null }) {
-            native.resizes.push(size);
+          resize(next: Size) {
+            native.resizes.push(next);
+            size = next;
             return context;
           },
           renderAsync: async () => ({
-            ...native.size,
+            width: size.width,
+            height: size.height,
             release: mocks.release,
-            saveAsync: async () => native.saved,
+            saveAsync: async (options: { format: string }) =>
+              native.encode?.(size, options.format) ?? native.saved,
           }),
         };
         return context;
@@ -210,6 +217,45 @@ describe("composer file attachments", () => {
       ]);
     });
 
+    it("shrinks a fitted PNG further when re-encoding it exceeds the image limit", async () => {
+      const header = Buffer.alloc(24);
+      Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(header);
+      header.write("IHDR", 12);
+      header.writeUInt32BE(1668, 16);
+      header.writeUInt32BE(2388, 20);
+      native.size = { width: 1668, height: 2388 };
+      // Native PNG encoding of the 2000px resample is larger than the 7 MB original.
+      native.encode = (size, format) => ({
+        uri: `file:///cache/fitted-${size.width}x${size.height}.${format}`,
+        base64: Buffer.alloc(size.width * size.height * 4).toString("base64"),
+      });
+      mocks.size.mockReturnValue(7 * 1024 * 1024);
+      mocks.readBase64.mockResolvedValue(header.toString("base64"));
+      mocks.pickMedia.mockResolvedValue({
+        canceled: false,
+        assets: [{ ...photo, fileName: "IMG_9280.png", mimeType: "image/png" }],
+      });
+
+      const result = await pickComposerImages({ existingCount: 0 });
+
+      expect(result.error).toBeNull();
+      const [image] = result.images;
+      const last = native.resizes.at(-1)!;
+      expect(native.resizes[0]).toEqual({ width: 1397, height: 2000 });
+      expect(Math.max(last.width, last.height)).toBeLessThan(2000);
+      expect(image).toEqual(
+        expect.objectContaining({
+          name: "IMG_9280.png",
+          mimeType: "image/png",
+          sizeBytes: last.width * last.height * 4,
+          previewUri: `file:///cache/fitted-${last.width}x${last.height}.png`,
+        }),
+      );
+      expect(image!.sizeBytes).toBeLessThanOrEqual(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES);
+      expect(mocks.delete).toHaveBeenCalledWith("file:///cache/fitted-1397x2000.png");
+      expect(mocks.delete).not.toHaveBeenCalledWith(image!.previewUri);
+    });
+
     it("measures the picker file instead of trusting the reported size", async () => {
       mocks.pickMedia.mockResolvedValue({
         canceled: false,
diff --git a/apps/mobile/src/lib/composerImageFit.ts b/apps/mobile/src/lib/composerImageFit.ts
index fddeac277bcfe..18cd93b3fe723 100644
--- a/apps/mobile/src/lib/composerImageFit.ts
+++ b/apps/mobile/src/lib/composerImageFit.ts
@@ -1,3 +1,4 @@
+import { PROVIDER_SEND_TURN_MAX_IMAGE_BYTES } from "@t3tools/contracts";
 import {
   downscalableImageMimeType,
   fitImageAttachmentSize,
@@ -6,8 +7,24 @@ import {
   IMAGE_DIMENSIONS_HEADER_BYTES,
   readImageDimensions,
 } from "@t3tools/shared/imageDimensions";
+import { estimateBase64ByteSize } from "./base64";
 
 const PHOTO_JPEG_QUALITY = 0.85;
+const MAX_BYTE_LIMIT_SHRINKS = 3;
+
+function shrinkToByteLimit(
+  size: { readonly width: number; readonly height: number },
+  bytes: number,
+): { width: number; height: number } | null {
+  if (bytes <= PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) return null;
+  // Encoded size tracks pixel count, so scale each edge by the square root with some headroom.
+  const scale = Math.sqrt(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES / bytes) * 0.9;
+  const next = {
+    width: Math.max(1, Math.floor(size.width * scale)),
+    height: Math.max(1, Math.floor(size.height * scale)),
+  };
+  return next.width < size.width || next.height < size.height ? next : null;
+}
 
 export async function renderPhoto(
   uri: string,
@@ -16,21 +33,35 @@ export async function renderPhoto(
   const { ImageManipulator, SaveFormat } = await import("expo-image-manipulator");
   let image = await ImageManipulator.manipulate(uri).renderAsync();
   try {
-    const fittedSize = fitImageAttachmentSize(image);
-    if (fittedSize !== null) {
-      const resized = await ImageManipulator.manipulate(image).resize(fittedSize).renderAsync();
-      image.release();
-      image = resized;
-    }
-    const saved = await image.saveAsync({
-      format: format === "png" ? SaveFormat.PNG : SaveFormat.JPEG,
-      compress: PHOTO_JPEG_QUALITY,
-      base64: true,
-    });
-    if (!saved.base64) {
-      throw new Error("The rendered photo has no bytes.");
+    let size = fitImageAttachmentSize(image);
+    for (let shrinks = 0; ; shrinks += 1) {
+      if (size !== null) {
+        const resized = await ImageManipulator.manipulate(image).resize(size).renderAsync();
+        image.release();
+        image = resized;
+      }
+      const saved = await image.saveAsync({
+        format: format === "png" ? SaveFormat.PNG : SaveFormat.JPEG,
+        compress: PHOTO_JPEG_QUALITY,
+        base64: true,
+      });
+      if (!saved.base64) {
+        throw new Error("The rendered photo has no bytes.");
+      }
+      // PNG ignores compress, so a resampled PNG can encode larger than its original.
+      size =
+        shrinks < MAX_BYTE_LIMIT_SHRINKS
+          ? shrinkToByteLimit(image, estimateBase64ByteSize(saved.base64))
+          : null;
+      if (size === null) return { base64: saved.base64, uri: saved.uri };
+      try {
+        const { File } = await import("expo-file-system");
+        const discarded = new File(saved.uri);
+        if (discarded.exists) discarded.delete();
+      } catch (error) {
+        console.warn("[composer-images] could not remove discarded render", error);
+      }
     }
-    return { base64: saved.base64, uri: saved.uri };
   } finally {
     image.release();
   }
diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts
index 5060f359ebcd3..acdee2249c0d0 100644
--- a/apps/mobile/src/lib/threadActivity.test.ts
+++ b/apps/mobile/src/lib/threadActivity.test.ts
@@ -31,10 +31,6 @@ import {
   type ThreadFeedCache,
   type ThreadFeedEntry,
   type ThreadFeedLatestRun,
-  togglePendingUserInputOptionSelection,
-  setPendingUserInputCustomAnswer,
-  isPendingUserInputOptionSelected,
-  buildPendingUserInputAnswers,
 } from "./threadActivity";
 
 const threadId = ThreadId.make("thread-1");
@@ -1368,17 +1364,6 @@ describe("retained v2 feed presentation", () => {
   });
 });
 
-const singleSelectQuestion = {
-  id: "runtime",
-  header: "Runtime",
-  question: "Which runtime should be used?",
-  options: [
-    { label: "Go", description: "One binary" },
-    { label: "Node.js", description: "Reuse TypeScript" },
-  ],
-  multiSelect: false,
-} as const;
-
 describe("subagent continued by a later turn", () => {
   const run2 = RunId.make("run-2");
   const at = (second: number) => `2026-10-09T10:00:${String(second).padStart(2, "0")}.000Z`;
@@ -1454,95 +1439,6 @@ describe("subagent continued by a later turn", () => {
   });
 });
 
-describe("pending user input answers", () => {
-  it("preserves exact editor text, including a deliberately cleared answer", () => {
-    const question = { ...singleSelectQuestion, initialAnswer: "  Proposed message\n" };
-    expect(
-      buildPendingUserInputAnswers([question], {
-        runtime: { customAnswer: question.initialAnswer },
-      }),
-    ).toEqual({ runtime: question.initialAnswer });
-    expect(
-      buildPendingUserInputAnswers([question], {
-        runtime: { customAnswer: "  Edited message\n\n" },
-      }),
-    ).toEqual({ runtime: "  Edited message\n\n" });
-    expect(buildPendingUserInputAnswers([question], { runtime: { customAnswer: "" } })).toEqual({
-      runtime: "",
-    });
-    expect(buildPendingUserInputAnswers([question], { runtime: { customAnswer: " \n" } })).toEqual({
-      runtime: " \n",
-    });
-    expect(setPendingUserInputCustomAnswer(question, { selectedOptionValues: ["Go"] }, "")).toEqual(
-      { customAnswer: "" },
-    );
-  });
-});
-
-describe("provider question values", () => {
-  const question = {
-    ...singleSelectQuestion,
-    allowCustomAnswer: false,
-    options: [
-      { label: "Same label", value: "  exact first  ", description: "First" },
-      { label: "Same label", value: "second", description: "Second" },
-    ],
-  } as const;
-
-  it("submits raw option values and distinguishes duplicate labels", () => {
-    const first = togglePendingUserInputOptionSelection(question, undefined, "  exact first  ");
-    expect(isPendingUserInputOptionSelected(question, first, "  exact first  ")).toBe(true);
-    expect(isPendingUserInputOptionSelected(question, first, "second")).toBe(false);
-    expect(buildPendingUserInputAnswers([question], { runtime: first })).toEqual({
-      runtime: "  exact first  ",
-    });
-    expect(togglePendingUserInputOptionSelection(question, first, "Same label")).toBe(first);
-  });
-
-  it("rejects arbitrary text when the provider only accepts offered options", () => {
-    expect(setPendingUserInputCustomAnswer(question, undefined, "Other")).toEqual({});
-    expect(
-      buildPendingUserInputAnswers([question], { runtime: { customAnswer: "Other" } }),
-    ).toBeNull();
-    expect(
-      buildPendingUserInputAnswers([question], { runtime: { selectedOptionValues: ["unknown"] } }),
-    ).toBeNull();
-    expect(
-      buildPendingUserInputAnswers([question], {
-        runtime: { selectedOptionValues: ["second"], customAnswer: "stale draft" },
-      }),
-    ).toEqual({ runtime: "second" });
-  });
-});
-
-it("accepts ready attachment-only answers while preserving selected options", () => {
-  const question = {
-    id: "q",
-    header: "Spec",
-    question: "Provide a specification",
-    options: [{ label: "Yes", description: "Approve" }],
-    multiSelect: false,
-  };
-  expect(buildPendingUserInputAnswers([question], { q: { attachmentCount: 1 } })).toEqual({
-    q: "",
-  });
-  expect(
-    buildPendingUserInputAnswers([question], {
-      q: { attachmentCount: 1, selectedOptionValues: ["Yes"] },
-    }),
-  ).toEqual({ q: "Yes" });
-  expect(
-    buildPendingUserInputAnswers([question], {
-      q: { attachmentCount: 1, attachmentsBlocked: true },
-    }),
-  ).toBeNull();
-  expect(
-    buildPendingUserInputAnswers([{ ...question, allowCustomAnswer: false }], {
-      q: { attachmentCount: 1 },
-    }),
-  ).toBeNull();
-});
-
 it("stops stranded thinking after a steer and follows the next thought or tool", () => {
   const at = "2026-06-20T00:00:02.000Z";
   const thought = (id: string): OrchestrationV2TurnItem => ({
diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts
index fc085a7c50a0d..e17748d77aa6c 100644
--- a/apps/mobile/src/lib/threadActivity.ts
+++ b/apps/mobile/src/lib/threadActivity.ts
@@ -1,7 +1,6 @@
 import type {
   ThreadPendingApproval,
   ThreadPendingUserInput,
-  ThreadUserInputQuestion,
 } from "@t3tools/client-runtime/state/thread-requests";
 import { turnItemIsWorkspacePreparation } from "@t3tools/client-runtime/state/turn-item-presentation";
 import type { ThreadCheckpointSummary } from "@t3tools/client-runtime/state/thread-checkpoints";
@@ -81,13 +80,6 @@ import {
 export type PendingApproval = ThreadPendingApproval;
 export type PendingUserInput = ThreadPendingUserInput;
 
-export interface PendingUserInputDraftAnswer {
-  readonly selectedOptionValues?: ReadonlyArray<string>;
-  readonly customAnswer?: string;
-  readonly attachmentCount?: number;
-  readonly attachmentsBlocked?: boolean;
-}
-
 export interface ThreadFeedActivity {
   readonly id: string;
   readonly createdAt: string;
@@ -406,73 +398,6 @@ function isUserInputActivityGroup(entry: ThreadFeedActivityGroup): boolean {
   return entry.activities.some((activity) => activity.workEntry.questionAnswer !== undefined);
 }
 
-function normalizeDraftAnswer(value: string | undefined): string | null {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function resolvePendingUserInputOptionValue(
-  question: ThreadUserInputQuestion,
-  value: string,
-): string | null {
-  if (question.options.some((option) => option.value === value)) {
-    return value;
-  }
-
-  const label = value.trim();
-  return label.length > 0 &&
-    question.options.some((option) => option.value === undefined && option.label.trim() === label)
-    ? label
-    : null;
-}
-
-function normalizeSelectedOptionValues(
-  question: ThreadUserInputQuestion,
-  value: ReadonlyArray<string> | undefined,
-): ReadonlyArray<string> {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-
-  return Array.from(
-    new Set(
-      value
-        .map((entry) => resolvePendingUserInputOptionValue(question, entry))
-        .filter((entry): entry is string => entry !== null),
-    ),
-  );
-}
-
-function resolvePendingUserInputAnswer(
-  question: ThreadUserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-): string | ReadonlyArray<string> | null {
-  if (draft?.attachmentsBlocked) return null;
-  const customAnswer =
-    question.allowCustomAnswer === false
-      ? null
-      : question.initialAnswer !== undefined
-        ? (draft?.customAnswer ?? null)
-        : normalizeDraftAnswer(draft?.customAnswer);
-  if (customAnswer !== null && customAnswer.length > 0) {
-    return customAnswer;
-  }
-
-  const selectedOptionValues = normalizeSelectedOptionValues(question, draft?.selectedOptionValues);
-  if (question.multiSelect) {
-    return selectedOptionValues.length > 0
-      ? selectedOptionValues
-      : (customAnswer ??
-          (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null));
-  }
-  return (
-    selectedOptionValues[0] ??
-    customAnswer ??
-    (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null)
-  );
-}
-
 function capitalizePhrase(value: string): string {
   const trimmed = value.trim();
   return trimmed.length === 0 ? value : `${trimmed.charAt(0).toUpperCase()}${trimmed.slice(1)}`;
@@ -1974,93 +1899,6 @@ function liveToolActivitySummary(activity: ThreadFeedActivity, presentTense: boo
   return activity.detail ?? activity.summary;
 }
 
-export function setPendingUserInputCustomAnswer(
-  question: ThreadUserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-  customAnswer: string,
-): PendingUserInputDraftAnswer {
-  if (question.allowCustomAnswer === false) {
-    return draft ?? {};
-  }
-
-  const selectedOptionValues =
-    question.initialAnswer !== undefined || customAnswer.trim().length > 0
-      ? undefined
-      : normalizeSelectedOptionValues(question, draft?.selectedOptionValues);
-  return {
-    customAnswer,
-    ...(selectedOptionValues && selectedOptionValues.length > 0 ? { selectedOptionValues } : {}),
-  };
-}
-
-export function isPendingUserInputOptionSelected(
-  question: ThreadUserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-  optionValue: string,
-): boolean {
-  if (question.allowCustomAnswer !== false && normalizeDraftAnswer(draft?.customAnswer)) {
-    return false;
-  }
-
-  const resolvedOptionValue = resolvePendingUserInputOptionValue(question, optionValue);
-  return (
-    resolvedOptionValue !== null &&
-    normalizeSelectedOptionValues(question, draft?.selectedOptionValues).includes(
-      resolvedOptionValue,
-    )
-  );
-}
-
-export function togglePendingUserInputOptionSelection(
-  question: ThreadUserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-  optionValue: string,
-): PendingUserInputDraftAnswer {
-  const resolvedOptionValue = resolvePendingUserInputOptionValue(question, optionValue);
-  if (resolvedOptionValue === null) {
-    return draft ?? {};
-  }
-
-  if (question.multiSelect) {
-    const selectedOptionValues = normalizeSelectedOptionValues(
-      question,
-      draft?.selectedOptionValues,
-    );
-    const nextSelectedOptionValues = selectedOptionValues.includes(resolvedOptionValue)
-      ? selectedOptionValues.filter((value) => value !== resolvedOptionValue)
-      : [...selectedOptionValues, resolvedOptionValue];
-
-    return {
-      customAnswer: "",
-      ...(nextSelectedOptionValues.length > 0
-        ? { selectedOptionValues: nextSelectedOptionValues }
-        : {}),
-    };
-  }
-
-  return {
-    customAnswer: "",
-    selectedOptionValues: [resolvedOptionValue],
-  };
-}
-
-export function buildPendingUserInputAnswers(
-  questions: ReadonlyArray<ThreadUserInputQuestion>,
-  draftAnswers: Record<string, PendingUserInputDraftAnswer>,
-): Record<string, string | ReadonlyArray<string>> | null {
-  const answers: Record<string, string | ReadonlyArray<string>> = {};
-
-  for (const question of questions) {
-    const answer = resolvePendingUserInputAnswer(question, draftAnswers[question.id]);
-    if (answer === null) {
-      return null;
-    }
-    answers[question.id] = answer;
-  }
-
-  return answers;
-}
-
 interface ThreadFeedBuild {
   readonly rows: ReadonlyArray<OrchestrationV2ProjectedTurnItem>;
   readonly attempts: ReadonlyArray<OrchestrationV2RunAttempt> | undefined;
diff --git a/apps/mobile/src/state/acknowledged-thread-messages.ts b/apps/mobile/src/state/acknowledged-thread-messages.ts
index ab9f26dd7d412..d7935d1debcab 100644
--- a/apps/mobile/src/state/acknowledged-thread-messages.ts
+++ b/apps/mobile/src/state/acknowledged-thread-messages.ts
@@ -1,31 +1,39 @@
 import * as Option from "effect/Option";
 import { Atom } from "effect/reactivity";
 import { appAtomRegistry } from "./atom-registry";
-import type { QueuedThreadMessage } from "./thread-outbox-model";
+import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/threads";
+import type { AcknowledgedThreadMessage, QueuedThreadMessage } from "./thread-outbox-model";
 import { environmentThreadDetails } from "./threads";
 
-// Keep acknowledged rows until their subscribed projection arrives; command receipts can precede messages.
-// Render hides rows the projection has echoed, so dropping them here only frees memory.
-export const acknowledgedThreadMessagesAtom = Atom.make<ReadonlyArray<QueuedThreadMessage>>(
+// Keep acknowledged rows until the thread catches up; command receipts can precede messages.
+export const acknowledgedThreadMessagesAtom = Atom.make<ReadonlyArray<AcknowledgedThreadMessage>>(
   [],
 ).pipe(Atom.keepAlive);
 
 // Peeks at a thread only when something already has it in the registry: reading
 // it through the registry would open a snapshot load and a live stream of its own.
-function isEchoedInMountedThread(message: QueuedThreadMessage): boolean {
-  const threadAtom = environmentThreadDetails.threadAtom({
+function isEchoedInMountedThread(message: AcknowledgedThreadMessage): boolean {
+  const stateAtom = environmentThreadDetails.stateAtom({
     environmentId: message.environmentId,
     threadId: message.threadId,
   });
-  const node = appAtomRegistry.getNodes().get(threadAtom);
+  const node = appAtomRegistry.getNodes().get(stateAtom);
   if (node === undefined) return false;
-  const loaded: Option.Option<Atom.Type<typeof threadAtom>> = node.valueOption();
-  const thread = Option.getOrNull(loaded);
-  return thread?.projection.messages.some((entry) => entry.id === message.messageId) ?? false;
+  const loaded: Option.Option<Atom.Type<typeof stateAtom>> = node.valueOption();
+  return Option.match(loaded, {
+    onNone: () => false,
+    onSome: (thread) =>
+      threadHasCaughtUpTo(message, {
+        sequence: thread.sequence,
+        messages: Option.getOrUndefined(thread.data)?.messages,
+      }),
+  });
 }
 
 function writeAcknowledgedThreadMessages(
-  update: (current: ReadonlyArray<QueuedThreadMessage>) => ReadonlyArray<QueuedThreadMessage>,
+  update: (
+    current: ReadonlyArray<AcknowledgedThreadMessage>,
+  ) => ReadonlyArray<AcknowledgedThreadMessage>,
 ) {
   const current = appAtomRegistry.get(acknowledgedThreadMessagesAtom);
   const next = update(current).filter((entry) => !isEchoedInMountedThread(entry));
@@ -35,7 +43,7 @@ function writeAcknowledgedThreadMessages(
   appAtomRegistry.set(acknowledgedThreadMessagesAtom, next);
 }
 
-export function retainAcknowledgedThreadMessage(message: QueuedThreadMessage) {
+export function retainAcknowledgedThreadMessage(message: AcknowledgedThreadMessage) {
   writeAcknowledgedThreadMessages((current) =>
     current.some((entry) => entry.messageId === message.messageId)
       ? current
diff --git a/apps/mobile/src/state/thread-outbox-model.ts b/apps/mobile/src/state/thread-outbox-model.ts
index 16f2de8f099b4..6c5da0db20991 100644
--- a/apps/mobile/src/state/thread-outbox-model.ts
+++ b/apps/mobile/src/state/thread-outbox-model.ts
@@ -287,3 +287,8 @@ export function resolveThreadOutboxFailureAction(input: {
   }
   return "restore";
 }
+
+export type AcknowledgedThreadMessage = QueuedThreadMessage & {
+  /** The server sequence that committed the message; older servers do not report it. */
+  readonly sequence?: number;
+};
diff --git a/apps/mobile/src/state/thread-task-permissions.test.ts b/apps/mobile/src/state/thread-task-permissions.test.ts
index acfdd803d4259..0b529e9947805 100644
--- a/apps/mobile/src/state/thread-task-permissions.test.ts
+++ b/apps/mobile/src/state/thread-task-permissions.test.ts
@@ -113,6 +113,7 @@ vi.mock("./threads", async () => {
     environmentThreadDetails: {
       queueWorkflowAtom: () => Atom.make(null),
       checkpointSummariesAtom: () => Atom.make([]),
+      sequenceAtom: () => Atom.make(0),
       pendingRequestsAtom: () => Atom.make(state.pendingRequests),
     },
     threadEnvironment: {
diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts
index edc80c5007024..0ea64764e5da2 100644
--- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts
+++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts
@@ -100,7 +100,7 @@ vi.mock("./threads", async () => {
       familyAtom: () => Atom.make(AsyncResult.success({})),
       refresh: vi.fn(),
     },
-    environmentThreadDetails: { threadAtom: () => Atom.make(null) },
+    environmentThreadDetails: { stateAtom: () => Atom.make(null) },
   };
 });
 vi.mock("./git", () => ({ gitEnvironment: { preparePullRequestThread: state.checkout } }));
@@ -224,6 +224,7 @@ beforeEach(() => {
   ]) {
     command.mockReset().mockResolvedValue(AsyncResult.success(undefined));
   }
+  state.start.mockResolvedValue(AsyncResult.success({}));
   state.prepare.mockReset().mockImplementation(async ({ attachments }) => ({
     status: "ready",
     attachments: [],
@@ -427,7 +428,8 @@ describe("queued task operation access", () => {
       );
       await state.manager.enqueue(queued);
       const started = Promise.withResolvers<void>();
-      const delivery = Promise.withResolvers<AsyncResult.AsyncResult<void, Error>>();
+      const delivery =
+        Promise.withResolvers<AsyncResult.AsyncResult<{ readonly sequence?: number }, Error>>();
       state.start.mockImplementationOnce(() => {
         started.resolve();
         return delivery.promise;
@@ -437,7 +439,7 @@ describe("queued task operation access", () => {
       setOperateGrant("secondary", false);
       delivery.resolve(
         accepted
-          ? AsyncResult.success(undefined)
+          ? AsyncResult.success({})
           : AsyncResult.failure(Cause.fail(new Error("This connection cannot control this task."))),
       );
       await drained;
diff --git a/apps/mobile/src/state/threadOutboxDelivery.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts
index 901ffaa9e8291..d77ffe1942b6c 100644
--- a/apps/mobile/src/state/threadOutboxDelivery.test.ts
+++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts
@@ -13,9 +13,12 @@ import type { PreparedTurnAttachments } from "../lib/attachmentUpload";
 
 const harness = vi.hoisted(() => ({
   canOperate: true,
-  threadProjection: null as unknown as import("effect/reactivity").Atom.Writable<{
-    readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> };
-  } | null>,
+  threadState: null as unknown as import("effect/reactivity").Atom.Writable<{
+    readonly data: import("effect/Option").Option<{
+      readonly messages: ReadonlyArray<{ readonly id: string }>;
+    }>;
+    readonly sequence: number;
+  }>,
   manager: null as unknown as ReturnType<
     typeof import("./thread-outbox-manager").createThreadOutboxManager
   >,
@@ -92,12 +95,14 @@ vi.mock("./git", () => ({ gitEnvironment: {} }));
 
 vi.mock("./threads", async () => {
   const { Atom } = await import("effect/reactivity");
-  harness.threadProjection = Atom.make<{
-    readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> };
-  } | null>(null).pipe(Atom.keepAlive);
+  const Option = await import("effect/Option");
+  harness.threadState = Atom.make({
+    data: Option.none<{ readonly messages: ReadonlyArray<{ readonly id: string }> }>(),
+    sequence: 0,
+  }).pipe(Atom.keepAlive);
   return {
     threadEnvironment: {},
-    environmentThreadDetails: { threadAtom: () => harness.threadProjection },
+    environmentThreadDetails: { stateAtom: () => harness.threadState },
   };
 });
 
@@ -138,6 +143,7 @@ vi.mock("./thread-outbox", async () => {
   };
 });
 
+import * as Option from "effect/Option";
 import { appAtomRegistry } from "./atom-registry";
 import { pendingThreadCreationOutcomesAtom } from "./pending-thread-creation";
 import { clearThreadComposerError, threadComposerErrorsAtom } from "./thread-composer-error";
@@ -204,7 +210,7 @@ function remainingMessages(): ReadonlyArray<QueuedThreadMessage> {
 
 beforeEach(() => {
   appAtomRegistry.set(acknowledgedThreadMessagesAtom, []);
-  appAtomRegistry.set(harness.threadProjection, null);
+  appAtomRegistry.set(harness.threadState, { data: Option.none(), sequence: 0 });
   harness.canOperate = true;
   harness.draftFile.setDocument({ schemaVersion: 1, drafts: {} });
 });
@@ -330,26 +336,32 @@ describe("thread outbox attachment preparation", () => {
 });
 
 describe("thread outbox drain delivery cleanup", () => {
-  it("drops echoed acknowledged rows at the next delivery without subscribing to the thread", async () => {
+  it("drops caught-up acknowledged rows at the next delivery without subscribing to the thread", async () => {
     const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" });
     const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" });
     await harness.manager.enqueue(first);
     await harness.manager.enqueue(second);
 
     await expect(
-      completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId)),
+      completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId), 7),
     ).resolves.toBe("removed");
-    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]);
-
-    appAtomRegistry.set(harness.threadProjection, {
-      projection: { messages: [{ id: "unrelated" }, { id: first.messageId }] },
+    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
+      { ...first, sequence: 7 },
+    ]);
+
+    // The thread applied the message, but its bounded window does not hold it.
+    appAtomRegistry.set(harness.threadState, {
+      data: Option.some({ messages: [{ id: "unrelated" }] }),
+      sequence: 7,
     });
-    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]);
+    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1);
 
     await expect(
-      completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId)),
+      completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId), 9),
     ).resolves.toBe("removed");
-    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([second]);
+    expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
+      { ...second, sequence: 9 },
+    ]);
   });
 
   it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => {
@@ -359,7 +371,11 @@ describe("thread outbox drain delivery cleanup", () => {
     harness.draftFile.setWriteError(new Error("Draft storage unavailable"));
 
     await expect(
-      completeQueuedMessageDelivery(message, harness.manager.revisionOf(message.messageId)),
+      completeQueuedMessageDelivery(
+        message,
+        harness.manager.revisionOf(message.messageId),
+        undefined,
+      ),
     ).resolves.toBe("removed");
     expect(remainingMessages()).toEqual([]);
 
@@ -390,9 +406,9 @@ describe("thread outbox drain delivery cleanup", () => {
       ).toEqual([message]);
 
       if (cleared) await harness.manager.clearEnvironment(message.environmentId);
-      await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe(
-        cleared ? "edited" : "removed",
-      );
+      await expect(
+        completeQueuedMessageDelivery(message, deliveryRevision, undefined),
+      ).resolves.toBe(cleared ? "edited" : "removed");
 
       appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, {
         accountId: null,
@@ -412,7 +428,9 @@ describe("thread outbox drain delivery cleanup", () => {
     await harness.manager.update(edited);
     await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]));
     await harness.manager.clearEnvironment(message.environmentId);
-    await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("edited");
+    await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
+      "edited",
+    );
     await composerDrafts.restoreCloudComposerDrafts("account-a");
     expect(remainingMessages()).toEqual([edited]);
   });
@@ -447,7 +465,9 @@ describe("thread outbox drain delivery cleanup", () => {
     const edited = { ...message, text: "edited while the turn delivered" };
     await harness.manager.update(edited);
 
-    await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("edited");
+    await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
+      "edited",
+    );
 
     expect(remainingMessages()).toEqual([edited]);
     expect(harness.removePersistedFile).not.toHaveBeenCalled();
@@ -458,7 +478,9 @@ describe("thread outbox drain delivery cleanup", () => {
     await harness.manager.enqueue(message);
     const deliveryRevision = harness.manager.revisionOf(message.messageId);
 
-    await expect(completeQueuedMessageDelivery(message, deliveryRevision)).resolves.toBe("removed");
+    await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
+      "removed",
+    );
 
     expect(remainingMessages()).toEqual([]);
     expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]);
@@ -479,7 +501,7 @@ describe("thread outbox drain delivery cleanup", () => {
     await harness.manager.enqueue(message);
     const deliveryRevision = harness.manager.revisionOf(message.messageId);
 
-    const cleanup = completeQueuedMessageDelivery(message, deliveryRevision);
+    const cleanup = completeQueuedMessageDelivery(message, deliveryRevision, undefined);
     await removeStarted.promise;
     appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
     removeBarrier.resolve();
diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts
index 5ba633de634a7..4a20db3b9e965 100644
--- a/apps/mobile/src/state/threadOutboxDelivery.ts
+++ b/apps/mobile/src/state/threadOutboxDelivery.ts
@@ -250,6 +250,7 @@ function isQueuedMessagePayloadCurrent(
 export async function completeQueuedMessageDelivery(
   queuedMessage: QueuedThreadMessage,
   deliveryRevision: number,
+  sequence: number | undefined,
 ): Promise<"removed" | "edited" | "failed"> {
   clearThreadComposerError(
     scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
@@ -266,7 +267,9 @@ export async function completeQueuedMessageDelivery(
     if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
       return "edited";
     }
-    retainAcknowledgedThreadMessage(queuedMessage);
+    retainAcknowledgedThreadMessage(
+      sequence === undefined ? queuedMessage : { ...queuedMessage, sequence },
+    );
     const removed = await removeThreadOutboxMessage(
       queuedMessage,
       deliveryRevision,
@@ -616,6 +619,12 @@ const settledCreationOutcomeKeysAtom = Atom.make((get): ReadonlyArray<string> =>
   );
 }).pipe(Atom.withLabel("mobile:thread-outbox:settled-creation-outcomes"));
 
+function deliveredSequence(
+  result: AtomCommandResult<{ readonly sequence?: number }, unknown>,
+): number | undefined {
+  return AsyncResult.isSuccess(result) ? result.value.sequence : undefined;
+}
+
 const runDeliveryCommand = <W, A, E>(
   command: AtomCommand<W, A, E>,
   input: W,
@@ -896,7 +905,11 @@ export function createThreadOutboxDelivery(): {
     }
     acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId);
     const delivered =
-      (await completeQueuedMessageDelivery(persistedMessage, deliveryRevision)) === "removed";
+      (await completeQueuedMessageDelivery(
+        persistedMessage,
+        deliveryRevision,
+        deliveredSequence(deliveryResult),
+      )) === "removed";
     if (delivered) {
       acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId);
     }
@@ -1052,7 +1065,11 @@ export function createThreadOutboxDelivery(): {
       return restoreQueuedMessage(persistedMessage, failure.message);
     }
     recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage });
-    const outcome = await completeQueuedMessageDelivery(persistedMessage, deliveryRevision);
+    const outcome = await completeQueuedMessageDelivery(
+      persistedMessage,
+      deliveryRevision,
+      deliveredSequence(deliveryResult),
+    );
     if (outcome === "edited") {
       if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
         return true;
diff --git a/apps/mobile/src/state/use-selected-thread-requests.ts b/apps/mobile/src/state/use-selected-thread-requests.ts
index f869719601750..d4bbc6bfe5bc0 100644
--- a/apps/mobile/src/state/use-selected-thread-requests.ts
+++ b/apps/mobile/src/state/use-selected-thread-requests.ts
@@ -42,7 +42,7 @@ import {
   setPendingUserInputCustomAnswer,
   togglePendingUserInputOptionSelection,
   type PendingUserInputDraftAnswer,
-} from "../lib/threadActivity";
+} from "@t3tools/client-runtime/state/pending-user-input";
 import { appAtomRegistry } from "./atom-registry";
 import { useSelectedThreadPendingRequests } from "./use-thread-detail";
 import { useThreadSelection } from "./use-thread-selection";
diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts
index 45f06e198f47a..4c14fb56254cf 100644
--- a/apps/mobile/src/state/use-thread-composer-state.ts
+++ b/apps/mobile/src/state/use-thread-composer-state.ts
@@ -110,6 +110,7 @@ const EMPTY_QUEUE_WORKFLOW_ATOM = Atom.make<null>(null).pipe(
   Atom.withLabel("mobile-thread-queue-workflow:empty"),
 );
 const EMPTY_CHECKPOINT_SUMMARIES_ATOM = Atom.make<ReadonlyArray<ThreadCheckpointSummary>>([]);
+const EMPTY_THREAD_SEQUENCE_ATOM = Atom.make(0);
 
 export function appendReviewCommentToDraft(input: {
   readonly environmentId: EnvironmentId;
@@ -227,6 +228,11 @@ export function useThreadComposerState() {
   const selectedThreadMessages = selectedThreadProjection?.projection.messages;
   const selectedThreadAttempts = selectedThreadProjection?.projection.attempts;
   const selectedThreadNodes = selectedThreadProjection?.projection.nodes;
+  const selectedThreadSequence = useAtomValue(
+    selectedThreadDetailRef === null
+      ? EMPTY_THREAD_SEQUENCE_ATOM
+      : environmentThreadDetails.sequenceAtom(selectedThreadDetailRef),
+  );
   const checkpointSummaries = useAtomValue(
     selectedThreadDetailRef === null
       ? EMPTY_CHECKPOINT_SUMMARIES_ATOM
@@ -254,6 +260,7 @@ export function useThreadComposerState() {
     const pendingAcknowledgments = selectPendingAcknowledgedMessages(acknowledgedMessages, {
       threadKey: selectedThreadKey,
       queuedMessages: selectedThreadQueuedMessages,
+      sequence: selectedThreadSequence,
       projectedMessages: selectedThreadMessages,
     });
     if (pendingAcknowledgments.length === 0) return feed;
diff --git a/apps/server/package.json b/apps/server/package.json
index 5abc769412d1a..9ee890670abbf 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "t3",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -58,6 +58,7 @@
     "@t3tools/source-control-github": "workspace:*",
     "@t3tools/source-control-gitlab": "workspace:*",
     "character-entities": "2.0.2",
+    "diff": "8.0.3",
     "effect": "catalog:",
     "jose": "catalog:",
     "node-pty": "^1.2.0-beta.15",
diff --git a/apps/server/scripts/acp-mock-agent.ts b/apps/server/scripts/acp-mock-agent.ts
index 3d11bc8e7083c..a10f9855cbbbf 100644
--- a/apps/server/scripts/acp-mock-agent.ts
+++ b/apps/server/scripts/acp-mock-agent.ts
@@ -38,6 +38,7 @@ const omitInitializeModelState = process.env.T3_ACP_OMIT_INITIALIZE_MODEL_STATE
 const completeFirstPromptOnCancel = process.env.T3_ACP_COMPLETE_FIRST_PROMPT_ON_CANCEL === "1";
 const floodStderr = process.env.T3_ACP_FLOOD_STDERR === "1";
 const hangPromptForever = process.env.T3_ACP_HANG_PROMPT_FOREVER === "1";
+const emitTrackedToolCallKindThenHang = process.env.T3_ACP_EMIT_TRACKED_TOOL_CALL_KIND_THEN_HANG;
 const clientFsProbePath = process.env.T3_ACP_CLIENT_FS_PROBE_PATH;
 const clientFsProbeLogPath = process.env.T3_ACP_CLIENT_FS_PROBE_LOG_PATH;
 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
@@ -1265,6 +1266,21 @@ const program = Effect.gen(function* () {
         return yield* AcpError.AcpRequestError.internalError("Mock prompt failure");
       }
 
+      if (emitTrackedToolCallKindThenHang !== undefined) {
+        yield* agent.client.sessionUpdate({
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "tracked-tool-call",
+            title: "git status",
+            kind: emitTrackedToolCallKindThenHang as AcpSchema.ToolKind,
+            status: "pending",
+            rawInput: { command: "git status" },
+          },
+        });
+        return yield* Effect.never;
+      }
+
       if (hangPromptForever || (emitEmptySuccessfulBashThenHang && promptCount === 2)) {
         return yield* Effect.never;
       }
diff --git a/apps/server/src/auth/McpOAuth.ts b/apps/server/src/auth/McpOAuth.ts
index 8f664f5bc7cba..10aa0e430d742 100644
--- a/apps/server/src/auth/McpOAuth.ts
+++ b/apps/server/src/auth/McpOAuth.ts
@@ -573,6 +573,7 @@ export const layerMcpClientAuthenticator = Layer.effect(
                     label: client.label,
                     access: client.access,
                     linked: client.peerLink,
+                    ...(client.peerLink ? {} : { webOrigin: requestUrls(request).issuer }),
                   },
                   capabilities: new Set<McpInvocationContext.McpCapability>([
                     "orchestration",
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index f127f94fdba35..a1b05c32a0027 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -193,6 +193,7 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.deviceConfigure]: AuthSettingsWriteScope,
   [WS_METHODS.deviceTestHost]: AuthSettingsWriteScope,
   [WS_METHODS.deviceEasAccount]: AuthSettingsWriteScope,
+  [WS_METHODS.deviceSimlockIdentity]: AuthSettingsWriteScope,
   [WS_METHODS.deviceList]: AuthOrchestrationReadScope,
   [WS_METHODS.deviceOpen]: AuthOrchestrationOperateScope,
   [WS_METHODS.deviceClose]: AuthOrchestrationOperateScope,
diff --git a/apps/server/src/cli/consoleStdin.test.ts b/apps/server/src/cli/consoleStdin.test.ts
new file mode 100644
index 0000000000000..c799d3c2a5e10
--- /dev/null
+++ b/apps/server/src/cli/consoleStdin.test.ts
@@ -0,0 +1,127 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+const io = vi.hoisted(() => ({
+  platform: vi.fn(() => "win32"),
+  stat: vi.fn(() => ({ isCharacterDevice: (): boolean => true })),
+  open: vi.fn(() => 42),
+  close: vi.fn(),
+  isatty: vi.fn((fd: number) => fd !== 0),
+}));
+
+vi.mock("node:fs", () => ({ fstatSync: io.stat, openSync: io.open, closeSync: io.close }));
+vi.mock("node:tty", async () => {
+  const { EventEmitter } = await import("node:events");
+  return {
+    isatty: io.isatty,
+    ReadStream: class extends EventEmitter {
+      readonly isTTY = true;
+      readonly _readableState = { reading: true };
+      _handle: { reading: boolean; readStop: () => void } | undefined = {
+        reading: true,
+        readStop: vi.fn(),
+      };
+    },
+  };
+});
+vi.mock("@t3tools/shared/HostProcess", () => ({ Platform: { defaultValue: io.platform } }));
+
+const originalStdin = Object.getOwnPropertyDescriptor(process, "stdin")!;
+
+beforeEach(() => {
+  vi.resetModules();
+  vi.resetAllMocks();
+  vi.stubEnv("T3CODE_DESKTOP_CLI_LAUNCHER", "1");
+});
+
+afterEach(() => {
+  Object.defineProperty(process, "stdin", originalStdin);
+  vi.unstubAllEnvs();
+});
+
+describe("attachConsoleStdin", () => {
+  it("reopens the console when Node replaces missing Windows stdin with NUL", async () => {
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+
+    expect(attachConsoleStdin()).toBe(42);
+    expect(process.stdin.isTTY).toBe(true);
+    expect(interactiveStdin()).toBe(42);
+    expect(process.env.T3CODE_DESKTOP_CLI_LAUNCHER).toBeUndefined();
+  });
+
+  it("releases console reads when the picker pauses stdin before launching an agent", async () => {
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+    attachConsoleStdin();
+    const stdin = process.stdin as unknown as {
+      emit(event: string): boolean;
+      _readableState: { reading: boolean };
+      _handle: { reading: boolean; readStop: () => void };
+    };
+    stdin.emit("pause");
+    expect(stdin._readableState.reading).toBe(false);
+    expect(stdin._handle.reading).toBe(false);
+    expect(stdin._handle.readStop).toHaveBeenCalledOnce();
+    expect(interactiveStdin()).toBe(42);
+  });
+
+  it("can pause after the reopened stream's handle has been closed", async () => {
+    const { attachConsoleStdin } = await import("./consoleStdin.ts");
+    attachConsoleStdin();
+    const stdin = process.stdin as unknown as {
+      emit(event: string): boolean;
+      _handle: undefined;
+    };
+    stdin._handle = undefined;
+    expect(() => stdin.emit("pause")).not.toThrow();
+  });
+
+  it("still reopens a closed stdin", async () => {
+    io.stat.mockImplementation(() => {
+      throw new Error("EBADF");
+    });
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+    expect(attachConsoleStdin()).toBe(42);
+    expect(interactiveStdin()).toBe(42);
+  });
+
+  it.each(["pipe", "file"])("preserves redirected %s input", async () => {
+    io.stat.mockReturnValue({ isCharacterDevice: () => false });
+    const stdin = process.stdin;
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+    expect(attachConsoleStdin()).toBeUndefined();
+    expect(process.stdin).toBe(stdin);
+    expect(interactiveStdin()).toBe("inherit");
+    expect(io.open).not.toHaveBeenCalled();
+  });
+
+  it.each(["console input", "redirected output", "unmarked process", "non-Windows"])(
+    "leaves %s alone",
+    async (scenario) => {
+      if (scenario === "console input") io.isatty.mockReturnValue(true);
+      if (scenario === "redirected output") io.isatty.mockReturnValue(false);
+      if (scenario === "unmarked process") delete process.env.T3CODE_DESKTOP_CLI_LAUNCHER;
+      if (scenario === "non-Windows") io.platform.mockReturnValue("darwin");
+      const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+      expect(attachConsoleStdin()).toBeUndefined();
+      expect(interactiveStdin()).toBe("inherit");
+      expect(io.open).not.toHaveBeenCalled();
+      expect(process.env.T3CODE_DESKTOP_CLI_LAUNCHER).toBeUndefined();
+    },
+  );
+
+  it("keeps inherited input when CONIN$ cannot be opened", async () => {
+    io.open.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+    expect(attachConsoleStdin()).toBeUndefined();
+    expect(interactiveStdin()).toBe("inherit");
+  });
+
+  it("closes a reopened descriptor that is not a console", async () => {
+    io.isatty.mockImplementation((fd) => fd === 1);
+    const { attachConsoleStdin, interactiveStdin } = await import("./consoleStdin.ts");
+    expect(attachConsoleStdin()).toBeUndefined();
+    expect(interactiveStdin()).toBe("inherit");
+    expect(io.close).toHaveBeenCalledWith(42);
+  });
+});
diff --git a/apps/server/src/cli/consoleStdin.ts b/apps/server/src/cli/consoleStdin.ts
index 91232cb310871..18ee7bed6d5a1 100644
--- a/apps/server/src/cli/consoleStdin.ts
+++ b/apps/server/src/cli/consoleStdin.ts
@@ -5,31 +5,30 @@ import * as NodeTty from "node:tty";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 
 /**
- * Electron's Windows executable is a GUI program, so `t3.cmd` under
- * `ELECTRON_RUN_AS_NODE` gets the console for stdout and stderr but no stdin.
- * Piped or redirected input and runs whose output is not a console are left alone.
+ * Electron's Windows launcher has no stdin; Node substitutes a non-console NUL device.
+ * Preserve pipes, files, console input, and runs without console output.
+ * Explicit `< NUL` is indistinguishable from missing launcher stdin and also reattaches.
  */
 function needsConsoleStdin(input: {
   readonly platform: NodeJS.Platform;
   readonly env: NodeJS.ProcessEnv;
-  readonly stdinOpen: boolean;
+  readonly stdinMissing: boolean;
   readonly stdoutIsConsole: boolean;
 }): boolean {
   return (
     input.platform === "win32" &&
     // Set only by the launcher (DesktopCliShim), never for the desktop backend.
     input.env.T3CODE_DESKTOP_CLI_LAUNCHER === "1" &&
-    !input.stdinOpen &&
+    input.stdinMissing &&
     input.stdoutIsConsole
   );
 }
 
-const isOpen = (fd: number) => {
+const isMissingInput = (fd: number) => {
   try {
-    NodeFS.fstatSync(fd);
-    return true;
+    return NodeFS.fstatSync(fd).isCharacterDevice() && !NodeTty.isatty(fd);
   } catch {
-    return false;
+    return true;
   }
 };
 
@@ -38,7 +37,7 @@ export function attachConsoleStdin(): number | undefined {
   const needed = needsConsoleStdin({
     platform: HostProcess.Platform.defaultValue(),
     env: process.env,
-    stdinOpen: isOpen(0),
+    stdinMissing: isMissingInput(0),
     stdoutIsConsole: NodeTty.isatty(1),
   });
   // The launcher marker must not propagate to child shells or t3 processes.
@@ -55,6 +54,18 @@ export function attachConsoleStdin(): number | undefined {
     return undefined;
   }
   const stdin = new NodeTty.ReadStream(fd);
+  // Like Node's built-in stdin, release pending console reads before a child takes over.
+  stdin.on("pause", () => {
+    const internal = stdin as unknown as {
+      _handle?: { reading: boolean; readStop(): void };
+      _readableState: { reading: boolean };
+    };
+    const handle = internal._handle;
+    if (!handle) return;
+    internal._readableState.reading = false;
+    handle.reading = false;
+    handle.readStop();
+  });
   Object.defineProperty(process, "stdin", { value: stdin, configurable: true, enumerable: true });
   consoleStdinFd = fd;
   return fd;
diff --git a/apps/server/src/cloud/selfUpdate.test.ts b/apps/server/src/cloud/selfUpdate.test.ts
index 84877d41a70c9..1e3157adfff59 100644
--- a/apps/server/src/cloud/selfUpdate.test.ts
+++ b/apps/server/src/cloud/selfUpdate.test.ts
@@ -313,3 +313,36 @@ it.layer(NodeServices.layer)("pruning runtimes on start", (it) => {
     }),
   );
 });
+
+it("a host crosses tracks only to a release that knows its whole database", () => {
+  const cross = (
+    serverVersion: string,
+    targetVersion: string,
+    targetDatabaseMigration: number | undefined,
+    databaseMigration = 72,
+  ) =>
+    ServerSelfUpdate.trackSwitchBlockReason({
+      serverVersion,
+      targetVersion,
+      targetDatabaseMigration,
+      databaseMigration: () => databaseMigration,
+    });
+  const nightly = "0.1.4-nightly.20261027.3796";
+
+  expect(cross(nightly, "0.1.4", 72)).toBeNull();
+  // Another client moved this host to a newer Nightly after the switch was planned.
+  expect(cross(nightly, "0.1.4", 72, 73)).toContain("does not support yet");
+  expect(cross(nightly, "0.1.4", undefined)).toContain("Cannot confirm");
+  // A Stable tag can carry a migration the latest Nightly lacks.
+  expect(cross("0.1.4", nightly, 72, 73)).toContain("does not support yet");
+  expect(cross("0.1.3", "0.1.4", undefined)).toBeNull();
+  // A database that exists but cannot be read proves nothing.
+  expect(
+    ServerSelfUpdate.trackSwitchBlockReason({
+      serverVersion: nightly,
+      targetVersion: "0.1.4",
+      targetDatabaseMigration: 72,
+      databaseMigration: () => undefined,
+    }),
+  ).toContain("Cannot confirm");
+});
diff --git a/apps/server/src/cloud/selfUpdate.ts b/apps/server/src/cloud/selfUpdate.ts
index ab6a69fc50a83..d72c5e9218df2 100644
--- a/apps/server/src/cloud/selfUpdate.ts
+++ b/apps/server/src/cloud/selfUpdate.ts
@@ -20,11 +20,12 @@ import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
 import { HttpClient } from "effect/http";
 
-import { CLI_RELEASE_BASE_URL_ENV } from "@t3tools/shared/cliRelease";
+import { CLI_RELEASE_BASE_URL_ENV, crossesReleaseTrack } from "@t3tools/shared/cliRelease";
 
 import packageJson from "../../package.json" with { type: "json" };
 import * as ServerConfig from "../config.ts";
 import * as DesktopAppUpdate from "../desktopUpdate/DesktopAppUpdate.ts";
+import { databaseMigrationHead } from "../persistence/databaseMigrationHead.ts";
 import * as ProcessRunner from "../processRunner.ts";
 import {
   ensurePinnedRuntimeInstalled,
@@ -93,6 +94,26 @@ export const pruneRuntimesOnStart = Effect.fn("cloud.server_self_update.prune_on
   },
 );
 
+/** The client checks this when planning; the host checks again because its database may have
+ * moved on since (another client updated it). Stable and Nightly each build their own commits,
+ * so crossing tracks needs the target release to know every migration this database holds. */
+export function trackSwitchBlockReason(input: {
+  readonly serverVersion: string;
+  readonly targetVersion: string;
+  readonly targetDatabaseMigration: number | undefined;
+  /** Read only for a crossing; undefined when the database cannot be read. */
+  readonly databaseMigration: () => number | undefined;
+}): string | null {
+  if (!crossesReleaseTrack(input.serverVersion, input.targetVersion)) return null;
+  const databaseMigration = input.databaseMigration();
+  if (input.targetDatabaseMigration === undefined || databaseMigration === undefined) {
+    return `Cannot confirm this database works with t3@${input.targetVersion}. Switch tracks from Settings → About → Update track, which checks it first.`;
+  }
+  return input.targetDatabaseMigration < databaseMigration
+    ? `This database has changes t3@${input.targetVersion} does not support yet; it stays on this release.`
+    : null;
+}
+
 export const make = Effect.fn("cloud.server_self_update.make")(function* () {
   const serverConfig = yield* ServerConfig.ServerConfig;
   const desktopAppUpdate = yield* DesktopAppUpdate.DesktopAppUpdate;
@@ -119,12 +140,27 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {
       ? new ServerSelfUpdateError({ reason })
       : new ServerSelfUpdateError({ reason, cause });
 
+  const crossesTrackUnsafely = (input: ServerSelfUpdateInput) =>
+    trackSwitchBlockReason({
+      serverVersion: packageJson.version,
+      targetVersion: input.targetVersion,
+      targetDatabaseMigration: input.targetDatabaseMigration,
+      databaseMigration: () => databaseMigrationHead(serverConfig.dbPath),
+    });
+
   const update: ServerSelfUpdate["Service"]["update"] = Effect.fn(
     "cloud.server_self_update.update",
   )(function* (input, reportProgress = () => Effect.void, onHandoffAccepted = () => Effect.void) {
     if (capability === "desktop-managed") {
+      const unsafeCrossing = input.channel === undefined ? null : crossesTrackUnsafely(input);
+      if (unsafeCrossing !== null) return yield* failWith(unsafeCrossing);
       if (desktopAppUpdate.available) {
-        return yield* desktopAppUpdate.run(reportProgress);
+        return yield* desktopAppUpdate.run(
+          reportProgress,
+          input.channel === undefined
+            ? undefined
+            : { channel: input.channel, targetVersion: input.targetVersion },
+        );
       }
       return yield* failWith(
         "This server is managed by the T3 Code desktop app on its machine; update the desktop app to update it.",
@@ -136,6 +172,8 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {
       );
     }
 
+    const unsafeCrossing = crossesTrackUnsafely(input);
+    if (unsafeCrossing !== null) return yield* failWith(unsafeCrossing);
     const targetVersion = input.targetVersion.trim();
     if (!isExactServiceVersion(targetVersion)) {
       return yield* failWith(`'${targetVersion}' is not an exact t3 version.`);
diff --git a/apps/server/src/cloud/servicePreflight.test.ts b/apps/server/src/cloud/servicePreflight.test.ts
index 18a5323cd590c..efc37266be8b0 100644
--- a/apps/server/src/cloud/servicePreflight.test.ts
+++ b/apps/server/src/cloud/servicePreflight.test.ts
@@ -1,4 +1,16 @@
+import * as NodeSqlite from "node:sqlite";
+
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+
+import {
+  BUILD_MIGRATION_HEAD,
+  databaseMigrationHead,
+} from "../persistence/databaseMigrationHead.ts";
+import { migrationManifest } from "../persistence/Migrations.ts";
 
 import { runServicePreflight } from "./servicePreflight.ts";
 import { SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts";
@@ -20,3 +32,49 @@ it.each([1])("blocks legacy launcher protocol %i with exact recovery steps", (la
   expect(reason).toContain("t3 --version");
   expect(reason).toContain("which -a t3");
 });
+
+it.layer(NodeServices.layer)("service preflight database", (it) => {
+  it.effect("blocks a database that a newer build migrated", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const databasePath = path.join(
+        yield* fs.makeTempDirectoryScoped({ prefix: "t3-preflight-" }),
+        "state.sqlite",
+      );
+      const db = new NodeSqlite.DatabaseSync(databasePath);
+      db.exec("CREATE TABLE effect_sql_migrations (migration_id INTEGER PRIMARY KEY, name TEXT)");
+      const insert = db.prepare("INSERT INTO effect_sql_migrations VALUES (?, ?)");
+      for (const [id, name] of migrationManifest) insert.run(id, name);
+      const preflight = () =>
+        runServicePreflight({ databasePath, launcherProtocol: SERVICE_LAUNCHER_PROTOCOL });
+
+      expect(preflight().status).toBe("ready");
+      expect(databaseMigrationHead(databasePath)).toBe(BUILD_MIGRATION_HEAD);
+
+      const newerId = Math.max(...migrationManifest.map(([id]) => id)) + 1;
+      insert.run(newerId, "FromNightly");
+      db.close();
+      const result = preflight();
+      expect(result.status).toBe("blocked");
+      expect(result.status === "blocked" ? result.reason : "").toContain(`${newerId}_FromNightly`);
+      // Servers report this head, so clients see a database a newer build migrated.
+      expect(databaseMigrationHead(databasePath)).toBe(newerId);
+
+      // A database that exists but cannot be read has an unknown history, so it blocks.
+      const unreadable = path.join(path.dirname(databasePath), "unreadable.sqlite");
+      yield* fs.writeFileString(unreadable, "not a database");
+      expect(databaseMigrationHead(unreadable)).toBeUndefined();
+      expect(
+        runServicePreflight({
+          databasePath: unreadable,
+          launcherProtocol: SERVICE_LAUNCHER_PROTOCOL,
+        }).status,
+      ).toBe("blocked");
+      // A missing database is a fresh install.
+      expect(databaseMigrationHead(path.join(path.dirname(databasePath), "missing.sqlite"))).toBe(
+        BUILD_MIGRATION_HEAD,
+      );
+    }),
+  );
+});
diff --git a/apps/server/src/cloud/servicePreflight.ts b/apps/server/src/cloud/servicePreflight.ts
index 8865ce7b3d11f..9479f3f4a8194 100644
--- a/apps/server/src/cloud/servicePreflight.ts
+++ b/apps/server/src/cloud/servicePreflight.ts
@@ -1,4 +1,5 @@
 import packageJson from "../../package.json" with { type: "json" };
+import { BUILD_MIGRATION_HEAD, recordedMigrations } from "../persistence/databaseMigrationHead.ts";
 import { SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts";
 
 export type ServicePreflightResult =
@@ -34,9 +35,34 @@ export function runServicePreflight(input: {
     };
   }
 
+  const newer = newerRecordedMigrations(input.databasePath);
+  if (newer === null) {
+    return {
+      status: "blocked",
+      version,
+      reason: `Could not read this database to confirm t3@${version} supports it.`,
+    };
+  }
+  if (newer.length > 0) {
+    return {
+      status: "blocked",
+      version,
+      reason: `This database has migrations that t3@${version} does not know: ${newer.join(", ")}. A newer build wrote them, and running t3@${version} on this database is not safe. Stay on the newer release, or wait for a release that includes these migrations.`,
+    };
+  }
+
   return { status: "ready", version, launcherProtocol: SERVICE_LAUNCHER_PROTOCOL };
 }
 
+/** Migrations a newer build recorded, or null when the database exists but cannot be read.
+ * Startup already handles renamed ids this build knows. */
+function newerRecordedMigrations(databasePath: string): ReadonlyArray<string> | null {
+  const recorded = recordedMigrations(databasePath);
+  return recorded === null
+    ? null
+    : recorded.filter(({ id }) => id > BUILD_MIGRATION_HEAD).map(({ id, name }) => `${id}_${name}`);
+}
+
 export function decodeServicePreflightResult(value: unknown): ServicePreflightResult | undefined {
   if (typeof value !== "object" || value === null) {
     return undefined;
diff --git a/apps/server/src/desktopUpdate/DesktopAppUpdate.test.ts b/apps/server/src/desktopUpdate/DesktopAppUpdate.test.ts
index 86d445d1a52c4..f90bef39fcf03 100644
--- a/apps/server/src/desktopUpdate/DesktopAppUpdate.test.ts
+++ b/apps/server/src/desktopUpdate/DesktopAppUpdate.test.ts
@@ -132,6 +132,24 @@ it.layer(NodeServices.layer)("desktop app update", (it) => {
     }),
   );
 
+  it.effect("succeeds without an install when a track switch finds the host current", () =>
+    Effect.gen(function* () {
+      const { service } = yield* makeHarness({
+        reports: (requestId) => [
+          report(requestId, makeState({ status: "up-to-date", currentVersion: "1.2.3" }), {
+            outcome: "up-to-date",
+          }),
+        ],
+      });
+      const trackSwitch = { channel: "latest" as const, targetVersion: "1.2.3" };
+
+      expect(yield* service.run(() => Effect.void, trackSwitch)).toEqual({
+        targetVersion: "1.2.3",
+        method: "desktop-app",
+      });
+    }),
+  );
+
   it.effect("replays a retained commit failure for the preparation token", () =>
     Effect.gen(function* () {
       const { service } = yield* makeHarness({
diff --git a/apps/server/src/desktopUpdate/DesktopAppUpdate.ts b/apps/server/src/desktopUpdate/DesktopAppUpdate.ts
index d02c3108777dd..e901b04cfb5d7 100644
--- a/apps/server/src/desktopUpdate/DesktopAppUpdate.ts
+++ b/apps/server/src/desktopUpdate/DesktopAppUpdate.ts
@@ -44,6 +44,7 @@ export class DesktopAppUpdate extends Context.Service<
       reportProgress: (
         stage: ServerSelfUpdateProgressStage,
       ) => Effect.Effect<void, ServerSelfUpdateError>,
+      trackSwitch?: DesktopTelemetryReceiver.DesktopTrackSwitch,
     ) => Effect.Effect<ServerSelfUpdateResult, ServerSelfUpdateError>;
     /** Success stops the server; returns only on installation failure or timeout. */
     readonly commit: (
@@ -71,6 +72,7 @@ export const make = Effect.fn("desktopUpdate.desktopAppUpdate.make")(function* (
     reportProgress: (
       stage: ServerSelfUpdateProgressStage,
     ) => Effect.Effect<void, ServerSelfUpdateError>,
+    trackSwitch: boolean,
   ) {
     const lastStage = yield* Ref.make<ServerSelfUpdateProgressStage | null>(null);
     const emitStage = (
@@ -122,6 +124,11 @@ export const make = Effect.fn("desktopUpdate.desktopAppUpdate.make")(function* (
       return { targetVersion, method: "desktop-app" as const, desktopUpdateToken: requestId };
     }
     if (report.outcome === "up-to-date") {
+      // A switch's host already on the newest build of its track only saved the track.
+      if (trackSwitch) {
+        yield* Ref.set(inFlight, false);
+        return { targetVersion: report.state.currentVersion, method: "desktop-app" as const };
+      }
       return yield* failWith(
         `The T3 Code desktop app on this machine is already up to date on ${report.state.currentVersion}.`,
       );
@@ -132,7 +139,7 @@ export const make = Effect.fn("desktopUpdate.desktopAppUpdate.make")(function* (
   });
 
   const run: DesktopAppUpdate["Service"]["run"] = Effect.fn("desktopUpdate.desktopAppUpdate.run")(
-    function* (reportProgress) {
+    function* (reportProgress, trackSwitch) {
       if (!available) {
         return yield* failWith(
           "This server was not started by the T3 Code desktop app, so it cannot drive a desktop update.",
@@ -154,13 +161,18 @@ export const make = Effect.fn("desktopUpdate.desktopAppUpdate.make")(function* (
           // Subscribe before requesting to catch fast reports.
           const { changes } = yield* receiver.desktopUpdates;
           yield* receiver
-            .requestDesktopUpdate(requestId)
+            .requestDesktopUpdate(requestId, trackSwitch)
             .pipe(
               Effect.mapError((error) =>
                 failWith("Could not reach the T3 Code desktop app on this machine.", error),
               ),
             );
-          return yield* consumeReports(requestId, changes, reportProgress).pipe(
+          return yield* consumeReports(
+            requestId,
+            changes,
+            reportProgress,
+            trackSwitch !== undefined,
+          ).pipe(
             Effect.onInterrupt(() => receiver.cancelDesktopUpdate(requestId).pipe(Effect.ignore)),
           );
         }),
diff --git a/apps/server/src/device/AgentDeviceTarget.ts b/apps/server/src/device/AgentDeviceTarget.ts
index de5ff7ec713d4..ac66a52f6d2aa 100644
--- a/apps/server/src/device/AgentDeviceTarget.ts
+++ b/apps/server/src/device/AgentDeviceTarget.ts
@@ -9,7 +9,11 @@ import type { AgentDaemonEndpoint } from "./DeviceHost.ts";
 
 const encodeEndpoint = Schema.encodeEffect(
   Schema.fromJsonString(
-    Schema.Struct({ daemonBaseUrl: Schema.String, daemonAuthToken: Schema.String }),
+    Schema.Struct({
+      daemonBaseUrl: Schema.String,
+      daemonAuthToken: Schema.String,
+      stateDir: Schema.optionalKey(Schema.String),
+    }),
   ),
 );
 
@@ -40,7 +44,7 @@ export const agentDeviceSession = (threadId: string, hostId: string, deviceId: s
 
 export const writeAgentDeviceConfig = Effect.fn("AgentDeviceTarget.writeConfig")(function* (
   file: string,
-  endpoint: AgentDaemonEndpoint,
+  endpoint: AgentDaemonEndpoint & { readonly stateDir?: string | undefined },
 ) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
@@ -48,6 +52,7 @@ export const writeAgentDeviceConfig = Effect.fn("AgentDeviceTarget.writeConfig")
   const content = yield* encodeEndpoint({
     daemonBaseUrl: endpoint.baseUrl,
     daemonAuthToken: endpoint.token,
+    ...(endpoint.stateDir === undefined ? {} : { stateDir: endpoint.stateDir }),
   });
   if ((yield* fs.readFileString(file).pipe(Effect.orElseSucceed(() => ""))) === content) return;
   const temporary = yield* fs.makeTempFile({ directory: path.dirname(file), prefix: ".endpoint-" });
diff --git a/apps/server/src/device/DeviceHost.ts b/apps/server/src/device/DeviceHost.ts
index 13a1e55e14882..c168ba657afe6 100644
--- a/apps/server/src/device/DeviceHost.ts
+++ b/apps/server/src/device/DeviceHost.ts
@@ -84,6 +84,17 @@ export interface DeviceOpenContext {
 
 export type AgentDaemonEndpoint = Pick<AgentDeviceEndpoint, "baseUrl" | "token">;
 
+export interface AgentDeviceBinding extends AgentDaemonEndpoint {
+  /** Null when the session alone picks the device and selector flags would be refused. */
+  readonly agentDeviceId: string | null;
+  /** The one session the device is leased to, shared by every thread. */
+  readonly session?: string;
+  /** agent-device state holding that session's connection. */
+  readonly stateDir?: string;
+  /** agent-device accepts installs into the session only from the directory that opened it. */
+  readonly installDirectory?: string;
+}
+
 /** Where the proxy sends a device hub request, for hosts that serve several upstreams. */
 export interface HubUpstream {
   readonly url: string;
@@ -124,10 +135,7 @@ export interface DeviceOperations {
    */
   readonly agentEndpoint?: (
     deviceId: string,
-  ) => Effect.Effect<
-    AgentDaemonEndpoint & { readonly agentDeviceId: string },
-    DeviceHostUnavailableError
-  >;
+  ) => Effect.Effect<AgentDeviceBinding, DeviceHostUnavailableError>;
   /**
    * Set by hosts that end devices on their own (EAS stops sessions at their
    * limits), so a session on a device the host stops listing is dropped.
diff --git a/apps/server/src/device/DeviceHubProxy.stream.test.ts b/apps/server/src/device/DeviceHubProxy.stream.test.ts
index 0251dabf7ace7..72340560d4f39 100644
--- a/apps/server/src/device/DeviceHubProxy.stream.test.ts
+++ b/apps/server/src/device/DeviceHubProxy.stream.test.ts
@@ -1,9 +1,12 @@
 import { expect, it } from "@effect/vitest";
 import { NodeWS } from "@effect/platform-node/NodeSocket";
+import * as NodeNet from "node:net";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import { HttpRouter, HttpServer } from "effect/http";
+import * as Socket from "effect/socket/Socket";
 import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
 import {
   AuthOrchestrationOperateScope,
@@ -87,3 +90,34 @@ it.effect("preserves binary input and admission frames through the real socket p
     expect(frames).toEqual([[0x83], [0x03, 1], [0x03, 2]]);
   }),
 );
+
+it.live("closes an upstream socket that is still connecting without an unhandled error", () =>
+  Effect.gen(function* () {
+    const dialed = Promise.withResolvers<NodeNet.Socket>();
+    // Accepts the connection and never answers the WebSocket handshake.
+    const hub = yield* Effect.acquireRelease(
+      Effect.promise(
+        () =>
+          new Promise<NodeNet.Server>((resolve) => {
+            const server = NodeNet.createServer((socket) => dialed.resolve(socket));
+            server.listen(0, "127.0.0.1", () => resolve(server));
+          }),
+      ),
+      (server) =>
+        Effect.promise(() => new Promise<void>((resolve) => server.close(() => resolve()))),
+    );
+    const address = hub.address();
+    if (typeof address !== "object" || !address) throw new Error("Missing hub port");
+    // Handshake headers, as Simlock's routes send, select the `ws` package over the global WebSocket.
+    const upstream = yield* Socket.makeWebSocket(`ws://127.0.0.1:${address.port}`, {
+      headers: { authorization: "Bearer test" },
+    }).pipe(Effect.provide(DeviceHubProxy.upstreamWebSocketConstructor));
+    const reading = yield* Effect.forkChild(
+      Effect.scoped(Effect.flatMap(upstream.reader, ({ pull }) => pull)),
+    );
+    const connection = yield* Effect.promise(() => dialed.promise);
+    const abandoned = new Promise<void>((resolve) => connection.once("close", () => resolve()));
+    yield* Fiber.interrupt(reading);
+    yield* Effect.promise(() => abandoned);
+  }),
+);
diff --git a/apps/server/src/device/DeviceHubProxy.ts b/apps/server/src/device/DeviceHubProxy.ts
index 390247e2bda05..89cad0d7206e2 100644
--- a/apps/server/src/device/DeviceHubProxy.ts
+++ b/apps/server/src/device/DeviceHubProxy.ts
@@ -2,6 +2,7 @@
 // Proxy with environment read scope for streams and operate scope for input and tuning.
 import { AuthOrchestrationReadScope, AuthOrchestrationOperateScope } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import {
   HttpClient,
@@ -75,16 +76,32 @@ const forwardHeaders = (request: HttpServerRequest.HttpServerRequest, origin: st
   return headers;
 };
 
+// Effect drops its listeners before closing a socket that is still connecting, and `ws` then
+// emits an `error` nobody handles, which exits the server.
+export const upstreamWebSocketConstructor = Layer.effect(
+  Socket.WebSocketConstructor,
+  Effect.gen(function* () {
+    const make = yield* Socket.WebSocketConstructor;
+    return (url, options) => {
+      const socket = make(url, options);
+      socket.addEventListener("error", () => undefined);
+      return socket;
+    };
+  }),
+).pipe(Layer.provide(NodeSocket.layerWebSocketConstructor));
+
 const proxyWebSocket = Effect.fn("DeviceHubProxy.proxyWebSocket")(function* (
   request: HttpServerRequest.HttpServerRequest,
   upstreamUrl: string,
   protocols: ReadonlyArray<string> = [],
+  headers: Readonly<Record<string, string>> = {},
 ) {
   const client = yield* request.upgrade;
   const upstream = yield* Socket.makeWebSocket(upstreamUrl, {
     openTimeout: "10 seconds",
     ...(protocols.length > 0 ? { protocols: [...protocols] } : {}),
-  }).pipe(Effect.provide(NodeSocket.layerWebSocketConstructor));
+    ...(Object.keys(headers).length > 0 ? { headers: { ...headers } } : {}),
+  }).pipe(Effect.provide(upstreamWebSocketConstructor));
   yield* Effect.scoped(
     Effect.gen(function* () {
       const writeToClient = yield* client.writer;
@@ -194,7 +211,12 @@ const handler = Effect.gen(function* () {
   }
   const upstreamUrl = routed?.url ?? `${ready.hub.origin}${hubPath}${search}`;
   if (upgrade) {
-    return yield* proxyWebSocket(request, upstreamUrl.replace(/^http/, "ws"), routed?.protocols);
+    return yield* proxyWebSocket(
+      request,
+      upstreamUrl.replace(/^http/, "ws"),
+      routed?.protocols,
+      routed?.headers,
+    );
   }
   return yield* proxyHttp(request, upstreamUrl, routed?.headers);
 });
diff --git a/apps/server/src/device/DeviceService.test.ts b/apps/server/src/device/DeviceService.test.ts
index 1261094338901..a9ff957b91997 100644
--- a/apps/server/src/device/DeviceService.test.ts
+++ b/apps/server/src/device/DeviceService.test.ts
@@ -52,7 +52,7 @@ const fixture = Effect.fn("fixture")(function* (
     | DeviceHost.AgentDeviceStartError,
   inspectError = false,
   installTool?: Parameters<typeof DeviceService.makeWithHosts>[3],
-  options: { readonly endsDevices?: boolean } = {},
+  options: { readonly endsDevices?: boolean; readonly routesStreams?: boolean } = {},
 ) {
   const settings = yield* Ref.make(DEFAULT_SERVER_SETTINGS);
   const starts: string[] = [];
@@ -137,6 +137,7 @@ const fixture = Effect.fn("fixture")(function* (
     },
     helpers: { serveSimAxSettings: null, serveSimCli: null },
     run,
+    ...(options.routesStreams ? { upstream: () => Effect.succeed(null) } : {}),
   };
   const host: DeviceHost.DeviceHost["Service"] = {
     ...(inspectError
@@ -401,6 +402,29 @@ describe("device setup consent", () => {
     }).pipe(Effect.scoped),
   );
 
+  it.effect("opens emulators on hosts that route their own streams without ffmpeg", () =>
+    Effect.gen(function* () {
+      const { service, requests, encoderResult } = yield* fixture(
+        Effect.void,
+        undefined,
+        false,
+        undefined,
+        false,
+        undefined,
+        { routesStreams: true },
+      );
+      yield* Ref.set(encoderResult, { code: 127, stdout: "", stderr: "host commands unavailable" });
+      yield* service.configure({ enabled: true });
+      const session = yield* service.open({
+        threadId: ThreadId.make("pool-emulator"),
+        deviceId: "Pixel_API_35",
+        platform: "android",
+      });
+      expect(session.deviceId).toBe("emulator-5554");
+      expect(requests.filter((url) => url.endsWith("/boot"))).toHaveLength(1);
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("installs agent support only after the separate agent permission", () =>
     Effect.gen(function* () {
       const { service, agentStarts, agentStops, settings } = yield* fixture();
@@ -787,6 +811,103 @@ it.effect.each(["shutdown", "close"] as const)(
     }).pipe(Effect.provide(ServerSettings.layerTest({ enableDeviceSupport: true })), Effect.scoped),
 );
 
+it.effect("leaves a session its host leases to every thread open when one thread closes", () =>
+  Effect.gen(function* () {
+    const deviceId = DeviceId.make("33333333-3333-3333-3333-333333333333");
+    const http = HttpClient.make((request) =>
+      Effect.sync(() =>
+        new URL(request.url).pathname === "/api/devices"
+          ? HttpClientResponse.fromWeb(
+              request,
+              Response.json({
+                emulators: [],
+                simulators: [
+                  {
+                    id: deviceId,
+                    name: "iPhone",
+                    platform: "ios",
+                    version: "26",
+                    physical: false,
+                    booted: true,
+                  },
+                ],
+              }),
+            )
+          : HttpClientResponse.fromWeb(request, Response.json({ ok: true, id: deviceId })),
+      ),
+    );
+    const run = () => Effect.succeed({ code: 0, stdout: "", stderr: "" });
+    const ready: DeviceHost.DeviceHostAgentReady = {
+      nodePath: process.execPath,
+      hub: { origin: "http://device.test" },
+      devices: {
+        ...makeDeviceHubOperations({
+          hostId: LOCAL_DEVICE_HOST_ID,
+          origin: "http://device.test",
+          http,
+          run,
+          androidAvailable: Effect.succeed(true),
+        }),
+        agentEndpoint: () =>
+          Effect.succeed({
+            baseUrl: "http://agent.test",
+            token: "agent-token",
+            agentDeviceId: null,
+            session: "lease-session",
+          }),
+      },
+      helpers: { serveSimAxSettings: null, serveSimCli: null },
+      run,
+      agentDevice: null,
+    };
+    const host: DeviceHost.DeviceHost["Service"] = {
+      id: LOCAL_DEVICE_HOST_ID,
+      label: "Pool",
+      summary: Effect.succeed({
+        id: LOCAL_DEVICE_HOST_ID,
+        kind: "local",
+        label: "Pool",
+        platforms: [{ platform: "ios", available: true }],
+        hubInstalled: true,
+        agentDeviceInstalled: true,
+      }),
+      platformAvailability: (platform) => Effect.succeed({ platform, available: true }),
+      ensureReady: () => Effect.succeed(ready),
+      ensureAgentReady: () => Effect.succeed(ready),
+      current: Effect.succeed(ready),
+      stopAgent: Effect.void,
+      stop: Effect.void,
+    };
+    const released: string[] = [];
+    const service = yield* DeviceService.makeWithHosts(
+      new Map([[host.id, host]]),
+      undefined,
+      () => Effect.succeed("agent-device.json"),
+      undefined,
+      {
+        bind: ({ session }) => Effect.succeed(session),
+        prune: () => Effect.void,
+        release: (launcher) => Effect.sync(() => void released.push(launcher)),
+      },
+    ).pipe(Effect.provide(NodeCrypto.layer));
+    const threads = [ThreadId.make("pool-a"), ThreadId.make("pool-b")];
+    for (const threadId of threads) {
+      yield* service.open({ threadId, deviceId, platform: "ios" });
+      const target = { threadId, hostId: LOCAL_DEVICE_HOST_ID, deviceId };
+      const agent = yield* service.agentTarget(target);
+      expect(agent.session).toBe("lease-session");
+      yield* service.agentLauncher({ ...target, targetArgs: agent.args });
+    }
+    yield* service.close({ threadId: threads[0]! });
+    expect(released).toEqual([]);
+  }).pipe(
+    Effect.provide(
+      ServerSettings.layerTest({ enableDeviceSupport: true, enableAgentDeviceAccess: true }),
+    ),
+    Effect.scoped,
+  ),
+);
+
 it.effect.each([
   { hubReports: "off", outcome: "succeeds" },
   { hubReports: "booted", outcome: "fails" },
diff --git a/apps/server/src/device/DeviceService.ts b/apps/server/src/device/DeviceService.ts
index 6d7ede5e845fb..b2ef41f148a14 100644
--- a/apps/server/src/device/DeviceService.ts
+++ b/apps/server/src/device/DeviceService.ts
@@ -20,8 +20,12 @@ import {
   type DeviceEasAccount,
   DeviceEasAccountError,
   type DeviceEasAccountInput,
+  type DeviceSimlockIdentity,
+  DeviceSimlockIdentityError,
+  type DeviceSimlockIdentityInput,
   type DeviceHostConfig,
   type EasDeviceHostConfig,
+  type SimlockDeviceHostConfig,
   type SshDeviceHostConfig,
   type DeviceHostSummary,
   LOCAL_DEVICE_HOST_ID,
@@ -67,6 +71,8 @@ import * as ProcessRunner from "../processRunner.ts";
 import * as DeviceHost from "./DeviceHost.ts";
 import * as SshDeviceHost from "./SshDeviceHost.ts";
 import * as EasDeviceHost from "./EasDeviceHost.ts";
+import * as SimlockDeviceHost from "./SimlockDeviceHost.ts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
 import { makeExpoApi, resolveExpoCredential } from "./ExpoApi.ts";
 import * as Exit from "effect/Exit";
 import * as LocalDeviceHost from "./LocalDeviceHost.ts";
@@ -140,6 +146,10 @@ export class DeviceService extends Context.Service<
     readonly easAccount: (
       input: DeviceEasAccountInput,
     ) => Effect.Effect<DeviceEasAccount, DeviceEasAccountError>;
+    /** Who a Simlock agent token is; without a gateway or token, this machine's agent-device's. */
+    readonly simlockIdentity: (
+      input: DeviceSimlockIdentityInput,
+    ) => Effect.Effect<DeviceSimlockIdentity, DeviceSimlockIdentityError>;
     /**
      * The agent-device flags that reach the device: its config and session,
      * and the id agent-device selects it by, which can differ from its id here.
@@ -150,9 +160,10 @@ export class DeviceService extends Context.Service<
       deviceId: DeviceId;
     }) => Effect.Effect<
       {
-        readonly agentDeviceId: string;
+        readonly agentDeviceId: string | null;
         readonly session: string;
         readonly args: ReadonlyArray<string>;
+        readonly installDirectory?: string | undefined;
       },
       DeviceError
     >;
@@ -247,7 +258,7 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
     ),
   configureAgent: (
     hostId: DeviceHostId,
-    endpoint: DeviceHost.AgentDaemonEndpoint,
+    endpoint: DeviceHost.AgentDaemonEndpoint & { readonly stateDir?: string | undefined },
     deviceId?: DeviceId,
   ) => Effect.Effect<string, DeviceError> = (hostId) =>
     Effect.fail(
@@ -284,6 +295,7 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
       supportsToolUpdate: installTool !== undefined,
       supportsToolInspection: true,
       supportsEasHosts: true,
+      supportsSimlockHosts: true,
       hosts: initialHosts,
       hostStatus: initialSettings.enabled ? "idle" : "disabled",
       hostStatuses: {},
@@ -299,6 +311,8 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
   const launcherLock = yield* Semaphore.make(1);
   /** Launchers bound since startup, by agent-device session. */
   const boundLaunchers = new Map<string, string>();
+  /** Launchers on a session the host leases to every thread; the host ends it, not a retiring thread. */
+  const hostSessionLaunchers = new Set<string>();
   // Binding and pruning read sessions under the lock, so neither acts on a session list the other has outdated.
   // A retired session's agent-device session ends before its launcher goes, and a reopen of the same
   // device waits for the lock, so the close cannot end the reopened session.
@@ -313,9 +327,10 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
       );
       const retired = [...boundLaunchers].filter(([session]) => !live.has(session));
       for (const [session] of retired) boundLaunchers.delete(session);
+      const ending = retired.filter(([session]) => !hostSessionLaunchers.delete(session));
       const release = launchers.release;
       if (release)
-        yield* Effect.forEach(retired, ([, launcher]) => release(launcher), {
+        yield* Effect.forEach(ending, ([, launcher]) => release(launcher), {
           concurrency: "unbounded",
           discard: true,
         });
@@ -703,7 +718,8 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
       if (!device) {
         return yield* new DeviceNotFoundError({ hostId: host.id, deviceId: input.deviceId });
       }
-      if (device.platform === "android" && !device.physical) {
+      // Hosts that route their own streams never encode emulator video with serve-emu's ffmpeg.
+      if (device.platform === "android" && !device.physical && !ready.upstream) {
         // Resolve the override on the device host the way its hub does.
         const encoders = yield* ready.run(ready.nodePath, [
           "-e",
@@ -1004,6 +1020,13 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
           }),
         );
       }),
+      simlockIdentity: Effect.fn("DeviceService.simlockIdentity")(function () {
+        return Effect.fail(
+          new DeviceSimlockIdentityError({
+            reason: "Simlock hosts are unavailable in this device service.",
+          }),
+        );
+      }),
       agentTarget: Effect.fn("DeviceService.agentTarget")(function* (input) {
         const host = yield* resolveHost(input.hostId);
         const ready = yield* agentReadinessIfSupported(input.hostId);
@@ -1014,39 +1037,51 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
             reason:
               "Agent device access requires enabled device support, agent access, and an available simulator platform on this host.",
           });
-        const { configPath, agentDeviceId } = yield* lifecycleLock.withPermit(
-          Effect.gen(function* () {
-            if (hosts.get(host.id) !== host)
-              return yield* new DeviceHostUnavailableError({
-                hostId: host.id,
-                hostLabel: host.label,
-                reason: "Host configuration changed. Retry the operation.",
-              });
-            if (ready.devices.agentEndpoint) {
-              const endpoint = yield* ready.devices.agentEndpoint(input.deviceId);
+        const { configPath, agentDeviceId, boundSession, installDirectory } =
+          yield* lifecycleLock.withPermit(
+            Effect.gen(function* () {
+              if (hosts.get(host.id) !== host)
+                return yield* new DeviceHostUnavailableError({
+                  hostId: host.id,
+                  hostLabel: host.label,
+                  reason: "Host configuration changed. Retry the operation.",
+                });
+              if (ready.devices.agentEndpoint) {
+                const endpoint = yield* ready.devices.agentEndpoint(input.deviceId);
+                return {
+                  configPath: yield* configureAgent(input.hostId, endpoint, input.deviceId),
+                  agentDeviceId: endpoint.agentDeviceId,
+                  boundSession: endpoint.session,
+                  installDirectory: endpoint.installDirectory,
+                };
+              }
+              if (!ready.agentDevice)
+                return yield* new DeviceHostUnavailableError({
+                  hostId: host.id,
+                  hostLabel: host.label,
+                  reason: "This host has no agent-device daemon.",
+                });
               return {
-                configPath: yield* configureAgent(input.hostId, endpoint, input.deviceId),
-                agentDeviceId: endpoint.agentDeviceId,
+                configPath: yield* configureAgent(input.hostId, ready.agentDevice),
+                agentDeviceId: input.deviceId,
+                boundSession: undefined,
+                installDirectory: undefined,
               };
-            }
-            if (!ready.agentDevice)
-              return yield* new DeviceHostUnavailableError({
-                hostId: host.id,
-                hostLabel: host.label,
-                reason: "This host has no agent-device daemon.",
-              });
-            return {
-              configPath: yield* configureAgent(input.hostId, ready.agentDevice),
-              agentDeviceId: input.deviceId,
-            };
-          }),
-        );
-        const session = yield* agentDeviceSession(
+            }),
+          );
+        const ownSession = yield* agentDeviceSession(
           input.threadId,
           input.hostId,
           input.deviceId,
         ).pipe(Effect.provideService(Crypto.Crypto, crypto));
-        return { agentDeviceId, session, args: ["--config", configPath, "--session", session] };
+        if (boundSession) hostSessionLaunchers.add(ownSession);
+        const session = boundSession ?? ownSession;
+        return {
+          agentDeviceId,
+          session,
+          args: ["--config", configPath, "--session", session],
+          installDirectory,
+        };
       }),
       agentLauncher: Effect.fn("DeviceService.agentLauncher")(function* ({
         targetArgs,
@@ -1139,7 +1174,7 @@ export const make = Effect.gen(function* () {
   const configureAgent = Effect.fn("DeviceService.configureAgent")(
     function* (
       hostId: DeviceHostId,
-      endpoint: DeviceHost.AgentDaemonEndpoint,
+      endpoint: DeviceHost.AgentDaemonEndpoint & { readonly stateDir?: string | undefined },
       deviceId?: DeviceId,
     ) {
       const file = yield* configPath(hostId, deviceId);
@@ -1290,6 +1325,23 @@ export const make = Effect.gen(function* () {
     yield* Effect.context<Effect.Services<ReturnType<typeof SshDeviceHost.make>>>();
   const easContext =
     yield* Effect.context<Effect.Services<ReturnType<typeof EasDeviceHost.make>>>();
+  const simlockContext =
+    yield* Effect.context<Effect.Services<ReturnType<typeof SimlockDeviceHost.make>>>();
+  const simlockAgentCli = Effect.fn("DeviceService.simlockAgentCli")(
+    function* (hostId: string) {
+      const nodePath = yield* resolveNodeExecutable("Device automation");
+      const tool = yield* ensureAgentDevice(config.baseDir).pipe(
+        Effect.mapError(
+          (cause) =>
+            new DeviceHost.DeviceHostError({ hostId, step: "installing agent tools", cause }),
+        ),
+      );
+      return { nodePath, entryPath: tool.entryPath };
+    },
+    Effect.provideService(FileSystem.FileSystem, fs),
+    Effect.provideService(Path.Path, path),
+    Effect.provideService(ProcessRunner.ProcessRunner, runner),
+  );
   const configured = new Map<string, { config: DeviceHostConfig; scope: Scope.Closeable }>();
   const unchanged = (current: DeviceHostConfig, previous: DeviceHostConfig) =>
     current.kind === "ssh" && previous.kind === "ssh"
@@ -1334,6 +1386,24 @@ export const make = Effect.gen(function* () {
           if (configured.has(host.id)) continue;
           added = true;
           const hostScope = yield* Scope.fork(scope);
+          if (host.kind === "simlock") {
+            // Closing this scope releases the host's leases back to the pool.
+            const instance = yield* SimlockDeviceHost.make(host, simlockAgentCli(host.id)).pipe(
+              Effect.provideService(Scope.Scope, hostScope),
+              Effect.provide(simlockContext),
+            );
+            hosts.set(host.id, instance);
+            configured.set(host.id, { config: host, scope: hostScope });
+            // Ask the gateway now, so a refused token shows in Settings before anyone opens a device.
+            if ((yield* settings.getSettings).enableDeviceSupport)
+              yield* instance
+                .platformAvailability("ios")
+                .pipe(
+                  Effect.andThen(service.withLifecycleLock(service.refreshHosts)),
+                  Effect.forkIn(hostScope),
+                );
+            continue;
+          }
           if (host.kind === "eas") {
             // Closing this scope stops the host's running sessions, so a changed
             // limit or token never leaves a billed session behind.
@@ -1375,14 +1445,22 @@ export const make = Effect.gen(function* () {
     );
   });
   const changes = yield* settings.subscribeChanges;
-  // Settings keep EAS hosts apart from SSH hosts; an id both lists use stays the SSH host's.
+  // Each kind has its own settings list; an id two lists share stays the first one's.
   const configuredHosts = (value: {
     readonly deviceHosts: ReadonlyArray<SshDeviceHostConfig>;
     readonly easDeviceHosts: ReadonlyArray<EasDeviceHostConfig>;
-  }): ReadonlyArray<DeviceHostConfig> => [
-    ...value.deviceHosts,
-    ...value.easDeviceHosts.filter((host) => !value.deviceHosts.some((ssh) => ssh.id === host.id)),
-  ];
+    readonly simlockDeviceHosts: ReadonlyArray<SimlockDeviceHostConfig>;
+    readonly simlockDeviceHostsEnabled: boolean;
+  }): ReadonlyArray<DeviceHostConfig> => {
+    const hosts: Array<DeviceHostConfig> = [...value.deviceHosts];
+    for (const host of [
+      ...value.easDeviceHosts,
+      ...(value.simlockDeviceHostsEnabled ? value.simlockDeviceHosts : []),
+    ]) {
+      if (!hosts.some((existing) => existing.id === host.id)) hosts.push(host);
+    }
+    return hosts;
+  };
   yield* reconcile(configuredHosts(yield* settings.getSettings));
   yield* changes.pipe(
     Stream.runForEach((value) => reconcile(configuredHosts(value))),
@@ -1423,9 +1501,62 @@ export const make = Effect.gen(function* () {
     ),
   );
 
+  const simlockIdentity: DeviceService["Service"]["simlockIdentity"] = Effect.fn(
+    "DeviceService.simlockIdentity",
+  )(
+    function* (input) {
+      const environment = yield* HostProcess.Environment;
+      const gatewayUrl = (
+        input.gatewayUrl || SimlockDeviceHost.machineSimlockToken(environment)?.gatewayUrl
+      )?.replace(/\/$/, "");
+      if (!gatewayUrl)
+        return yield* new DeviceSimlockIdentityError({
+          reason: "This machine's agent-device does not point at a Simlock gateway.",
+        });
+      const savedHost =
+        input.hostId === undefined
+          ? undefined
+          : (yield* settings.getSettings).simlockDeviceHosts.find(
+              (host) => host.id === input.hostId,
+            );
+      const token = input.agentToken
+        ? { agentToken: input.agentToken, source: "entered" as const }
+        : SimlockDeviceHost.resolveSimlockToken(gatewayUrl, savedHost, environment);
+      if (!token)
+        return yield* new DeviceSimlockIdentityError({
+          reason: savedHost?.agentToken
+            ? "The saved token is for another gateway. Enter one for this gateway."
+            : "No agent token for this gateway on this machine.",
+        });
+      const identity = yield* SimlockDeviceHost.simlockIdentity(gatewayUrl, token.agentToken).pipe(
+        Effect.mapError(
+          (cause) =>
+            new DeviceSimlockIdentityError({
+              reason: SimlockDeviceHost.describeGatewayFailure(
+                cause,
+                gatewayUrl,
+                token.source === "env" ? "this machine" : "this environment",
+              ),
+            }),
+        ),
+      );
+      if (identity.role !== "agent")
+        return yield* new DeviceSimlockIdentityError({
+          reason: `That is a ${identity.role} token. Create one with --role agent.`,
+        });
+      return { gatewayUrl, signedInAs: identity.name, tokenSource: token.source };
+    },
+    Effect.catchTags({
+      ServerSettingsError: () =>
+        Effect.fail(new DeviceSimlockIdentityError({ reason: "Could not read the saved token." })),
+    }),
+    Effect.provide(simlockContext),
+  );
+
   return {
     ...service,
     easAccount,
+    simlockIdentity,
   };
 });
 
diff --git a/apps/server/src/device/EasDeviceHost.test.ts b/apps/server/src/device/EasDeviceHost.test.ts
index 31b0ed0b1291c..5802956e699b7 100644
--- a/apps/server/src/device/EasDeviceHost.test.ts
+++ b/apps/server/src/device/EasDeviceHost.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "@effect/vitest";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import type { EasDeviceHostConfig } from "@t3tools/contracts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
@@ -455,6 +456,24 @@ describe("EAS Simulator host", () => {
     }).pipe(Effect.scoped, Effect.provide(layer)),
   );
 
+  it.effect("reports iOS unavailable on a server with no Expo credential", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-expo-home-" });
+      const host = yield* makeHost(
+        fakeExpo(),
+        config({ accessToken: "" }),
+        yield* Scope.make(),
+      ).pipe(
+        Effect.provideService(HostProcess.HomeDirectory, home),
+        Effect.provideService(HostProcess.Environment, {}),
+      );
+      const [ios] = (yield* host.summary).platforms;
+      expect(ios).toMatchObject({ platform: "ios", available: false });
+      expect(ios?.reason).toContain("No Expo credential on the server");
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
   it.effect("stops a session that is still starting when the host stops", () =>
     Effect.gen(function* () {
       const previewGate = yield* makeGate;
diff --git a/apps/server/src/device/EasDeviceHost.ts b/apps/server/src/device/EasDeviceHost.ts
index 72c88de1afe20..da8a665d4b4ed 100644
--- a/apps/server/src/device/EasDeviceHost.ts
+++ b/apps/server/src/device/EasDeviceHost.ts
@@ -830,16 +830,22 @@ export const make = Effect.fn("EasDeviceHost.make")(function* (config: EasDevice
     ),
   );
 
+  // Each server signs in on its own, so one with no Expo credential answers for itself. Reading
+  // the credential is local; whether Expo accepts it is only known once a session starts.
   const platformAvailability = (platform: DevicePlatform) =>
-    Effect.succeed(
-      platform === "ios"
-        ? { platform, available: true }
-        : {
-            platform,
-            available: false,
-            reason: "EAS Simulator Android emulators are not supported yet.",
-          },
-    );
+    platform === "ios"
+      ? resolveExpoCredential(config.accessToken).pipe(
+          Effect.provide(services),
+          Effect.as({ platform, available: true }),
+          Effect.catch((error) =>
+            Effect.succeed({ platform, available: false, reason: error.message }),
+          ),
+        )
+      : Effect.succeed({
+          platform,
+          available: false,
+          reason: "EAS Simulator Android emulators are not supported yet.",
+        });
 
   const summary: Effect.Effect<DeviceHostSummary> = Effect.all([
     platformAvailability("ios"),
diff --git a/apps/server/src/device/SimlockDeviceHost.test.ts b/apps/server/src/device/SimlockDeviceHost.test.ts
new file mode 100644
index 0000000000000..1b670a06cd078
--- /dev/null
+++ b/apps/server/src/device/SimlockDeviceHost.test.ts
@@ -0,0 +1,419 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import type { SimlockDeviceHostConfig } from "@t3tools/contracts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as Deferred from "effect/Deferred";
+import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Scope from "effect/Scope";
+import * as TestClock from "effect/testing/TestClock";
+import { HttpClient, HttpClientResponse } from "effect/http";
+import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
+
+import * as ServerConfig from "../config.ts";
+import * as ProcessRunner from "../processRunner.ts";
+import * as SimlockDeviceHost from "./SimlockDeviceHost.ts";
+
+const GATEWAY = "https://simlock.test:4700";
+
+const config = (overrides: Partial<SimlockDeviceHostConfig> = {}): SimlockDeviceHostConfig => ({
+  kind: "simlock",
+  id: "pool",
+  label: "Device pool",
+  gatewayUrl: `${GATEWAY}/`,
+  agentToken: "agent-token",
+  maxLeases: 2,
+  maxLeaseMinutes: 60,
+  ...overrides,
+});
+
+const CATALOG = {
+  platforms: [
+    {
+      platform: "ios",
+      modelRuntimes: { "iPhone 17 Pro": ["27.0"], "Apple TV 4K": ["27.0"], "iPhone 12": [] },
+      modelClasses: { "iPhone 17 Pro": "phone", "Apple TV 4K": "tv", "iPhone 12": "phone" },
+    },
+    {
+      platform: "android",
+      modelRuntimes: { "Pixel 9": ["36"], "Pixel 8": ["36"] },
+      modelWorkers: { "Pixel 9": ["worker-a"], "Pixel 8": [] },
+    },
+  ],
+};
+
+/** The gateway's HTTP API and T3's agent-device CLI, recording what was asked of them. */
+const fakePool = (
+  options: {
+    readonly failOpen?: boolean;
+    readonly holdOpen?: {
+      readonly entered: Deferred.Deferred<void>;
+      readonly proceed: Deferred.Deferred<void>;
+    };
+  } = {},
+) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const requests: Array<string> = [];
+    const commands: Array<{ readonly args: ReadonlyArray<string>; readonly cwd?: string }> = [];
+    let leases = 0;
+    let renewStatus = 200;
+    let catalog: unknown = CATALOG;
+    const http = HttpClient.make((request) =>
+      Effect.sync(() => {
+        const url = new URL(request.url);
+        requests.push(`${request.method} ${url.pathname}`);
+        const json = (body: unknown, status = 200) =>
+          HttpClientResponse.fromWeb(request, Response.json(body, { status }));
+        if (request.headers.authorization !== "Bearer agent-token")
+          return json({ error: { code: "UNAUTHENTICATED", message: "Unknown bearer token" } }, 401);
+        if (url.pathname === "/v1/catalog") return json(catalog);
+        if (url.pathname.endsWith("/renew")) return json({}, renewStatus);
+        if (request.method === "DELETE") return json({}, 202);
+        return json({}, 404);
+      }),
+    );
+    const runner = ProcessRunner.ProcessRunner.of({
+      run: (input) =>
+        Effect.gen(function* () {
+          const args = input.args.slice(1);
+          commands.push({ args, ...(input.cwd ? { cwd: input.cwd } : {}) });
+          const command = args[0];
+          const session = args[args.indexOf("--session") + 1]!;
+          const configFile = args[args.indexOf("--config") + 1]!;
+          const stateDir = (
+            JSON.parse(yield* fs.readFileString(configFile)) as { stateDir: string }
+          ).stateDir;
+          if (command === "open") {
+            if (options.failOpen) {
+              return {
+                stdout: JSON.stringify({
+                  error: { message: "No device matches.", hint: "Retry." },
+                }),
+                stderr: "",
+                code: ChildProcessSpawner.ExitCode(1),
+                timedOut: false,
+                stdoutTruncated: false,
+                stderrTruncated: false,
+                stdoutInvalidUtf8: false,
+                stderrInvalidUtf8: false,
+              };
+            }
+            if (options.holdOpen) {
+              yield* Deferred.succeed(options.holdOpen.entered, undefined);
+              yield* Deferred.await(options.holdOpen.proceed);
+            }
+            const dir = path.join(stateDir, "remote-connections");
+            yield* fs.makeDirectory(dir, { recursive: true });
+            yield* fs.writeFileString(
+              path.join(dir, `${session}.json`),
+              JSON.stringify({ leaseId: `lease-${++leases}` }),
+            );
+          }
+          if (command === "screenshot") yield* fs.writeFile(args[1]!, new Uint8Array([1, 2, 3]));
+          return {
+            stdout: "{}",
+            stderr: "",
+            code: ChildProcessSpawner.ExitCode(0),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+            stdoutInvalidUtf8: false,
+            stderrInvalidUtf8: false,
+          };
+        }).pipe(Effect.orDie),
+    });
+    const ran = (command: string) => commands.filter(({ args }) => args[0] === command);
+    return {
+      http,
+      runner,
+      requests,
+      ran,
+      endLeases: () => {
+        renewStatus = 404;
+      },
+      setCatalog: (next: unknown) => {
+        catalog = next;
+      },
+    };
+  });
+
+const layer = Layer.mergeAll(
+  ServerConfig.layerTest(process.cwd(), { prefix: "t3-simlock-host-" }),
+).pipe(Layer.provideMerge(NodeServices.layer));
+
+const makeHost = (
+  pool: Effect.Success<ReturnType<typeof fakePool>>,
+  hostConfig: SimlockDeviceHostConfig,
+  scope: Scope.Scope,
+) =>
+  SimlockDeviceHost.make(
+    hostConfig,
+    Effect.succeed({ nodePath: "node", entryPath: "/tools/agent-device.mjs" }),
+  ).pipe(
+    Effect.provideService(HttpClient.HttpClient, pool.http),
+    Effect.provideService(ProcessRunner.ProcessRunner, pool.runner),
+    Effect.provideService(Scope.Scope, scope),
+  );
+
+describe("Simlock device host", () => {
+  it.effect("leases a pool device for agents and serves its screen and input to the panel", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const fs = yield* FileSystem.FileSystem;
+      const workspace = yield* fs.makeTempDirectoryScoped();
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config(), scope);
+      const ready = yield* host.ensureReady(() => Effect.void);
+
+      const catalog = (yield* ready.devices.list).devices;
+      // Only models a worker can make right now, and only phones and tablets.
+      expect(catalog.map((device) => [device.id, device.version])).toEqual([
+        ["simlock:ios:iPhone 17 Pro", "iOS 27.0"],
+        ["simlock:android:Pixel 9", "Android 36"],
+      ]);
+
+      const leaseId = yield* ready.devices.boot(catalog[1]!, { workspaceRoot: workspace });
+      expect(leaseId).toBe("lease-1");
+      const [open] = pool.ran("open");
+      expect(open?.args.slice(0, 5)).toEqual([
+        "open",
+        "--platform",
+        "android",
+        "--device",
+        "Pixel 9",
+      ]);
+      expect(open?.cwd).toBe(yield* fs.realPath(workspace));
+      expect(pool.ran("connect")[0]?.args).toContain(`${GATEWAY}/v1/agent-device`);
+
+      const binding = yield* ready.devices.agentEndpoint!(leaseId);
+      expect(binding).toMatchObject({
+        baseUrl: `${GATEWAY}/v1/agent-device`,
+        token: "agent-token",
+        agentDeviceId: null,
+        session: open?.args[open.args.indexOf("--session") + 1],
+        installDirectory: yield* fs.realPath(workspace),
+      });
+      expect((yield* ready.devices.list).devices.at(-1)).toMatchObject({
+        id: "lease-1",
+        name: "Pixel 9",
+        booted: true,
+      });
+
+      expect(
+        yield* ready.upstream!(
+          "/vendor/serve-sim/helper/lease-1/stream.avcc",
+          new URLSearchParams(),
+        ),
+      ).toEqual({
+        url: `${GATEWAY}/v1/leases/lease-1/stream`,
+        headers: { authorization: "Bearer agent-token" },
+        protocols: [],
+      });
+      expect(
+        yield* ready.upstream!(
+          "/vendor/serve-sim/helper/ws",
+          new URLSearchParams({ device: "lease-1" }),
+        ),
+      ).toEqual({
+        url: `${GATEWAY}/v1/leases/lease-1/input`,
+        headers: { authorization: "Bearer agent-token" },
+        protocols: [],
+      });
+      expect(
+        yield* ready.upstream!("/vendor/serve-sim/helper/lease-1/config", new URLSearchParams()),
+      ).toBeNull();
+      expect(
+        yield* ready.upstream!(
+          "/vendor/serve-sim/helper/ws",
+          new URLSearchParams({ device: "lease-2" }),
+        ),
+      ).toBeNull();
+      expect([...(yield* ready.devices.screenshot({ ...catalog[1]!, id: leaseId }))]).toEqual([
+        1, 2, 3,
+      ]);
+
+      yield* ready.devices.shutdown({ id: leaseId, platform: "android" });
+      expect(pool.ran("close")).toHaveLength(1);
+      expect((yield* ready.devices.list).devices.some((device) => device.booted)).toBe(false);
+      yield* Scope.close(scope, Exit.void);
+      expect(pool.ran("close")).toHaveLength(1);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("caps leases at the limit", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config({ maxLeases: 1 }), scope);
+      const ready = yield* host.ensureReady(() => Effect.void);
+      const [iphone] = (yield* ready.devices.list).devices;
+      yield* ready.devices.boot(iphone!);
+
+      const refused = yield* ready.devices.boot(iphone!).pipe(Effect.flip);
+      expect(refused.message).toContain("limited to 1 device");
+      expect(pool.ran("open")).toHaveLength(1);
+      yield* Scope.close(scope, Exit.void);
+      expect(pool.ran("close")).toHaveLength(1);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("reports its platforms unavailable when the gateway refuses the agent token", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config({ agentToken: "revoked" }), scope);
+      expect(yield* host.platformAvailability("ios")).toEqual({
+        platform: "ios",
+        available: false,
+        reason: "The Simlock gateway refused the agent token for Device pool.",
+      });
+      expect((yield* host.summary).platforms.every((platform) => !platform.available)).toBe(true);
+      yield* Scope.close(scope, Exit.void);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("sends saved and machine tokens only to the gateway each belongs to", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const availability = (baseUrl: string) =>
+        Effect.gen(function* () {
+          const scope = yield* Scope.make();
+          const host = yield* makeHost(pool, config({ agentToken: "" }), scope).pipe(
+            Effect.provideService(HostProcess.Environment, {
+              AGENT_DEVICE_DAEMON_BASE_URL: baseUrl,
+              AGENT_DEVICE_DAEMON_AUTH_TOKEN: "agent-token",
+            }),
+          );
+          const result = yield* host.platformAvailability("ios");
+          yield* Scope.close(scope, Exit.void);
+          return result;
+        });
+
+      expect(
+        SimlockDeviceHost.resolveSimlockToken(
+          "https://elsewhere.example:4700",
+          config({ agentToken: "saved-token" }),
+          {},
+        ),
+      ).toBeNull();
+
+      expect(yield* availability(`${GATEWAY}/v1/agent-device`)).toEqual({
+        platform: "ios",
+        available: true,
+      });
+      const requests = pool.requests.length;
+      expect(yield* availability("https://elsewhere.example:4700/v1/agent-device")).toEqual({
+        platform: "ios",
+        available: false,
+        reason: "Add an agent token for Device pool in Settings.",
+      });
+      expect(pool.requests).toHaveLength(requests);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("lists a platform again as soon as its workers return", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config(), scope);
+      const ready = yield* host.ensureReady(() => Effect.void);
+      pool.setCatalog({ platforms: [] });
+      expect((yield* ready.devices.list).devices).toEqual([]);
+      // Mid-reconnect, the gateway knows the Android models but no worker that makes them.
+      pool.setCatalog({
+        platforms: [
+          CATALOG.platforms[0]!,
+          { ...CATALOG.platforms[1]!, modelWorkers: { "Pixel 9": [], "Pixel 8": [] } },
+        ],
+      });
+      const during = (yield* ready.devices.list).devices;
+      expect(during.some((device) => device.platform === "android")).toBe(false);
+      pool.setCatalog(CATALOG);
+      const after = (yield* ready.devices.list).devices;
+      expect(after.some((device) => device.platform === "android")).toBe(true);
+      yield* Scope.close(scope, Exit.void);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("closes the session of a failed open so no lease is left behind", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool({ failOpen: true });
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config(), scope);
+      const ready = yield* host.ensureReady(() => Effect.void);
+      const [iphone] = (yield* ready.devices.list).devices;
+      const failure = yield* ready.devices.boot(iphone!).pipe(Effect.flip);
+      expect(String(failure.cause)).toContain("No device matches. Retry.");
+      expect(pool.ran("close")).toHaveLength(1);
+      // The failed open freed its slot.
+      expect(yield* ready.devices.boot(iphone!).pipe(Effect.flip)).toBeDefined();
+      yield* Scope.close(scope, Exit.void);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("keeps a watched lease renewed and stops listing it once Simlock ends it", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const scope = yield* Scope.make();
+      const host = yield* makeHost(pool, config(), scope);
+      const ready = yield* host.ensureReady(() => Effect.void);
+      const [iphone] = (yield* ready.devices.list).devices;
+      const leaseId = yield* ready.devices.boot(iphone!);
+
+      yield* TestClock.adjust("2 minutes");
+      expect(pool.requests).toContain(`POST /v1/leases/${leaseId}/renew`);
+      expect((yield* ready.devices.list).devices.some((device) => device.id === leaseId)).toBe(
+        true,
+      );
+
+      pool.endLeases();
+      yield* TestClock.adjust("2 minutes");
+      expect((yield* ready.devices.list).devices.some((device) => device.id === leaseId)).toBe(
+        false,
+      );
+      yield* Scope.close(scope, Exit.void);
+      expect(pool.ran("close")).toHaveLength(0);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("returns a lease whose open finishes after the host stopped", () =>
+    Effect.gen(function* () {
+      const holdOpen = {
+        entered: yield* Deferred.make<void>(),
+        proceed: yield* Deferred.make<void>(),
+      };
+      const pool = yield* fakePool({ holdOpen });
+      const host = yield* makeHost(pool, config(), yield* Scope.make());
+      const ready = yield* host.ensureReady(() => Effect.void);
+      const [iphone] = (yield* ready.devices.list).devices;
+      const opening = yield* Effect.forkChild(ready.devices.boot(iphone!));
+      yield* Deferred.await(holdOpen.entered);
+      yield* host.stop;
+      yield* Deferred.succeed(holdOpen.proceed, undefined);
+      expect(Exit.isFailure(yield* Fiber.await(opening))).toBe(true);
+      expect(pool.ran("close")).toHaveLength(1);
+      expect((yield* ready.devices.list).devices.every((device) => !device.booted)).toBe(true);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+
+  it.effect("holds a lease for its full maximum age, then returns it", () =>
+    Effect.gen(function* () {
+      const pool = yield* fakePool();
+      const host = yield* makeHost(pool, config({ maxLeaseMinutes: 5 }), yield* Scope.make());
+      const ready = yield* host.ensureReady(() => Effect.void);
+      const [iphone] = (yield* ready.devices.list).devices;
+      yield* ready.devices.boot(iphone!);
+
+      yield* TestClock.adjust("299 seconds");
+      expect(pool.ran("close")).toHaveLength(0);
+      yield* TestClock.adjust("1 second");
+      expect(pool.ran("close")).toHaveLength(1);
+    }).pipe(Effect.scoped, Effect.provide(layer)),
+  );
+});
diff --git a/apps/server/src/device/SimlockDeviceHost.ts b/apps/server/src/device/SimlockDeviceHost.ts
new file mode 100644
index 0000000000000..75476f0333ce3
--- /dev/null
+++ b/apps/server/src/device/SimlockDeviceHost.ts
@@ -0,0 +1,663 @@
+/**
+ * Alpha: devices leased from a Simlock gateway the user runs. Opening a device
+ * takes a lease through the gateway's agent-device front, so agents drive it
+ * with the same session; closing it returns the device to the pool, wiped.
+ * A lease left by a server that crashed ends one TTL after its last renewal.
+ */
+import {
+  DeviceBootError,
+  type DeviceHostSummary,
+  DeviceHostUnavailableError,
+  DeviceOperationError,
+  type DevicePlatform,
+  type DevicePlatformAvailability,
+  type SimlockDeviceHostConfig,
+} from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as FiberMap from "effect/FiberMap";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Random from "effect/Random";
+import * as Schema from "effect/Schema";
+import * as Semaphore from "effect/Semaphore";
+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
+import * as HostProcess from "@t3tools/shared/HostProcess";
+import type { NodeRuntimeUnavailableError } from "@t3tools/shared/nodeRuntime";
+
+import * as ServerConfig from "../config.ts";
+import * as ProcessRunner from "../processRunner.ts";
+import { writeAgentDeviceConfig } from "./AgentDeviceTarget.ts";
+import * as DeviceHost from "./DeviceHost.ts";
+
+const CATALOG_TTL_MS = 60_000;
+const REQUEST_TIMEOUT = Duration.seconds(15);
+// The gateway queues a lease request for up to five minutes when every device is busy.
+const OPEN_TIMEOUT = Duration.minutes(7);
+const COMMAND_TIMEOUT = Duration.minutes(2);
+// Renewal keeps a watched but idle device; a lease this server stops renewing ends after LEASE_TTL.
+const RENEW_INTERVAL = Duration.minutes(2);
+const LEASE_TTL_MS = 10 * 60_000;
+const STREAM_PATH = /^\/vendor\/serve-sim\/helper\/([^/]+)\/stream\.avcc$/;
+const INPUT_PATH = "/vendor/serve-sim/helper/ws";
+
+const Catalog = Schema.Struct({
+  platforms: Schema.Array(
+    Schema.Struct({
+      platform: Schema.String,
+      modelRuntimes: Schema.Record(Schema.String, Schema.Array(Schema.String)),
+      modelClasses: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+      modelWorkers: Schema.optional(Schema.Record(Schema.String, Schema.Array(Schema.String))),
+    }),
+  ),
+});
+const decodeCatalog = Schema.decodeUnknownEffect(Catalog);
+const decodeSessionRecord = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.Struct({ leaseId: Schema.String })),
+);
+const decodeCliFailure = Schema.decodeUnknownOption(
+  Schema.fromJsonString(
+    Schema.Struct({
+      error: Schema.Struct({ message: Schema.String, hint: Schema.optional(Schema.String) }),
+    }),
+  ),
+);
+
+interface Lease {
+  readonly leaseId: string;
+  readonly platform: DevicePlatform;
+  readonly name: string;
+  readonly version: string;
+  readonly session: string;
+  readonly dir: string;
+  readonly configPath: string;
+  readonly installDirectory: string;
+}
+
+const catalogId = (platform: DevicePlatform, model: string) => `simlock:${platform}:${model}`;
+const parseCatalogId = (id: string) => {
+  const match = /^simlock:(ios|android):(.+)$/.exec(id);
+  return match ? { platform: match[1] as DevicePlatform, model: match[2]! } : null;
+};
+const platformVersion = (platform: DevicePlatform, runtime: string | undefined) =>
+  `${platform === "ios" ? "iOS" : "Android"}${runtime ? ` ${runtime}` : ""}`;
+
+const AGENT_DEVICE_PATH = "/v1/agent-device";
+const sameOrigin = (left: string, right: string) => {
+  try {
+    return new URL(left).origin === new URL(right).origin;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * The gateway and token this machine's agent-device uses, from agent-device's own remote-daemon
+ * variables, which Simlock tells its clients to set. Null unless they point at a Simlock gateway.
+ */
+export const machineSimlockToken = (environment: NodeJS.ProcessEnv) => {
+  const base = environment.AGENT_DEVICE_DAEMON_BASE_URL?.trim().replace(/\/+$/, "");
+  const agentToken = environment.AGENT_DEVICE_DAEMON_AUTH_TOKEN?.trim();
+  if (!base?.endsWith(AGENT_DEVICE_PATH) || !agentToken) return null;
+  const gatewayUrl = base.slice(0, -AGENT_DEVICE_PATH.length);
+  return URL.canParse(gatewayUrl) ? { gatewayUrl, agentToken } : null;
+};
+
+/**
+ * The saved token, else this machine's agent-device token; each only for the gateway it belongs to,
+ * so a URL being edited never receives either.
+ */
+export const resolveSimlockToken = (
+  gatewayUrl: string,
+  saved: { readonly gatewayUrl: string; readonly agentToken: string } | undefined,
+  environment: NodeJS.ProcessEnv,
+) => {
+  if (saved?.agentToken && sameOrigin(saved.gatewayUrl, gatewayUrl))
+    return { agentToken: saved.agentToken, source: "settings" as const };
+  const machine = machineSimlockToken(environment);
+  return machine && sameOrigin(machine.gatewayUrl, gatewayUrl)
+    ? { agentToken: machine.agentToken, source: "env" as const }
+    : null;
+};
+
+/** What went wrong talking to a gateway, without the gateway's own text. */
+export const describeGatewayFailure = (cause: unknown, gatewayUrl: string, tokenOwner: string) => {
+  if (Cause.isTimeoutError(cause)) return `Could not reach the Simlock gateway at ${gatewayUrl}.`;
+  if (!HttpClientError.isHttpClientError(cause))
+    return `The Simlock gateway at ${gatewayUrl} sent an answer T3 could not read.`;
+  if (cause.reason._tag === "StatusCodeError") {
+    const status = cause.reason.response.status;
+    return status === 401 || status === 403
+      ? `The Simlock gateway refused the agent token for ${tokenOwner}.`
+      : `The Simlock gateway at ${gatewayUrl} answered HTTP ${status}.`;
+  }
+  return cause.reason._tag === "TransportError"
+    ? `Could not reach the Simlock gateway at ${gatewayUrl}.`
+    : `The Simlock gateway at ${gatewayUrl} sent an answer T3 could not read.`;
+};
+
+const decodeIdentity = Schema.decodeUnknownEffect(
+  Schema.Struct({ name: Schema.String, role: Schema.String }),
+);
+
+/** Who the gateway says a token is, via GET /v1/identity. */
+export const simlockIdentity = Effect.fn("SimlockDeviceHost.identity")(function* (
+  gatewayUrl: string,
+  agentToken: string,
+) {
+  const http = yield* HttpClient.HttpClient;
+  return yield* http
+    .execute(
+      HttpClientRequest.get(`${gatewayUrl.replace(/\/$/, "")}/v1/identity`).pipe(
+        HttpClientRequest.bearerToken(agentToken),
+      ),
+    )
+    .pipe(
+      Effect.flatMap(HttpClientResponse.filterStatusOk),
+      Effect.flatMap((response) => response.json),
+      Effect.flatMap(decodeIdentity),
+      Effect.scoped,
+      Effect.timeout(REQUEST_TIMEOUT),
+    );
+});
+
+/** T3's own agent-device CLI, installed on first use. */
+export type AgentDeviceCli = Effect.Effect<
+  { readonly nodePath: string; readonly entryPath: string },
+  DeviceHost.DeviceHostError | NodeRuntimeUnavailableError
+>;
+
+export const make = Effect.fn("SimlockDeviceHost.make")(function* (
+  config: SimlockDeviceHostConfig,
+  agentDeviceCli: AgentDeviceCli,
+) {
+  const http = yield* HttpClient.HttpClient;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const runner = yield* ProcessRunner.ProcessRunner;
+  const server = yield* ServerConfig.ServerConfig;
+  const services = yield* Effect.context<FileSystem.FileSystem | Path.Path>();
+  const environment = yield* HostProcess.Environment;
+  const hostId = config.id;
+  const gateway = config.gatewayUrl.replace(/\/$/, "");
+  const agentToken = resolveSimlockToken(config.gatewayUrl, config, environment)?.agentToken ?? "";
+  const agentDeviceUrl = `${gateway}/v1/agent-device`;
+  const hostDir = path.join(server.stateDir, "device", "simlock", hostId);
+  const leases = new Map<string, Lease>();
+  let starting = 0;
+  // Bumped by every stop, so an open that finishes after one returns its lease instead of keeping it.
+  let stops = 0;
+  const slotLock = yield* Semaphore.make(1);
+  const keepAlive = yield* FiberMap.make<string>();
+  let catalog: {
+    readonly at: number;
+    readonly devices: ReadonlyArray<DeviceHost.HostDevice>;
+  } | null = null;
+  // The last answer from the gateway; empty until it gives one.
+  let platforms: ReadonlyArray<DevicePlatformAvailability> = [];
+  let ready: DeviceHost.DeviceHostReady | null = null;
+  let cli: { readonly nodePath: string; readonly entryPath: string } | null = null;
+
+  const unavailable = (reason: string, cause?: unknown) =>
+    new DeviceHostUnavailableError({
+      hostId,
+      hostLabel: config.label,
+      reason,
+      ...(cause === undefined ? {} : { cause }),
+    });
+
+  const request = (
+    method: "GET" | "POST" | "DELETE",
+    route: string,
+    body?: Readonly<Record<string, unknown>>,
+  ) =>
+    http
+      .execute(
+        (method === "GET"
+          ? HttpClientRequest.get(`${gateway}${route}`)
+          : method === "POST"
+            ? HttpClientRequest.post(`${gateway}${route}`).pipe(
+                HttpClientRequest.bodyJsonUnsafe(body ?? {}),
+              )
+            : HttpClientRequest.delete(`${gateway}${route}`)
+        ).pipe(HttpClientRequest.bearerToken(agentToken)),
+      )
+      .pipe(
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap((response) => response.json),
+        Effect.scoped,
+        Effect.timeout(REQUEST_TIMEOUT),
+      );
+
+  const agentEnvironment: NodeJS.ProcessEnv = Object.fromEntries(
+    Object.entries({
+      ...environment,
+      ELECTRON_RUN_AS_NODE: "1",
+      AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1",
+      NO_COLOR: "1",
+      FORCE_COLOR: "0",
+    }).filter(
+      ([name]) =>
+        !/^AGENT_DEVICE_(DAEMON_BASE_URL|DAEMON_AUTH_TOKEN|CONFIG|STATE_DIR|SESSION)$/.test(name),
+    ),
+  );
+
+  /** Runs T3's own agent-device CLI against the lease's session; its failure message is the reason. */
+  const agentDevice = Effect.fn("SimlockDeviceHost.agentDevice")(function* (
+    lease: Pick<Lease, "session" | "configPath">,
+    args: ReadonlyArray<string>,
+    options: { readonly cwd?: string; readonly timeout?: Duration.Input } = {},
+  ) {
+    if (!cli) return yield* unavailable(`${config.label} is not ready.`);
+    const result = yield* runner
+      .run({
+        command: cli.nodePath,
+        args: [
+          cli.entryPath,
+          ...args,
+          "--session",
+          lease.session,
+          "--config",
+          lease.configPath,
+          "--json",
+        ],
+        env: agentEnvironment,
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        timeout: options.timeout ?? COMMAND_TIMEOUT,
+      })
+      .pipe(Effect.mapError((cause) => unavailable("agent-device could not run.", cause)));
+    if (result.code !== 0) {
+      const failure = decodeCliFailure(result.stdout);
+      return yield* unavailable(
+        Option.match(failure, {
+          onNone: () => `agent-device ${args[0]} failed (exit code ${result.code ?? "none"}).`,
+          onSome: ({ error }) => (error.hint ? `${error.message} ${error.hint}` : error.message),
+        }),
+      );
+    }
+    return result.stdout;
+  });
+
+  const fetchCatalog = Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    if (catalog && now - catalog.at < CATALOG_TTL_MS) return catalog.devices;
+    if (!agentToken) {
+      return yield* unavailable(`Add an agent token for ${config.label} in Settings.`);
+    }
+    const decoded = yield* request("GET", "/v1/catalog").pipe(
+      Effect.flatMap(decodeCatalog),
+      Effect.mapError((cause) =>
+        unavailable(describeGatewayFailure(cause, gateway, config.label), cause),
+      ),
+    );
+    const byPlatform = decoded.platforms.map((entry) => {
+      if (entry.platform !== "ios" && entry.platform !== "android") return null;
+      const platform: DevicePlatform = entry.platform;
+      return Object.entries(entry.modelRuntimes).flatMap(([model, runtimes]) => {
+        const kind = entry.modelClasses?.[model];
+        const workers = entry.modelWorkers?.[model];
+        if (runtimes.length === 0 || (workers !== undefined && workers.length === 0)) return [];
+        if (kind !== undefined && kind !== "phone" && kind !== "tablet") return [];
+        return [
+          {
+            id: catalogId(platform, model),
+            platform,
+            name: model,
+            version: platformVersion(platform, runtimes.at(-1)),
+            booted: false,
+            physical: false,
+          } satisfies DeviceHost.HostDevice,
+        ];
+      });
+    });
+    const devices = byPlatform.flatMap((entry) => entry ?? []);
+    // A platform with nothing to offer is usually its workers reconnecting; caching that would
+    // hide it for the TTL, so only a catalog with devices on every platform is kept.
+    catalog =
+      devices.length > 0 && byPlatform.every((entry) => entry === null || entry.length > 0)
+        ? { at: now, devices }
+        : null;
+    return devices;
+  });
+
+  const loadCatalog = fetchCatalog.pipe(
+    Effect.tap((devices) =>
+      Effect.sync(() => {
+        platforms = (["ios", "android"] as const).map((platform) =>
+          devices.some((device) => device.platform === platform)
+            ? { platform, available: true }
+            : {
+                platform,
+                available: false,
+                reason: `The pool has no ${platform === "ios" ? "iOS" : "Android"} devices.`,
+              },
+        );
+      }),
+    ),
+    Effect.tapError((error) =>
+      Effect.sync(() => {
+        platforms = (["ios", "android"] as const).map((platform) => ({
+          platform,
+          available: false,
+          reason: error.reason,
+        }));
+      }),
+    ),
+  );
+
+  const forget = (lease: Lease) =>
+    Effect.suspend(() => {
+      leases.delete(lease.leaseId);
+      return fs.remove(lease.dir, { recursive: true, force: true }).pipe(Effect.ignore);
+    });
+
+  /** Ends the lease through its session, or over HTTP when the session is gone. */
+  const release = Effect.fn("SimlockDeviceHost.release")(function* (lease: Lease) {
+    yield* agentDevice(lease, ["close"]).pipe(
+      Effect.catch(() => request("DELETE", `/v1/leases/${encodeURIComponent(lease.leaseId)}`)),
+      Effect.tapError((cause) =>
+        Effect.logWarning("Could not release Simlock lease", { leaseId: lease.leaseId, cause }),
+      ),
+      Effect.ignore,
+    );
+    yield* forget(lease);
+  });
+
+  /** Renews until the lease ends on its own or reaches its maximum age, then releases it. */
+  const renewLoop = Effect.fn("SimlockDeviceHost.renewLoop")(function* (lease: Lease) {
+    const deadline =
+      (yield* Clock.currentTimeMillis) +
+      Duration.toMillis(Duration.minutes(config.maxLeaseMinutes));
+    while (true) {
+      const left = deadline - (yield* Clock.currentTimeMillis);
+      yield* Effect.sleep(Duration.millis(Math.min(left, Duration.toMillis(RENEW_INTERVAL))));
+      if ((yield* Clock.currentTimeMillis) >= deadline) break;
+      const renewed = yield* request(
+        "POST",
+        `/v1/leases/${encodeURIComponent(lease.leaseId)}/renew`,
+        { ttlMs: LEASE_TTL_MS },
+      ).pipe(Effect.result);
+      if (renewed._tag === "Success") continue;
+      const error = renewed.failure;
+      // Simlock ended it (lease_lost, an agent's close, or its TTL): stop listing it.
+      if (
+        error._tag === "HttpClientError" &&
+        error.reason._tag === "StatusCodeError" &&
+        error.reason.response.status === 404
+      ) {
+        return yield* forget(lease);
+      }
+      yield* Effect.logWarning("Could not renew Simlock lease", { leaseId: lease.leaseId, error });
+    }
+    yield* Effect.logInfo("Releasing Simlock lease at its maximum age", {
+      leaseId: lease.leaseId,
+    });
+    yield* release(lease);
+  });
+
+  const reserveSlot = slotLock.withPermit(
+    Effect.suspend(() => {
+      if (leases.size + starting >= config.maxLeases) {
+        return Effect.fail(
+          unavailable(
+            `${config.label} is limited to ${config.maxLeases} ${config.maxLeases === 1 ? "device" : "devices"} at once. Close one in the Device panel first.`,
+          ),
+        );
+      }
+      starting++;
+      return Effect.void;
+    }),
+  );
+
+  const openLease = Effect.fn("SimlockDeviceHost.openLease")(function* (
+    device: DeviceHost.HostDevice,
+    context: DeviceHost.DeviceOpenContext | undefined,
+  ) {
+    const target = parseCatalogId(device.id);
+    if (!target) {
+      return yield* new DeviceBootError({
+        hostId,
+        deviceId: device.id,
+        reason: "launch_failed",
+        cause: new Error("This Simlock device is no longer leased. Open it again from the list."),
+      });
+    }
+    const suffix = (yield* Random.nextIntBetween(0, 0xffffff)).toString(16).padStart(6, "0");
+    const session = `t3-${suffix}`;
+    const dir = path.join(hostDir, suffix);
+    const configPath = path.join(dir, "agent-device.json");
+    yield* writeAgentDeviceConfig(configPath, {
+      baseUrl: agentDeviceUrl,
+      token: agentToken,
+      stateDir: dir,
+    }).pipe(
+      Effect.provide(services),
+      Effect.mapError((cause) => unavailable("Could not write the agent-device config.", cause)),
+    );
+    // agent-device ties installs to the directory that opened the session.
+    const installDirectory = context?.workspaceRoot
+      ? yield* fs.realPath(context.workspaceRoot).pipe(Effect.orElseSucceed(() => dir))
+      : dir;
+    const pending = { session, configPath };
+    const stopsAtOpen = stops;
+    return yield* Effect.gen(function* () {
+      yield* agentDevice(pending, ["connect", "proxy", "--daemon-base-url", agentDeviceUrl]);
+      yield* agentDevice(
+        pending,
+        ["open", "--platform", target.platform, "--device", target.model],
+        { cwd: installDirectory, timeout: OPEN_TIMEOUT },
+      );
+      const record = yield* fs
+        .readFileString(path.join(dir, "remote-connections", `${session}.json`))
+        .pipe(
+          Effect.flatMap(decodeSessionRecord),
+          Effect.mapError((cause) => unavailable("agent-device recorded no Simlock lease.", cause)),
+        );
+      const opened: Lease = {
+        leaseId: record.leaseId,
+        platform: target.platform,
+        name: target.model,
+        version: device.version,
+        session,
+        dir,
+        configPath,
+        installDirectory,
+      };
+      if (stops !== stopsAtOpen)
+        return yield* unavailable("Device support stopped while the device was opening.");
+      leases.set(opened.leaseId, opened);
+      yield* FiberMap.run(keepAlive, opened.leaseId, renewLoop(opened));
+      return opened.leaseId;
+    }).pipe(
+      // A failed or interrupted open may still hold a lease: close the session either way.
+      Effect.onExit((exit) =>
+        exit._tag === "Success"
+          ? Effect.void
+          : agentDevice(pending, ["close"]).pipe(
+              Effect.ignore,
+              Effect.andThen(fs.remove(dir, { recursive: true, force: true }).pipe(Effect.ignore)),
+            ),
+      ),
+      Effect.mapError((error) =>
+        error._tag === "DeviceHostUnavailableError"
+          ? new DeviceBootError({
+              hostId,
+              deviceId: device.id,
+              reason: "launch_failed",
+              cause: new Error(error.reason),
+            })
+          : error,
+      ),
+    );
+  });
+
+  const leaseFor = (deviceId: string) => Option.fromNullishOr(leases.get(deviceId));
+  const operationError = (operation: string) => (cause: unknown) =>
+    new DeviceOperationError({ operation, reason: "request_failed", cause });
+
+  const screenshotLease = Effect.fn("SimlockDeviceHost.screenshot")(
+    function* (lease: Lease) {
+      const file = path.join(
+        lease.dir,
+        `screenshot-${(yield* Random.nextIntBetween(0, 0xffffff)).toString(16)}.png`,
+      );
+      yield* agentDevice(lease, ["screenshot", file]);
+      return yield* fs
+        .readFile(file)
+        .pipe(Effect.ensuring(fs.remove(file, { force: true }).pipe(Effect.ignore)));
+    },
+    Effect.mapError(operationError("screenshot")),
+  );
+
+  const devices: DeviceHost.DeviceOperations = {
+    list: loadCatalog.pipe(
+      Effect.mapError(operationError("list")),
+      Effect.map((available) => ({
+        devices: [
+          ...available,
+          ...[...leases.values()].map((lease): DeviceHost.HostDevice => ({
+            id: lease.leaseId,
+            platform: lease.platform,
+            name: lease.name,
+            version: lease.version,
+            booted: true,
+            physical: false,
+          })),
+        ],
+        detail: undefined,
+      })),
+    ),
+    boot: (device, context) =>
+      leases.has(device.id)
+        ? Effect.succeed(device.id)
+        : Effect.acquireUseRelease(
+            reserveSlot,
+            () => openLease(device, context),
+            () => Effect.sync(() => void starting--),
+          ),
+    attach: () => Effect.void,
+    shutdown: (device) =>
+      Option.match(leaseFor(device.id), {
+        onNone: () => Effect.void,
+        onSome: (lease) =>
+          FiberMap.remove(keepAlive, lease.leaseId).pipe(Effect.andThen(release(lease))),
+      }),
+    screenshot: (device) =>
+      Option.match(leaseFor(device.id), {
+        onNone: () =>
+          Effect.fail(operationError("screenshot")(new Error("The Simlock lease has ended"))),
+        onSome: screenshotLease,
+      }),
+    agentEndpoint: (deviceId) =>
+      Option.match(leaseFor(deviceId), {
+        onNone: () => Effect.fail(unavailable("This Simlock lease has ended.")),
+        onSome: (lease) =>
+          Effect.succeed({
+            baseUrl: agentDeviceUrl,
+            token: agentToken,
+            agentDeviceId: null,
+            session: lease.session,
+            stateDir: lease.dir,
+            installDirectory: lease.installDirectory,
+          }),
+      }),
+    endsDevices: true,
+  };
+
+  /**
+   * The client speaks serve-sim to every Simlock lease: its AVCC stream and its input
+   * socket map to the lease's own stream and input routes, which take the agent token.
+   */
+  const upstream: NonNullable<DeviceHost.DeviceHostReady["upstream"]> = (hubPath, search) =>
+    Effect.sync(() => {
+      const stream = STREAM_PATH.exec(hubPath);
+      let deviceId: string | null;
+      try {
+        deviceId = stream
+          ? decodeURIComponent(stream[1]!)
+          : hubPath === INPUT_PATH
+            ? search.get("device")
+            : null;
+      } catch {
+        return null;
+      }
+      const lease = deviceId === null ? undefined : leases.get(deviceId);
+      if (!lease) return null;
+      return {
+        url: `${gateway}/v1/leases/${encodeURIComponent(lease.leaseId)}/${stream ? "stream" : "input"}`,
+        headers: { authorization: `Bearer ${agentToken}` },
+        protocols: [],
+      };
+    });
+
+  const ensureReady: DeviceHost.DeviceHost["Service"]["ensureReady"] = Effect.fn(
+    "SimlockDeviceHost.ensureReady",
+  )(function* (onPhase) {
+    if (ready) return ready;
+    // A missing token or unreachable gateway does not stop readiness: listing
+    // and opening devices say what is wrong instead.
+    yield* onPhase("installing");
+    cli = yield* agentDeviceCli;
+    const { nodePath } = cli;
+    ready = {
+      nodePath,
+      hub: { origin: gateway },
+      devices,
+      upstream,
+      // Simlock relays only simctl, adb, and devicectl, and only to a lease's owner.
+      run: () =>
+        Effect.succeed({
+          stdout: "",
+          stderr: "Simlock devices cannot run host commands.",
+          code: 127,
+        }),
+      helpers: { serveSimAxSettings: null, serveSimCli: null },
+    };
+    return ready;
+  });
+
+  const stopAll = Effect.gen(function* () {
+    stops++;
+    yield* FiberMap.clear(keepAlive);
+    yield* Effect.forEach([...leases.values()], release, { discard: true, concurrency: 4 });
+  }).pipe(Effect.ignore);
+  yield* Effect.addFinalizer(() => stopAll);
+
+  const platformAvailability = (platform: DevicePlatform) =>
+    loadCatalog.pipe(
+      Effect.ignore,
+      Effect.map(
+        (): DevicePlatformAvailability =>
+          platforms.find((candidate) => candidate.platform === platform) ?? {
+            platform,
+            available: false,
+          },
+      ),
+    );
+
+  const summary: Effect.Effect<DeviceHostSummary> = Effect.sync(() => ({
+    id: hostId,
+    label: config.label,
+    kind: "simlock" as const,
+    platforms,
+    hubInstalled: true,
+    agentDeviceInstalled: true,
+  }));
+
+  return DeviceHost.DeviceHost.of({
+    id: hostId,
+    label: config.label,
+    summary,
+    platformAvailability,
+    ensureReady,
+    ensureAgentReady: Effect.fn("SimlockDeviceHost.ensureAgentReady")(function* (onPhase) {
+      return { ...(yield* ensureReady(onPhase)), agentDevice: null };
+    }),
+    current: Effect.sync(() => ready),
+    stopAgent: Effect.void,
+    stop: stopAll,
+  });
+});
diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts
index 2b9b1f95b0719..cef18fbe325c3 100644
--- a/apps/server/src/environment/ServerEnvironment.ts
+++ b/apps/server/src/environment/ServerEnvironment.ts
@@ -20,6 +20,7 @@ import { readAgentActivityPublishingActive } from "../cloud/config.ts";
 import { resolveServerSelfUpdateCapability } from "../cloud/selfUpdate.ts";
 import { resolveServiceLauncherMode } from "../cloud/serviceLauncherClient.ts";
 import * as ServerConfig from "../config.ts";
+import { databaseMigrationHead } from "../persistence/databaseMigrationHead.ts";
 import * as ProcessRunner from "../processRunner.ts";
 import { resolveServerEnvironmentLabel } from "./ServerEnvironmentLabel.ts";
 import { detectServerEnvironmentMachineKind } from "./ServerEnvironmentMachine.ts";
@@ -203,6 +204,7 @@ export const make = Effect.gen(function* () {
   const desktopAppUpdate =
     serverSelfUpdate === "desktop-managed" && serverConfig.desktopTelemetryControlFd !== undefined;
 
+  const databaseMigration = databaseMigrationHead(serverConfig.dbPath);
   const descriptor: ExecutionEnvironmentDescriptor = {
     environmentId,
     label,
@@ -213,6 +215,7 @@ export const make = Effect.gen(function* () {
     },
     serverVersion: packageJson.version,
     orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
+    ...(databaseMigration === undefined ? {} : { databaseMigration }),
     capabilities: {
       repositoryIdentity: true,
       connectionProbe: true,
@@ -246,6 +249,7 @@ export const make = Effect.gen(function* () {
       threadPinReorder: true,
       threadActiveReorder: true,
       threadAutoSettleOptOut: true,
+      threadProjectFromScratch: true,
       threadTitleRegeneration: true,
       commandOutputStreaming: true,
       threadVisitedTracking: true,
@@ -265,7 +269,7 @@ export const make = Effect.gen(function* () {
       ...(serverSelfUpdate === "boot-service" || desktopAppUpdate
         ? { serverSelfUpdateProgress: true }
         : {}),
-      ...(desktopAppUpdate ? { desktopAppUpdate: true } : {}),
+      ...(desktopAppUpdate ? { desktopAppUpdate: true, desktopAppChannelSwitch: true } : {}),
       serverBrowser: true,
       peerLinks: true,
       mcpModeLimitHeader: true,
diff --git a/apps/server/src/git/GitManager.test.ts b/apps/server/src/git/GitManager.test.ts
index 8e6a42c2271d2..7f374a79934ce 100644
--- a/apps/server/src/git/GitManager.test.ts
+++ b/apps/server/src/git/GitManager.test.ts
@@ -1,3 +1,5 @@
+import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
+import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
 import { SourceControlProviderKind } from "@t3tools/contracts";
 // @effect-diagnostics nodeBuiltinImport:off
 import * as NodeFS from "node:fs";
@@ -69,6 +71,10 @@ type FakeChangeRequest = Omit<ChangeRequest, "provider" | "state" | "updatedAt">
 };
 
 interface FakeProviderScenario {
+  prListGate?: {
+    readonly started: Deferred.Deferred<void>;
+    readonly release: Deferred.Deferred<void>;
+  };
   /** The kind the fake host reports itself as. */
   kind?: string;
   /** Answers to successive change request listings, whatever their head selector. */
@@ -452,6 +458,13 @@ function createFakeSourceControlProvider(scenario: FakeProviderScenario = {}): {
               []
             ).map(toChangeRequest),
           ),
+          Effect.tap(() =>
+            scenario.prListGate
+              ? Deferred.succeed(scenario.prListGate.started, undefined).pipe(
+                  Effect.andThen(Deferred.await(scenario.prListGate.release)),
+                )
+              : Effect.void,
+          ),
         ),
       createChangeRequest: (input) =>
         record(input.cwd, {
@@ -723,6 +736,108 @@ const layerGitManagerTest = GitVcsDriver.layer.pipe(
 );
 
 it.layer(layerGitManagerTest)("GitManager", (it) => {
+  it.effect(
+    "publishes local Git changes during a held PR lookup without caching its old branch",
+    () =>
+      Effect.gen(function* () {
+        const repoDir = yield* makeTempDir("t3code-refresh-status-gh-gate-");
+        yield* initRepo(repoDir);
+        yield* runGit(repoDir, ["checkout", "-b", "release"]);
+        const remoteDir = yield* createBareRemote();
+        yield* runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+        yield* runGit(repoDir, ["push", "-u", "origin", "release"]);
+        yield* runGit(repoDir, ["tag", "release"]);
+        const oldPr = {
+          number: 613,
+          title: "Release PR",
+          url: "https://github.com/pingdotgg/codething-mvp/pull/613",
+          baseRefName: "main",
+          headRefName: "release",
+        };
+        const newPr = { ...oldPr, number: 614, headRefName: "heads/release" };
+        const providerScenario: FakeProviderScenario = {
+          prListSequence: [oldPr, oldPr, newPr].map((pr) => [pr]),
+        };
+        const { manager } = yield* makeManager({ providerScenario });
+        const context = yield* Layer.build(
+          VcsStatusBroadcaster.layer.pipe(
+            Layer.provide(
+              GitWorkflowService.layer.pipe(
+                Layer.provide(Layer.succeed(GitManager.GitManager, manager)),
+                Layer.provide(
+                  VcsDriverRegistry.layer.pipe(
+                    Layer.provide(VcsProjectConfig.layer),
+                    Layer.provide(VcsProcess.layer),
+                  ),
+                ),
+              ),
+            ),
+            Layer.provide(
+              Layer.mock(BackgroundPolicy.BackgroundPolicy)({
+                shouldRunScopeWork: () => Effect.succeed(true),
+              }),
+            ),
+          ),
+        );
+        const broadcaster = Context.get(context, VcsStatusBroadcaster.VcsStatusBroadcaster);
+        const initial = yield* broadcaster.getStatus({ cwd: repoDir });
+        expect(initial.refName).toBe("release");
+        expect(initial.pr?.number).toBe(613);
+
+        const subscribed = yield* Deferred.make<void>();
+        const published = yield* Deferred.make<void>();
+        yield* broadcaster.streamStatus({ cwd: repoDir, includeRemote: false }).pipe(
+          Stream.runForEach((event) => {
+            if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
+            if (event._tag === "localUpdated" && event.local.hasWorkingTreeChanges) {
+              return Deferred.succeed(published, undefined);
+            }
+            return Effect.void;
+          }),
+          Effect.forkScoped,
+        );
+        yield* Deferred.await(subscribed);
+        const gate = {
+          started: yield* Deferred.make<void>(),
+          release: yield* Deferred.make<void>(),
+        };
+        providerScenario.prListGate = gate;
+        const fs = yield* FileSystem.FileSystem;
+        yield* fs.writeFileString(NodePath.join(repoDir, "README.md"), "changed before refresh\n");
+        const completed = yield* Deferred.make<void>();
+        const refresh = yield* broadcaster
+          .refreshStatus(repoDir)
+          .pipe(Effect.ensuring(Deferred.succeed(completed, undefined)), Effect.forkScoped);
+        yield* Deferred.await(gate.started);
+        const pending = Option.getOrThrow(
+          yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
+        );
+        expect(pending._tag).toBe("snapshot");
+        if (pending._tag === "snapshot") expect(pending.local.hasWorkingTreeChanges).toBe(true);
+        yield* Deferred.await(published);
+        expect(yield* Deferred.isDone(completed)).toBe(false);
+
+        yield* runGit(repoDir, ["checkout", "-b", "heads/release"]);
+        yield* runGit(repoDir, ["push", "-u", "origin", "refs/heads/heads/release"]);
+        yield* Deferred.succeed(gate.release, undefined);
+        const refreshed = yield* Fiber.join(refresh);
+        expect(refreshed.refName).toBe("heads/release");
+        expect(refreshed.hasWorkingTreeChanges).toBe(true);
+        expect(refreshed.pr).toBeNull();
+        const snapshot = Option.getOrThrow(
+          yield* Stream.runHead(broadcaster.streamStatus({ cwd: repoDir, includeRemote: false })),
+        );
+        expect(snapshot._tag).toBe("snapshot");
+        if (snapshot._tag === "snapshot") expect(snapshot.remote).toBeNull();
+
+        delete providerScenario.prListGate;
+        const recovered = yield* broadcaster.getStatus({ cwd: repoDir });
+        expect(recovered.refName).toBe("heads/release");
+        expect(recovered.pr?.number).toBe(614);
+        expect((yield* broadcaster.getStatus({ cwd: repoDir })).pr?.number).toBe(614);
+      }),
+  );
+
   it.effect("status reports the listed PR whose head is the branch", () =>
     Effect.gen(function* () {
       const repoDir = yield* makeTempDir("t3code-git-manager-");
diff --git a/apps/server/src/git/GitWorkflowService.ts b/apps/server/src/git/GitWorkflowService.ts
index 832dc6c4ef625..7bb098da87862 100644
--- a/apps/server/src/git/GitWorkflowService.ts
+++ b/apps/server/src/git/GitWorkflowService.ts
@@ -52,6 +52,7 @@ export class GitWorkflowService extends Context.Service<
     readonly localStatus: (
       input: VcsStatusInput,
     ) => Effect.Effect<VcsStatusLocalResult, GitManagerServiceError>;
+    readonly currentBranch: (cwd: string) => Effect.Effect<string | null, GitManagerServiceError>;
     readonly remoteStatus: (
       input: VcsStatusInput,
       options?: GitManager.GitRemoteStatusOptions,
@@ -332,6 +333,32 @@ export const make = Effect.gen(function* () {
         ),
       );
     }),
+    currentBranch: Effect.fn("GitWorkflowService.currentBranch")(function* (cwd) {
+      if (!(yield* detectGitRepositoryForStatus("GitWorkflowService.currentBranch", cwd))) {
+        return null;
+      }
+      const result = yield* git.execute({
+        operation: "GitWorkflowService.currentBranch",
+        cwd,
+        args: ["symbolic-ref", "--quiet", "HEAD"],
+        allowNonZeroExit: true,
+        timeoutMs: 5_000,
+      });
+      if (result.exitCode === 0) {
+        return result.stdout.trim().replace(/^refs\/heads\//, "") || null;
+      }
+      if (result.exitCode === 1) return null;
+      return yield* new GitCommandError({
+        operation: "GitWorkflowService.currentBranch",
+        command: "git symbolic-ref",
+        cwd,
+        argumentCount: 3,
+        ...(result.exitCode === null ? {} : { exitCode: result.exitCode }),
+        stdoutLength: result.stdout.length,
+        stderrLength: result.stderr.length,
+        detail: "Failed to read the checked-out branch.",
+      });
+    }),
     remoteStatus: Effect.fn("GitWorkflowService.remoteStatus")(function (input, options) {
       return detectGitRepositoryForStatus("GitWorkflowService.remoteStatus", input.cwd).pipe(
         Effect.flatMap((isGitRepository) =>
diff --git a/apps/server/src/guest/GuestShareService.test.ts b/apps/server/src/guest/GuestShareService.test.ts
index 31acd7bdb60bf..1ef25744c8c55 100644
--- a/apps/server/src/guest/GuestShareService.test.ts
+++ b/apps/server/src/guest/GuestShareService.test.ts
@@ -411,7 +411,6 @@ it.effect("serves no render for an item outside the shared thread", () =>
   }).pipe(Effect.provide(layerTest)),
 );
 
-/** A message from the owner, which opens a run for the command below. */
 const ownerRun = Effect.gen(function* () {
   const orchestrator = yield* Orchestrator.OrchestratorV2;
   yield* orchestrator.dispatch({
@@ -430,12 +429,17 @@ const ownerRun = Effect.gen(function* () {
   return runs[0]!.id;
 });
 
-const writeCommand = (
+const writeItem = (
   id: string,
-  fields: Pick<
-    Extract<OrchestrationV2TurnItem, { type: "command_execution" }>,
-    "status" | "output"
-  >,
+  fields:
+    | Pick<
+        Extract<OrchestrationV2TurnItem, { type: "command_execution" }>,
+        "type" | "status" | "input" | "output"
+      >
+    | Pick<
+        Extract<OrchestrationV2TurnItem, { type: "file_change" }>,
+        "type" | "status" | "fileName" | "diffStr" | "oldStr" | "newStr"
+      >,
 ) =>
   Effect.gen(function* () {
     const runId = yield* ownerRun;
@@ -464,8 +468,6 @@ const writeCommand = (
             startedAt: now,
             completedAt: fields.status === "running" ? null : now,
             updatedAt: now,
-            type: "command_execution",
-            input: "ls /work/src",
             ...fields,
           },
         },
@@ -474,17 +476,40 @@ const writeCommand = (
     return TurnItemId.make(id);
   });
 
-it.effect("gives the guest a command's detail and output, as the owner's row loads them", () =>
+it.effect("gives the guest a command's detail and output, but no file diffs", () =>
   Effect.gen(function* () {
     const { guestShares, credential } = yield* shareThread;
     const { token: session } = yield* guestShares.redeem({ credential, name: "Sam" });
-    const command = yield* writeCommand("item:command", {
+    const command = yield* writeItem("item:command", {
+      type: "command_execution",
       status: "completed",
+      input: "ls /work/src",
       output: "/work/src/auth.ts\n",
     });
 
     const detail = (yield* guestShares.item(session, command)).item;
     assert.deepInclude(detail, { input: "ls /work/src", output: "/work/src/auth.ts\n" });
+    const edit = yield* writeItem("item:edit", {
+      type: "file_change",
+      status: "completed",
+      fileName: "src/auth.ts",
+      diffStr: "-const token = 1;\n+const token = 2;\n",
+    });
+    const write = yield* writeItem("item:write", {
+      type: "file_change",
+      status: "completed",
+      fileName: "src/config.ts",
+      oldStr: "",
+      newStr: "export const key = 1;\n",
+    });
+    for (const [id, fileName] of [
+      [edit, "src/auth.ts"],
+      [write, "src/config.ts"],
+    ] as const) {
+      const change = (yield* guestShares.item(session, id)).item;
+      assert.deepInclude(change, { type: "file_change", fileName });
+      assert.doesNotHaveAnyKeys(change, ["diffStr", "oldStr", "newStr"]);
+    }
     const frames = Array.from(
       yield* Stream.runCollect(yield* guestShares.commandOutput(session, command)),
     );
@@ -508,7 +533,11 @@ it.effect("ends a running command's output once the owner stops sharing", () =>
   Effect.gen(function* () {
     const { orchestrator, guestShares, credential } = yield* shareThread;
     const { token: session } = yield* guestShares.redeem({ credential, name: "Sam" });
-    const command = yield* writeCommand("item:running", { status: "running" });
+    const command = yield* writeItem("item:running", {
+      type: "command_execution",
+      status: "running",
+      input: "ls /work/src",
+    });
     const collecting = yield* Stream.runCollect(
       yield* guestShares.commandOutput(session, command),
     ).pipe(Effect.forkChild);
diff --git a/apps/server/src/guest/GuestShareService.ts b/apps/server/src/guest/GuestShareService.ts
index 0346068bc546f..347bdc11ece5b 100644
--- a/apps/server/src/guest/GuestShareService.ts
+++ b/apps/server/src/guest/GuestShareService.ts
@@ -57,6 +57,7 @@ import { buildBoundedThreadStreamSnapshot } from "../orchestration-v2/ThreadStre
 import {
   projectDomainEventForWire,
   projectTurnItemForDetail,
+  projectTurnItemForWire,
 } from "../orchestration-v2/WireProjection.ts";
 import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import * as ServerSettings from "../serverSettings.ts";
@@ -179,7 +180,7 @@ export class GuestShareService extends Context.Service<
       session: string,
       itemId: string,
     ) => Effect.Effect<{ readonly path: string; readonly title: string }, GuestShareAccessError>;
-    /** One item of the shared thread, as the owner's expanded row loads it. */
+    /** One item of the shared thread, as the owner's expanded row loads it, without file diffs. */
     readonly item: (
       session: string,
       itemId: string,
@@ -658,7 +659,10 @@ const make = Effect.gen(function* () {
 
   const item = Effect.fn("GuestShareService.item")(function* (session: string, itemId: string) {
     const { item } = yield* threadItem(session, itemId);
-    return { item: projectTurnItemForDetail(item) };
+    return {
+      item:
+        item.type === "file_change" ? projectTurnItemForWire(item) : projectTurnItemForDetail(item),
+    };
   });
 
   const commandOutput = Effect.fn("GuestShareService.commandOutput")(function* (
diff --git a/apps/server/src/mcp/McpInvocationContext.ts b/apps/server/src/mcp/McpInvocationContext.ts
index 26795c51696bd..5ce9669bc4d83 100644
--- a/apps/server/src/mcp/McpInvocationContext.ts
+++ b/apps/server/src/mcp/McpInvocationContext.ts
@@ -12,6 +12,7 @@ import {
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
+import { formatThreadLink } from "@t3tools/shared/threadLinks";
 
 const ALL_MCP_CAPABILITIES = [
   "preview",
@@ -44,6 +45,8 @@ export interface McpClientCaller {
    * another environment passing on the limits of the agent it calls for.
    */
   readonly narrowedTo?: ClientModes | undefined;
+  /** The origin an outside client reached; its thread links open the web app there. */
+  readonly webOrigin?: string | undefined;
 }
 
 /**
@@ -105,6 +108,20 @@ export interface McpInvocationScope {
   readonly linkedEnvironments?: boolean;
 }
 
+/**
+ * T3 Code renders `t3-thread://` links as thread chips. Other MCP clients cannot open them, so
+ * they get a web URL on the origin they reached instead.
+ */
+export const threadLinkFor = (
+  scope: Pick<McpInvocationScope, "environmentId" | "client">,
+  threadId: ThreadId,
+): string => {
+  const origin = scope.client?.webOrigin;
+  return origin === undefined
+    ? formatThreadLink({ environmentId: scope.environmentId, threadId })
+    : `${origin}/${encodeURIComponent(scope.environmentId)}/${encodeURIComponent(threadId)}`;
+};
+
 export class McpInvocationContext extends Context.Service<
   McpInvocationContext,
   McpInvocationScope
diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
index 8b32603a7194e..d8dacb35a0617 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.ts
@@ -1,6 +1,5 @@
 import {
   CommandId,
-  type EnvironmentId,
   type RunId,
   isProviderAvailable,
   MessageId,
@@ -108,6 +107,7 @@ import {
   type McpInvocationScope,
   type McpThreadInvocationScope,
   requireThreadScope,
+  threadLinkFor,
 } from "./McpInvocationContext.ts";
 import * as Metrics from "../observability/Metrics.ts";
 import {
@@ -752,7 +752,7 @@ function threadPullRequests(
 }
 
 function listItemFromShell(
-  environmentId: EnvironmentId,
+  scope: McpInvocationScope,
   shell: OrchestrationV2ThreadShell,
   nowMs: number,
 ): OrchestratorMcpThreadListItem {
@@ -760,7 +760,7 @@ function listItemFromShell(
     threadId: shell.id,
     projectId: shell.projectId,
     title: shell.title,
-    link: formatThreadLink({ environmentId, threadId: shell.id }),
+    link: threadLinkFor(scope, shell.id),
     createdBy: shell.createdBy,
     creationSource: shell.creationSource,
     status: shell.activityRunStatus ?? shell.status,
@@ -782,7 +782,7 @@ function listItemFromShell(
 }
 
 function threadDetail(
-  environmentId: EnvironmentId,
+  scope: McpInvocationScope,
   projection: Pick<OrchestrationV2ThreadProjection, "thread" | "runs" | "runtimeRequests">,
   itemCount: number,
   shell: OrchestrationV2ThreadShell,
@@ -794,7 +794,7 @@ function threadDetail(
     threadId: projection.thread.id,
     projectId: projection.thread.projectId,
     title: projection.thread.title,
-    link: formatThreadLink({ environmentId, threadId: projection.thread.id }),
+    link: threadLinkFor(scope, projection.thread.id),
     createdBy: projection.thread.createdBy,
     creationSource: projection.thread.creationSource,
     status: active?.status ?? latest?.status ?? "idle",
@@ -2806,7 +2806,7 @@ const make = Effect.gen(function* () {
       return {
         projectId,
         currentThreadId: parent?.thread.id ?? null,
-        threads: page.map((shell) => listItemFromShell(scope.environmentId, shell, nowMs)),
+        threads: page.map((shell) => listItemFromShell(scope, shell, nowMs)),
         nextCursor,
         total: filtered.length,
       } satisfies OrchestratorMcpThreadListResult;
@@ -2887,7 +2887,7 @@ const make = Effect.gen(function* () {
       }
       return {
         thread: threadDetail(
-          scope.environmentId,
+          scope,
           target,
           timeline.totalItems,
           shell,
@@ -2951,7 +2951,7 @@ const make = Effect.gen(function* () {
         );
       return {
         threadId: input.threadId,
-        link: formatThreadLink({ environmentId: scope.environmentId, threadId: input.threadId }),
+        link: threadLinkFor(scope, input.threadId),
         messageId,
         runId: result.run.id,
         ...(result.run.delegatedTaskId === undefined ? {} : { taskId: result.run.delegatedTaskId }),
diff --git a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
index dba3bf7c08ee4..ec8c9434bec43 100644
--- a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
@@ -182,6 +182,7 @@ const layerUnusedScheduledTaskStub = Layer.succeed(
     setEnabled: () => Effect.die("ScheduledTaskService.setEnabled is unused in this test"),
     delete: () => Effect.die("ScheduledTaskService.delete is unused in this test"),
     deleteForThread: () => Effect.die("unused in this test"),
+    moveThreadTasks: () => Effect.die("unused in this test"),
     runNow: () => Effect.die("ScheduledTaskService.runNow is unused in this test"),
     rotateWebhookToken: () => Effect.die("unused in this test"),
     listWebhookDeliveries: () => Effect.die("unused in this test"),
diff --git a/apps/server/src/mcp/toolkits/device/handlers.ts b/apps/server/src/mcp/toolkits/device/handlers.ts
index 4036f083ca910..6812754af199b 100644
--- a/apps/server/src/mcp/toolkits/device/handlers.ts
+++ b/apps/server/src/mcp/toolkits/device/handlers.ts
@@ -30,16 +30,28 @@ export function agentDeviceQuickStart(
   device: DeviceSummary,
   targetArgs = agentDeviceTargetArgs(device),
   command = "agent-device",
-  cloud = false,
+  host?:
+    | { readonly kind: "eas" }
+    | { readonly kind: "simlock"; readonly installDirectory?: string },
 ): string {
   const executable = shellWord(command);
   const target = targetArgs.map(shellWord).join(" ");
   const run = (args: string) => [executable, args, target].filter(Boolean).join(" ");
-  const platformNotes = cloud
-    ? "This is an EAS Simulator session in the cloud. It bills the Expo account per minute until it stops, so call device_close with shutdown: true when you are done. It starts with no apps installed: install-from-source <url> installs a build from a URL (iOS needs a .tar.gz containing a .app), and install uploads one from this machine."
-    : device.platform === "ios"
-      ? "First use builds an XCTest runner and can take a couple of minutes; later commands are fast."
-      : "The Android snapshot helper installs itself on first use.";
+  const platformNotes =
+    host?.kind === "simlock"
+      ? [
+          "This device is leased from a Simlock pool (alpha in T3 Code). The lease returns it to the pool, wiped, when it ends, so call device_close with shutdown: true when you are done. It starts with no apps installed.",
+          host.installDirectory
+            ? `agent-device accepts install for this lease only when run from ${host.installDirectory}.`
+            : "",
+        ]
+          .filter(Boolean)
+          .join(" ")
+      : host?.kind === "eas"
+        ? "This is an EAS Simulator session in the cloud. It bills the Expo account per minute until it stops, so call device_close with shutdown: true when you are done. It starts with no apps installed: install-from-source <url> installs a build from a URL (iOS needs a .tar.gz containing a .app), and install uploads one from this machine."
+        : device.platform === "ios"
+          ? "First use builds an XCTest runner and can take a couple of minutes; later commands are fast."
+          : "The Android snapshot helper installs itself on first use.";
   return [
     `The user is watching ${device.name} (${device.version}) in the Device panel.`,
     target === ""
@@ -222,9 +234,11 @@ const handlers = {
         deviceId: session.deviceId,
       };
       const agent = yield* devices.agentTarget(opened);
-      const cloud = after.hosts.some((host) => host.id === device.hostId && host.kind === "eas");
+      const hostKind = after.hosts.find((host) => host.id === device.hostId)?.kind;
       const targetArgs = [
-        ...agentDeviceTargetArgs({ ...device, id: agent.agentDeviceId }),
+        ...(agent.agentDeviceId === null
+          ? []
+          : agentDeviceTargetArgs({ ...device, id: agent.agentDeviceId })),
         ...agent.args,
       ];
       const launcher = yield* devices.agentLauncher({ ...opened, targetArgs });
@@ -238,7 +252,19 @@ const handlers = {
       return {
         device,
         agentDevice: { command, targetArgs, session: agent.session },
-        quickStart: agentDeviceQuickStart(device, [], command, cloud),
+        quickStart: agentDeviceQuickStart(
+          device,
+          [],
+          command,
+          hostKind === "simlock"
+            ? {
+                kind: "simlock",
+                ...(agent.installDirectory ? { installDirectory: agent.installDirectory } : {}),
+              }
+            : hostKind === "eas"
+              ? { kind: "eas" }
+              : undefined,
+        ),
       };
     }).pipe(Effect.mapError(toolError)),
   ),
diff --git a/apps/server/src/mcp/toolkits/project/handlers.test.ts b/apps/server/src/mcp/toolkits/project/handlers.test.ts
index 4031654a8c826..03b97c32af6db 100644
--- a/apps/server/src/mcp/toolkits/project/handlers.test.ts
+++ b/apps/server/src/mcp/toolkits/project/handlers.test.ts
@@ -1,8 +1,11 @@
+import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts";
 import { expect, it } from "@effect/vitest";
 import {
   EnvironmentId,
   ProjectId,
   ProviderInstanceId,
+  ProviderDriverKind,
+  type ServerProvider,
   type Project as ProjectRecord,
   type ModelSelection,
   type RuntimeMode,
@@ -37,11 +40,14 @@ import { ProjectToolkit } from "./tools.ts";
 const clientLaunchHarness = (input: {
   readonly runtimeModeCeiling: RuntimeMode;
   readonly defaultRuntimeMode?: RuntimeMode;
+  readonly fallbackModel?: ModelSelection;
+  readonly providers?: readonly ServerProvider[];
   /** Where Settings saves a project's model; the legacy project field stays null. */
   readonly overrideModel?: ModelSelection;
   readonly launched: Array<ThreadLaunch.ThreadLaunchInput>;
   readonly workspaceRoot?: string;
   readonly checkWorktreeBase?: ThreadLaunch.ThreadLaunchService["Service"]["checkWorktreeBase"];
+  readonly webOrigin?: string;
 }) => {
   const projectId = ProjectId.make("project:client-target");
   const modelSelection = {
@@ -53,7 +59,11 @@ const clientLaunchHarness = (input: {
     model: input.overrideModel === undefined ? modelSelection : null,
   };
   const layerDependencies = Layer.mergeAll(
+    Layer.mock(ProviderRegistry.ProviderRegistry)({
+      getProviders: Effect.succeed(input.providers ?? []),
+    }),
     ServerSettings.layerTest({
+      fallbackModelSelection: input.fallbackModel ?? null,
       ...(input.defaultRuntimeMode === undefined
         ? {}
         : { defaultRuntimeMode: input.defaultRuntimeMode }),
@@ -75,6 +85,7 @@ const clientLaunchHarness = (input: {
         sessionId: "session-1",
         label: "Claude Code",
         access: input.runtimeModeCeiling,
+        webOrigin: input.webOrigin,
       },
       issuedAt: 0,
       capabilities: new Set(["orchestration" as const]),
@@ -155,15 +166,17 @@ it.effect(
           readonly runtimeMode?: RuntimeMode;
           readonly targeted?: false;
           readonly overrideModel?: ModelSelection;
+          readonly webOrigin?: string;
         },
       ) {
-        const { targeted, overrideModel, ...input } = params;
+        const { targeted, overrideModel, webOrigin, ...input } = params;
         const launched: Array<ThreadLaunch.ThreadLaunchInput> = [];
         const { projectId, modelSelection, dependencies } = clientLaunchHarness({
           runtimeModeCeiling,
           defaultRuntimeMode,
           launched,
           ...(overrideModel === undefined ? {} : { overrideModel }),
+          ...(webOrigin === undefined ? {} : { webOrigin }),
         });
         const toolkit = yield* ProjectToolkit.pipe(
           Effect.provide(
@@ -190,8 +203,14 @@ it.effect(
       expect(belowCeiling.launched[0]?.runtimeMode).toBe("approval-required");
       expect(belowCeiling.launched[0]?.initialMessage?.senderThreadId).toBeUndefined();
 
-      const aboveCeiling = yield* launchWith("auto-accept-edits", "full-access", { title: "Fix" });
+      const aboveCeiling = yield* launchWith("auto-accept-edits", "full-access", {
+        title: "Fix",
+        webOrigin: "https://box.example.ts.net",
+      });
       expect(aboveCeiling.launched[0]?.runtimeMode).toBe("auto-accept-edits");
+      expect(aboveCeiling.result).toMatchObject({
+        link: `https://box.example.ts.net/environment/${encodeURIComponent(aboveCeiling.launched[0]?.threadId ?? "")}`,
+      });
 
       const requested = yield* launchWith("full-access", "approval-required", {
         title: "Fix",
@@ -463,3 +482,52 @@ it.effect("a retried worktree launch replays after its base ref is gone", () =>
     ]);
   }),
 );
+
+it.effect("a client launches with the fallback for an exhausted default", () =>
+  Effect.gen(function* () {
+    const launched: ThreadLaunch.ThreadLaunchInput[] = [];
+    const fallbackModel = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-6.1-sol" };
+    const providers: ServerProvider[] = ["claudeAgent", "codex"].map((driver) => ({
+      instanceId: ProviderInstanceId.make(driver),
+      driver: ProviderDriverKind.make(driver),
+      enabled: true,
+      installed: true,
+      status: "ready",
+      version: null,
+      auth: { status: "authenticated" },
+      checkedAt: "2026-01-01T00:00:00Z",
+      models: [],
+      slashCommands: [],
+      skills: [],
+      ...(driver === "claudeAgent"
+        ? {
+            usageLimits: {
+              checkedAt: "2026-01-01T00:00:00Z",
+              windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 100 }],
+            },
+          }
+        : {}),
+    }));
+    const { projectId, dependencies } = clientLaunchHarness({
+      runtimeModeCeiling: "full-access",
+      launched,
+      fallbackModel,
+      providers,
+    });
+    const toolkit = yield* ProjectToolkit.pipe(
+      Effect.provide(
+        McpToolAccess.HandlersLayer.layer(ProjectHandlers.layer).pipe(Layer.provide(dependencies)),
+      ),
+    );
+    const result = yield* toolkit
+      .handle("t3_thread_launch", {
+        projectId,
+        title: "Fallback",
+      })
+      .pipe(Stream.unwrap, Stream.runCollect, Effect.provide(dependencies));
+    expect(result.at(-1)?.result).toMatchObject({
+      modelSelection: fallbackModel,
+    });
+    expect(launched[0]?.modelSelection).toEqual(fallbackModel);
+  }),
+);
diff --git a/apps/server/src/mcp/toolkits/project/handlers.ts b/apps/server/src/mcp/toolkits/project/handlers.ts
index 950cb38c6c4fd..014b109448f34 100644
--- a/apps/server/src/mcp/toolkits/project/handlers.ts
+++ b/apps/server/src/mcp/toolkits/project/handlers.ts
@@ -18,8 +18,10 @@ import * as ManagedProjectFolders from "../../../project/ManagedProjectFolders.t
 import * as Repositories from "../../../sourceControl/SourceControlRepositoryService.ts";
 import * as GitVcsDriver from "../../../vcs/GitVcsDriver.ts";
 import * as ServerSettings from "../../../serverSettings.ts";
+import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts";
+import * as DateTime from "effect/DateTime";
+import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
-import { formatThreadLink } from "@t3tools/shared/threadLinks";
 import { resolveRuntimeMode } from "../../delegatedTaskModes.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
 import * as McpToolAccess from "../../McpToolAccess.ts";
@@ -181,7 +183,18 @@ export const layer = McpToolAccess.toLayer(ProjectToolkit, {
           input.modelSelection ??
           launchedModel ??
           caller?.modelSelection ??
-          projectDefaults?.defaultModelSelection ??
+          (projectDefaults
+            ? resolveNewThreadModelSelection({
+                defaultSelection: projectDefaults.defaultModelSelection,
+                fallbackSelection: projectDefaults.fallbackModelSelection,
+                providers: yield* ProviderRegistry.ProviderRegistry.pipe(
+                  Effect.flatMap((registry) => registry.getProviders),
+                ),
+                settings: projectDefaults,
+                projectId,
+                now: DateTime.toEpochMillis(yield* DateTime.now),
+              }).selection
+            : null) ??
           undefined;
         if (modelSelection === undefined)
           return yield* new OrchestratorMcpFailure({
@@ -240,7 +253,7 @@ export const layer = McpToolAccess.toLayer(ProjectToolkit, {
         const run = result.projection.runs.find((run) => run.userMessageId === messageId);
         return {
           threadId: thread.id,
-          link: formatThreadLink({ environmentId: scope.environmentId, threadId: thread.id }),
+          link: McpInvocationContext.threadLinkFor(scope, thread.id),
           projectId: thread.projectId,
           modelSelection: thread.modelSelection,
           runId: run?.id ?? null,
diff --git a/apps/server/src/mcp/toolkits/project/tools.ts b/apps/server/src/mcp/toolkits/project/tools.ts
index 38931596868b4..3ea5a8ea9e48f 100644
--- a/apps/server/src/mcp/toolkits/project/tools.ts
+++ b/apps/server/src/mcp/toolkits/project/tools.ts
@@ -23,6 +23,7 @@ import {
 import * as FileSystem from "effect/FileSystem";
 import * as DocumentText from "../../../provider/DocumentText.ts";
 import * as ServerConfig from "../../../config.ts";
+import * as ProviderRegistry from "../../../provider/ProviderRegistry.ts";
 import * as ServerSettings from "../../../serverSettings.ts";
 import * as ThreadLaunchService from "../../../orchestration-v2/ThreadLaunchService.ts";
 import * as Crypto from "effect/Crypto";
@@ -166,6 +167,7 @@ const ThreadLaunchTool = Tool.make("t3_thread_launch", {
     FileSystem.FileSystem,
     ServerConfig.ServerConfig,
     ServerSettings.ServerSettingsService,
+    ProviderRegistry.ProviderRegistry,
     DocumentText.DocumentText,
   ],
 })
diff --git a/apps/server/src/mcp/toolkits/thread/handlers.ts b/apps/server/src/mcp/toolkits/thread/handlers.ts
index 8ad9afa435193..b1d34c91be8af 100644
--- a/apps/server/src/mcp/toolkits/thread/handlers.ts
+++ b/apps/server/src/mcp/toolkits/thread/handlers.ts
@@ -9,7 +9,6 @@ import {
 } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
 import { modelSelectionCommandType } from "@t3tools/shared/model";
-import { formatThreadLink } from "@t3tools/shared/threadLinks";
 
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
 import * as McpToolAccess from "../../McpToolAccess.ts";
@@ -104,11 +103,15 @@ export const layer = McpToolAccess.toLayer(ThreadToolkit, {
       const { task, threadId } = yield* scheduler
         .runNow({ id: input.taskId })
         .pipe(Effect.mapError(unavailable));
-      const { environmentId } = yield* McpInvocationContext.McpInvocationContext;
+      const scope = yield* McpInvocationContext.McpInvocationContext;
       return {
         taskId: task.id,
         threadId,
-        ...(threadId === null ? {} : { link: formatThreadLink({ environmentId, threadId }) }),
+        ...(threadId === null
+          ? {}
+          : {
+              link: McpInvocationContext.threadLinkFor(scope, threadId),
+            }),
         lastRunStatus: task.lastRunStatus,
         runCount: task.runCount,
         nextRunAt: task.nextRunAt,
@@ -118,7 +121,7 @@ export const layer = McpToolAccess.toLayer(ThreadToolkit, {
   t3_thread_search: McpToolAccess.reads((input) =>
     Effect.gen(function* () {
       const { caller } = yield* readCaller();
-      const { environmentId } = yield* McpInvocationContext.McpInvocationContext;
+      const scope = yield* McpInvocationContext.McpInvocationContext;
       const threadSearch = yield* ThreadSearch.ThreadSearch;
       const { matches } = yield* threadSearch
         .searchThreads({ ...input, projectId: input.projectId ?? caller?.projectId })
@@ -126,7 +129,7 @@ export const layer = McpToolAccess.toLayer(ThreadToolkit, {
       return {
         matches: matches.map((match) => ({
           ...match,
-          link: formatThreadLink({ environmentId, threadId: match.threadId }),
+          link: McpInvocationContext.threadLinkFor(scope, match.threadId),
         })),
       };
     }),
diff --git a/apps/server/src/observability/RpcInstrumentation.ts b/apps/server/src/observability/RpcInstrumentation.ts
index 504e533b37e05..259fa92a66023 100644
--- a/apps/server/src/observability/RpcInstrumentation.ts
+++ b/apps/server/src/observability/RpcInstrumentation.ts
@@ -150,6 +150,7 @@ const RPC_AGGREGATES = {
   [WS_METHODS.projectsWriteFile]: "workspace",
   [WS_METHODS.projectsEnsureScratch]: "orchestration",
   [WS_METHODS.projectsCreateNew]: "orchestration",
+  [WS_METHODS.projectsCreateFromThread]: "orchestration",
   [WS_METHODS.shellOpenInEditor]: "workspace",
   [WS_METHODS.filesystemBrowse]: "workspace",
   [WS_METHODS.filesystemGetMetadata]: "workspace",
@@ -203,6 +204,7 @@ const RPC_AGGREGATES = {
   [WS_METHODS.deviceConfigure]: "device",
   [WS_METHODS.deviceTestHost]: "device",
   [WS_METHODS.deviceEasAccount]: "device",
+  [WS_METHODS.deviceSimlockIdentity]: "device",
   [WS_METHODS.deviceList]: "device",
   [WS_METHODS.deviceOpen]: "device",
   [WS_METHODS.deviceClose]: "device",
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
index f05ace7ff750d..8a68e92b89160 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
@@ -3115,6 +3115,155 @@ describe("AcpAdapterV2", () => {
     }).pipe(Effect.provide(layerTest), Effect.scoped),
   );
 
+  it.effect.each([
+    {
+      label: "grants an ID-only execute approval its tracked command",
+      kind: "execute",
+      granted: true,
+    },
+    {
+      label: "does not grant execution to an ID-only approval of another tool",
+      kind: "other",
+      granted: false,
+    },
+  ] as const)("$label", ({ kind, granted }) =>
+    Effect.gen(function* () {
+      const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+      const path = yield* Path.Path;
+      const selfInvocation = yield* resolveSelfInvocation();
+      const mockAgentPath = yield* path.fromFileUrl(
+        new URL("../../../scripts/acp-mock-agent.ts", import.meta.url),
+      );
+      type RuntimeService = AcpSessionRuntime.AcpSessionRuntime["Service"];
+      let requestPermission: Parameters<RuntimeService["handleRequestPermission"]>[0] | undefined;
+      let createTerminal: Parameters<RuntimeService["handleCreateTerminal"]>[0] | undefined;
+      let runtimeInput: AcpAdapterV2RuntimeInput | undefined;
+      const makeRuntime = makeMockRuntime({
+        childProcessSpawner,
+        mockAgentPath,
+        environment: { T3_ACP_EMIT_TRACKED_TOOL_CALL_KIND_THEN_HANG: kind },
+        wrapRuntime: (runtime) => ({
+          ...runtime,
+          handleRequestPermission: (handler) =>
+            Effect.sync(() => {
+              requestPermission = handler;
+            }).pipe(Effect.andThen(runtime.handleRequestPermission(handler))),
+          handleCreateTerminal: (handler) =>
+            Effect.sync(() => {
+              createTerminal = handler;
+            }).pipe(Effect.andThen(runtime.handleCreateTerminal(handler))),
+        }),
+      });
+      const instanceId = ProviderInstanceId.make("acp-test-id-only-permission");
+      const adapter = yield* makeAcpAdapterV2({
+        instanceId,
+        flavor: {
+          driver: ACP_TEST_DRIVER,
+          capabilities: AcpProviderCapabilitiesV2,
+          interruptPromptOnCancel: true,
+          makeRuntime: (input) =>
+            Effect.sync(() => {
+              runtimeInput = input;
+            }).pipe(Effect.andThen(makeRuntime(input))),
+        },
+        selfInvocation,
+        clientTerminals: {},
+      });
+      const threadId = ThreadId.make("thread-acp-id-only-permission");
+      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+        runtimeMode: "approval-required",
+        interactionMode: "default",
+        cwd: process.cwd(),
+      });
+      const modelSelection = { instanceId, model: "default" } as const;
+      const runtime = yield* adapter.openSession({
+        threadId,
+        providerSessionId: ProviderSessionId.make("provider-session-acp-id-only-permission"),
+        modelSelection,
+        runtimePolicy,
+      });
+      const providerThread = yield* runtime.ensureThread({
+        threadId,
+        modelSelection,
+        runtimePolicy,
+      });
+      const turnFiber = yield* runtime
+        .startTurn(
+          makeTurnInput({
+            threadId,
+            providerThread,
+            instanceId,
+            runtimePolicy,
+            now: yield* DateTime.now,
+          }),
+        )
+        .pipe(Effect.forkScoped);
+      if (requestPermission === undefined || createTerminal === undefined) {
+        return yield* Effect.die("ACP runtime must register permission and terminal handlers");
+      }
+      yield* runtime.events.pipe(
+        Stream.filter(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.nativeItemRef?.nativeId === "tracked-tool-call",
+        ),
+        Stream.runHead,
+      );
+
+      const permissionFiber = yield* requestPermission(
+        {
+          sessionId: "mock-session-1",
+          toolCall: { toolCallId: "tracked-tool-call" },
+          options: [{ optionId: "allow-once", name: "Allow once", kind: "allow_once" }],
+        },
+        { requestId: "id-only-permission-request", method: "session/request_permission" },
+      ).pipe(Effect.forkScoped);
+      const approvalEvent = Option.getOrThrow(
+        yield* runtime.events.pipe(
+          Stream.filter(
+            (event) =>
+              event.type === "turn_item.updated" && event.turnItem.type === "approval_request",
+          ),
+          Stream.runHead,
+        ),
+      );
+      if (
+        approvalEvent.type !== "turn_item.updated" ||
+        approvalEvent.turnItem.type !== "approval_request" ||
+        approvalEvent.turnItem.providerTurnId === null
+      ) {
+        return yield* Effect.die("Expected an ACP approval request");
+      }
+      const approval = approvalEvent.turnItem;
+      const providerTurnId = approvalEvent.turnItem.providerTurnId;
+      const responseFiber = yield* runtime
+        .respondToRuntimeRequest({ requestId: approval.requestId, decision: "accept" })
+        .pipe(Effect.forkScoped);
+      assert.equal((yield* Fiber.join(permissionFiber)).outcome.outcome, "selected");
+      if (runtimeInput?.onOutgoingResponse === undefined) {
+        return yield* Effect.die("ACP runtime must expose native response acknowledgements");
+      }
+      yield* runtimeInput.onOutgoingResponse("id-only-permission-request");
+      yield* Fiber.join(responseFiber);
+
+      const terminalExit = yield* createTerminal(
+        {
+          sessionId: "mock-session-1",
+          command: process.execPath,
+          args: ["-e", ""],
+        },
+        { requestId: "id-only-permission-terminal", method: "terminal/create" },
+      ).pipe(Effect.exit);
+      assert.deepEqual(
+        { prompt: approval.prompt, terminalCreated: Exit.isSuccess(terminalExit) },
+        { prompt: "git status", terminalCreated: granted },
+      );
+
+      yield* runtime.interruptTurn({ providerThread, providerTurnId });
+      yield* Fiber.join(turnFiber);
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
   it.effect("replaces the ACP session and clears conversation state on rollback", () =>
     Effect.gen(function* () {
       const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts
index fab0020b7e03e..e086f8e2d1a7c 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts
@@ -1007,6 +1007,42 @@ describe("AcpRegistryAdapterV2", () => {
     }).pipe(Effect.provide(layerTest), Effect.scoped),
   );
 
+  // regression: #26695 cancelling a Copilot prompt kills its background agents
+  it.effect("never steers Copilot by cancelling its prompt", () =>
+    Effect.gen(function* () {
+      const steering = Effect.fn("steering")(function* (config: Record<string, unknown>) {
+        const instanceId = ProviderInstanceId.make("acp-registry-steering");
+        const adapter = yield* makeAcpRegistryAdapterV2({
+          selfInvocation: yield* resolveSelfInvocation(),
+          instanceId,
+          settings: yield* decodeAcpRegistryAdapterSettings(config),
+          environment: {},
+        }).pipe(Effect.provide(layerInjectedRuntimeCatalog));
+        const { turns } = yield* adapter.getCapabilities();
+        return {
+          supportsInterrupt: turns.supportsInterrupt,
+          supportsActiveSteering: turns.supportsActiveSteering,
+          supportsSteeringByInterruptRestart: turns.supportsSteeringByInterruptRestart,
+        };
+      });
+      const copilot = {
+        supportsInterrupt: true,
+        supportsActiveSteering: false,
+        supportsSteeringByInterruptRestart: false,
+      };
+
+      assert.deepEqual(yield* steering({ agentId: "github-copilot-cli" }), copilot);
+      assert.deepEqual(
+        yield* steering({ source: "local", commandPath: "C:\\tools\\copilot.cmd" }),
+        copilot,
+      );
+      assert.deepEqual(yield* steering({ agentId: "gemini" }), {
+        ...copilot,
+        supportsSteeringByInterruptRestart: true,
+      });
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
   it.effect("settles Claude's accepted foreground reply while retaining child output", () =>
     Effect.gen(function* () {
       const gate = makeProviderReplayGate(["accepted", "child-output", "wake"]);
diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts
index 4876465a960d3..90226cc68bd2a 100644
--- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.test.ts
@@ -127,7 +127,7 @@ const layerSession = Layer.mergeAll(
 );
 
 describe("AntigravityAdapterV2 client file system", () => {
-  it.effect("confines agent file requests to the workspace under full access", () =>
+  it.effect("serves confined reads and leaves edits to the agent's diff tools", () =>
     Effect.gen(function* () {
       const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
       const fileSystem = yield* FileSystem.FileSystem;
@@ -140,6 +140,8 @@ describe("AntigravityAdapterV2 client file system", () => {
       // effect-acp keeps the last handler registered per method; so does this.
       let readTextFile: Parameters<RuntimeService["handleReadTextFile"]>[0] | undefined;
       let writeTextFile: Parameters<RuntimeService["handleWriteTextFile"]>[0] | undefined;
+      const logs = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-antigravity-log-" });
+      const requestLog = path.join(logs, "requests.ndjson");
       const crypto = yield* Crypto.Crypto;
       const instanceId = ProviderInstanceId.make("antigravity-containment-test");
       const adapter = yield* makeAntigravityAdapterV2({
@@ -153,7 +155,7 @@ describe("AntigravityAdapterV2 client file system", () => {
               command: process.execPath,
               args: [mockAgentPath],
               cwd: input.cwd,
-              env: { T3_ACP_ANTIGRAVITY: "1" },
+              env: { T3_ACP_ANTIGRAVITY: "1", T3_ACP_REQUEST_LOG_PATH: requestLog },
             },
           }).pipe(
             Effect.provideService(Crypto.Crypto, crypto),
@@ -198,17 +200,31 @@ describe("AntigravityAdapterV2 client file system", () => {
         runtimePolicy,
       });
       yield* session.ensureThread({ threadId, modelSelection, runtimePolicy });
-      if (readTextFile === undefined || writeTextFile === undefined) {
-        return yield* Effect.die("Antigravity sessions must serve client file requests");
+      const initialize = (yield* fileSystem.readFileString(requestLog))
+        .trim()
+        .split("\n")
+        .map(
+          (line) =>
+            JSON.parse(line) as {
+              method?: string;
+              params?: { clientCapabilities?: { fs?: unknown }; clientInfo?: { name?: string } };
+            },
+        )
+        .find((request) => request.method === "initialize");
+      assert.deepEqual(initialize?.params?.clientCapabilities?.fs, {
+        readTextFile: true,
+        writeTextFile: false,
+      });
+      assert.equal(initialize?.params?.clientInfo?.name, "zed");
+      assert.isUndefined(writeTextFile);
+      if (readTextFile === undefined) {
+        return yield* Effect.die("Antigravity sessions must serve client file reads");
       }
       const context = (method: string) => ({ requestId: `test-${method}`, method });
 
       const insidePath = path.join(workspace, "src", "inside.ts");
-      yield* writeTextFile(
-        { sessionId: "mock-session-1", path: insidePath, content: "inside" },
-        context("fs/write_text_file"),
-      );
-      assert.equal(yield* fileSystem.readFileString(insidePath), "inside");
+      yield* fileSystem.makeDirectory(path.dirname(insidePath), { recursive: true });
+      yield* fileSystem.writeFileString(insidePath, "inside");
       const pasted = yield* readTextFile(
         { sessionId: "mock-session-1", path: attachment },
         context("fs/read_text_file"),
@@ -220,13 +236,6 @@ describe("AntigravityAdapterV2 client file system", () => {
         context("fs/read_text_file"),
       ).pipe(Effect.exit);
       assert.isTrue(Exit.isFailure(outsideRead));
-      const outsideWrite = yield* writeTextFile(
-        { sessionId: "mock-session-1", path: path.join(outside, "planted.txt"), content: "x" },
-        context("fs/write_text_file"),
-      ).pipe(Effect.exit);
-      assert.isTrue(Exit.isFailure(outsideWrite));
-      assert.isFalse(yield* fileSystem.exists(path.join(outside, "planted.txt")));
-
       const linkPath = path.join(workspace, "linked-secret.txt");
       yield* fileSystem.symlink(outsideFile, linkPath);
       const linkedRead = yield* readTextFile(
@@ -234,45 +243,6 @@ describe("AntigravityAdapterV2 client file system", () => {
         context("fs/read_text_file"),
       ).pipe(Effect.exit);
       assert.isTrue(Exit.isFailure(linkedRead), "a read through an escaping symlink is denied");
-      const linkedWrite = yield* writeTextFile(
-        { sessionId: "mock-session-1", path: linkPath, content: "overwritten" },
-        context("fs/write_text_file"),
-      ).pipe(Effect.exit);
-      assert.isTrue(Exit.isFailure(linkedWrite), "a write through an escaping symlink is denied");
-      assert.equal(yield* fileSystem.readFileString(outsideFile), "secret");
-      const plantedTarget = path.join(outside, "created-through-link.txt");
-      const danglingLink = path.join(workspace, "dangling.txt");
-      yield* fileSystem.symlink(plantedTarget, danglingLink);
-      const danglingWrite = yield* writeTextFile(
-        { sessionId: "mock-session-1", path: danglingLink, content: "planted" },
-        context("fs/write_text_file"),
-      ).pipe(Effect.exit);
-      assert.isTrue(Exit.isFailure(danglingWrite), "a write through a dangling symlink is denied");
-      assert.isFalse(yield* fileSystem.exists(plantedTarget));
-      yield* fileSystem.symlink(outside, path.join(workspace, "linked-dir"));
-      const linkedDirWrite = yield* writeTextFile(
-        {
-          sessionId: "mock-session-1",
-          path: path.join(workspace, "linked-dir", "new.txt"),
-          content: "planted",
-        },
-        context("fs/write_text_file"),
-      ).pipe(Effect.exit);
-      assert.isTrue(Exit.isFailure(linkedDirWrite), "a write under an escaping directory link");
-      assert.isFalse(yield* fileSystem.exists(path.join(outside, "new.txt")));
-      const nestedLinkedDirWrite = yield* writeTextFile(
-        {
-          sessionId: "mock-session-1",
-          path: path.join(workspace, "linked-dir", "a", "b", "file.txt"),
-          content: "planted",
-        },
-        context("fs/write_text_file"),
-      ).pipe(Effect.exit);
-      assert.isTrue(
-        Exit.isFailure(nestedLinkedDirWrite),
-        "a write to missing directories under an escaping directory link",
-      );
-      assert.isFalse(yield* fileSystem.exists(path.join(outside, "a")));
       const insideLink = path.join(workspace, "inside-link.ts");
       yield* fileSystem.symlink(insidePath, insideLink);
       const viaInsideLink = yield* readTextFile(
@@ -737,3 +707,212 @@ describe("AntigravityAdapterV2 html_render pages", () => {
     }).pipe(Effect.provide(layerSession), Effect.scoped),
   );
 });
+
+describe("AntigravityAdapterV2 subagent reads", () => {
+  it.effect("completes a read T3 served when the agent later fails it with a step error", () =>
+    Effect.gen(function* () {
+      const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const crypto = yield* Crypto.Crypto;
+      const mockAgentPath = yield* path.fromFileUrl(
+        new URL("../../../scripts/acp-mock-agent.ts", import.meta.url),
+      );
+      const workspace = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-antigravity-reads-",
+      });
+      const outside = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-antigravity-reads-outside-",
+      });
+      const served = path.join(workspace, "served.ts");
+      yield* fileSystem.writeFileString(served, "export {};");
+      const denied = path.join(outside, "secret.txt");
+      yield* fileSystem.writeFileString(denied, "secret");
+      const unseen = path.join(workspace, "unseen.ts");
+      const retried = path.join(workspace, "retried.ts");
+      const stepError = 'Model produced invalid output. ("model output error")';
+      type RuntimeService = AcpSessionRuntime.AcpSessionRuntime["Service"];
+      let sessionUpdate: Parameters<RuntimeService["handleSessionUpdate"]>[0] | undefined;
+      let readTextFile: Parameters<RuntimeService["handleReadTextFile"]>[0] | undefined;
+      const instanceId = ProviderInstanceId.make("antigravity-subagent-reads-test");
+      const threadId = ThreadId.make("thread-antigravity-subagent-reads");
+      const adapter = yield* makeAntigravityAdapterV2({
+        instanceId,
+        selfInvocation: yield* resolveSelfInvocation(),
+        makeRuntime: (input) =>
+          makeAntigravityAcpRuntime({
+            ...input,
+            childProcessSpawner,
+            spawn: {
+              command: process.execPath,
+              args: [mockAgentPath],
+              cwd: input.cwd,
+              env: { T3_ACP_ANTIGRAVITY: "1" },
+            },
+          }).pipe(
+            Effect.provideService(Crypto.Crypto, crypto),
+            Effect.map((runtime): RuntimeService => ({
+              ...runtime,
+              handleSessionUpdate: (handler) =>
+                Effect.sync(() => {
+                  sessionUpdate = handler;
+                }).pipe(Effect.andThen(runtime.handleSessionUpdate(handler))),
+              handleReadTextFile: (handler) =>
+                Effect.sync(() => {
+                  readTextFile = handler;
+                }).pipe(Effect.andThen(runtime.handleReadTextFile(handler))),
+              // agy_acp_server announces a subagent's client_view_file on the parent session,
+              // never completes it, then fails every open call with the next step error.
+              prompt: () =>
+                Effect.gen(function* () {
+                  if (sessionUpdate === undefined || readTextFile === undefined) {
+                    return yield* Effect.die("the adapter must handle updates and reads");
+                  }
+                  const send = sessionUpdate;
+                  const handleRead = readTextFile;
+                  const update = (update: EffectAcpSchema.SessionUpdate) =>
+                    send(
+                      normalizeAntigravitySessionUpdate({ sessionId: "mock-session-1", update }),
+                    );
+                  // The agent's own view_file never reaches T3, so it must not take a served read.
+                  const reads = [
+                    ["call_native", served, "Running view_file"],
+                    ["call_served", served, "Running client_view_file"],
+                    ["call_missing", retried, "Running client_view_file"],
+                    ["call_retried", retried, "Running client_view_file"],
+                    ["call_denied", denied, "Running client_view_file"],
+                    ["call_unseen", unseen, "Running client_view_file"],
+                  ] as const;
+                  for (const [toolCallId, target, title] of reads) {
+                    yield* update({
+                      sessionUpdate: "tool_call",
+                      toolCallId,
+                      title,
+                      kind: "read",
+                      status: "in_progress",
+                      rawInput: { absolute_path: target },
+                      locations: [{ path: target }],
+                    });
+                  }
+                  const serve = (target: string) =>
+                    handleRead(
+                      { sessionId: "subagent-conversation", path: target },
+                      { requestId: `read-${target}`, method: "fs/read_text_file" },
+                    ).pipe(Effect.exit);
+                  yield* serve(served);
+                  yield* serve(retried);
+                  yield* fileSystem.writeFileString(retried, "export {};").pipe(Effect.orDie);
+                  yield* serve(retried);
+                  yield* serve(denied);
+                  for (const [toolCallId] of reads) {
+                    yield* update({
+                      sessionUpdate: "tool_call_update",
+                      toolCallId,
+                      status: "failed",
+                      rawOutput: stepError,
+                    });
+                  }
+                  return { stopReason: "end_turn" as const };
+                }),
+            })),
+          ),
+        withProcess: (_stop, task) => task,
+        // @effect-diagnostics-next-line effectSucceedWithVoid:off - This optional result requires undefined, not the wider void type.
+        defaultModel: Effect.succeed(undefined),
+      });
+      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+        runtimeMode: "full-access",
+        interactionMode: "default",
+        cwd: workspace,
+      });
+      const modelSelection = { instanceId, model: "gemini-test-low" } as const;
+      const session = yield* adapter.openSession({
+        threadId,
+        providerSessionId: ProviderSessionId.make("provider-session-antigravity-subagent-reads"),
+        modelSelection,
+        runtimePolicy,
+      });
+      const providerThread = yield* session.ensureThread({
+        threadId,
+        modelSelection,
+        runtimePolicy,
+      });
+      const now = yield* DateTime.now;
+      yield* session.startTurn({
+        appThread: {
+          createdBy: "user",
+          creationSource: "web",
+          id: threadId,
+          projectId: ProjectId.make("project-antigravity-subagent-reads"),
+          title: "Antigravity subagent reads",
+          providerInstanceId: instanceId,
+          modelSelection,
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath: workspace,
+          activeProviderThreadId: providerThread.id,
+          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
+          forkedFrom: null,
+          createdAt: now,
+          updatedAt: now,
+          archivedAt: null,
+          settledOverride: null,
+          settledAt: null,
+          lastVisitedAt: null,
+          deletedAt: null,
+        },
+        threadId,
+        runId: RunId.make("run-antigravity-subagent-reads"),
+        runOrdinal: 1,
+        providerTurnOrdinal: 1,
+        attemptId: RunAttemptId.make("attempt-antigravity-subagent-reads"),
+        rootNodeId: NodeId.make("node-antigravity-subagent-reads"),
+        providerThread,
+        message: {
+          createdBy: "user",
+          creationSource: "web",
+          messageId: MessageId.make("message-antigravity-subagent-reads"),
+          text: "review the codebase",
+          attachments: [],
+        },
+        modelSelection,
+        runtimePolicy,
+      });
+      const events = Array.from(
+        yield* session.events.pipe(
+          Stream.takeUntil((event) => event.type === "turn.terminal"),
+          Stream.runCollect,
+        ),
+      );
+      const read = (nativeId: string) => {
+        const event = events.findLast(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.nativeItemRef?.nativeId === nativeId,
+        );
+        return event?.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool"
+          ? { status: event.turnItem.status, output: event.turnItem.output }
+          : undefined;
+      };
+
+      const firstEvent = (nativeId: string, status: string) =>
+        events.findIndex(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.nativeItemRef?.nativeId === nativeId &&
+            event.turnItem.status === status,
+        );
+      // T3 completes a served read itself instead of leaving it running until the flush.
+      assert.isAbove(firstEvent("call_served", "completed"), -1);
+      assert.isBelow(firstEvent("call_served", "completed"), firstEvent("call_native", "failed"));
+      const failed = { status: "failed" as const, output: stepError };
+      assert.deepEqual(read("call_served"), { status: "completed", output: undefined });
+      assert.deepEqual(read("call_retried"), { status: "completed", output: undefined });
+      assert.deepEqual(read("call_native"), failed);
+      assert.deepEqual(read("call_missing"), failed);
+      assert.deepEqual(read("call_denied"), failed);
+      assert.deepEqual(read("call_unseen"), failed);
+    }).pipe(Effect.provide(layerSession), Effect.scoped),
+  );
+});
diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts
index 2c41e007edf65..4d06da900f4a8 100644
--- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts
@@ -11,6 +11,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as Exit from "effect/Exit";
+import * as Semaphore from "effect/Semaphore";
 import * as Scope from "effect/Scope";
 import * as EffectAcpErrors from "effect-acp/errors";
 
@@ -23,15 +24,13 @@ import {
   buildAntigravityPrompt,
   type AntigravityAcpRuntimeInput,
 } from "../../provider/acp/AntigravityAcpSupport.ts";
-import {
-  readAntigravityClientTextFile,
-  writeAntigravityClientTextFile,
-} from "../../provider/acp/AntigravityClientFiles.ts";
+import { readAntigravityClientTextFile } from "../../provider/acp/AntigravityClientFiles.ts";
 import {
   antigravityApprovalOptions,
   antigravitySubagentOutput,
   classifyAntigravitySubagentToolCall,
   extractAntigravityUserInputQuestion,
+  makeAntigravityReadRepair,
   makeAntigravityUserInputResponse,
   normalizeAntigravityToolCall,
 } from "../../provider/acp/AntigravityProtocol.ts";
@@ -82,7 +81,7 @@ export interface AntigravityAdapterV2Options {
   readonly continuationRequests?: Parameters<typeof makeAcpAdapterV2>[0]["continuationRequests"];
 }
 
-/** ACP 1.1.1 reports `start_subagent` tools without child session ids. */
+/** Native subagent tools report no child session ids. */
 const extractAntigravitySubagentUpdate: NonNullable<AcpAdapterV2Flavor["extractSubagentUpdate"]> = (
   toolCall,
 ) => {
@@ -126,13 +125,47 @@ export function makeAntigravityAcpAdapterFlavor(
           Scope.close(scope, Exit.void),
           options.makeRuntime({
             ...input,
-            clientFileSystem: true,
+            clientFileReads: true,
             additionalDirectories: [options.host.paths.attachmentsDir],
           }),
         )
         .pipe(Effect.provideService(Scope.Scope, scope));
+      // Repair keeps state across updates, so each runtime must have one session-update handler.
+      const reads = makeAntigravityReadRepair();
+      // Served reads are reported from the read handler, so they take turns with agent updates.
+      const updates = yield* Semaphore.make(1);
+      let projectUpdate: Parameters<typeof runtime.handleSessionUpdate>[0] | undefined;
       return {
         ...runtime,
+        handleReadTextFile: (handler) =>
+          runtime.handleReadTextFile((request, context) =>
+            handler(request, context).pipe(
+              Effect.onExit((exit) => {
+                const served = reads.attempted(request.path, Exit.isSuccess(exit));
+                if (served === undefined || projectUpdate === undefined) return Effect.void;
+                return updates
+                  .withPermit(
+                    projectUpdate({
+                      sessionId: served.sessionId,
+                      update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: served.toolCallId,
+                        status: "completed",
+                      },
+                    }),
+                  )
+                  .pipe(Effect.ignore);
+              }),
+            ),
+          ),
+        prompt: (payload, promptOptions) =>
+          Effect.sync(reads.reset).pipe(Effect.andThen(runtime.prompt(payload, promptOptions))),
+        handleSessionUpdate: (handler) => {
+          projectUpdate = handler;
+          return runtime.handleSessionUpdate((notification) =>
+            updates.withPermit(handler(reads.repair(notification))),
+          );
+        },
         start: () =>
           runtime
             .start()
@@ -141,7 +174,7 @@ export function makeAntigravityAcpAdapterFlavor(
                 (started) => options.onSessionStarted?.(started, input.cwd) ?? Effect.void,
               ),
             ),
-      };
+      } satisfies typeof runtime;
     },
     Effect.provideService(Crypto.Crypto, options.crypto),
     Effect.mapError((cause): EffectAcpErrors.AcpError =>
@@ -191,13 +224,6 @@ export function makeAntigravityAcpAdapterFlavor(
           allowedRoots: antigravityClientFileRoots(cwd),
           request,
         }),
-      writeTextFile: (request, cwd) =>
-        writeAntigravityClientTextFile({
-          fileSystem: options.fileSystem,
-          path: options.path,
-          allowedRoots: antigravityClientFileRoots(cwd),
-          request,
-        }),
     },
     approvalOptions: antigravityApprovalOptions,
     extractPermissionQuestion: (request) => {
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index d7b3c756ecfd2..ea5ee249a787f 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -893,8 +893,11 @@ describe("ClaudeAdapterV2 Auto-accept edits", () => {
         assert.isFunction(canUseTool);
 
         const requestEvent = yield* runtime.events.pipe(
-          Stream.filter((event) => event.type === "runtime_request.updated"),
-          Stream.runHead,
+          Stream.takeUntil(
+            (event) =>
+              event.type === "turn_item.updated" && event.turnItem.type === "approval_request",
+          ),
+          Stream.runCollect,
           Effect.forkScoped,
         );
         const command = { command: "node -e 'console.log(42)'" };
@@ -903,6 +906,7 @@ describe("ClaudeAdapterV2 Auto-accept edits", () => {
             signal: new AbortController().signal,
             toolUseID: "tool-bash-accept-edits",
             requestId: "request-bash-accept-edits",
+            description: "Check the Node runtime",
           }),
         ).pipe(Effect.forkScoped);
         const first = yield* Effect.raceFirst(
@@ -915,12 +919,16 @@ describe("ClaudeAdapterV2 Auto-accept edits", () => {
         );
         assert.equal(first.type, "request", "the command ran without asking");
         if (first.type !== "request") return;
-        const event = first.event;
-        if (Option.isNone(event) || event.value.type !== "runtime_request.updated") return;
-        assert.equal(event.value.runtimeRequest.kind, "command");
+        const event = first.event.find((event) => event.type === "runtime_request.updated");
+        assert.equal(event?.runtimeRequest.kind, "command");
+        const approval = first.event.findLast((event) => event.type === "turn_item.updated");
+        assert.equal(
+          approval?.turnItem.type === "approval_request" ? approval.turnItem.prompt : undefined,
+          command.command,
+        );
 
         yield* runtime.respondToRuntimeRequest({
-          requestId: event.value.runtimeRequest.id,
+          requestId: event!.runtimeRequest.id,
           decision: "accept",
         });
         assert.equal((yield* Fiber.join(decision))?.behavior, "allow");
@@ -8732,6 +8740,152 @@ describe("ClaudeAdapterV2 background wake turns", () => {
     ),
   );
 
+  it.effect.each([
+    {
+      case: "an Edit",
+      toolName: "Edit",
+      toolInput: {
+        file_path: "/workspace/src/math.ts",
+        old_string: "  return a - b;",
+        new_string: "  return a + b;",
+      },
+      toolUseResult: {
+        filePath: "/workspace/src/math.ts",
+        oldString: "  return a - b;",
+        newString: "  return a + b;",
+        originalFile: "export function add(a: number, b: number) {\n  return a - b;\n}\n",
+        structuredPatch: [
+          {
+            oldStart: 1,
+            oldLines: 3,
+            newStart: 1,
+            newLines: 3,
+            lines: [
+              " export function add(a: number, b: number) {",
+              "-  return a - b;",
+              "+  return a + b;",
+              " }",
+            ],
+          },
+        ],
+        userModified: false,
+        replaceAll: false,
+      },
+      diffStr:
+        "--- /workspace/src/math.ts\n+++ /workspace/src/math.ts\n@@ -1,3 +1,3 @@\n export function add(a: number, b: number) {\n-  return a - b;\n+  return a + b;\n }\n",
+    },
+    {
+      case: "a Write that creates a file",
+      toolName: "Write",
+      toolInput: { file_path: "/workspace/notes.md", content: "# Notes\n\nShip it.\n" },
+      toolUseResult: {
+        type: "create",
+        filePath: "/workspace/notes.md",
+        content: "# Notes\n\nShip it.\n",
+        structuredPatch: [],
+        originalFile: null,
+        userModified: false,
+      },
+      diffStr: "--- /dev/null\n+++ /workspace/notes.md\n@@ -0,0 +1,3 @@\n+# Notes\n+\n+Ship it.\n",
+    },
+    {
+      case: "a Write that creates an empty file",
+      toolName: "Write",
+      toolInput: { file_path: "/workspace/.keep", content: "" },
+      toolUseResult: {
+        type: "create",
+        filePath: "/workspace/.keep",
+        content: "",
+        structuredPatch: [],
+        originalFile: null,
+        userModified: false,
+      },
+      diffStr: undefined,
+    },
+  ])("stores the diff panel patch for $case", (testCase) =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeWakeHarness;
+        const toolUseId = `toolu_01${testCase.toolName}Patch`;
+
+        yield* harness.runtime.startTurn(
+          makeClaudeTestTurnInput({
+            threadId: harness.threadId,
+            providerThread: harness.providerThread,
+            now: yield* DateTime.now,
+            attemptId: RunAttemptId.make(`attempt-claude-${testCase.toolName}-patch`),
+            text: "Change it.",
+            attachments: [],
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          claudeSdkFrame({
+            type: "assistant",
+            message: {
+              model: "claude-sonnet-4-6",
+              id: `msg_${testCase.toolName}_patch`,
+              type: "message",
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_use",
+                  id: toolUseId,
+                  name: testCase.toolName,
+                  input: testCase.toolInput,
+                },
+              ],
+            },
+            parent_tool_use_id: null,
+            uuid: "00000000-0000-4000-8000-000000000793",
+            session_id: WAKE_NATIVE_SESSION,
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          claudeSdkFrame({
+            type: "user",
+            message: {
+              role: "user",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: toolUseId,
+                  content: `The file ${testCase.toolInput.file_path} has been updated successfully.`,
+                },
+              ],
+            },
+            parent_tool_use_id: null,
+            uuid: "00000000-0000-4000-8000-000000000794",
+            session_id: WAKE_NATIVE_SESSION,
+            tool_use_result: testCase.toolUseResult,
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          makeResultFrame({ uuid: "00000000-0000-4000-8000-000000000795", result: "Done." }),
+        );
+        yield* harness.awaitTerminal(1);
+
+        const fileChange = harness.events.findLast(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.nativeItemRef?.nativeId === toolUseId,
+        );
+        assert.deepEqual(
+          fileChange?.type === "turn_item.updated" && fileChange.turnItem.type === "file_change"
+            ? { diffStr: fileChange.turnItem.diffStr }
+            : undefined,
+          { diffStr: testCase.diffStr },
+        );
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
+        ),
+      ),
+    ),
+  );
+
   it.effect("answers an approval a held wake turn raises without waiting for the echo", () =>
     Effect.scoped(
       Effect.gen(function* () {
@@ -12755,7 +12909,7 @@ describe("ClaudeAdapterV2 background wake turns", () => {
       yield* fileSystem.makeDirectory(transcriptDir, { recursive: true });
       yield* fileSystem.writeFileString(
         NodePath.join(transcriptDir, "agent-a1.jsonl"),
-        `{"type":"assistant","uuid":"wf-line-1-${options?.nativeSessionId ?? "default"}","message":{"role":"assistant","stop_reason":"end_turn","id":"msg_a1","content":[{"type":"text","text":"A1 from the transcript"}]}}\n`,
+        `{"type":"assistant","effort":"xhigh","uuid":"wf-line-1-${options?.nativeSessionId ?? "default"}","message":{"role":"assistant","stop_reason":"end_turn","id":"msg_a1","usage":{"speed":"standard"},"content":[{"type":"text","text":"A1 from the transcript"}]}}\n`,
       );
       const harness = yield* makeWakeHarnessWithOptions({
         ...options,
@@ -14014,6 +14168,97 @@ describe("ClaudeAdapterV2 background wake turns", () => {
       ),
   );
 
+  it.effect("clears workflow member metadata only after a successful transcript read", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeWorkflowHarness;
+        const now = yield* DateTime.now;
+        yield* harness.runtime.startTurn(
+          makeClaudeTestTurnInput({
+            threadId: harness.threadId,
+            providerThread: harness.providerThread,
+            now,
+            attemptId: RunAttemptId.make("attempt-claude-workflow-metadata"),
+            text: "Run the alpha workflow in the background.",
+            attachments: [],
+          }),
+        );
+        yield* harness.offerAndWait(workflowToolUse);
+        yield* harness.offerAndWait(workflowTaskStarted);
+        yield* harness.offerAndWait(workflowLaunchAck(harness.transcriptDir));
+        yield* harness.offerAndWait(
+          workflowSnapshot({ uuid: "00000000-0000-4000-8000-000000001040", state: "done" }),
+        );
+        yield* harness.until(
+          () =>
+            workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow?.agents[0]
+              ?.effort === "xhigh",
+        );
+        let coordinator = workflowCoordinatorEvents(harness.events).at(-1)!.subagent;
+        assert.equal(coordinator.workflow?.agents[0]?.speed, "standard");
+
+        const transcriptPath = NodePath.join(harness.transcriptDir, "agent-a1.jsonl");
+        NodeFS.renameSync(transcriptPath, `${transcriptPath}.saved`);
+        yield* harness.offerAndWait(
+          workflowSnapshot({
+            uuid: "00000000-0000-4000-8000-000000001041",
+            state: "done",
+            label: "alpha:unreadable",
+          }),
+        );
+        yield* harness.until(
+          () =>
+            workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow?.agents[0]
+              ?.label === "alpha:unreadable",
+        );
+        coordinator = workflowCoordinatorEvents(harness.events).at(-1)!.subagent;
+        assert.equal(coordinator.workflow?.agents[0]?.effort, "xhigh");
+        assert.equal(coordinator.workflow?.agents[0]?.speed, "standard");
+
+        NodeFS.renameSync(`${transcriptPath}.saved`, transcriptPath);
+        NodeFS.appendFileSync(
+          transcriptPath,
+          '{"type":"assistant","uuid":"wf-metadata-cleared","message":{"role":"assistant","stop_reason":"end_turn","id":"msg_new","content":[{"type":"text","text":"New answer without metadata"}]}}\n',
+        );
+        yield* harness.offerAndWait(
+          workflowSnapshot({
+            uuid: "00000000-0000-4000-8000-000000001042",
+            state: "done",
+            label: "alpha:new-response",
+          }),
+        );
+        yield* harness.until(() => {
+          const member = workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow
+            ?.agents[0];
+          return (
+            member?.label === "alpha:new-response" &&
+            member.effort === undefined &&
+            member.speed === undefined
+          );
+        });
+        yield* harness.offerAndWait(
+          makeResultFrame({ uuid: "00000000-0000-4000-8000-000000001043", result: "Done." }),
+        );
+        yield* Queue.take(harness.terminalReceipts);
+        const member = workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow
+          ?.agents[0];
+        assert.isUndefined(member?.effort);
+        assert.isUndefined(member?.speed);
+        const childThreadId = member?.childThreadId;
+        assert.deepEqual(
+          threadMessages(harness.events, childThreadId)
+            .filter((event) => event.message.role === "assistant")
+            .map((event) => event.message.text),
+          ["A1 from the transcript", "New answer without metadata"],
+        );
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
+        ),
+      ),
+    ),
+  );
+
   it.effect("answers settled workflow members from a transcript, or the snapshot excerpt", () =>
     Effect.scoped(
       Effect.gen(function* () {
@@ -14078,11 +14323,19 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         );
         yield* harness.until(() => threadMessages(harness.events, secondThreadId).length === 2);
 
-        const coordinator = workflowCoordinatorEvents(harness.events).at(-1)?.subagent;
+        yield* harness.until(
+          () =>
+            workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow?.agents[0]
+              ?.effort === "xhigh",
+        );
+        const coordinator = workflowCoordinatorEvents(harness.events).at(-1)!.subagent;
         assert.deepEqual(
-          coordinator?.workflow?.agents.map((member) => member.state),
+          coordinator.workflow?.agents.map((member) => member.state),
           ["completed", "completed"],
         );
+        assert.equal(coordinator.workflow?.agents[0]?.speed, "standard");
+        assert.isUndefined(coordinator.workflow?.agents[1]?.effort);
+        assert.isUndefined(coordinator.workflow?.agents[1]?.speed);
         assert.equal(workflowMemberEvents(harness.events, 1).at(-1)?.subagent.status, "completed");
         assert.equal(workflowMemberEvents(harness.events, 2).at(-1)?.subagent.status, "completed");
         assert.deepEqual(
@@ -14158,6 +14411,12 @@ describe("ClaudeAdapterV2 background wake turns", () => {
           completedMember?.completedAt && DateTime.toEpochMillis(completedMember.completedAt),
           4432,
         );
+        assert.isUndefined(
+          workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow?.agents[0]?.effort,
+        );
+        assert.isUndefined(
+          workflowCoordinatorEvents(harness.events).at(-1)?.subagent.workflow?.agents[0]?.speed,
+        );
         assert.notDeepEqual(
           workflowMemberEvents(harness.events, 1).at(-1)?.subagent.startedAt,
           previousStartedAt,
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index fb204153f27e8..b1273cee72061 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -7,6 +7,7 @@ import {
   formatSearchToolLabel,
 } from "@t3tools/shared/toolActivity";
 import { field, text } from "../unknownField.ts";
+import { mergeWorkflowAgentMetadata, type WorkflowAgentMetadata } from "../workflowAgentAnswers.ts";
 import {
   initialWorkflowAgentTranscriptCursor,
   readWorkflowAgentTranscript,
@@ -105,6 +106,7 @@ import {
   resolveIdleCompaction,
 } from "@t3tools/contracts";
 
+import { FILE_HEADERS_ONLY, formatPatch, structuredPatch } from "diff";
 import * as Cause from "effect/Cause";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
@@ -2964,6 +2966,44 @@ function claudeNativeToolOutputText(output: ClaudeNativeToolOutput): string {
   return typeof value === "string" ? value : value === undefined ? "" : jsonStringifyForTool(value);
 }
 
+const decodeClaudeFileEditResult = Schema.decodeUnknownOption(
+  Schema.Struct({
+    type: Schema.optional(Schema.String),
+    filePath: Schema.String,
+    content: Schema.optional(Schema.String),
+    structuredPatch: Schema.mutable(
+      Schema.Array(
+        Schema.Struct({
+          oldStart: Schema.Number,
+          oldLines: Schema.Number,
+          newStart: Schema.Number,
+          newLines: Schema.Number,
+          lines: Schema.mutable(Schema.Array(Schema.String)),
+        }),
+      ),
+    ),
+  }),
+);
+
+function claudeFileChangeText(output: ClaudeNativeToolOutput): string {
+  const result =
+    output.type === "structured_tool_use_result"
+      ? Option.getOrUndefined(decodeClaudeFileEditResult(output.value))
+      : undefined;
+  if (result === undefined) return claudeNativeToolOutputText(output);
+  const patch =
+    result.structuredPatch.length === 0 && result.type === "create" && result.content !== undefined
+      ? structuredPatch("/dev/null", result.filePath, "", result.content)
+      : {
+          oldFileName: result.filePath,
+          newFileName: result.filePath,
+          oldHeader: undefined,
+          newHeader: undefined,
+          hunks: result.structuredPatch,
+        };
+  return patch.hunks.length === 0 ? "" : formatPatch(patch, FILE_HEADERS_ONLY);
+}
+
 function claudeCommandOutputText(output: ClaudeNativeToolOutput): string {
   const value = claudeNativeToolOutputValue(output);
   if (typeof value === "object" && value !== null) {
@@ -4541,6 +4581,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
               readonly finalTranscriptRead: boolean;
               readonly agentId: string | undefined;
               readonly transcriptCursor: WorkflowAgentTranscriptCursor;
+              readonly transcriptMetadata: WorkflowAgentMetadata;
               readonly nextItemOrdinal: number;
               readonly toolCalls: Map<string, ActiveClaudeToolCall>;
               readonly textShown: boolean;
@@ -5496,7 +5537,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           const outputText =
             itemType === "command_execution"
               ? claudeCommandOutputText(input.output)
-              : claudeNativeToolOutputText(input.output);
+              : itemType === "file_change"
+                ? claudeFileChangeText(input.output)
+                : claudeNativeToolOutputText(input.output);
           const turnItem: OrchestrationV2TurnItem =
             itemType === "command_execution"
               ? {
@@ -5726,8 +5769,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           const now = yield* DateTime.now;
           const seen = yield* Ref.get(workflowMemberStates);
           const transcriptDir = input.workflow.runHandles?.transcriptDir;
+          const membersWithMetadata = input.workflow.agents.slice();
 
-          for (const member of input.workflow.agents) {
+          for (const [memberIndex, member] of input.workflow.agents.entries()) {
             if ((yield* Ref.get(sessionSubagentsByTaskId)).get(taskId) !== input.coordinator)
               return;
             const memberKey = `${input.coordinator.childThreadId}:agent:${member.index}`;
@@ -5913,6 +5957,10 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
               previous === undefined || restarted || previous.agentId !== agentId
                 ? initialWorkflowAgentTranscriptCursor
                 : previous.transcriptCursor;
+            let transcriptMetadata =
+              previous === undefined || restarted || previous.agentId !== agentId
+                ? {}
+                : previous.transcriptMetadata;
             let textShown = !restarted && previous?.textShown === true;
             let resultShown = !restarted && previous?.resultShown === true;
             let turnEnded = !restarted && previous?.turnEnded === true;
@@ -5957,6 +6005,10 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                   transcriptRead = true;
                   const advanced = read.value.cursor.offset !== transcriptCursor.offset;
                   transcriptCursor = read.value.cursor;
+                  transcriptMetadata = mergeWorkflowAgentMetadata(
+                    read.value.lines,
+                    transcriptMetadata,
+                  );
                   for (const line of read.value.lines) {
                     if (yield* projectSubagentTranscriptLine(target, line)) textShown = true;
                     turnEnded = isClaudeTranscriptTurnEnd(line);
@@ -5979,6 +6031,17 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                 if (!(yield* drain())) return;
               }
             }
+            if (
+              transcriptRead &&
+              (transcriptMetadata.effort !== member.effort ||
+                transcriptMetadata.speed !== member.speed)
+            ) {
+              membersWithMetadata[memberIndex] = {
+                ...member,
+                effort: transcriptMetadata.effort,
+                speed: transcriptMetadata.speed,
+              };
+            }
             if (settled) {
               // Open calls receive no results after their member settles.
               yield* endOpenToolCalls();
@@ -6021,6 +6084,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                     textShown &&
                     input.coordinator.task.status !== "running"),
                 transcriptCursor,
+                transcriptMetadata,
                 nextItemOrdinal,
                 toolCalls,
                 textShown,
@@ -6032,6 +6096,21 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
               }),
             );
           }
+          if (
+            membersWithMetadata.some((member, index) => member !== input.workflow.agents[index])
+          ) {
+            if ((yield* Ref.get(sessionSubagentsByTaskId)).get(taskId) !== input.coordinator)
+              return;
+            input.coordinator.task = {
+              ...input.coordinator.task,
+              workflow: { ...input.workflow, agents: membersWithMetadata },
+            };
+            yield* emitProviderEvent({
+              type: "subagent.updated",
+              driver: CLAUDE_PROVIDER,
+              subagent: input.coordinator.task,
+            });
+          }
         });
 
         const confirmedSubagentOutcome = (task: OrchestrationV2Subagent | undefined) => {
@@ -9513,7 +9592,10 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           }
 
           const requestKind = providerRequestKindFromClaudeTool(toolName);
+          // The user approves the command itself; Claude's title and description only summarize it.
+          const command = inputRecordValue(nativeToolInput, "command");
           const prompt =
+            (typeof command === "string" && command.trim() !== "" ? command : undefined) ??
             callbackOptions.title ??
             callbackOptions.description ??
             callbackOptions.decisionReason ??
diff --git a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
index baea36ca738da..360a21c068f25 100644
--- a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
@@ -128,7 +128,10 @@ describe("mergeClaudeWorkflowProgress", () => {
     expect(first?.agents[0]?.completedAt).toBe(2010);
     expect(first?.agents[1]).not.toHaveProperty("completedAt");
     const second = mergeClaudeWorkflowProgress({
-      previous: first,
+      previous: first && {
+        ...first,
+        agents: first.agents.map((member) => ({ ...member, effort: "max", speed: "standard" })),
+      },
       message: snapshotFrame([
         { type: "workflow_agent", index: 1, label: "alpha:one", state: "start", attempt: 2 },
       ]),
@@ -142,7 +145,7 @@ describe("mergeClaudeWorkflowProgress", () => {
         phaseIndex: 1,
         phaseTitle: "Alpha",
       },
-      first?.agents[1],
+      { ...first?.agents[1], effort: "max", speed: "standard" },
     ]);
     expect(second?.phases).toEqual(first?.phases);
   });
@@ -179,6 +182,37 @@ describe("mergeClaudeWorkflowProgress", () => {
     expect(second?.agents).toEqual(first?.agents);
   });
 
+  it("retains member fields omitted by a later frame in the same attempt", () => {
+    const first = mergeClaudeWorkflowProgress({
+      previous: undefined,
+      message: snapshotFrame([
+        agent({
+          attempt: 2,
+          model: "claude-opus-5[1m]",
+          promptPreview: "Current prompt",
+          tokens: 100,
+        }),
+      ]),
+    });
+    const second = mergeClaudeWorkflowProgress({
+      previous: first && {
+        ...first,
+        agents: first.agents.map((member) => ({ ...member, effort: "xhigh", speed: "standard" })),
+      },
+      message: snapshotFrame([agent({ state: "done", resultPreview: "Current result" })]),
+    });
+    expect(second?.agents[0]).toMatchObject({
+      state: "completed",
+      attempt: 2,
+      prompt: "Current prompt",
+      result: "Current result",
+      totalTokens: 100,
+      model: "claude-opus-5[1m]",
+      effort: "xhigh",
+      speed: "standard",
+    });
+  });
+
   it("drops malformed entries instead of failing the frame", () => {
     const workflow = mergeClaudeWorkflowProgress({
       previous: undefined,
diff --git a/apps/server/src/orchestration-v2/CommandPolicy.test.ts b/apps/server/src/orchestration-v2/CommandPolicy.test.ts
index 1bf294641a01c..cf982c9699f77 100644
--- a/apps/server/src/orchestration-v2/CommandPolicy.test.ts
+++ b/apps/server/src/orchestration-v2/CommandPolicy.test.ts
@@ -164,6 +164,53 @@ it.each([
   );
 });
 
+// regression: #26695 an interrupt-restart steer cancels Copilot's background agents
+it("queues a steer for a provider that cannot steer either way", () => {
+  const projection = dispatchProjection(
+    capabilities((current) => ({
+      ...current,
+      turns: {
+        ...current.turns,
+        supportsActiveSteering: false,
+        supportsSteeringByInterruptRestart: false,
+        supportsQueuedMessages: true,
+      },
+    })),
+  );
+  for (const deliveryIntent of ["auto", "steer"] as const) {
+    assert.deepEqual(
+      CommandPolicy.resolveMessageDispatchIntent(
+        projection,
+        { type: "start_immediately" },
+        deliveryIntent,
+      ),
+      { type: "queue_after_active" },
+    );
+  }
+  assert.deepEqual(
+    CommandPolicy.resolveMessageDispatchIntent(projection, {
+      type: "steer_active",
+      targetRunId: activeRunId,
+    }),
+    { type: "queue_after_active" },
+  );
+  assert.deepEqual(
+    CommandPolicy.resolveMessageDispatchIntent(
+      projection,
+      { type: "start_immediately" },
+      "restart",
+    ),
+    { type: "restart_active", targetRunId: activeRunId },
+  );
+  assert.deepEqual(
+    CommandPolicy.resolveMessageDispatchIntent(projection, {
+      type: "steer_active",
+      targetRunId: RunId.make("command-policy-missing-run"),
+    }),
+    { type: "steer_active", targetRunId: RunId.make("command-policy-missing-run") },
+  );
+});
+
 it.each(["/compact", " /LOGOUT "])("queues a steer sent while %s runs", (text) => {
   const projection = dispatchProjection(baseCapabilities);
   const maintenance = {
diff --git a/apps/server/src/orchestration-v2/CommandPolicy.ts b/apps/server/src/orchestration-v2/CommandPolicy.ts
index 302bb12f797cb..869851790177a 100644
--- a/apps/server/src/orchestration-v2/CommandPolicy.ts
+++ b/apps/server/src/orchestration-v2/CommandPolicy.ts
@@ -99,11 +99,47 @@ export function resolveMessageDispatchIntent(
   // Compaction and sign-out cannot accept steers; queue follow-ups.
   const target = projection.runs.find((run) => run.id === mode.targetRunId);
   const targetMessage = projection.messages.find((message) => message.id === target?.userMessageId);
-  return targetMessage !== undefined && isNativeMaintenanceCommand(targetMessage)
+  if (targetMessage !== undefined && isNativeMaintenanceCommand(targetMessage)) {
+    return { type: "queue_after_active" };
+  }
+  // A provider that can neither steer nor restart its turn takes the message after the turn.
+  const turns =
+    target === undefined || !isActiveRun(target)
+      ? undefined
+      : providerTurnCapabilities(projection, target);
+  return turns !== undefined &&
+    !turns.supportsActiveSteering &&
+    !(turns.supportsInterrupt && turns.supportsSteeringByInterruptRestart) &&
+    turns.supportsQueuedMessages
     ? { type: "queue_after_active" }
     : mode;
 }
 
+function isActiveRun(run: OrchestrationV2Run): boolean {
+  return (
+    run.status === "preparing" ||
+    run.status === "starting" ||
+    run.status === "running" ||
+    run.status === "waiting"
+  );
+}
+
+function providerTurnCapabilities(
+  projection: OrchestrationV2ThreadProjection,
+  run: OrchestrationV2Run,
+) {
+  const providerThread = projection.providerThreads.find(
+    (candidate) => candidate.id === run.providerThreadId,
+  );
+  const providerSession =
+    providerThread?.providerSessionId == null
+      ? undefined
+      : projection.providerSessions.find(
+          (candidate) => candidate.id === providerThread.providerSessionId,
+        );
+  return providerSession?.capabilities.turns;
+}
+
 function resolveDeliveryIntent(
   projection: OrchestrationV2ThreadProjection,
   requestedMode: MessageDispatchMode,
@@ -111,13 +147,7 @@ function resolveDeliveryIntent(
 ): MessageDispatchMode {
   if (deliveryIntent === undefined) return requestedMode;
 
-  const activeRun = projection.runs.findLast(
-    (run) =>
-      run.status === "preparing" ||
-      run.status === "starting" ||
-      run.status === "running" ||
-      run.status === "waiting",
-  );
+  const activeRun = projection.runs.findLast(isActiveRun);
   if (activeRun === undefined) return { type: "start_immediately" };
   if (deliveryIntent === "steer") {
     return { type: "steer_active", targetRunId: activeRun.id };
@@ -137,16 +167,7 @@ function resolveDeliveryIntent(
     return { type: "queue_after_active" };
   }
 
-  const providerThread = projection.providerThreads.find(
-    (candidate) => candidate.id === activeRun.providerThreadId,
-  );
-  const providerSession =
-    providerThread?.providerSessionId == null
-      ? undefined
-      : projection.providerSessions.find(
-          (candidate) => candidate.id === providerThread.providerSessionId,
-        );
-  const capabilities = providerSession?.capabilities.turns;
+  const capabilities = providerTurnCapabilities(projection, activeRun);
   if (capabilities?.supportsActiveSteering === true) {
     return { type: "steer_active", targetRunId: activeRun.id };
   }
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts
index 91acb881637c1..d0edd5dacf8f6 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.ts
@@ -455,6 +455,23 @@ function wakeWorkStartedAt(
 
 const threadPullRequestLinksEqual = Schema.toEquivalence(Schema.NullOr(ThreadLinkedPullRequest));
 
+/** Unfinished runs (including queued) or open requests block moving a thread to another project. */
+export function threadHasUnfinishedWork(records: {
+  readonly runs: ReadonlyArray<{ readonly status: string }>;
+  readonly runtimeRequests: ReadonlyArray<{ readonly status: string }>;
+}): boolean {
+  return (
+    records.runs.some(
+      (run) =>
+        run.status !== "completed" &&
+        run.status !== "failed" &&
+        run.status !== "cancelled" &&
+        run.status !== "interrupted" &&
+        run.status !== "rolled_back",
+    ) || records.runtimeRequests.some((request) => request.status === "pending")
+  );
+}
+
 function commandThreadId(command: OrchestrationV2ServerCommand): ThreadId {
   switch (command.type) {
     case "thread.create":
@@ -486,6 +503,7 @@ function commandThreadId(command: OrchestrationV2ServerCommand): ThreadId {
     case "thread.pull-request-watch.sync":
     case "thread.pull-request.sync":
     case "thread.title.regeneration.complete":
+    case "thread.project.adopt-folder":
     case "thread.runtime-mode.set":
     case "thread.interaction-mode.set":
     case "thread.model-selection.set":
@@ -3983,6 +4001,56 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
     },
   );
 
+  const dispatchThreadProjectAdoptFolder = Effect.fn(
+    "orchestrationV2.dispatch.threadProjectAdoptFolder",
+  )(function* (
+    command: Extract<
+      OrchestrationV2ServerCommand,
+      { readonly type: "thread.project.adopt-folder" }
+    >,
+    events: Ref.Ref<Array<OrchestrationV2DomainEvent>>,
+  ) {
+    const reject = (cause: string) =>
+      new OrchestratorDispatchError({
+        commandId: command.commandId,
+        commandType: command.type,
+        cause: `Thread ${command.threadId} ${cause}`,
+      });
+    const projection = yield* projectionStore
+      .getThreadRecords(command.threadId, ["runs", "runtimeRequests"], { turnItemTypes: [] })
+      .pipe(
+        Effect.mapError(
+          (cause) => new OrchestratorProjectionError({ threadId: command.threadId, cause }),
+        ),
+      );
+    const thread = projection.thread;
+    if (thread.deletedAt !== null) return yield* reject("is deleted.");
+    if (threadHasUnfinishedWork(projection)) {
+      return yield* reject("still has work in progress. Finish or stop it first.");
+    }
+    const current = yield* projects.get(thread.projectId).pipe(mapDispatchError(command));
+    const target = yield* projects.get(command.projectId).pipe(mapDispatchError(command));
+    if (Option.isNone(target) || target.value.deletedAt !== null) {
+      return yield* reject(`cannot move to missing project ${command.projectId}.`);
+    }
+    // The thread always lands in the project root, so the move must not change its cwd.
+    const cwd = thread.worktreePath ?? Option.getOrUndefined(current)?.workspaceRoot;
+    if (cwd !== target.value.workspaceRoot) {
+      return yield* reject(`does not work in ${target.value.workspaceRoot}.`);
+    }
+    const now = yield* DateTime.now;
+    yield* emit(
+      events,
+      command,
+    )({
+      type: "thread.metadata-updated",
+      threadId: command.threadId,
+      providerInstanceId: thread.providerInstanceId,
+      occurredAt: now,
+      payload: { ...thread, projectId: command.projectId, worktreePath: null, updatedAt: now },
+    });
+  });
+
   const refuseAboveDispatchModeLimit = Effect.fn("orchestrationV2.dispatch.refuseAboveModeLimit")(
     function* (
       command: OrchestrationV2ServerCommand,
@@ -12487,6 +12555,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       case "provider-session.detach":
         yield* dispatchProviderSessionDetach(command, events, effects);
         break;
+      case "thread.project.adopt-folder":
+        yield* dispatchThreadProjectAdoptFolder(command, events);
+        break;
       case "message.dispatch": {
         // Providers own native subagent conversations; messages cannot target them, and adapters ask questions on the parent.
         const thread = yield* projectionStore
diff --git a/apps/server/src/orchestration-v2/ProviderEventIngestor.test.ts b/apps/server/src/orchestration-v2/ProviderEventIngestor.test.ts
index 3fecc1c7d2d61..7f1006f1c5ec5 100644
--- a/apps/server/src/orchestration-v2/ProviderEventIngestor.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderEventIngestor.test.ts
@@ -46,6 +46,9 @@ import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
 import * as ProjectionStore from "./ProjectionStore.ts";
 import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
 import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
+import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
+import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
+import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
 import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
 import {
   makeProviderEventRoutingState,
@@ -68,8 +71,16 @@ const layerGit = GitVcsDriver.layer.pipe(
   Layer.provideMerge(NodeServices.layer),
 );
 
-const makeLayerTest = <E>(ingestorEventSink: Layer.Layer<EventSink.EventSinkV2, E>) =>
+const layerEmptyInstances = Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
+  // @effect-diagnostics-next-line effectSucceedWithVoid:off - Optional instances require undefined rather than void.
+  getInstance: () => Effect.succeed(undefined),
+});
+const makeLayerTest = <E>(
+  ingestorEventSink: Layer.Layer<EventSink.EventSinkV2, E>,
+  instances = layerEmptyInstances,
+) =>
   Layer.mergeAll(
+    instances,
     layerTestDatabase,
     layerTestStores,
     layerTestEventSink,
@@ -79,6 +90,7 @@ const makeLayerTest = <E>(ingestorEventSink: Layer.Layer<EventSink.EventSinkV2,
     ProviderEventIngestor.layer.pipe(
       Layer.provide(
         Layer.mergeAll(
+          instances,
           layerTestStores,
           ingestorEventSink,
           IdAllocator.layer,
@@ -217,6 +229,101 @@ function threadCreatedEvent(
 
 const layer = it.layer(layerTest);
 
+it.effect("refreshes the failing instance snapshot after a committed usage_limit terminal", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const refreshed = yield* Deferred.make<void>();
+      const adapter = yield* ProviderAdapter.ProviderAdapterV2.pipe(
+        Effect.provide(
+          Layer.mock(ProviderAdapter.ProviderAdapterV2)({
+            instanceId: ProviderInstanceId.make("cursor-work"),
+            driver: ProviderDriverKind.make("cursor"),
+          }),
+        ),
+      );
+      const instance: ProviderInstance = {
+        instanceId: ProviderInstanceId.make("cursor-work"),
+        driverKind: ProviderDriverKind.make("cursor"),
+        continuationIdentity: {
+          driverKind: ProviderDriverKind.make("cursor"),
+          continuationKey: "work",
+        },
+        enabled: true,
+        displayName: undefined,
+        orchestrationAdapter: adapter,
+        textGeneration: {
+          generateBranchName: () => Effect.die("unused"),
+          generateCommitMessage: () => Effect.die("unused"),
+          generatePrContent: () => Effect.die("unused"),
+          generateThreadTitle: () => Effect.die("unused"),
+          generateReviewGuide: () => Effect.die("unused"),
+        },
+        snapshot: {
+          refreshUsage: Deferred.succeed(refreshed, undefined).pipe(Effect.asVoid),
+          getSnapshot: Effect.die("unused"),
+          refresh: Effect.die("unused"),
+          resolveMaintenance: () => Effect.die("unused"),
+          applyUsageLimits: () => Effect.die("unused"),
+          streamChanges: Stream.empty,
+        },
+      };
+      const lookups: ProviderInstanceId[] = [];
+      const instances = Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
+        getInstance: (id) =>
+          Effect.sync(() => {
+            lookups.push(id);
+            return id === instance.instanceId ? instance : undefined;
+          }),
+      });
+      yield* Effect.gen(function* () {
+        const now = yield* DateTime.now;
+        const eventSink = yield* EventSink.EventSinkV2;
+        const ingestor = yield* ProviderEventIngestor.ProviderEventIngestorV2;
+        const idAllocator = yield* IdAllocator.IdAllocatorV2;
+        const threadEvent = yield* threadCreatedEvent(now);
+        yield* eventSink.write({ events: [threadEvent] });
+        const input = {
+          providerSessionId: yield* idAllocator.allocate.providerSession({
+            providerInstanceId: instance.instanceId,
+            threadId: threadEvent.threadId,
+          }),
+          providerInstanceId: instance.instanceId,
+          threadId: threadEvent.threadId,
+        };
+        for (const failureClass of ["validation_error", "usage_limit"] as const) {
+          const stored = yield* ingestor.ingestNormalized({
+            ...input,
+            event: {
+              type: "turn.terminal",
+              driver: instance.driverKind,
+              providerThreadId: idAllocator.derive.providerThread({
+                driver: instance.driverKind,
+                nativeThreadId: "limited",
+              }),
+              providerTurnId: idAllocator.derive.providerTurn({
+                driver: instance.driverKind,
+                nativeTurnId: failureClass,
+              }),
+              runOrdinal: 1,
+              failureItemOrdinal: 1,
+              status: "failed",
+              failure: makeProviderFailure({
+                class: failureClass,
+                message: "Provider rejected turn.",
+              }),
+              threadDisposition: "reusable",
+            },
+          });
+          assert.equal(stored.length, 1);
+          if (failureClass === "validation_error") assert.deepEqual(lookups, []);
+        }
+        assert.deepEqual(lookups, [instance.instanceId]);
+        yield* Deferred.await(refreshed);
+      }).pipe(Effect.provide(makeLayerTest(layerTestEventSink, instances)));
+    }),
+  ),
+);
+
 it.effect("records accepted billed turn usage once without billing the context window", () => {
   const recorded: Array<Readonly<Record<string, unknown>>> = [];
   const layerAnalytics = Layer.succeed(ProviderEventIngestor.ProviderTurnAnalytics, {
diff --git a/apps/server/src/orchestration-v2/ProviderEventIngestor.ts b/apps/server/src/orchestration-v2/ProviderEventIngestor.ts
index 6beb4d0e55471..06f444776cb3c 100644
--- a/apps/server/src/orchestration-v2/ProviderEventIngestor.ts
+++ b/apps/server/src/orchestration-v2/ProviderEventIngestor.ts
@@ -34,6 +34,7 @@ import { isTemporaryWorktreeBranch } from "@t3tools/shared/git";
 import { getModelSelectionStringOptionValue, modelSelectionsEqual } from "@t3tools/shared/model";
 import * as AnalyticsService from "../telemetry/AnalyticsService.ts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
+import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
 import * as EventSink from "./EventSink.ts";
 import * as ProjectionStore from "./ProjectionStore.ts";
 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
@@ -326,6 +327,7 @@ export const layer: Layer.Layer<
   | IdAllocator.IdAllocatorV2
   | ProjectionStore.ProjectionStoreV2
   | ThreadCommandExecutor.ThreadCommandExecutor
+  | ProviderInstanceRegistry.ProviderInstanceRegistry
 > = Layer.effect(
   ProviderEventIngestorV2,
   Effect.gen(function* () {
@@ -336,6 +338,8 @@ export const layer: Layer.Layer<
     const threadCommands = yield* ThreadCommandExecutor.ThreadCommandExecutor;
     const analytics = yield* ProviderTurnAnalytics;
     const agentScope = yield* AgentScope;
+    const instances = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
+    const scope = yield* Effect.scope;
     const completedTurnAnalytics = new Set<string>();
 
     const makeDomainEvent =
@@ -794,6 +798,23 @@ export const layer: Layer.Layer<
           },
           (effect, input) =>
             effect.pipe(
+              Effect.tap((storedEvents) =>
+                Effect.gen(function* () {
+                  if (
+                    storedEvents.length === 0 ||
+                    input.event.type !== "turn.terminal" ||
+                    input.event.status !== "failed" ||
+                    input.event.failure.class !== "usage_limit"
+                  )
+                    return;
+                  const instance = yield* instances.getInstance(input.providerInstanceId);
+                  if (!instance?.snapshot.refreshUsage) return;
+                  yield* instance.snapshot.refreshUsage.pipe(
+                    Effect.ignoreCause({ log: true }),
+                    Effect.forkIn(scope, { startImmediately: true }),
+                  );
+                }),
+              ),
               Effect.flatMap((storedEvents) =>
                 Effect.gen(function* () {
                   if (input.event.type !== "app_thread.created") return storedEvents;
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
index 9ae9ddce81a99..cac8e4fbbb8e0 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
@@ -47,6 +47,7 @@ import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
 import * as ProjectionStore from "./ProjectionStore.ts";
 import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
 import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
+import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
 import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
 import * as ProviderSessionManager from "./ProviderSessionManager.ts";
@@ -533,6 +534,10 @@ function layerTest(input: {
   const layerProviderEventIngestorTest = ProviderEventIngestor.layer.pipe(
     Layer.provide(
       Layer.mergeAll(
+        Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
+          // @effect-diagnostics-next-line effectSucceedWithVoid:off - Optional instances require undefined rather than void.
+          getInstance: () => Effect.succeed(undefined),
+        }),
         layerConfiguredEventSink,
         IdAllocator.layer,
         layerTestStores,
diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
index d8ac4769e140f..1015e44694c81 100644
--- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
+++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
@@ -447,16 +447,18 @@ const composerSelection = {
 const nextTurnSelectionHarness = Effect.fn("nextTurnSelectionHarness")(function* (
   name: string,
   canRestart = false,
+  canSteer = true,
 ) {
   const cwd = yield* checkpointWorkspace(name);
   const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
   const started: ProviderAdapter.ProviderAdapterV2TurnInput[] = [];
   const steered: string[] = [];
+  const interrupted: ProviderTurnId[] = [];
   const capabilities = {
     ...CodexProviderCapabilitiesV2,
     turns: {
       ...CodexProviderCapabilitiesV2.turns,
-      supportsActiveSteering: true,
+      supportsActiveSteering: canSteer,
       supportsSteeringByInterruptRestart: canRestart,
     },
   };
@@ -533,7 +535,10 @@ const nextTurnSelectionHarness = Effect.fn("nextTurnSelectionHarness")(function*
             Effect.sync(() => {
               steered.push(turn.message.text);
             }),
-          interruptTurn: () => Effect.void,
+          interruptTurn: ({ providerTurnId }) =>
+            Effect.sync(() => {
+              interrupted.push(providerTurnId);
+            }),
           respondToRuntimeRequest: () => Effect.void,
           readThreadSnapshot: () => Effect.die("unused"),
           rollbackThread: () => Effect.die("unused"),
@@ -588,7 +593,7 @@ const nextTurnSelectionHarness = Effect.fn("nextTurnSelectionHarness")(function*
     yield* Fiber.join(running);
     return threadId;
   });
-  return { cwd, events, started, steered, layer, startFirstTurn };
+  return { cwd, events, started, steered, interrupted, layer, startFirstTurn };
 });
 
 it.effect("sends a selected held message once and preserves the remaining queue order", () =>
@@ -938,6 +943,82 @@ it.effect("starts a steer that missed the turn on the saved next-turn selection"
   ),
 );
 
+// regression: #26695 cancelling a Copilot prompt to steer it kills its background agents
+it.effect("queues a steer until the turn ends when the provider cannot steer it", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const { events, started, steered, interrupted, layer, startFirstTurn } =
+        yield* nextTurnSelectionHarness("steering-unsupported", false, false);
+      yield* Effect.gen(function* () {
+        const orchestrator = yield* Orchestrator.OrchestratorV2;
+        const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+        const threadId = yield* startFirstTurn;
+        const first = started[0]!;
+        const messageId = MessageId.make("message:steer");
+        yield* orchestrator.dispatch({
+          type: "message.dispatch",
+          commandId: CommandId.make("steer"),
+          threadId,
+          messageId,
+          text: "follow up",
+          attachments: [],
+          modelSelection: runSelection,
+          dispatchMode: { type: "start_immediately" },
+          deliveryIntent: "steer",
+          createdBy: "user",
+          creationSource: "web",
+        });
+        yield* worker.drain();
+
+        const held = yield* orchestrator.getThreadProjection(threadId);
+        assert.deepEqual(steered, []);
+        assert.deepEqual(interrupted, []);
+        assert.equal(started.length, 1);
+        assert.equal(held.runs.find((run) => run.id === first.runId)?.status, "running");
+        const queued = held.runs.find((run) => run.userMessageId === messageId);
+        assert.equal(queued?.status, "queued");
+
+        const settled = yield* orchestrator.streamDomainEvents.pipe(
+          Stream.filter(
+            (event) =>
+              event.type === "run.updated" &&
+              event.payload.id === first.runId &&
+              event.payload.status === "waiting",
+          ),
+          Stream.take(1),
+          Stream.runDrain,
+          Effect.forkScoped,
+        );
+        const turn = held.providerTurns[0]!;
+        yield* Queue.offer(events, {
+          type: "provider_turn.updated",
+          driver,
+          providerTurn: { ...turn, status: "completed", completedAt: yield* DateTime.now },
+        });
+        yield* Queue.offer(events, {
+          type: "turn.terminal",
+          driver,
+          providerThreadId: turn.providerThreadId,
+          providerTurnId: turn.id,
+          runOrdinal: first.runOrdinal,
+          status: "completed",
+          failure: null,
+          threadDisposition: "reusable",
+        });
+        yield* Fiber.join(settled);
+        yield* worker.drain();
+        yield* orchestrator.resumeQueuedRuns;
+        yield* worker.drain();
+
+        assert.deepEqual(interrupted, []);
+        assert.equal(started.length, 2);
+        assert.equal(started[1]?.runId, queued?.id);
+        assert.equal(started[1]?.message.text, "follow up");
+      }).pipe(Effect.provide(layer));
+    }),
+  ),
+);
+
 // Codex flushes held drafts after the final answer; reserve their pre-steer position before turn end.
 it.effect("keeps a held commentary draft before the steer when turn end flushes it", () =>
   Effect.scoped(
diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts
index 88fc87d3bc092..ea1669f4b7ddc 100644
--- a/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts
@@ -1380,6 +1380,9 @@ it.effect("replays a server-allocated launch", () =>
       assert.equal(first.threadId, retry.threadId);
       assert.isFalse(first.resumed);
       assert.isTrue(retry.resumed);
+      // Clients drop their pending copy once the thread reaches the message's commit.
+      assert.isNumber(first.sequence);
+      assert.equal(retry.sequence, first.sequence);
       assert.equal(harness.runSetup.mock.calls.length, 1);
       assert.equal(retry.projection.messages.length, 1);
       assert.equal(retry.projection.runs.length, 1);
diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.ts
index 289df535c12ea..7a45a54a312f4 100644
--- a/apps/server/src/orchestration-v2/ThreadLaunchService.ts
+++ b/apps/server/src/orchestration-v2/ThreadLaunchService.ts
@@ -123,6 +123,7 @@ export interface ThreadLaunchResult {
   readonly projection: OrchestrationV2ThreadProjection;
   /** The launch's last write (the initial message, else the thread claim) was accepted before this call. */
   readonly resumed: boolean;
+  readonly sequence?: number;
 }
 
 export class ThreadLaunchError extends Schema.TaggedError<ThreadLaunchError>()(
@@ -941,6 +942,7 @@ const make = Effect.gen(function* () {
           return yield* mapError(input, "resolve-project", threadId)("Project identity changed.");
         }
         let runId: RunId | null = null;
+        let messageSequence: number | undefined;
         let messageWasAlreadyAccepted = false;
         if (input.initialMessage !== undefined) {
           const messageCommandId = CommandId.make(`${input.commandId}:initial-message`);
@@ -987,6 +989,7 @@ const make = Effect.gen(function* () {
             );
           // A concurrent retry can read no receipt and still replay the dispatch.
           messageWasAlreadyAccepted ||= dispatched.replayed === true;
+          messageSequence = dispatched.sequence;
           const runCreated = dispatched.storedEvents.find(
             (stored) => stored.event.type === "run.created",
           );
@@ -1053,6 +1056,7 @@ const make = Effect.gen(function* () {
             input.initialMessage === undefined
               ? Option.isSome(launchReceipt) || claimed.replayed === true
               : messageWasAlreadyAccepted,
+          ...(messageSequence === undefined ? {} : { sequence: messageSequence }),
         };
       });
     },
diff --git a/apps/server/src/orchestration-v2/runtimeLayer.test.ts b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
index c77837094b201..65c0c040e0daf 100644
--- a/apps/server/src/orchestration-v2/runtimeLayer.test.ts
+++ b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
@@ -37,6 +37,7 @@ import * as DateTime from "effect/DateTime";
 import * as Deferred from "effect/Deferred";
 import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
@@ -76,6 +77,7 @@ import { shellStreamItemFromThreadShell } from "./ShellStream.ts";
 import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
 import * as ThreadManagementService from "./ThreadManagementService.ts";
 import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
+import * as ScratchThreadPromotion from "../project/ScratchThreadPromotion.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as Scheduler from "../scheduling/Scheduler.ts";
 import * as SecretRequests from "../secrets/SecretRequests.ts";
@@ -5805,6 +5807,198 @@ it.layer(layerTest)("snooze queued runs", (it) => {
   );
 });
 
+const SCRATCH_ROOT = "/tmp/runtime-layer-promotion-scratch";
+const SCRATCH_PROJECT_ID = ProjectId.make("runtime-layer-promotion-scratch");
+const layerScratchPromotionTest = ScratchThreadPromotion.layer.pipe(
+  Layer.provide(
+    Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
+      scratchRoot: Effect.succeedSome(SCRATCH_ROOT),
+      isScratchProject: (projectId) => Effect.succeed(projectId === SCRATCH_PROJECT_ID),
+      namedProjectsRoot: "/projects",
+    }),
+  ),
+  Layer.provide(NodeServices.layer),
+  Layer.provideMerge(layerProjectDeletionTest),
+);
+
+it.layer(layerScratchPromotionTest)("turning a No project thread into a project", (it) => {
+  const setup = Effect.fn(function* (name: string) {
+    const projects = yield* ProjectService.ProjectService;
+    const orchestrator = yield* Orchestrator.OrchestratorV2;
+    const folder = `${SCRATCH_ROOT}/2026-01-01-${name}`;
+    if (Option.isNone(yield* projects.getById(SCRATCH_PROJECT_ID))) {
+      yield* projects.create({
+        commandId: CommandId.make("promotion-scratch-create"),
+        projectId: SCRATCH_PROJECT_ID,
+        title: "No project",
+        workspaceRoot: SCRATCH_ROOT,
+      });
+    }
+    const createThread = (suffix: string, worktreePath: string) =>
+      orchestrator
+        .dispatch({
+          type: "thread.create",
+          createdBy: "user",
+          creationSource: "web",
+          commandId: CommandId.make(`promotion-${name}-${suffix}-create`),
+          threadId: ThreadId.make(`promotion-${name}-${suffix}`),
+          projectId: SCRATCH_PROJECT_ID,
+          title: `${name} ${suffix}`,
+          modelSelection,
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath,
+        })
+        .pipe(Effect.as(ThreadId.make(`promotion-${name}-${suffix}`)));
+    return { folder, createThread };
+  });
+  const shellOf = (threadId: ThreadId) =>
+    Orchestrator.OrchestratorV2.pipe(
+      Effect.flatMap((orchestrator) => orchestrator.getThreadShell(threadId)),
+    );
+
+  it.effect("moves every thread in the folder and its bound tasks into one project", () =>
+    Effect.gen(function* () {
+      const promotion = yield* ScratchThreadPromotion.ScratchThreadPromotion;
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const tasks = yield* ScheduledTaskService.ScheduledTaskService;
+      const { folder, createThread } = yield* setup("moves");
+      const threadId = yield* createThread("main", folder);
+      const siblingId = yield* createThread("sibling", folder);
+      const otherId = yield* createThread("other", `${SCRATCH_ROOT}/2026-01-01-elsewhere`);
+      yield* orchestrator.dispatch({
+        type: "thread.archive",
+        commandId: CommandId.make("promotion-moves-sibling-archive"),
+        threadId: siblingId,
+      });
+      const { task } = yield* tasks.upsert({
+        id: ScheduledTaskId.make("promotion-moves-bound"),
+        title: "Bound",
+        prompt: "Check in",
+        enabled: true,
+        schedule: { type: "interval", everyMs: 60_000 },
+        projectId: SCRATCH_PROJECT_ID,
+        threadId: siblingId,
+        workspaceStrategy: { type: "root" },
+        modelSelection,
+        runtimeMode: "full-access",
+        interactionMode: "default",
+        createdBy: "user",
+        creationSource: "web",
+      });
+
+      const { projectId } = yield* promotion.promote({ threadId });
+
+      const project = yield* projects.getById(projectId);
+      assert.equal(Option.getOrUndefined(project)?.workspaceRoot, folder);
+      assert.equal(Option.getOrUndefined(project)?.title, "moves main");
+      for (const id of [threadId, siblingId]) {
+        const shell = yield* shellOf(id);
+        assert.equal(shell?.projectId, projectId);
+        assert.isNull(shell?.worktreePath);
+      }
+      assert.equal((yield* shellOf(otherId))?.projectId, SCRATCH_PROJECT_ID);
+      const saved = (yield* tasks.list()).tasks.find((candidate) => candidate.id === task.id);
+      assert.equal(saved?.projectId, projectId);
+      assert.deepEqual(yield* promotion.promote({ threadId }), { projectId });
+    }),
+  );
+
+  it.effect("changes nothing while a thread in the folder is busy", () =>
+    Effect.gen(function* () {
+      const promotion = yield* ScratchThreadPromotion.ScratchThreadPromotion;
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const { folder, createThread } = yield* setup("busy");
+      const threadId = yield* createThread("idle", folder);
+      const busyId = yield* createThread("delegate", folder);
+      yield* orchestrator.dispatch({
+        type: "message.dispatch",
+        createdBy: "user",
+        creationSource: "web",
+        commandId: CommandId.make("promotion-busy-message"),
+        threadId: busyId,
+        messageId: MessageId.make("promotion-busy-message"),
+        text: "Keep this run active.",
+        attachments: [],
+        modelSelection,
+        dispatchMode: { type: "start_immediately" },
+      });
+
+      const error = yield* promotion.promote({ threadId }).pipe(Effect.flip);
+
+      assert.equal(error.message, '"busy delegate" is still working. Finish or stop it first.');
+      assert.isTrue(Option.isNone(yield* projects.getByWorkspaceRoot(folder)));
+      assert.equal((yield* shellOf(threadId))?.projectId, SCRATCH_PROJECT_ID);
+    }),
+  );
+
+  it.effect("finishes a partial move from either thread", () =>
+    Effect.gen(function* () {
+      const promotion = yield* ScratchThreadPromotion.ScratchThreadPromotion;
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const { folder, createThread } = yield* setup("partial");
+      const movedId = yield* createThread("moved", folder);
+      const leftId = yield* createThread("left", folder);
+      const earlier = yield* projects.create({
+        commandId: CommandId.make("promotion-partial-project"),
+        projectId: ProjectId.make("promotion-partial-project"),
+        title: "Earlier",
+        workspaceRoot: folder,
+      });
+      yield* orchestrator.dispatch({
+        type: "thread.project.adopt-folder",
+        commandId: CommandId.make("promotion-partial-adopt"),
+        threadId: movedId,
+        projectId: earlier.id,
+      });
+
+      assert.deepEqual(yield* promotion.promote({ threadId: movedId }), { projectId: earlier.id });
+      assert.equal((yield* shellOf(leftId))?.projectId, earlier.id);
+    }),
+  );
+
+  it.effect("refuses a thread outside No project", () =>
+    Effect.gen(function* () {
+      const promotion = yield* ScratchThreadPromotion.ScratchThreadPromotion;
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const projectId = ProjectId.make("promotion-regular-project");
+      const threadId = ThreadId.make("promotion-regular-thread");
+      yield* projects.create({
+        commandId: CommandId.make("promotion-regular-project"),
+        projectId,
+        title: "Regular",
+        workspaceRoot: "/tmp/runtime-layer-promotion-regular",
+      });
+      yield* orchestrator.dispatch({
+        type: "thread.create",
+        createdBy: "user",
+        creationSource: "web",
+        commandId: CommandId.make("promotion-regular-thread-create"),
+        threadId,
+        projectId,
+        title: "Regular",
+        modelSelection,
+        runtimeMode: "full-access",
+        interactionMode: "default",
+        branch: null,
+        worktreePath: null,
+      });
+
+      const error = yield* promotion.promote({ threadId }).pipe(Effect.flip);
+
+      assert.equal(
+        error.message,
+        "Only a No project thread with its own folder can become a project.",
+      );
+    }),
+  );
+});
+
 it.layer(layerSharedApplicationDataPlaneTest)("snooze projection", (it) => {
   it.effect("carries snooze state through the V2 shell projection", () =>
     Effect.gen(function* () {
@@ -5900,6 +6094,88 @@ it.layer(layerSharedApplicationDataPlaneTest)("snooze projection", (it) => {
       assert.isNull(awakened.thread.snoozedAt);
     }),
   );
+
+  it.effect("moves a thread into a project rooted at its own folder", () =>
+    Effect.gen(function* () {
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const scratchProjectId = ProjectId.make("runtime-layer-adopt-scratch");
+      const folderProjectId = ProjectId.make("runtime-layer-adopt-folder");
+      const otherProjectId = ProjectId.make("runtime-layer-adopt-other");
+      const folder = "/tmp/runtime-layer-adopt-scratch/2026-01-01-notes-a1b2c3d4";
+      const createProject = (projectId: ProjectId, workspaceRoot: string) =>
+        projects.create({
+          commandId: CommandId.make(`${projectId}-create`),
+          projectId,
+          title: projectId,
+          workspaceRoot,
+        });
+      const createThread = (threadId: ThreadId) =>
+        orchestrator.dispatch({
+          type: "thread.create",
+          createdBy: "user",
+          creationSource: "web",
+          commandId: CommandId.make(`${threadId}-create`),
+          threadId,
+          projectId: scratchProjectId,
+          title: "Scratch work",
+          modelSelection,
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath: folder,
+        });
+      const adopt = (threadId: ThreadId, projectId: ProjectId, suffix: string) =>
+        orchestrator.dispatch({
+          type: "thread.project.adopt-folder",
+          commandId: CommandId.make(`${threadId}-adopt-${suffix}`),
+          threadId,
+          projectId,
+        });
+      yield* createProject(scratchProjectId, "/tmp/runtime-layer-adopt-scratch");
+      yield* createProject(folderProjectId, folder);
+      yield* createProject(otherProjectId, "/tmp/runtime-layer-adopt-other");
+      const idleThreadId = ThreadId.make("runtime-layer-adopt-idle");
+      const busyThreadId = ThreadId.make("runtime-layer-adopt-busy");
+      yield* createThread(idleThreadId);
+      yield* createThread(busyThreadId);
+      yield* orchestrator.dispatch({
+        type: "message.dispatch",
+        createdBy: "user",
+        creationSource: "web",
+        commandId: CommandId.make("runtime-layer-adopt-busy-message"),
+        threadId: busyThreadId,
+        messageId: MessageId.make("runtime-layer-adopt-busy-message"),
+        text: "Keep this run active.",
+        attachments: [],
+        modelSelection,
+        dispatchMode: { type: "start_immediately" },
+      });
+
+      const otherFolder = yield* adopt(idleThreadId, otherProjectId, "other").pipe(Effect.flip);
+      assert.equal(
+        otherFolder.cause,
+        `Thread ${idleThreadId} does not work in /tmp/runtime-layer-adopt-other.`,
+      );
+      const missing = yield* adopt(idleThreadId, ProjectId.make("missing"), "missing").pipe(
+        Effect.flip,
+      );
+      assert.equal(missing.cause, `Thread ${idleThreadId} cannot move to missing project missing.`);
+      const busy = yield* adopt(busyThreadId, folderProjectId, "busy").pipe(Effect.flip);
+      assert.equal(
+        busy.cause,
+        `Thread ${busyThreadId} still has work in progress. Finish or stop it first.`,
+      );
+
+      yield* adopt(idleThreadId, folderProjectId, "folder");
+      const shell = yield* orchestrator.getShellSnapshot();
+      const moved = shell.threads.find((thread) => thread.id === idleThreadId);
+      assert.equal(moved?.projectId, folderProjectId);
+      assert.isNull(moved?.worktreePath);
+      const stayed = shell.threads.find((thread) => thread.id === busyThreadId);
+      assert.equal(stayed?.projectId, scratchProjectId);
+    }),
+  );
 });
 
 it.layer(layerSharedApplicationDataPlaneTest)("visited projection", (it) => {
diff --git a/apps/server/src/orchestration-v2/runtimeLayer.ts b/apps/server/src/orchestration-v2/runtimeLayer.ts
index 6bd33ebd26187..1b54627595372 100644
--- a/apps/server/src/orchestration-v2/runtimeLayer.ts
+++ b/apps/server/src/orchestration-v2/runtimeLayer.ts
@@ -16,6 +16,7 @@ import * as AgentSessionScanner from "../project/AgentSessionScanner.ts";
 import * as ProjectService from "../project/ProjectService.ts";
 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
 import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
+import * as ScratchThreadPromotion from "../project/ScratchThreadPromotion.ts";
 import * as CheckpointCaptureService from "./CheckpointCaptureService.ts";
 import * as CheckpointService from "./CheckpointService.ts";
 import * as CheckpointRollbackService from "./CheckpointRollbackService.ts";
@@ -289,6 +290,16 @@ const layerScheduledTaskProvided = ScheduledTaskService.layer.pipe(
     ),
   ),
 );
+const layerScratchThreadPromotionProvided = ScratchThreadPromotion.layer.pipe(
+  Layer.provide(
+    Layer.mergeAll(
+      layerProjectService,
+      layerManagedProjectFoldersProvided,
+      layerThreadManagementProvided,
+      layerScheduledTaskProvided,
+    ),
+  ),
+);
 const layerProviderContinuationWorkerProvided = ProviderContinuationService.layer.pipe(
   Layer.provide(
     Layer.mergeAll(
@@ -362,6 +373,7 @@ export const layerProduction = Layer.mergeAll(
   layerManagedProjectFoldersProvided,
   layerThreadLaunchProvided,
   layerScheduledTaskProvided,
+  layerScratchThreadPromotionProvided,
   layerSecretRequestsProvided,
   GuestShareService.layer.pipe(
     Layer.provide(Layer.merge(layerOrchestratorProvided, layerCommandOutputHubProvided)),
diff --git a/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts b/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
index 4da359f74c920..afd11a9ab7ecb 100644
--- a/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
+++ b/apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts
@@ -40,6 +40,7 @@ import * as ProviderAuthService from "../../provider/ProviderAuthService.ts";
 import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
 import * as ProviderContinuationService from "../ProviderContinuationService.ts";
 import * as ProviderEventIngestor from "../ProviderEventIngestor.ts";
+import * as ProviderInstanceRegistry from "../../provider/ProviderInstanceRegistry.ts";
 import * as ProviderRuntimeRecoveryService from "../ProviderRuntimeRecoveryService.ts";
 import * as ProviderSessionManager from "../ProviderSessionManager.ts";
 import * as CommandOutputRecorder from "./CommandOutputRecorder.ts";
@@ -320,6 +321,10 @@ export function layerWithRegistry<Error>(
   const layerProviderEventIngestorProvided = ProviderEventIngestor.layer.pipe(
     Layer.provide(
       Layer.mergeAll(
+        Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
+          // @effect-diagnostics-next-line effectSucceedWithVoid:off - Optional instances require undefined rather than void.
+          getInstance: () => Effect.succeed(undefined),
+        }),
         layerStores,
         layerEventSinkProvided,
         IdAllocator.layer,
diff --git a/apps/server/src/orchestration-v2/workflowAgentAnswers.test.ts b/apps/server/src/orchestration-v2/workflowAgentAnswers.test.ts
new file mode 100644
index 0000000000000..8a24b95028875
--- /dev/null
+++ b/apps/server/src/orchestration-v2/workflowAgentAnswers.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { mergeWorkflowAgentMetadata } from "./workflowAgentAnswers.ts";
+
+describe("mergeWorkflowAgentMetadata", () => {
+  it("keeps effort and speed across reads of a split assistant message", () => {
+    const metadata = mergeWorkflowAgentMetadata([
+      {
+        type: "assistant",
+        effort: "xhigh",
+        message: { id: "a", content: [], usage: { speed: "standard" } },
+      },
+    ]);
+    expect(metadata).toEqual({ messageId: "a", effort: "xhigh", speed: "standard" });
+    expect(
+      mergeWorkflowAgentMetadata(
+        [{ type: "assistant", message: { id: "a", content: [{ type: "text", text: "Done" }] } }],
+        metadata,
+      ),
+    ).toEqual(metadata);
+    expect(mergeWorkflowAgentMetadata([], metadata)).toEqual(metadata);
+  });
+
+  it("ignores bookkeeping and API errors without clearing prior metadata", () => {
+    const metadata = { messageId: "a", effort: "max", speed: "standard" };
+    expect(
+      mergeWorkflowAgentMetadata(
+        [
+          { type: "user", effort: "high", message: { usage: { speed: "fast" } } },
+          { type: "assistant", isMeta: true, effort: "high" },
+          { type: "assistant", isApiErrorMessage: true, message: { id: "error" } },
+          { type: "assistant", effort: 1, message: { id: "a", usage: { speed: false } } },
+        ],
+        metadata,
+      ),
+    ).toEqual(metadata);
+  });
+
+  it.each(["b", undefined])("clears omitted metadata for a new response with id %s", (id) => {
+    expect(
+      mergeWorkflowAgentMetadata([{ type: "assistant", message: { id, content: [] } }], {
+        messageId: "a",
+        effort: "max",
+        speed: "standard",
+      }),
+    ).toEqual(id === undefined ? {} : { messageId: id });
+  });
+});
diff --git a/apps/server/src/orchestration-v2/workflowAgentAnswers.ts b/apps/server/src/orchestration-v2/workflowAgentAnswers.ts
new file mode 100644
index 0000000000000..d96f3684a4e2b
--- /dev/null
+++ b/apps/server/src/orchestration-v2/workflowAgentAnswers.ts
@@ -0,0 +1,33 @@
+import type { OrchestrationV2WorkflowAgent } from "@t3tools/contracts";
+
+import { field, text } from "./unknownField.ts";
+
+export type WorkflowAgentMetadata = Pick<OrchestrationV2WorkflowAgent, "effort" | "speed"> & {
+  readonly messageId?: string;
+};
+
+export function mergeWorkflowAgentMetadata(
+  lines: ReadonlyArray<unknown>,
+  previous: WorkflowAgentMetadata = {},
+): WorkflowAgentMetadata {
+  let metadata = previous;
+  for (const entry of lines) {
+    if (
+      field(entry, "type") !== "assistant" ||
+      field(entry, "isMeta") === true ||
+      field(entry, "isApiErrorMessage") === true
+    )
+      continue;
+    const message = field(entry, "message");
+    const messageId = text(field(message, "id"));
+    const effort = text(field(entry, "effort"));
+    const speed = text(field(field(message, "usage"), "speed"));
+    metadata = {
+      ...(messageId !== undefined && messageId === metadata.messageId ? metadata : {}),
+      ...(messageId === undefined ? {} : { messageId }),
+      ...(effort === undefined ? {} : { effort }),
+      ...(speed === undefined ? {} : { speed }),
+    };
+  }
+  return metadata;
+}
diff --git a/apps/server/src/persistence/Migrations.test.ts b/apps/server/src/persistence/Migrations.test.ts
index 67f238b7484f5..54e4a711aa8a1 100644
--- a/apps/server/src/persistence/Migrations.test.ts
+++ b/apps/server/src/persistence/Migrations.test.ts
@@ -1,7 +1,10 @@
 import { assert, describe, it } from "@effect/vitest";
 import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as SqlClient from "effect/sql/SqlClient";
 
 import { migrationManifest, runMigrations } from "./Migrations.ts";
@@ -123,3 +126,20 @@ describe("runMigrations", () => {
     }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: ":memory:" }))),
   );
 });
+
+// The npm launcher reads the highest migration id from these file names.
+it.effect("registers every migration file", () =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const dir = path.join(import.meta.dirname, "Migrations");
+    const files = (yield* fs.readDirectory(dir)).flatMap((name) => {
+      const match = /^(\d+)_(\w+)\.ts$/.exec(name);
+      return match ? [[Number(match[1]), match[2]] as const] : [];
+    });
+    assert.deepStrictEqual(
+      files.toSorted(([a], [b]) => a - b),
+      migrationManifest,
+    );
+  }).pipe(Effect.provide(NodeServices.layer)),
+);
diff --git a/apps/server/src/persistence/databaseMigrationHead.ts b/apps/server/src/persistence/databaseMigrationHead.ts
new file mode 100644
index 0000000000000..046039a703410
--- /dev/null
+++ b/apps/server/src/persistence/databaseMigrationHead.ts
@@ -0,0 +1,49 @@
+// @effect-diagnostics nodeBuiltinImport:off - read synchronously by the preflight subprocess and at startup.
+import * as NodeFS from "node:fs";
+import * as NodeSqlite from "node:sqlite";
+
+import { migrationManifest } from "./Migrations.ts";
+
+export const BUILD_MIGRATION_HEAD = Math.max(...migrationManifest.map(([id]) => id));
+
+/** Migrations the database records, read-only. A missing or new database records none; one that
+ * exists but cannot be read is null, since its history is unknown. */
+export function recordedMigrations(
+  databasePath: string,
+): ReadonlyArray<{ readonly id: number; readonly name: string }> | null {
+  let db: NodeSqlite.DatabaseSync;
+  try {
+    db = new NodeSqlite.DatabaseSync(databasePath, { readOnly: true });
+  } catch {
+    return NodeFS.existsSync(databasePath) ? null : [];
+  }
+  try {
+    const hasTable = db
+      .prepare(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'effect_sql_migrations'",
+      )
+      .get();
+    if (hasTable === undefined) return [];
+    return db
+      .prepare("SELECT migration_id, name FROM effect_sql_migrations ORDER BY migration_id")
+      .all()
+      .map((row) => ({ id: Number(row.migration_id), name: String(row.name) }));
+  } catch {
+    return null;
+  } finally {
+    try {
+      db.close();
+    } catch {
+      // A read-only handle has nothing to flush; the result above already stands.
+    }
+  }
+}
+
+/** Highest migration the database holds once this build's startup migrations have run. A newer
+ * build may have recorded more than this build knows. Undefined when the database is unreadable. */
+export function databaseMigrationHead(databasePath: string): number | undefined {
+  const recorded = recordedMigrations(databasePath);
+  return recorded === null
+    ? undefined
+    : Math.max(BUILD_MIGRATION_HEAD, ...recorded.map(({ id }) => id));
+}
diff --git a/apps/server/src/project/ScratchThreadPromotion.ts b/apps/server/src/project/ScratchThreadPromotion.ts
new file mode 100644
index 0000000000000..671a480a95832
--- /dev/null
+++ b/apps/server/src/project/ScratchThreadPromotion.ts
@@ -0,0 +1,161 @@
+import {
+  CommandId,
+  type OrchestrationV2ThreadShell,
+  ProjectId,
+  type ThreadId,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+
+import { threadHasUnfinishedWork } from "../orchestration-v2/Orchestrator.ts";
+import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
+import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
+import * as ManagedProjectFolders from "./ManagedProjectFolders.ts";
+import * as ProjectService from "./ProjectService.ts";
+
+export class ScratchThreadPromotionError extends Schema.TaggedError<ScratchThreadPromotionError>()(
+  "ScratchThreadPromotionError",
+  {
+    reason: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {
+  override get message(): string {
+    return this.reason;
+  }
+}
+
+export class ScratchThreadPromotion extends Context.Service<
+  ScratchThreadPromotion,
+  {
+    /**
+     * Turns a No project thread's folder into a project, in place, and moves every
+     * thread working in that folder into it. Running it again finishes a partial move.
+     */
+    readonly promote: (input: {
+      readonly threadId: ThreadId;
+    }) => Effect.Effect<{ readonly projectId: ProjectId }, ScratchThreadPromotionError>;
+  }
+>()("t3/project/ScratchThreadPromotion") {}
+
+const make = Effect.gen(function* () {
+  const managedFolders = yield* ManagedProjectFolders.ManagedProjectFolders;
+  const projects = yield* ProjectService.ProjectService;
+  const threads = yield* ThreadManagementService.ThreadManagementService;
+  const scheduledTasks = yield* ScheduledTaskService.ScheduledTaskService;
+  const crypto = yield* Crypto.Crypto;
+  const path = yield* Path.Path;
+
+  const fail = (reason: string) => (cause: unknown) =>
+    new ScratchThreadPromotionError({ reason, cause });
+
+  const promote: ScratchThreadPromotion["Service"]["promote"] = Effect.fn(
+    "ScratchThreadPromotion.promote",
+  )(function* (input) {
+    const thread = yield* threads.getThreadShell(input.threadId).pipe(
+      Effect.mapError(fail("Could not read the thread.")),
+      Effect.filterOrFail(
+        (shell) => shell !== null,
+        () => new ScratchThreadPromotionError({ reason: "Thread not found." }),
+      ),
+    );
+    const project = yield* projects
+      .getById(thread.projectId)
+      .pipe(Effect.mapError(fail("Could not read the thread's project.")));
+    const folder = thread.worktreePath ?? Option.getOrUndefined(project)?.workspaceRoot;
+    const scratchRoot = Option.getOrUndefined(yield* managedFolders.scratchRoot);
+    const isScratch = yield* managedFolders.isScratchProject(thread.projectId);
+    // A thread already rooted at its folder is a partial earlier promotion; finish it.
+    const alreadyPromoted =
+      Option.isSome(project) && project.value.workspaceRoot === folder && !isScratch;
+    if (
+      folder === undefined ||
+      scratchRoot === undefined ||
+      path.dirname(folder) !== scratchRoot ||
+      !(isScratch || alreadyPromoted)
+    ) {
+      return yield* new ScratchThreadPromotionError({
+        reason: "Only a No project thread with its own folder can become a project.",
+      });
+    }
+
+    const snapshot = yield* Effect.flatten(
+      threads.readShellSnapshot({ worktreePath: folder }),
+    ).pipe(Effect.mapError(fail("Could not read the threads in this folder.")));
+    const moveSet = new Map<ThreadId, OrchestrationV2ThreadShell>();
+    if (isScratch) moveSet.set(thread.id, thread);
+    for (const candidate of [...snapshot.threads, ...snapshot.archivedThreads]) {
+      if (yield* managedFolders.isScratchProject(candidate.projectId)) {
+        moveSet.set(candidate.id, candidate);
+      }
+    }
+
+    for (const candidate of moveSet.values()) {
+      const records = yield* threads
+        .getThreadRecords(candidate.id, ["runs", "runtimeRequests"], { turnItemTypes: [] })
+        .pipe(Effect.mapError(fail(`Could not read "${candidate.title}".`)));
+      if (threadHasUnfinishedWork(records)) {
+        return yield* new ScratchThreadPromotionError({
+          reason: `"${candidate.title}" is still working. Finish or stop it first.`,
+        });
+      }
+    }
+
+    return yield* Effect.uninterruptible(
+      Effect.gen(function* () {
+        const projectId = yield* createProject(thread.title, folder);
+        yield* scheduledTasks
+          .moveThreadTasks({ threadIds: [...moveSet.keys()], projectId })
+          .pipe(Effect.mapError(fail("Could not move the thread's scheduled tasks.")));
+        for (const candidate of moveSet.values()) {
+          const commandId = CommandId.make(`scratch-promotion:${yield* randomId}`);
+          yield* threads
+            .dispatch({
+              type: "thread.project.adopt-folder",
+              commandId,
+              threadId: candidate.id,
+              projectId,
+            })
+            .pipe(Effect.mapError(fail(`Could not move "${candidate.title}". Try again.`)));
+        }
+        return { projectId };
+      }),
+    );
+  });
+
+  const randomId = crypto
+    .randomUUIDv4()
+    .pipe(Effect.mapError(fail("Could not create an id for the project.")));
+
+  // bootstrap returns the project that already owns the folder, so retries reuse it.
+  const createProject = Effect.fn("ScratchThreadPromotion.createProject")(function* (
+    title: string,
+    workspaceRoot: string,
+  ) {
+    const id = yield* randomId;
+    return yield* projects
+      .bootstrap({
+        commandId: CommandId.make(`scratch-promotion-project:${id}`),
+        projectId: ProjectId.make(id),
+        title,
+        workspaceRoot,
+      })
+      .pipe(
+        Effect.map(({ project }) => project.id),
+        // bootstrap reads before locking; racing creates return the winner in a conflict.
+        Effect.catchTags({
+          ProjectConflictError: (conflict) => Effect.succeed(conflict.conflictingProjectId),
+        }),
+        Effect.mapError(fail("Could not create the project.")),
+      );
+  });
+
+  return ScratchThreadPromotion.of({ promote });
+});
+
+export const layer = Layer.effect(ScratchThreadPromotion, make);
diff --git a/apps/server/src/provider/AgentContextBudget.test.ts b/apps/server/src/provider/AgentContextBudget.test.ts
index ad19948c06886..9a26b53bff4e6 100644
--- a/apps/server/src/provider/AgentContextBudget.test.ts
+++ b/apps/server/src/provider/AgentContextBudget.test.ts
@@ -123,7 +123,10 @@ it.effect("agent context matches the committed budget", () =>
       ),
     };
 
-    expect(measured).toEqual(budget);
+    expect(
+      measured,
+      "Set agentContextBudget.json to the measured values. Before you cut text to fit, run the evals that cover it (evals/README.md).",
+    ).toEqual(budget);
   }).pipe(
     Effect.provide(
       McpHttpServer.layerTools.pipe(
diff --git a/apps/server/src/provider/AntigravityInstallation.ts b/apps/server/src/provider/AntigravityInstallation.ts
index 3d590abda0bdb..902e6508ca25d 100644
--- a/apps/server/src/provider/AntigravityInstallation.ts
+++ b/apps/server/src/provider/AntigravityInstallation.ts
@@ -398,7 +398,6 @@ export const makeAntigravityInstallation = Effect.fn("AntigravityInstallation.ma
                   }),
                 )
               : spawner,
-          clientInfo: { name: "t3-code", version: "0.0.0" },
         });
         const initialized = yield* runtime.initialize();
         if (
diff --git a/apps/server/src/provider/AntigravityProvider.test.ts b/apps/server/src/provider/AntigravityProvider.test.ts
index ade033551f655..1f852ad8bcc87 100644
--- a/apps/server/src/provider/AntigravityProvider.test.ts
+++ b/apps/server/src/provider/AntigravityProvider.test.ts
@@ -214,6 +214,69 @@ describe("Antigravity model catalog", () => {
       "gemini-pro-agent",
     );
   });
+
+  it("labels models that share a display name with their IDs", () => {
+    const models = buildAntigravityModelsFromSession({
+      configOptions: [
+        {
+          ...modelConfig,
+          currentValue: "gemini-3.8-flash",
+          options: [
+            { value: "gemini-3.8-flash", name: "Gemini 3.8 Flash" },
+            { value: "gemini-3.8-flash-preview", name: "Gemini 3.8 Flash" },
+          ],
+        },
+      ],
+    });
+    expect(models.map((model) => model.name)).toEqual([
+      "Gemini 3.8 Flash",
+      "Gemini 3.8 Flash (gemini-3.8-flash-preview)",
+    ]);
+  });
+
+  it("offers each model the thinking levels it reported when selected", () => {
+    const thinking = (currentValue: string) =>
+      ({
+        id: "thinking_level",
+        name: "Thinking Level",
+        category: "thought_level",
+        type: "select",
+        currentValue,
+        options: [
+          { value: "low", name: "Low" },
+          { value: "high", name: "High" },
+        ],
+      }) satisfies EffectAcpSchema.SessionConfigOption;
+    const models = buildAntigravityModelsFromSession(
+      {
+        configOptions: [
+          {
+            ...modelConfig,
+            currentValue: "gemini",
+            options: [
+              { value: "gemini", name: "Gemini" },
+              { value: "claude", name: "Claude" },
+              { value: "plain", name: "Plain" },
+              { value: "unseen", name: "Unseen" },
+            ],
+          },
+          thinking("high"),
+        ],
+      },
+      new Map([
+        ["claude", thinking("low")],
+        ["plain", null],
+      ]),
+    );
+    const thinkingOf = (slug: string) =>
+      models.find((model) => model.slug === slug)?.capabilities?.optionDescriptors?.[0];
+
+    expect(thinkingOf("gemini")).toMatchObject({ id: "thinking_level", currentValue: "high" });
+    expect(thinkingOf("claude")).toMatchObject({ id: "thinking_level", currentValue: "low" });
+    expect(thinkingOf("plain")).toBeUndefined();
+    expect(thinkingOf("unseen")).toMatchObject({ id: "thinking_level" });
+    expect(thinkingOf("unseen")).not.toHaveProperty("currentValue");
+  });
 });
 
 it.layer(layerTest)("Antigravity provider snapshots", (it) => {
diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts
index c6809c3577132..db7d22a45e0cd 100644
--- a/apps/server/src/provider/AntigravityProvider.ts
+++ b/apps/server/src/provider/AntigravityProvider.ts
@@ -20,6 +20,7 @@ import type * as EffectAcpErrors from "effect-acp/errors";
 import type * as EffectAcpSchema from "effect-acp/compat";
 
 import type * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
+import { acpProviderOptionDescriptors } from "@t3tools/provider-acp/server/sessionConfig";
 import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
 import {
   makeManualOnlyProviderMaintenanceCapabilities,
@@ -32,6 +33,8 @@ import {
 } from "@t3tools/provider-core/server/snapshotProbe";
 import { resolveUsageLimitsAfterProbe } from "@t3tools/provider-core/server/usageLimits";
 
+import { antigravityThinkingConfig } from "./acp/AntigravityAcpSupport.ts";
+
 const EMPTY_MODEL_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
 const MAX_WORKSPACE_SNAPSHOTS = 32;
 const HEALTH_CHECK_TIMEOUT = "90 seconds";
@@ -44,8 +47,24 @@ type SessionSetupResult = Pick<
   "configOptions" | "models"
 >;
 
+type ThinkingConfig = NonNullable<ReturnType<typeof antigravityThinkingConfig>>;
+
+/** Thinking options each model reported when selected; `null` means it has none. */
+export type AntigravityThinkingLevels = ReadonlyMap<string, ThinkingConfig | null>;
+
+function thinkingCapabilities(config: ThinkingConfig | null | undefined, observed: boolean) {
+  const descriptor = config
+    ? acpProviderOptionDescriptors({ configOptions: [config], modeState: undefined })[0]
+    : undefined;
+  if (descriptor?.type !== "select") return EMPTY_MODEL_CAPABILITIES;
+  // Another model's selected level is not this model's default.
+  const { currentValue: _currentValue, ...unobserved } = descriptor;
+  return createModelCapabilities({ optionDescriptors: [observed ? descriptor : unobserved] });
+}
+
 export function buildAntigravityModelsFromSession(
   setup: SessionSetupResult,
+  thinkingLevels: AntigravityThinkingLevels = new Map(),
 ): ReadonlyArray<ServerProviderModel> {
   const config = setup.configOptions?.find(
     (option) => option.id === "model" || option.category === "model",
@@ -61,19 +80,30 @@ export function buildAntigravityModelsFromSession(
             name: model.name,
           })) ?? [])
         : [];
+  const currentThinking = antigravityThinkingConfig(setup.configOptions);
   const seen = new Set<string>();
+  // The agent can list two IDs under one name; label the later ones so the picker tells them apart.
+  const names = new Set<string>();
   return entries.flatMap((entry): ServerProviderModel[] => {
     if (!entry.value.trim() || seen.has(entry.value)) return [];
     seen.add(entry.value);
+    const baseName = entry.name.trim() ? entry.name : entry.value;
+    const name = names.has(baseName) ? `${baseName} (${entry.value})` : baseName;
+    names.add(baseName);
+    const observed =
+      entry.value === currentValue ? (currentThinking ?? null) : thinkingLevels.get(entry.value);
     return [
       {
         slug: entry.value,
-        name: entry.name.trim() ? entry.name : entry.value,
+        name,
         isCustom: false,
         ...(entry.value === currentValue
           ? { isDefault: true, aliases: [ANTIGRAVITY_DEFAULT_MODEL] }
           : {}),
-        capabilities: EMPTY_MODEL_CAPABILITIES,
+        capabilities:
+          observed === undefined
+            ? thinkingCapabilities(currentThinking, false)
+            : thinkingCapabilities(observed, true),
       },
     ];
   });
@@ -162,6 +192,17 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
   });
   // Preserve disk-discovered skills when callbacks replace workspace commands; the registry will not rescan them.
   const discoveredSkills = new Map<string, ServerProvider["skills"]>();
+  const thinkingLevels = new Map<string, ThinkingConfig | null>();
+  const observeThinkingLevels = (
+    configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption> | null | undefined,
+  ) => {
+    const model = configOptions?.find(
+      (option) => option.id === "model" || option.category === "model",
+    );
+    if (model?.type === "select" && model.currentValue) {
+      thinkingLevels.set(model.currentValue, antigravityThinkingConfig(configOptions) ?? null);
+    }
+  };
   const getSnapshot = SubscriptionRef.get(metadata).pipe(
     Effect.flatMap((state) => options.stampIdentity(state.draft)),
   );
@@ -267,6 +308,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
     cwd?: string,
   ) {
     if (!settings.enabled) return;
+    observeThinkingLevels(started.sessionSetupResult.configOptions);
     const before = yield* SubscriptionRef.get(metadata);
     const supportsTextGeneration = yield* options.supportsTextGeneration;
     const usageLimits =
@@ -301,7 +343,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
             published: draft.usageLimits,
             probed: usageLimits ?? draft.usageLimits,
           }),
-          models: buildAntigravityModelsFromSession(started.sessionSetupResult),
+          models: buildAntigravityModelsFromSession(started.sessionSetupResult, thinkingLevels),
           supportsTextGeneration,
           ...(cwd
             ? {
@@ -324,7 +366,8 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
   const onConfigOptionsUpdated = Effect.fn("AntigravityProvider.onConfigOptionsUpdated")(function* (
     configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>,
   ) {
-    const models = buildAntigravityModelsFromSession({ configOptions });
+    observeThinkingLevels(configOptions);
+    const models = buildAntigravityModelsFromSession({ configOptions }, thinkingLevels);
     yield* SubscriptionRef.update(metadata, (state) => {
       if (state.draft.auth.status !== "authenticated") return state;
       return { ...state, draft: { ...state.draft, models } };
@@ -391,6 +434,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
         }) satisfies AntigravityProviderState,
     );
     discoveredSkills.clear();
+    thinkingLevels.clear();
   });
 
   const snapshotForCwd = Effect.fn("AntigravityProvider.snapshotForCwd")(function* (
diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts
index fd5725c6cd798..f1f39e104b44c 100644
--- a/apps/server/src/provider/Drivers/AntigravityDriver.ts
+++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts
@@ -38,6 +38,8 @@ import {
   type AntigravityAuthConfig,
 } from "../antigravityAuthSupport.ts";
 import {
+  antigravityModelOptions,
+  antigravityThinkingConfig,
   makeAntigravityAcpRuntime,
   type AntigravityAcpRuntimeInput,
 } from "../acp/AntigravityAcpSupport.ts";
@@ -294,7 +296,6 @@ export const AntigravityDriver: ProviderDriver<
       );
       const runtime = yield* makeRuntime({
         cwd,
-        clientInfo: { name: "t3-code-provider-setup", version: "0.0.0" },
         mcpServers: [],
         ...(input.onAuthorizationUrl ? { onAuthorizationUrl: input.onAuthorizationUrl } : {}),
       });
@@ -313,7 +314,10 @@ export const AntigravityDriver: ProviderDriver<
 
     const publishCatalog = Effect.fn("AntigravityDriver.publishCatalog")(function* (
       started: AcpSessionRuntime.AcpSessionRuntimeStartResult,
-      runtime: Pick<AcpSessionRuntime.AcpSessionRuntime["Service"], "getEvents" | "drainEvents">,
+      runtime: Pick<
+        AcpSessionRuntime.AcpSessionRuntime["Service"],
+        "getEvents" | "drainEvents" | "setModel"
+      >,
     ) {
       yield* provider.onSessionStarted(started);
       yield* Stream.runForEach(runtime.getEvents(), (event) => {
@@ -327,6 +331,14 @@ export const AntigravityDriver: ProviderDriver<
           ? provider.onAvailableCommands(event.availableCommands)
           : Effect.void;
       }).pipe(Effect.forkScoped);
+      // Thinking levels differ per model and are reported only for the selected one.
+      const configOptions = started.sessionSetupResult.configOptions ?? [];
+      const current = configOptions.find((option) => option.id === "model")?.currentValue;
+      if (antigravityThinkingConfig(configOptions) !== undefined && typeof current === "string") {
+        for (const model of [...antigravityModelOptions(configOptions), { value: current }]) {
+          yield* runtime.setModel(model.value).pipe(Effect.ignore);
+        }
+      }
       yield* runtime.drainEvents;
     }, Effect.scoped);
 
@@ -439,7 +451,6 @@ export const AntigravityDriver: ProviderDriver<
       makeRuntime: (cwd) =>
         makeRuntime({
           cwd,
-          clientInfo: { name: "t3-code-text", version: "0.0.0" },
           mcpServers: [],
         }),
     });
diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts
index 86832d53d3119..e1fbcd30080fd 100644
--- a/apps/server/src/provider/Drivers/ClaudeDriver.ts
+++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts
@@ -299,6 +299,7 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv, Path.
           Effect.map(stampIdentity),
         ),
       checkProvider,
+      invalidateUsageCache: Cache.invalidateAll(capabilitiesProbeCache),
       enrichSnapshot: ({ settings, snapshot, publishSnapshot }) =>
         resolveMaintenance().pipe(
           Effect.flatMap((maintenanceCapabilities) =>
diff --git a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts
index bd48ee767ee46..8e0eed1371c5b 100644
--- a/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts
+++ b/apps/server/src/provider/acp/AntigravityAcpSupport.test.ts
@@ -38,8 +38,18 @@ function makeModelRuntime(
     if (failure) return yield* failure;
     selections.push(model);
   });
+  const setConfigOption = Effect.fn("AntigravityAcpSupportTest.setConfigOption")(function* (
+    configId: string,
+    value: string | boolean,
+    options?: { readonly allowUnlistedValue?: boolean },
+  ) {
+    selections.push(
+      `${configId}=${String(value)}${options?.allowUnlistedValue === true ? " (unlisted)" : ""}`,
+    );
+    return { configOptions };
+  });
   return {
-    runtime: { getConfigOptions: Effect.succeed(configOptions), setModel },
+    runtime: { getConfigOptions: Effect.succeed(configOptions), setModel, setConfigOption },
     selections,
   };
 }
@@ -137,6 +147,30 @@ describe("applyAntigravityAcpModelSelection", () => {
       expect(selections).toEqual(["gemini-saved"]);
     }),
   );
+
+  it.effect("passes a model ID saved on runtime 1.3 to the agent as its 1.4 family", () =>
+    Effect.gen(function* () {
+      // The cold-resume model has no thinking option, so the level is unknown locally.
+      const { runtime, selections } = makeModelRuntime([
+        {
+          ...modelConfig,
+          currentValue: "gpt-oss-120b-medium",
+          options: [
+            { value: "gemini-3.8-flash", name: "Gemini 3.8 Flash" },
+            { value: "gpt-oss-120b-medium", name: "GPT-OSS 120B (Medium)" },
+          ],
+        },
+      ]);
+      const model = yield* applyAntigravityAcpModelSelection({
+        runtime,
+        model: "gemini-3.8-flash-low",
+        mapError: (cause) => cause,
+      });
+
+      expect(model).toBe("gemini-3.8-flash");
+      expect(selections).toEqual(["model=gemini-3.8-flash-low (unlisted)"]);
+    }),
+  );
 });
 
 const imageAttachment = {
diff --git a/apps/server/src/provider/acp/AntigravityAcpSupport.ts b/apps/server/src/provider/acp/AntigravityAcpSupport.ts
index ac64c9da2a469..a57fc08f9b7af 100644
--- a/apps/server/src/provider/acp/AntigravityAcpSupport.ts
+++ b/apps/server/src/provider/acp/AntigravityAcpSupport.ts
@@ -31,6 +31,7 @@ export interface AntigravityAcpRuntimeInput extends Omit<
   | "authenticateEagerly"
   | "cancelBehavior"
   | "clientCapabilities"
+  | "clientInfo"
   | "onStderr"
   | "resumeMethod"
   | "transformSessionUpdate"
@@ -38,7 +39,7 @@ export interface AntigravityAcpRuntimeInput extends Omit<
 > {
   readonly childProcessSpawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
   readonly onAuthorizationUrl?: (url: string) => Effect.Effect<void, EffectAcpErrors.AcpError>;
-  readonly clientFileSystem?: boolean;
+  readonly clientFileReads?: boolean;
   readonly authMethod?: AntigravityAuthMethod;
 }
 
@@ -56,11 +57,11 @@ export const makeAntigravityAcpRuntime = Effect.fn("makeAntigravityAcpRuntime")(
       authenticateEagerly: true,
       resumeMethod: "resume",
       cancelBehavior: "wait-for-prompt",
+      // The agent offers non-Gemini models only to allowlisted clients such as Zed.
+      clientInfo: { name: "zed", version: "0.0.0" },
       clientCapabilities: {
-        fs: {
-          readTextFile: input.clientFileSystem === true,
-          writeTextFile: input.clientFileSystem === true,
-        },
+        // Advertising writes swaps the agent's diff edits for whole-file client_edit_file.
+        fs: { readTextFile: input.clientFileReads === true, writeTextFile: false },
         terminal: false,
       },
       transformStdout: makeAntigravityStdoutTransform(
@@ -91,7 +92,7 @@ export function antigravityPermissionMode(runtimeMode: RuntimeMode): string {
   }
 }
 
-function antigravityModelOptions(
+export function antigravityModelOptions(
   configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>,
 ) {
   const model = configOptions.find((option) => option.id === "model");
@@ -99,6 +100,28 @@ function antigravityModelOptions(
   return model.options.flatMap((entry) => ("value" in entry ? [entry] : entry.options));
 }
 
+/** Runtime 1.4 reports thinking as its own option; 1.3 encoded it in the model ID. */
+export function antigravityThinkingConfig(
+  configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption> | null | undefined,
+) {
+  const option = configOptions?.find((candidate) => candidate.category === "thought_level");
+  return option?.type === "select" ? option : undefined;
+}
+
+/**
+ * Runtime 1.4 lists `gemini-3.8-flash` where 1.3 listed `gemini-3.8-flash-high`. The agent
+ * still accepts the old IDs, so pass them through; the current model may have no thinking option.
+ */
+function legacyAntigravityFamily(
+  configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>,
+  model: string,
+) {
+  return antigravityModelOptions(configOptions)
+    .map((option) => option.value)
+    .filter((family) => model.startsWith(`${family}-`))
+    .toSorted((left, right) => right.length - left.length)[0];
+}
+
 function resolveAntigravityModel(input: {
   readonly configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>;
   readonly model: string | null | undefined;
@@ -108,7 +131,9 @@ function resolveAntigravityModel(input: {
   const current = modelConfig?.type === "select" ? modelConfig.currentValue : undefined;
   if (input.model && input.model !== ANTIGRAVITY_DEFAULT_MODEL) return input.model;
   const options = antigravityModelOptions(input.configOptions);
-  return input.defaultModel && options.some((option) => option.value === input.defaultModel)
+  return input.defaultModel &&
+    (options.some((option) => option.value === input.defaultModel) ||
+      legacyAntigravityFamily(input.configOptions, input.defaultModel) !== undefined)
     ? input.defaultModel
     : current;
 }
@@ -118,7 +143,7 @@ export const applyAntigravityAcpModelSelection = Effect.fn("applyAntigravityAcpM
   function* <E>(input: {
     readonly runtime: Pick<
       AcpSessionRuntime.AcpSessionRuntime["Service"],
-      "getConfigOptions" | "setModel"
+      "getConfigOptions" | "setModel" | "setConfigOption"
     >;
     readonly model: string | null | undefined;
     readonly defaultModel?: string | undefined;
@@ -135,6 +160,15 @@ export const applyAntigravityAcpModelSelection = Effect.fn("applyAntigravityAcpM
     const explicit = Boolean(input.model) && input.model !== ANTIGRAVITY_DEFAULT_MODEL;
     if (resolved === undefined || (!explicit && resolved === current)) return current;
     const options = antigravityModelOptions(configOptions);
+    const legacyFamily = options.some((option) => option.value === resolved)
+      ? undefined
+      : legacyAntigravityFamily(configOptions, resolved);
+    if (legacyFamily !== undefined) {
+      yield* input.runtime
+        .setConfigOption("model", resolved, { allowUnlistedValue: true })
+        .pipe(Effect.mapError(input.mapError));
+      return legacyFamily;
+    }
     if (!options.some((option) => option.value === resolved)) {
       return yield* Effect.fail(
         input.mapError(
diff --git a/apps/server/src/provider/acp/AntigravityClientFiles.ts b/apps/server/src/provider/acp/AntigravityClientFiles.ts
index 4efbc28a80ce2..c6079234d916c 100644
--- a/apps/server/src/provider/acp/AntigravityClientFiles.ts
+++ b/apps/server/src/provider/acp/AntigravityClientFiles.ts
@@ -5,7 +5,6 @@ import type * as Path from "effect/Path";
 import * as EffectAcpErrors from "effect-acp/errors";
 import type * as EffectAcpSchema from "effect-acp/compat";
 
-/** The agent requests permission for every write; check only path containment here. */
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 
 function isInsideRoot(path: Path.Path, root: string, candidate: string): boolean {
@@ -98,21 +97,3 @@ export const readAntigravityClientTextFile = Effect.fn("AntigravityClientFiles.r
     return { content: lines.slice(start, end).join("\n") };
   },
 );
-
-export const writeAntigravityClientTextFile = Effect.fn("AntigravityClientFiles.writeTextFile")(
-  function* (input: {
-    readonly fileSystem: FileSystem.FileSystem;
-    readonly path: Path.Path;
-    readonly allowedRoots: ReadonlyArray<string>;
-    readonly request: EffectAcpSchema.WriteTextFileRequest;
-  }): Effect.fn.Return<EffectAcpSchema.WriteTextFileResponse, EffectAcpErrors.AcpError> {
-    const filePath = yield* resolveClientFilePath({ ...input, requestPath: input.request.path });
-    yield* input.fileSystem.makeDirectory(input.path.dirname(filePath), { recursive: true }).pipe(
-      Effect.andThen(input.fileSystem.writeFileString(filePath, input.request.content)),
-      Effect.mapError(() =>
-        EffectAcpErrors.AcpRequestError.internalError(`Could not write '${input.request.path}'.`),
-      ),
-    );
-    return {};
-  },
-);
diff --git a/apps/server/src/provider/acp/AntigravityProtocol.test.ts b/apps/server/src/provider/acp/AntigravityProtocol.test.ts
index 192c8b43ffb14..909de58cb7557 100644
--- a/apps/server/src/provider/acp/AntigravityProtocol.test.ts
+++ b/apps/server/src/provider/acp/AntigravityProtocol.test.ts
@@ -13,6 +13,7 @@ import {
   normalizeAntigravitySessionUpdate,
   normalizeAntigravityToolCall,
   sanitizeAntigravityToolPayload,
+  makeAntigravityReadRepair,
 } from "./AntigravityProtocol.ts";
 import {
   mergeToolCallState,
@@ -24,7 +25,12 @@ const isSessionNotification = Schema.is(AcpWireSchema.SessionNotification);
 describe("native Antigravity subagent tools", () => {
   it("recognizes only native invocation titles and excludes MCP tools", () => {
     const toolCall = { toolCallId: "trajectory:4", kind: "other", data: {} };
-    for (const title of ["Running start_subagent", "Run start_subagent?"]) {
+    for (const title of [
+      "Running start_subagent",
+      "Run start_subagent?",
+      "Running invoke_subagent",
+      "Run invoke_subagent?",
+    ]) {
       expect(classifyAntigravitySubagentToolCall({ ...toolCall, title }, {})).toBe("subagent");
       expect(
         classifyAntigravitySubagentToolCall(
@@ -408,3 +414,82 @@ describe("Antigravity tool results", () => {
     expect(serialized).not.toContain("inline-data-url");
   });
 });
+
+describe("Antigravity served reads", () => {
+  const flush = (reads: ReturnType<typeof makeAntigravityReadRepair>, toolCallId: string) =>
+    reads.repair({
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "tool_call_update",
+        toolCallId,
+        status: "failed",
+        rawOutput: "Tool execution failed",
+      },
+    }).update;
+
+  it("credits a read T3 served before the agent announced it", () => {
+    const reads = makeAntigravityReadRepair();
+    reads.attempted("/repo/a.ts", true);
+    const announced = reads.repair({
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "tool_call",
+        toolCallId: "call_late",
+        title: "Running client_view_file",
+        kind: "read",
+        status: "in_progress",
+        locations: [{ path: "/repo/a.ts" }],
+      },
+    });
+    expect(announced.update).toMatchObject({ status: "completed" });
+    expect(flush(reads, "call_late")).toEqual({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "call_late",
+      status: "completed",
+    });
+  });
+
+  it("forgets an earlier turn's unannounced served read", () => {
+    const reads = makeAntigravityReadRepair();
+    reads.attempted("/repo/a.ts", true);
+    reads.reset();
+    reads.repair({
+      sessionId: "session-1",
+      update: {
+        sessionUpdate: "tool_call",
+        toolCallId: "call_refused",
+        title: "Running client_view_file",
+        kind: "read",
+        status: "in_progress",
+        locations: [{ path: "/repo/a.ts" }],
+      },
+    });
+    reads.attempted("/repo/a.ts", false);
+    expect(flush(reads, "call_refused")).toMatchObject({ status: "failed" });
+  });
+
+  it("drops an earlier turn's unanswered read so a new turn's served read gets the credit", () => {
+    const reads = makeAntigravityReadRepair();
+    const announce = (toolCallId: string) =>
+      reads.repair({
+        sessionId: "session-1",
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: "Running client_view_file",
+          kind: "read",
+          status: "in_progress",
+          locations: [{ path: "/repo/a.ts" }],
+        },
+      });
+    announce("call_abandoned");
+    reads.reset();
+    announce("call_current");
+    reads.attempted("/repo/a.ts", true);
+    expect(flush(reads, "call_current")).toEqual({
+      sessionUpdate: "tool_call_update",
+      toolCallId: "call_current",
+      status: "completed",
+    });
+  });
+});
diff --git a/apps/server/src/provider/acp/AntigravityProtocol.ts b/apps/server/src/provider/acp/AntigravityProtocol.ts
index 7e2f24a31d3b9..a91d45164caaf 100644
--- a/apps/server/src/provider/acp/AntigravityProtocol.ts
+++ b/apps/server/src/provider/acp/AntigravityProtocol.ts
@@ -216,6 +216,87 @@ export function sanitizeAntigravityToolPayload(payload: unknown): unknown {
 }
 const isJsonRecord = Schema.is(Schema.Record(Schema.String, Schema.Json));
 
+const ANTIGRAVITY_CLIENT_READ_TITLES = new Set([
+  "Running client_view_file",
+  "Run client_view_file?",
+]);
+
+function antigravityClientReadPath(update: {
+  readonly title?: string | null;
+  readonly locations?: ReadonlyArray<{ readonly path: string }> | null;
+  readonly rawInput?: unknown;
+}): string | undefined {
+  if (!update.title || !ANTIGRAVITY_CLIENT_READ_TITLES.has(update.title)) return undefined;
+  const target =
+    update.locations?.[0]?.path ??
+    (Predicate.isObject(update.rawInput) ? update.rawInput.absolute_path : undefined);
+  return typeof target === "string" && target ? target : undefined;
+}
+
+/**
+ * The agent never completes a subagent's `client_view_file` call, then fails every open call
+ * with the next unrelated step error. Report reads T3 served as completed instead.
+ */
+export function makeAntigravityReadRepair() {
+  type Outcome = "served" | "refused";
+  const openReads = new Map<
+    string,
+    { readonly path: string; readonly sessionId: string; outcome?: Outcome }
+  >();
+  // The agent runs a client tool in a background task, so its request can precede the announcement.
+  const earlyOutcomes: Array<{ readonly path: string; readonly outcome: Outcome }> = [];
+  return {
+    /** Earlier turns' rows are already settled, and their unanswered reads must not take credit. */
+    reset: () => {
+      openReads.clear();
+      earlyOutcomes.length = 0;
+    },
+    /**
+     * Each `fs/read_text_file` request answers the oldest open read of its path, in order.
+     * Returns the call a served read completes, so T3 can report it without waiting.
+     */
+    attempted: (path: string, served: boolean) => {
+      const outcome = served ? "served" : "refused";
+      for (const [toolCallId, read] of openReads) {
+        if (read.path !== path || read.outcome !== undefined) continue;
+        read.outcome = outcome;
+        return served ? { sessionId: read.sessionId, toolCallId } : undefined;
+      }
+      earlyOutcomes.push({ path, outcome });
+      return undefined;
+    },
+    repair: (
+      notification: EffectAcpSchema.SessionNotification,
+    ): EffectAcpSchema.SessionNotification => {
+      const update = notification.update;
+      if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
+        return notification;
+      }
+      const path = antigravityClientReadPath(update);
+      if (path !== undefined && !openReads.has(update.toolCallId)) {
+        const early = earlyOutcomes.findIndex((entry) => entry.path === path);
+        const outcome = early === -1 ? undefined : earlyOutcomes.splice(early, 1)[0]?.outcome;
+        const sessionId = notification.sessionId;
+        openReads.set(
+          update.toolCallId,
+          outcome === undefined ? { path, sessionId } : { path, sessionId, outcome },
+        );
+      }
+      const read = openReads.get(update.toolCallId);
+      if (update.status === "pending" || update.status === "in_progress") {
+        return read?.outcome === "served"
+          ? { ...notification, update: { ...update, status: "completed" } }
+          : notification;
+      }
+      if (update.status !== "completed" && update.status !== "failed") return notification;
+      openReads.delete(update.toolCallId);
+      if (update.status === "completed" || read?.outcome !== "served") return notification;
+      const { rawOutput: _stepError, ...rest } = update;
+      return { ...notification, update: { ...rest, status: "completed" } };
+    },
+  };
+}
+
 export function normalizeAntigravitySessionUpdate(
   notification: EffectAcpSchema.SessionNotification,
 ): EffectAcpSchema.SessionNotification {
@@ -324,14 +405,22 @@ export function normalizeAntigravityToolCall(toolCall: AcpToolCallState): AcpToo
   };
 }
 
-/** ACP 1.1.1 reports subagent calls as ordinary tools without child IDs or models. */
+const ANTIGRAVITY_SUBAGENT_TITLES = new Set([
+  "Running start_subagent",
+  "Run start_subagent?",
+  "Running invoke_subagent",
+  "Run invoke_subagent?",
+]);
+
+/** The ACP agent reports subagent calls as ordinary tools without child IDs or models. */
 export function classifyAntigravitySubagentToolCall(
   toolCall: AcpToolCallState,
   rawPayload?: unknown,
 ): "subagent" | "mcp" | undefined {
   if (
     (toolCall.kind !== undefined && toolCall.kind !== "other") ||
-    (toolCall.title !== "Running start_subagent" && toolCall.title !== "Run start_subagent?")
+    toolCall.title === undefined ||
+    !ANTIGRAVITY_SUBAGENT_TITLES.has(toolCall.title)
   )
     return undefined;
   const update = Predicate.isObject(rawPayload) ? rawPayload.update : undefined;
diff --git a/apps/server/src/provider/antigravityRelease.ts b/apps/server/src/provider/antigravityRelease.ts
index f00185865b05a..17173760d5e3d 100644
--- a/apps/server/src/provider/antigravityRelease.ts
+++ b/apps/server/src/provider/antigravityRelease.ts
@@ -1,4 +1,5 @@
-const ANTIGRAVITY_RELEASE_VERSION = "1.3.0";
+// 1.4.2 through 1.4.4 write skills/system/run-workflow/SKILL.md into every session workspace.
+const ANTIGRAVITY_RELEASE_VERSION = "1.4.1";
 
 export interface AntigravityReleaseAsset {
   readonly version: string;
@@ -20,66 +21,66 @@ const releaseAssets = new Map<string, AntigravityReleaseAsset>([
     "darwin-arm64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.3.0-darwin-arm64.zip",
-      sha256: "7cd97045f7b4fe81175a107cdf16f9c51484e3c78a5162cae415338bb6aa5b88",
-      archiveBytes: 111_456_962,
-      executable: { name: "agy_acp_server.par", bytes: 278_535_456 },
-      harness: { name: "localharness_external", bytes: 118_611_392 },
+      url: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.4.1-darwin-arm64.zip",
+      sha256: "f9bdd68291ae78c38d2141e63bc86b84e6cc7b9f60f71652c68435a7943deb17",
+      archiveBytes: 112_737_434,
+      executable: { name: "agy_acp_server.par", bytes: 280_996_576 },
+      harness: { name: "localharness_external", bytes: 120_246_928 },
     },
   ],
   [
     "darwin-x64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.3.0-darwin-x86_64.zip",
-      sha256: "bb23956b89984bf5d354af2c3725e6c57f0cc1b7228e77a0e91c9c2bc1d47646",
-      archiveBytes: 117_245_544,
-      executable: { name: "agy_acp_server.par", bytes: 282_840_688 },
-      harness: { name: "localharness_external", bytes: 124_175_392 },
+      url: "https://dl.google.com/agy-extensions/releases/macos/agy-acp-server-1.4.1-darwin-x86_64.zip",
+      sha256: "27e31f096874704f14167b07ef9e84cc77134615ee41d024f7b1c957add85307",
+      archiveBytes: 118_349_036,
+      executable: { name: "agy_acp_server.par", bytes: 285_186_624 },
+      harness: { name: "localharness_external", bytes: 124_910_048 },
     },
   ],
   [
     "linux-x64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.3.0-linux-x86_64.zip",
-      sha256: "9fb60956af0a9d76220a4db91ca9ac88e2a2372ad68f985ab5fceace6b825b96",
-      archiveBytes: 333_727_150,
-      executable: { name: "agy_acp_server.par", bytes: 926_533_965 },
-      harness: { name: "localharness_external", bytes: 130_388_040 },
+      url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.4.1-linux-x86_64.zip",
+      sha256: "2e37012ceb2a5c7fc7309b6e6596234fb637ee3c62a5199f65d4cbe777871384",
+      archiveBytes: 336_170_339,
+      executable: { name: "agy_acp_server.par", bytes: 930_826_753 },
+      harness: { name: "localharness_external", bytes: 131_187_512 },
     },
   ],
   [
     "linux-arm64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.3.0-linux-arm64.zip",
-      sha256: "500b0bc0fb858e88f4df404d4cedf80bf9298c178291e39e383d6c50b111cbdf",
-      archiveBytes: 321_690_363,
-      executable: { name: "agy_acp_server.par", bytes: 930_848_992 },
-      harness: { name: "localharness_external", bytes: 123_224_968 },
+      url: "https://dl.google.com/agy-extensions/releases/linux/agy-acp-server-1.4.1-linux-arm64.zip",
+      sha256: "609336a1c97545487e3ddd55dbd153dc0f40f4e6534486cc1c5f4c0ebb85c2da",
+      archiveBytes: 321_922_507,
+      executable: { name: "agy_acp_server.par", bytes: 933_416_796 },
+      harness: { name: "localharness_external", bytes: 124_895_000 },
     },
   ],
   [
     "win32-x64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.3.0-windows-x86_64.zip",
-      sha256: "65215e0688681fa3116e048a9eab27ef53af1bbd6f3da3f1c52bd4911d8b17f9",
-      archiveBytes: 124_509_787,
-      executable: { name: "agy_acp_server.exe", bytes: 81_437_336 },
-      harness: { name: "localharness_external.exe", bytes: 145_548_952 },
+      url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.4.1-windows-x86_64.zip",
+      sha256: "5f5b7d0328df17c128b2be338d4567b0d24e56ace8196e88794fec37d1372554",
+      archiveBytes: 129_599_308,
+      executable: { name: "agy_acp_server.exe", bytes: 86_098_784 },
+      harness: { name: "localharness_external.exe", bytes: 146_036_888 },
     },
   ],
   [
     "win32-arm64",
     {
       version: ANTIGRAVITY_RELEASE_VERSION,
-      url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.3.0-windows-arm64.zip",
-      sha256: "4a0f469720e9beb9438a979f543fdbfad5022ebe0992c052c590bd78b3144ca3",
-      archiveBytes: 124_654_803,
-      executable: { name: "agy_acp_server.exe", bytes: 85_893_472 },
-      harness: { name: "localharness_external.exe", bytes: 135_640_216 },
+      url: "https://dl.google.com/agy-extensions/releases/windows/agy-acp-server-1.4.1-windows-arm64.zip",
+      sha256: "24c52bbc12aae20f55eb53d373669412d95a9c44fd59be4ea4e355918b91fbf7",
+      archiveBytes: 132_507_344,
+      executable: { name: "agy_acp_server.exe", bytes: 93_197_744 },
+      harness: { name: "localharness_external.exe", bytes: 136_970_904 },
     },
   ],
 ]);
diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json
index b42932fcc6668..87ed61776ea9c 100644
--- a/apps/server/src/provider/model-manifest.json
+++ b/apps/server/src/provider/model-manifest.json
@@ -75,8 +75,12 @@
     {
       "driver": "antigravity",
       "t3CodeRange": ">=0.0.42",
-      "recommendedRange": "=1.1.1",
-      "ranges": [{ "range": "=1.1.1", "status": "supported" }]
+      "recommendedRange": "=1.4.1",
+      "ranges": [
+        { "range": "=1.4.1", "status": "supported" },
+        { "range": "=1.3.0", "status": "supported" },
+        { "range": "=1.1.1", "status": "supported" }
+      ]
     },
     {
       "driver": "pi",
diff --git a/apps/server/src/provider/providerCompatibility.test.ts b/apps/server/src/provider/providerCompatibility.test.ts
index e3d4f672016c0..12c541fbd776d 100644
--- a/apps/server/src/provider/providerCompatibility.test.ts
+++ b/apps/server/src/provider/providerCompatibility.test.ts
@@ -21,7 +21,12 @@ import {
   ProviderCompatibilityPolicy,
   resolveProviderCompatibility,
 } from "./providerCompatibility.ts";
+import { resolveAntigravityReleaseAsset } from "./antigravityRelease.ts";
+import bundledManifest from "./model-manifest.json" with { type: "json" };
 
+const decodeCompatibilityPolicies = Schema.decodeUnknownSync(
+  Schema.Array(ProviderCompatibilityPolicy),
+);
 const driver = ProviderDriverKind.make("codex");
 const policy: ProviderCompatibilityPolicy = {
   driver,
@@ -127,6 +132,19 @@ describe("provider compatibility", () => {
     }
   });
 
+  it("supports the managed Antigravity runtime in the bundled manifest", () => {
+    const policies = decodeCompatibilityPolicies(bundledManifest.compatibility);
+    const release = resolveAntigravityReleaseAsset("darwin", "arm64");
+    assert.strictEqual(
+      resolveProviderCompatibility(
+        policies,
+        ProviderDriverKind.make("antigravity"),
+        `agy_acp_server_${release?.version}`,
+      )?.status,
+      "supported",
+    );
+  });
+
   it("classifies boundaries and treats unlisted versions and release tags as unknown", () => {
     for (const [version, expected] of [
       ["0.9.9", "broken"],
diff --git a/apps/server/src/pullRequest/PullRequestService.test.ts b/apps/server/src/pullRequest/PullRequestService.test.ts
index 4b2d67738c20c..6c6c8215aa315 100644
--- a/apps/server/src/pullRequest/PullRequestService.test.ts
+++ b/apps/server/src/pullRequest/PullRequestService.test.ts
@@ -116,6 +116,65 @@ function hostedChangeRequest(body: string, additions = 1) {
   };
 }
 
+it.effect("reads maintainer edits and changes them through the update command", () =>
+  Effect.gen(function* () {
+    let enabled = true;
+    const provider = fakePullRequestProvider(SourceControlProviderKind.make("github"), {
+      getChangeRequest: () =>
+        Effect.succeed({ ...hostedChangeRequest("Body"), maintainerCanModify: enabled }),
+      updateChangeRequest: (input) =>
+        Effect.sync(() => {
+          assert.strictEqual(input.title, undefined);
+          assert.strictEqual(input.body, undefined);
+          enabled = input.maintainerCanModify!;
+        }),
+    });
+    const service = yield* makeService({
+      projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
+      providers: [
+        {
+          ...provider,
+          capabilities: {
+            ...provider.capabilities,
+            edit: { changeRequest: true, comment: true, maintainerEdits: true },
+          },
+        },
+      ],
+    });
+    const ref = { projectId: "p1" as ProjectId, repository: "acme/web", number: 1 };
+    assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, true);
+    yield* service.update({ ...ref, maintainerCanModify: false });
+    assert.strictEqual((yield* service.detail(ref)).maintainerCanModify, false);
+  }),
+);
+
+it.effect("refuses maintainer edits on a host without the capability", () =>
+  Effect.gen(function* () {
+    let writes = 0;
+    const service = yield* makeService({
+      projects: [project({ id: "p1", title: "web", workspaceRoot: "/w", repository: "acme/web" })],
+      providers: [
+        fakePullRequestProvider(SourceControlProviderKind.make("github"), {
+          updateChangeRequest: () =>
+            Effect.sync(() => {
+              writes += 1;
+            }),
+        }),
+      ],
+    });
+    const result = yield* service
+      .update({
+        projectId: "p1" as ProjectId,
+        repository: "acme/web",
+        number: 1,
+        maintainerCanModify: false,
+      })
+      .pipe(Effect.flip);
+    assert.strictEqual(result._tag, "PullRequestOperationError");
+    assert.strictEqual(writes, 0);
+  }),
+);
+
 it.effect("does not wait for an in-flight detail read to display a preview", () =>
   Effect.gen(function* () {
     const detailStarted = yield* Deferred.make<void>();
diff --git a/apps/server/src/pullRequest/PullRequestService.ts b/apps/server/src/pullRequest/PullRequestService.ts
index 5ee9b6274408a..854d182f155ec 100644
--- a/apps/server/src/pullRequest/PullRequestService.ts
+++ b/apps/server/src/pullRequest/PullRequestService.ts
@@ -1753,6 +1753,9 @@ export const make = Effect.gen(function* () {
             ...(changeRequest.autoMergeMethod === undefined
               ? {}
               : { autoMergeMethod: changeRequest.autoMergeMethod }),
+            ...(changeRequest.maintainerCanModify === undefined
+              ? {}
+              : { maintainerCanModify: changeRequest.maintainerCanModify }),
             ...(changeRequest.workflowApprovalsRequired === undefined
               ? {}
               : { workflowApprovalsRequired: changeRequest.workflowApprovalsRequired }),
@@ -2138,7 +2141,22 @@ export const make = Effect.gen(function* () {
             }),
           );
         }
-        if (input.title === undefined && input.body === undefined) {
+        if (
+          input.maintainerCanModify !== undefined &&
+          project.api.capabilities.edit?.maintainerEdits !== true
+        ) {
+          return Effect.fail(
+            new PullRequestOperationError({
+              operation: "update",
+              detail: "This host does not support maintainer edits.",
+            }),
+          );
+        }
+        if (
+          input.title === undefined &&
+          input.body === undefined &&
+          input.maintainerCanModify === undefined
+        ) {
           return Effect.fail(
             new PullRequestOperationError({
               operation: "update",
@@ -2151,6 +2169,9 @@ export const make = Effect.gen(function* () {
           repository: project.repository,
           host: project.host,
           number: input.number,
+          ...(input.maintainerCanModify === undefined
+            ? {}
+            : { maintainerCanModify: input.maintainerCanModify }),
           ...(input.title === undefined ? {} : { title: input.title }),
           ...(input.body === undefined ? {} : { body: input.body }),
         }).pipe(Effect.mapError(toPullRequestError("update")));
diff --git a/apps/server/src/resourceTelemetry/DesktopTelemetryReceiver.ts b/apps/server/src/resourceTelemetry/DesktopTelemetryReceiver.ts
index 770359b3e9307..70dc2e8d750ef 100644
--- a/apps/server/src/resourceTelemetry/DesktopTelemetryReceiver.ts
+++ b/apps/server/src/resourceTelemetry/DesktopTelemetryReceiver.ts
@@ -8,6 +8,7 @@ import {
   type DesktopHostTelemetryMessage as DesktopHostTelemetryMessageValue,
   type DesktopHostTelemetrySnapshot,
   DesktopTelemetryControlMessage,
+  type DesktopUpdateChannel,
   type DesktopUpdateStatusReport,
   type ResourceTelemetrySourceStatus,
 } from "@t3tools/contracts";
@@ -149,6 +150,12 @@ export interface DesktopTelemetryReceiverHealth {
   readonly lastError: Option.Option<string>;
 }
 
+/** Moves the desktop app to `channel` and installs only `targetVersion`. */
+export interface DesktopTrackSwitch {
+  readonly channel: DesktopUpdateChannel;
+  readonly targetVersion: string;
+}
+
 export class DesktopTelemetryReceiver extends Context.Service<
   DesktopTelemetryReceiver,
   {
@@ -176,6 +183,7 @@ export class DesktopTelemetryReceiver extends Context.Service<
     ) => Effect.Effect<void, DesktopTelemetryControlError>;
     readonly requestDesktopUpdate: (
       requestId: string,
+      trackSwitch?: DesktopTrackSwitch,
     ) => Effect.Effect<void, DesktopTelemetryControlError>;
     readonly commitDesktopUpdate: (
       requestId: string,
@@ -633,11 +641,12 @@ export const make = Effect.fn("resourceTelemetry.desktopTelemetryReceiver.make")
     subscribeHealth: subscribeBeforeSnapshotWithoutMutex(healthChanges, Ref.get(health)),
     setDiagnosticsDemand,
     requestDesktopUpdate: Effect.fn("DesktopTelemetryReceiver.requestDesktopUpdate")(
-      function (requestId) {
+      function (requestId, trackSwitch) {
         return sendControlMessage({
           version: 1,
           type: "requestDesktopUpdate",
           requestId,
+          ...trackSwitch,
         });
       },
     ),
diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts
index c1dcdd22abbae..82d165972750f 100644
--- a/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts
+++ b/apps/server/src/scheduledTasks/ScheduledTaskService.test.ts
@@ -402,3 +402,77 @@ it.effect("thread cleanup notifies subscribers and a finishing run cannot recrea
     }).pipe(Effect.provide(layer));
   }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
 );
+
+it.effect("a bound run follows its thread when promotion moves it mid-send", () =>
+  Effect.gen(function* () {
+    const scratch = ProjectId.make("project:scratch");
+    const promoted = ProjectId.make("project:promoted");
+    const sends = yield* Ref.make<Array<{ projectId: ProjectId; commandId: string }>>([]);
+    // Rebind lands first, then the promotion commits between the shell read and the retry.
+    const shellProjects = yield* Ref.make([scratch, promoted]);
+    const layer = ScheduledTaskService.layer.pipe(
+      Layer.provide(
+        Layer.mergeAll(
+          Layer.mock(ThreadLaunchService.ThreadLaunchService)({}),
+          Layer.mock(ThreadManagementService.ThreadManagementService)({
+            sendToThread: (input) =>
+              Ref.updateAndGet(sends, (all) => [
+                ...all,
+                { projectId: input.projectId, commandId: input.commandId },
+              ]).pipe(
+                Effect.flatMap((all) =>
+                  all.length < 3
+                    ? Effect.fail(
+                        new ThreadManagementService.ThreadManagementThreadNotFoundError({
+                          projectId: input.projectId,
+                          threadId: input.threadId,
+                        }),
+                      )
+                    : Effect.succeed({} as never),
+                ),
+              ),
+            getThreadShell: () =>
+              Ref.modify(shellProjects, ([next, ...rest]) => [
+                { projectId: next ?? promoted } as never,
+                rest,
+              ]),
+          }),
+          Layer.mock(SecretRequests.SecretRequests)({}),
+          Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
+            namedProjectsRoot: "/projects",
+            isScratchProject: () => Effect.succeed(false),
+          }),
+          NodeCrypto.layer,
+          Scheduler.layer,
+        ),
+      ),
+    );
+    yield* Effect.gen(function* () {
+      const service = yield* ScheduledTaskService.ScheduledTaskService;
+      const threadId = ThreadId.make("thread:promoted-during-run");
+      const { task } = yield* service.upsert({
+        id: ScheduledTaskId.make("task:promoted-during-run"),
+        title: "Check in",
+        prompt: "Check progress",
+        enabled: true,
+        schedule: { type: "interval", everyMs: 60_000 },
+        projectId: promoted,
+        threadId,
+        workspaceStrategy: { type: "root" },
+        modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
+        runtimeMode: "full-access",
+        interactionMode: "default",
+      });
+
+      const result = yield* service.runNow({ id: task.id });
+
+      assert.equal(result.threadId, threadId);
+      const attempts = yield* Ref.get(sends);
+      assert.deepEqual(
+        attempts.map((attempt) => attempt.projectId),
+        [promoted, scratch, promoted],
+      );
+      assert.equal(new Set(attempts.map((attempt) => attempt.commandId)).size, 1);
+    }).pipe(Effect.provide(layer));
+  }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
+);
diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.ts
index 3dfedb0dfeaf4..b3aa9440944bd 100644
--- a/apps/server/src/scheduledTasks/ScheduledTaskService.ts
+++ b/apps/server/src/scheduledTasks/ScheduledTaskService.ts
@@ -2,6 +2,7 @@ import {
   CommandId,
   MessageId,
   PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
+  type ProjectId,
   ScheduledTask,
   ScheduledTaskError,
   ScheduledTaskId,
@@ -240,6 +241,11 @@ export class ScheduledTaskService extends Context.Service<
     ) => Effect.Effect<ScheduledTaskDeleteResult, ScheduledTaskError>;
     /** Deletes only tasks that still target this thread, including their webhook deliveries. */
     readonly deleteForThread: (threadId: ThreadId) => Effect.Effect<void, ScheduledTaskError>;
+    /** Points tasks bound to these threads at the project the threads moved to. */
+    readonly moveThreadTasks: (input: {
+      readonly threadIds: ReadonlyArray<ThreadId>;
+      readonly projectId: ProjectId;
+    }) => Effect.Effect<void, ScheduledTaskError>;
     /** The dispatched thread, or null if dispatch failed; leaves the task's binding unchanged. */
     readonly runNow: (
       input: ScheduledTaskRunNowInput,
@@ -808,6 +814,42 @@ export const layer = Layer.effect(
         // A webhook prompt was rendered from the row when the request arrived.
         const prompt = webhook?.prompt ?? active.prompt;
 
+        // A bound thread can move to another project (No project to a project) while
+        // this fires. Follow it; one move needs at most two retries. Same ids replay safely.
+        const sendBound = (
+          threadId: ThreadId,
+          projectId: ProjectId,
+          retries: number,
+        ): ReturnType<typeof threadManagement.sendToThread> =>
+          threadManagement
+            .sendToThread({
+              projectId,
+              commandId,
+              threadId,
+              messageId,
+              scheduledTaskId: active.id,
+              text: prompt,
+              attachments: [],
+              mode: "queue",
+              createdBy: active.createdBy,
+              creationSource: active.creationSource,
+            })
+            .pipe(
+              Effect.catchTags({
+                ThreadManagementThreadNotFoundError: (error) =>
+                  retries === 0
+                    ? Effect.fail(error)
+                    : threadManagement.getThreadShell(threadId).pipe(
+                        Effect.orElseSucceed(() => null),
+                        Effect.flatMap((shell) =>
+                          shell === null || shell.projectId === projectId
+                            ? Effect.fail(error)
+                            : sendBound(threadId, shell.projectId, retries - 1),
+                        ),
+                      ),
+              }),
+            );
+
         // Capture defects and interrupts too so dispatch failures still reach markCompleted.
         const result =
           active.threadId === null
@@ -835,20 +877,9 @@ export const layer = Layer.effect(
             : yield* Effect.exit(
                 // The stored selection only seeds fresh threads. A bound run
                 // follows the thread's current provider, so it passes none.
-                threadManagement
-                  .sendToThread({
-                    projectId: active.projectId,
-                    commandId,
-                    threadId: ThreadId.make(active.threadId),
-                    messageId,
-                    scheduledTaskId: active.id,
-                    text: prompt,
-                    attachments: [],
-                    mode: "queue",
-                    createdBy: active.createdBy,
-                    creationSource: active.creationSource,
-                  })
-                  .pipe(Effect.as(ThreadId.make(active.threadId))),
+                sendBound(ThreadId.make(active.threadId), active.projectId, 2).pipe(
+                  Effect.as(ThreadId.make(active.threadId)),
+                ),
               );
 
         const runSucceeded = result._tag === "Success";
@@ -1262,6 +1293,22 @@ export const layer = Layer.effect(
       if (removed.length > 0) yield* notifyChanged;
     });
 
+    const moveThreadTasks: ScheduledTaskService["Service"]["moveThreadTasks"] = Effect.fn(
+      "ScheduledTaskService.moveThreadTasks",
+    )(function* (input) {
+      if (input.threadIds.length === 0) return;
+      const moved = yield* sql<{ task_id: ScheduledTaskId }>`
+        UPDATE scheduled_tasks SET project_id = ${input.projectId}
+        WHERE project_id != ${input.projectId} AND thread_id IN ${sql.in(input.threadIds)}
+        RETURNING task_id
+      `.pipe(
+        Effect.mapError((cause) =>
+          taskError("Could not move the thread's schedule tasks.", { cause }),
+        ),
+      );
+      if (moved.length > 0) yield* notifyChanged;
+    });
+
     const runNow: ScheduledTaskService["Service"]["runNow"] = Effect.fn(
       "ScheduledTaskService.runNow",
     )(function* (input: ScheduledTaskRunNowInput) {
@@ -2138,6 +2185,7 @@ export const layer = Layer.effect(
       setEnabled,
       delete: deleteTask,
       deleteForThread,
+      moveThreadTasks,
       runNow,
       rotateWebhookToken,
       listWebhookDeliveries,
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index 3131c84d880e7..a1e0d34c7dd53 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -435,6 +435,7 @@ const ATOMIC_SETTINGS_KEYS: ReadonlySet<string> = new Set([
   "sourceControlWriterModelSelection",
   "reviewGuideModelSelection",
   "textGenerationModelSelection",
+  "fallbackModelSelection",
   "pullRequestMergeMethod",
 ]);
 
diff --git a/apps/server/src/settingsSecrets.ts b/apps/server/src/settingsSecrets.ts
index b80ccabc03603..dff6b96f52a1b 100644
--- a/apps/server/src/settingsSecrets.ts
+++ b/apps/server/src/settingsSecrets.ts
@@ -4,6 +4,7 @@ import {
   CodexSettings,
   EasDeviceHostConfig,
   type ServerSettings,
+  SimlockDeviceHostConfig,
   UsageLimitSourceConfig,
   secretSettingsFields,
 } from "@t3tools/contracts";
@@ -33,6 +34,7 @@ const providerSecretFields = new Map([
 ]);
 const usageLimitSecretFields = secretSettingsFields(UsageLimitSourceConfig);
 const easDeviceHostSecretFields = secretSettingsFields(EasDeviceHostConfig);
+const simlockDeviceHostSecretFields = secretSettingsFields(SimlockDeviceHostConfig);
 const encode = (value: string) => Buffer.from(value, "utf8").toString("base64url");
 
 export interface SettingsSecret {
@@ -155,5 +157,24 @@ export function mapSettingsSecrets(
       ) as EasDeviceHostConfig,
   );
 
-  return { ...settings, providerInstances, sourceControlHosts, usageLimitSources, easDeviceHosts };
+  // Its own prefix: an EAS and a Simlock host may share an id.
+  const simlockDeviceHosts = settings.simlockDeviceHosts.map(
+    (host) =>
+      mapFields(
+        host,
+        simlockDeviceHostSecretFields,
+        (field, serverHost) =>
+          `simlock-device-host-${encode(host.id)}-${encode(field)}` +
+          (serverHost === null ? "" : `-${encode(serverHost)}`),
+      ) as SimlockDeviceHostConfig,
+  );
+
+  return {
+    ...settings,
+    providerInstances,
+    sourceControlHosts,
+    usageLimitSources,
+    easDeviceHosts,
+    simlockDeviceHosts,
+  };
 }
diff --git a/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts b/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts
index 395a24eeedc8d..3fcafcc151789 100644
--- a/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts
+++ b/apps/server/src/textGeneration/AntigravityTextGeneration.test.ts
@@ -170,6 +170,7 @@ const makeFixture = Effect.fn("makeAntigravityTextGenerationFixture")(function*
           Effect.sync(() => {
             state.selectedModels.push(model);
           }),
+        setConfigOption: () => Effect.succeed({ configOptions: [] }),
         prompt: (request) =>
           Effect.gen(function* () {
             state.prompts.push(request);
diff --git a/apps/server/src/textGeneration/AntigravityTextGeneration.ts b/apps/server/src/textGeneration/AntigravityTextGeneration.ts
index 670c2eb28d513..921a2f118e34a 100644
--- a/apps/server/src/textGeneration/AntigravityTextGeneration.ts
+++ b/apps/server/src/textGeneration/AntigravityTextGeneration.ts
@@ -31,6 +31,7 @@ type AntigravityTextRuntime = Pick<
   | "getConfigOptions"
   | "getEvents"
   | "setModel"
+  | "setConfigOption"
   | "prompt"
   | "cancel"
   | "handleSessionUpdate"
diff --git a/apps/server/src/textGeneration/CodexTextGeneration.test.ts b/apps/server/src/textGeneration/CodexTextGeneration.test.ts
index a83e09a4110df..04ae83952b3c4 100644
--- a/apps/server/src/textGeneration/CodexTextGeneration.test.ts
+++ b/apps/server/src/textGeneration/CodexTextGeneration.test.ts
@@ -1,3 +1,13 @@
+import {
+  DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER,
+  ProviderDriverKind,
+  type ModelSelection,
+  type ServerProvider,
+} from "@t3tools/contracts";
+import type { ProviderInstance } from "@t3tools/provider-core/server/driver";
+import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
+import * as ServerSettings from "../serverSettings.ts";
+import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { it } from "@effect/vitest";
 import * as Cause from "effect/Cause";
@@ -433,3 +443,96 @@ it.layer(layerCodexTextGenerationTest)("CodexTextGeneration", (it) => {
     ),
   );
 });
+
+it.effect.each([false, true])("text generation preflight: exhausted=%s", (exhausted) =>
+  Effect.gen(function* () {
+    const primary = ProviderInstanceId.make("codex");
+    const fallback = ProviderInstanceId.make("claude_work");
+    const selection = {
+      instanceId: primary,
+      model: "chat-model",
+      options: [{ id: "effort", value: "high" }],
+    };
+    const calls: ModelSelection[] = [];
+    const instances: ProviderInstance[] = [primary, fallback].map((instanceId) => {
+      const driver = ProviderDriverKind.make(instanceId === primary ? "codex" : "claudeAgent");
+      const snapshot: ServerProvider = {
+        instanceId,
+        driver,
+        enabled: true,
+        installed: true,
+        status: "ready",
+        auth: { status: "authenticated" },
+        version: null,
+        checkedAt: "1970-01-01T00:00:00Z",
+        models: [],
+        slashCommands: [],
+        skills: [],
+        ...(exhausted && instanceId === primary
+          ? {
+              usageLimits: {
+                checkedAt: "1970-01-01T00:00:00Z",
+                windows: [{ id: "session", kind: "session", label: "Session", usedPercent: 100 }],
+              },
+            }
+          : {}),
+      };
+      return {
+        instanceId,
+        driverKind: driver,
+        continuationIdentity: { driverKind: driver, continuationKey: instanceId },
+        displayName: undefined,
+        enabled: true,
+        snapshot: { getSnapshot: Effect.succeed(snapshot) } as ProviderInstance["snapshot"],
+        orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
+        textGeneration: TextGeneration.TextGeneration.of({
+          generateCommitMessage: () => Effect.die("unused"),
+          generatePrContent: () => Effect.die("unused"),
+          generateBranchName: () => Effect.die("unused"),
+          generateReviewGuide: () => Effect.die("unused"),
+          generateThreadTitle: (input) =>
+            Effect.sync(() => {
+              calls.push(input.modelSelection);
+              return { title: "Generated title" };
+            }),
+        }),
+      };
+    });
+    const service = yield* TextGeneration.make.pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
+            listInstances: Effect.succeed(instances),
+            getInstance: (id) =>
+              Effect.succeed(instances.find((instance) => instance.instanceId === id)),
+          }),
+          ServerSettings.layerTest({
+            providerInstances: {
+              [fallback]: { driver: ProviderDriverKind.make("claudeAgent"), config: {} },
+            },
+          }),
+          Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
+            resolveLink: () => Effect.die("unused"),
+          }),
+        ),
+      ),
+    );
+    expect(
+      yield* service.generateThreadTitle({
+        cwd: "/tmp",
+        message: "hello",
+        linkedContext: "",
+        modelSelection: selection,
+      }),
+    ).toEqual({ title: "Generated title" });
+    expect(calls).toEqual([
+      exhausted
+        ? {
+            instanceId: fallback,
+            model:
+              DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[ProviderDriverKind.make("claudeAgent")],
+          }
+        : selection,
+    ]);
+  }),
+);
diff --git a/apps/server/src/textGeneration/TextGeneration.ts b/apps/server/src/textGeneration/TextGeneration.ts
index 96f266c6f8959..fc8d0fb68da31 100644
--- a/apps/server/src/textGeneration/TextGeneration.ts
+++ b/apps/server/src/textGeneration/TextGeneration.ts
@@ -1,7 +1,19 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import type { ProviderInstanceId } from "@t3tools/contracts";
+import type { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";
+import {
+  isProviderAvailable,
+  isProviderTextGenerationCapable,
+  resolveProjectProviderInstanceEnabled,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import { exhaustedUsageWindow } from "@t3tools/shared/usageLimits";
+import {
+  defaultTextGenerationModel,
+  fallbackTextGenerationModelSelection,
+} from "@t3tools/shared/serverSettings";
+import * as ServerSettings from "../serverSettings.ts";
 import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textGeneration";
 import { TextGenerationError } from "@t3tools/contracts";
 
@@ -52,36 +64,94 @@ const resolveInstance = (
     ),
   );
 
+// Review guides investigate the checkout read-only; the other drivers reject that request.
+const INVESTIGATING_DRIVERS = new Set(["codex", "claudeAgent"]);
+
 /** @public */
 export const make = Effect.gen(function* () {
   const registry = yield* ProviderInstanceRegistry.ProviderInstanceRegistry;
   const sourceControl = yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
+  const serverSettings = yield* ServerSettings.ServerSettingsService;
+  const generate = Effect.fn("TextGeneration.generate")(function* <A>(
+    operation: TextGenerationOp,
+    selection: ModelSelection,
+    invoke: (
+      service: ProviderTextGeneration,
+      modelSelection: ModelSelection,
+    ) => Effect.Effect<A, TextGenerationError>,
+  ) {
+    const snapshots = yield* registry.listInstances.pipe(
+      Effect.flatMap((instances) =>
+        Effect.forEach(instances, (instance) => instance.snapshot.getSnapshot),
+      ),
+    );
+    const now = DateTime.toEpochMillis(yield* DateTime.now);
+    const limited = exhaustedUsageWindow(
+      snapshots.find((provider) => provider.instanceId === selection.instanceId),
+      now,
+      selection.model,
+    );
+    if (limited) {
+      const settings = yield* serverSettings.getSettings.pipe(
+        Effect.mapError(
+          (cause) =>
+            new TextGenerationError({
+              operation,
+              detail: "Could not read fallback model settings.",
+              cause,
+            }),
+        ),
+      );
+      selection =
+        fallbackTextGenerationModelSelection(
+          settings.providerInstances,
+          (instanceId, driver) => {
+            const provider = snapshots.find((candidate) => candidate.instanceId === instanceId);
+            return (
+              instanceId !== selection.instanceId &&
+              provider?.enabled === true &&
+              resolveProjectProviderInstanceEnabled(settings, null, instanceId) &&
+              provider.installed &&
+              provider.auth.status !== "unauthenticated" &&
+              isProviderAvailable(provider) &&
+              isProviderTextGenerationCapable(provider) &&
+              (operation !== "generateReviewGuide" || INVESTIGATING_DRIVERS.has(driver)) &&
+              !exhaustedUsageWindow(provider, now, defaultTextGenerationModel(driver))
+            );
+          },
+          { includeConfiguredInstances: true },
+        ) ?? selection;
+    }
+    return yield* resolveInstance(registry, operation, selection.instanceId).pipe(
+      Effect.flatMap((service) => invoke(service, selection)),
+    );
+  });
   return TextGeneration.of({
     generateCommitMessage: Effect.fn("TextGeneration.generateCommitMessage")(function (input) {
-      return resolveInstance(
-        registry,
-        "generateCommitMessage",
-        input.modelSelection.instanceId,
-      ).pipe(Effect.flatMap((textGeneration) => textGeneration.generateCommitMessage(input)));
+      return generate("generateCommitMessage", input.modelSelection, (service, modelSelection) =>
+        service.generateCommitMessage({ ...input, modelSelection }),
+      );
     }),
     generatePrContent: Effect.fn("TextGeneration.generatePrContent")(function (input) {
-      return resolveInstance(registry, "generatePrContent", input.modelSelection.instanceId).pipe(
-        Effect.flatMap((textGeneration) => textGeneration.generatePrContent(input)),
+      return generate("generatePrContent", input.modelSelection, (service, modelSelection) =>
+        service.generatePrContent({ ...input, modelSelection }),
       );
     }),
     generateBranchName: Effect.fn("TextGeneration.generateBranchName")(function (input) {
-      return resolveInstance(registry, "generateBranchName", input.modelSelection.instanceId).pipe(
-        Effect.flatMap((textGeneration) => textGeneration.generateBranchName(input)),
+      return generate("generateBranchName", input.modelSelection, (service, modelSelection) =>
+        service.generateBranchName({ ...input, modelSelection }),
       );
     }),
     generateReviewGuide: Effect.fn("TextGeneration.generateReviewGuide")(function (input) {
-      return resolveInstance(registry, "generateReviewGuide", input.modelSelection.instanceId).pipe(
-        Effect.flatMap((textGeneration) => textGeneration.generateReviewGuide(input)),
+      return generate("generateReviewGuide", input.modelSelection, (service, modelSelection) =>
+        service.generateReviewGuide({ ...input, modelSelection }),
       );
     }),
     generateThreadTitle: Effect.fn("TextGeneration.generateThreadTitle")(function (input) {
-      return resolveInstance(registry, "generateThreadTitle", input.modelSelection.instanceId).pipe(
-        Effect.flatMap((textGeneration) =>
+      return generate(
+        "generateThreadTitle",
+        input.modelSelection,
+        (textGeneration, modelSelection) =>
           Effect.gen(function* () {
             const linkedContext =
               input.linkedContext ??
@@ -91,9 +161,12 @@ export const make = Effect.gen(function* () {
                   sourceControl,
                 ),
               ));
-            return yield* textGeneration.generateThreadTitle({ ...input, linkedContext });
+            return yield* textGeneration.generateThreadTitle({
+              ...input,
+              linkedContext,
+              modelSelection,
+            });
           }),
-        ),
       );
     }),
   });
diff --git a/apps/server/src/vcs/VcsStatusBroadcaster.test.ts b/apps/server/src/vcs/VcsStatusBroadcaster.test.ts
index bdf5dfff6c4ca..cc1b6d24e3873 100644
--- a/apps/server/src/vcs/VcsStatusBroadcaster.test.ts
+++ b/apps/server/src/vcs/VcsStatusBroadcaster.test.ts
@@ -12,16 +12,17 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Scope from "effect/Scope";
+import * as Scheduler from "effect/Scheduler";
 import * as Stream from "effect/Stream";
 import * as TestClock from "effect/testing/TestClock";
+import * as Tracer from "effect/Tracer";
 import type {
   BackgroundScope,
   VcsStatusLocalResult,
   VcsStatusRemoteResult,
-  VcsStatusResult,
   VcsStatusStreamEvent,
 } from "@t3tools/contracts";
-import { GitManagerError } from "@t3tools/contracts";
+import { GitCommandError, GitManagerError } from "@t3tools/contracts";
 
 import * as VcsStatusBroadcaster from "./VcsStatusBroadcaster.ts";
 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
@@ -58,16 +59,11 @@ const remoteStatusWithPr: VcsStatusRemoteResult = {
     title: "[codex] Rewrite client connection architecture",
     url: "https://github.com/pingdotgg/t3code/pull/2978",
     baseRef: "main",
-    headRef: "codex/connection-state-audit",
+    headRef: "upstream-topic",
     state: "open",
   },
 };
 
-const baseStatus: VcsStatusResult = {
-  ...baseLocalStatus,
-  ...baseRemoteStatus,
-};
-
 function layerTestFor(state: {
   currentLocalStatus: VcsStatusLocalResult;
   currentRemoteStatus: VcsStatusRemoteResult | null;
@@ -76,12 +72,19 @@ function layerTestFor(state: {
   localInvalidationCalls: number;
   remoteInvalidationCalls: number;
   remoteStatusRefreshUpstreamValues?: Array<boolean | undefined>;
+  remoteStatusError?: GitManagerError;
   backgroundWorkEnabled?: boolean;
   automaticFetchInterval?: Effect.Effect<Duration.Duration>;
   beforeRemoteStatus?: Effect.Effect<void>;
+  fileSystem?: FileSystem.FileSystem;
+  pullCurrentBranch?: GitWorkflowService.GitWorkflowService["Service"]["pullCurrentBranch"];
 }) {
   return VcsStatusBroadcaster.layer.pipe(
-    Layer.provideMerge(NodeServices.layer),
+    Layer.provideMerge(
+      state.fileSystem
+        ? Layer.succeed(FileSystem.FileSystem, state.fileSystem)
+        : NodeServices.layer,
+    ),
     Layer.provide(layerBackgroundPolicy(() => state.backgroundWorkEnabled !== false)),
     Layer.provide(
       Layer.succeed(
@@ -96,16 +99,22 @@ function layerTestFor(state: {
             state.localStatusCalls += 1;
             return state.currentLocalStatus;
           }),
+        currentBranch: () => Effect.sync(() => state.currentLocalStatus.refName),
         remoteStatus: (_input, options) =>
-          Effect.suspend(() => state.beforeRemoteStatus ?? Effect.void).pipe(
-            Effect.andThen(
-              Effect.sync(() => {
-                state.remoteStatusCalls += 1;
-                state.remoteStatusRefreshUpstreamValues?.push(options?.refreshUpstream);
-                return state.currentRemoteStatus;
-              }),
-            ),
-          ),
+          Effect.suspend(() => {
+            return (state.beforeRemoteStatus ?? Effect.void).pipe(
+              Effect.andThen(
+                Effect.sync(() => {
+                  state.remoteStatusCalls += 1;
+                  state.remoteStatusRefreshUpstreamValues?.push(options?.refreshUpstream);
+                  return state.currentRemoteStatus;
+                }),
+              ),
+              Effect.tap(() =>
+                state.remoteStatusError ? Effect.fail(state.remoteStatusError) : Effect.void,
+              ),
+            );
+          }),
         invalidateLocalStatus: () =>
           Effect.sync(() => {
             state.localInvalidationCalls += 1;
@@ -119,6 +128,7 @@ function layerTestFor(state: {
             state.localInvalidationCalls += 1;
             state.remoteInvalidationCalls += 1;
           }),
+        ...(state.pullCurrentBranch ? { pullCurrentBranch: state.pullCurrentBranch } : {}),
       }),
     ),
   );
@@ -171,7 +181,7 @@ describe("VcsStatusBroadcaster", () => {
         Stream.tap((event) =>
           event._tag === "snapshot" ? Deferred.succeed(subscribed, undefined) : Effect.void,
         ),
-        Stream.take(2),
+        Stream.take(3),
         Stream.runCollect,
         Effect.forkScoped,
       );
@@ -183,12 +193,11 @@ describe("VcsStatusBroadcaster", () => {
       assert.isNull(refreshed.pr);
       assert.equal(state.localInvalidationCalls, 1);
       assert.equal(state.remoteStatusCalls, 1);
-      assert.equal(state.remoteInvalidationCalls, 1);
-      assert.deepStrictEqual((yield* Fiber.join(events))[1], {
-        _tag: "snapshot",
-        local: state.currentLocalStatus,
-        remote: null,
-      });
+      assert.equal(state.remoteInvalidationCalls, 2);
+      assert.deepStrictEqual((yield* Fiber.join(events)).slice(1), [
+        { _tag: "remoteUpdated", remote: null },
+        { _tag: "localUpdated", local: state.currentLocalStatus },
+      ]);
       assert.isNull((yield* broadcaster.getStatus({ cwd: "/repo" })).pr);
       const snapshot = yield* broadcaster
         .streamStatus({ cwd: "/repo", includeRemote: false })
@@ -220,7 +229,7 @@ describe("VcsStatusBroadcaster", () => {
         assert.deepStrictEqual(refreshed, initial);
         assert.deepStrictEqual(yield* broadcaster.getStatus({ cwd: "/repo" }), refreshed);
         assert.equal(state.localInvalidationCalls, 1);
-        assert.equal(state.remoteInvalidationCalls, 0);
+        assert.equal(state.remoteInvalidationCalls, 1);
         assert.equal(state.remoteStatusCalls, 1);
       }).pipe(Effect.provide(layerTestFor(state)));
     },
@@ -288,6 +297,7 @@ describe("VcsStatusBroadcaster", () => {
         Layer.provide(
           Layer.mock(GitWorkflowService.GitWorkflowService)({
             localStatus: () => Effect.succeed(localStatus),
+            currentBranch: () => Effect.succeed(localStatus.refName),
             remoteStatus: () => Effect.succeed(remoteStatus),
             invalidateLocalStatus: () => Effect.void,
             invalidateRemoteStatus: () => Effect.void,
@@ -350,7 +360,7 @@ describe("VcsStatusBroadcaster", () => {
       const refreshed = yield* broadcaster.refreshPullRequestStatus("/repo");
       assert.deepStrictEqual(refreshed, remoteStatusWithPr);
       assert.equal(state.remoteStatusCalls, 2);
-      assert.equal(state.remoteInvalidationCalls, 0);
+      assert.equal(state.remoteInvalidationCalls, 2);
 
       state.currentLocalStatus = { ...baseLocalStatus, refName: "feature/next" };
       state.currentRemoteStatus = baseRemoteStatus;
@@ -358,6 +368,11 @@ describe("VcsStatusBroadcaster", () => {
       const refreshedBranch = yield* broadcaster.refreshPullRequestStatus("/repo");
       assert.deepStrictEqual(refreshedBranch, baseRemoteStatus);
       assert.equal(state.remoteStatusCalls, 3);
+      const refreshedStatus = yield* broadcaster.getStatus({ cwd: "/repo" });
+      assert.equal(refreshedStatus.refName, "feature/next");
+      assert.isNull(refreshedStatus.pr);
+      assert.equal(state.remoteStatusCalls, 3);
+      assert.equal(state.remoteInvalidationCalls, 3);
     }).pipe(Effect.provide(layerTestFor(state)));
   });
 
@@ -371,6 +386,7 @@ describe("VcsStatusBroadcaster", () => {
       Layer.provide(
         Layer.mock(GitWorkflowService.GitWorkflowService)({
           localStatus: () => Effect.succeed(baseLocalStatus),
+          currentBranch: () => Effect.succeed(baseLocalStatus.refName),
           remoteStatus: () =>
             Effect.gen(function* () {
               remoteReads += 1;
@@ -416,6 +432,7 @@ describe("VcsStatusBroadcaster", () => {
       Layer.provide(
         Layer.mock(GitWorkflowService.GitWorkflowService)({
           localStatus: () => Effect.succeed(baseLocalStatus),
+          currentBranch: () => Effect.succeed(baseLocalStatus.refName),
           remoteStatus: () =>
             Effect.gen(function* () {
               remoteReads += 1;
@@ -426,6 +443,8 @@ describe("VcsStatusBroadcaster", () => {
               }
               return remoteStatusWithPr;
             }),
+          invalidateLocalStatus: () => Effect.void,
+          invalidateRemoteStatus: () => Effect.void,
           invalidateStatus: () => Effect.void,
         }),
       ),
@@ -446,7 +465,7 @@ describe("VcsStatusBroadcaster", () => {
     }).pipe(Effect.provide(layer), Effect.scoped);
   });
 
-  it.effect("keeps the cached snapshot unchanged when a refresh branch fails", () => {
+  it.effect("keeps the published local snapshot when a refresh remote read fails", () => {
     const state = {
       currentLocalStatus: baseLocalStatus,
       currentRemoteStatus: baseRemoteStatus,
@@ -466,6 +485,7 @@ describe("VcsStatusBroadcaster", () => {
               state.localStatusCalls += 1;
               return state.currentLocalStatus;
             }),
+          currentBranch: () => Effect.succeed(state.currentLocalStatus.refName),
           remoteStatus: () =>
             Effect.suspend(() => {
               state.remoteStatusCalls += 1;
@@ -511,10 +531,18 @@ describe("VcsStatusBroadcaster", () => {
       state.failRemoteStatus = true;
 
       const refreshExit = yield* broadcaster.refreshStatus("/repo").pipe(Effect.exit);
-      const cached = yield* broadcaster.getStatus({ cwd: "/repo" });
+      const snapshot = yield* Stream.runHead(
+        broadcaster.streamStatus({ cwd: "/repo", includeRemote: false }),
+      );
 
       assert.isTrue(Exit.isFailure(refreshExit));
-      assert.deepStrictEqual(cached, baseStatus);
+      assert.isTrue(Option.isSome(snapshot));
+      const event = Option.getOrThrow(snapshot);
+      assert.equal(event._tag, "snapshot");
+      if (event._tag === "snapshot") {
+        assert.equal(event.local.refName, "feature/partial-refresh");
+        assert.isNull(event.remote);
+      }
     }).pipe(Effect.provide(layerTest));
   });
 
@@ -541,6 +569,7 @@ describe("VcsStatusBroadcaster", () => {
                 state.localStatusCalls += 1;
                 return state.currentLocalStatus;
               }),
+            currentBranch: () => Effect.succeed(state.currentLocalStatus.refName),
             remoteStatus: (input) =>
               Effect.sync(() => {
                 seenCwds.push(input.cwd);
@@ -615,6 +644,256 @@ describe("VcsStatusBroadcaster", () => {
     }).pipe(Effect.provide(layerTestFor(state)));
   });
 
+  it.effect("publishes local status while an earlier lookup holds the remote lock", () => {
+    const state: Parameters<typeof layerTestFor>[0] = {
+      currentLocalStatus: baseLocalStatus,
+      currentRemoteStatus: baseRemoteStatus,
+      localStatusCalls: 0,
+      remoteStatusCalls: 0,
+      localInvalidationCalls: 0,
+      remoteInvalidationCalls: 0,
+    };
+
+    return Effect.gen(function* () {
+      const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
+      yield* broadcaster.getStatus({ cwd: "/repo" });
+      const subscribed = yield* Deferred.make<void>();
+      const published = yield* Deferred.make<VcsStatusLocalResult>();
+      yield* broadcaster.streamStatus({ cwd: "/repo", includeRemote: false }).pipe(
+        Stream.runForEach((event) => {
+          if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
+          if (event._tag === "localUpdated") return Deferred.succeed(published, event.local);
+          return Effect.void;
+        }),
+        Effect.forkScoped,
+      );
+      yield* Deferred.await(subscribed);
+      const started = yield* Deferred.make<void>();
+      const release = yield* Deferred.make<void>();
+      state.beforeRemoteStatus = Deferred.succeed(started, undefined).pipe(
+        Effect.andThen(Deferred.await(release)),
+      );
+      const earlier = yield* broadcaster.refreshPullRequestStatus("/repo").pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      state.currentLocalStatus = { ...baseLocalStatus, hasWorkingTreeChanges: true };
+      const completed = yield* Deferred.make<void>();
+      const refresh = yield* broadcaster
+        .refreshStatus("/repo")
+        .pipe(Effect.ensuring(Deferred.succeed(completed, undefined)), Effect.forkScoped);
+
+      assert.deepStrictEqual(yield* Deferred.await(published), state.currentLocalStatus);
+      assert.isFalse(yield* Deferred.isDone(completed));
+      assert.isFalse(yield* Deferred.isDone(release));
+      state.currentRemoteStatus = remoteStatusWithPr;
+      yield* Deferred.succeed(release, undefined);
+      yield* Fiber.join(earlier);
+      const status = yield* Fiber.join(refresh);
+      assert.isTrue(status.hasWorkingTreeChanges);
+      assert.deepStrictEqual(status.pr, remoteStatusWithPr.pr);
+    }).pipe(Effect.provide(layerTestFor(state)), Effect.scoped);
+  });
+
+  it.effect("publishes local changes before a remote error and propagates that error", () => {
+    const remoteError = new GitManagerError({
+      operation: "VcsStatusBroadcaster.remoteStatus",
+      cwd: "/repo",
+      detail: "The controlled remote lookup failed.",
+    });
+    const state: Parameters<typeof layerTestFor>[0] = {
+      currentLocalStatus: baseLocalStatus,
+      currentRemoteStatus: remoteStatusWithPr,
+      localStatusCalls: 0,
+      remoteStatusCalls: 0,
+      localInvalidationCalls: 0,
+      remoteInvalidationCalls: 0,
+    };
+
+    return Effect.gen(function* () {
+      const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
+      yield* broadcaster.getStatus({ cwd: "/repo" });
+      const subscribed = yield* Deferred.make<void>();
+      const published = yield* Deferred.make<VcsStatusLocalResult>();
+      yield* broadcaster.streamStatus({ cwd: "/repo", includeRemote: false }).pipe(
+        Stream.runForEach((event) => {
+          if (event._tag === "snapshot") return Deferred.succeed(subscribed, undefined);
+          if (event._tag === "localUpdated") return Deferred.succeed(published, event.local);
+          return Effect.void;
+        }),
+        Effect.forkScoped,
+      );
+      yield* Deferred.await(subscribed);
+      const started = yield* Deferred.make<void>();
+      const release = yield* Deferred.make<void>();
+      const completed = yield* Deferred.make<void>();
+      state.beforeRemoteStatus = Deferred.succeed(started, undefined).pipe(
+        Effect.andThen(Deferred.await(release)),
+      );
+      state.currentLocalStatus = { ...baseLocalStatus, hasWorkingTreeChanges: true };
+      state.remoteStatusError = remoteError;
+      const refresh = yield* broadcaster
+        .refreshStatus("/repo")
+        .pipe(
+          Effect.result,
+          Effect.ensuring(Deferred.succeed(completed, undefined)),
+          Effect.forkScoped,
+        );
+      yield* Deferred.await(started);
+      assert.isFalse(yield* Deferred.isDone(completed));
+      const pending = Option.getOrThrow(
+        yield* Stream.runHead(broadcaster.streamStatus({ cwd: "/repo", includeRemote: false })),
+      );
+      assert.equal(pending._tag, "snapshot");
+      if (pending._tag === "snapshot") assert.isTrue(pending.local.hasWorkingTreeChanges);
+      yield* Deferred.succeed(release, undefined);
+      const result = yield* Fiber.join(refresh);
+      assert.equal(result._tag, "Failure");
+      if (result._tag === "Failure") assert.strictEqual(result.failure, remoteError);
+      const cached = yield* broadcaster.getStatus({ cwd: "/repo" });
+      assert.isTrue(cached.hasWorkingTreeChanges);
+      assert.deepStrictEqual(cached.pr, remoteStatusWithPr.pr);
+      assert.deepStrictEqual(yield* Deferred.await(published), state.currentLocalStatus);
+    }).pipe(Effect.provide(layerTestFor(state)), Effect.scoped);
+  });
+
+  it.effect.each(["getStatus", "refreshStatus", "autoPull", "autoPullFailure"] as const)(
+    "%s keeps response parts consistent when local state changes after the remote cache write",
+    (operation) => {
+      const state: Parameters<typeof layerTestFor>[0] = {
+        currentLocalStatus: baseLocalStatus,
+        currentRemoteStatus: { ...remoteStatusWithPr, aheadCount: 3, behindCount: 5 },
+        localStatusCalls: 0,
+        remoteStatusCalls: 0,
+        localInvalidationCalls: 0,
+        remoteInvalidationCalls: 0,
+        fileSystem: FileSystem.makeNoop({ realPath: (cwd) => Effect.succeed(cwd) }),
+      };
+      const autoPull = operation === "autoPull" || operation === "autoPullFailure";
+      if (autoPull) {
+        state.currentLocalStatus = { ...baseLocalStatus, isDefaultRef: true };
+        state.currentRemoteStatus = { ...remoteStatusWithPr, aheadCount: 0, behindCount: 5 };
+        state.pullCurrentBranch = () =>
+          operation === "autoPullFailure"
+            ? Effect.fail(
+                new GitCommandError({
+                  operation: "test.pull",
+                  command: "pull",
+                  cwd: "/repo",
+                  detail: "Pull failed.",
+                }),
+              )
+            : Effect.succeed({
+                status: "pulled",
+                refName: "feature/status-broadcast",
+                upstreamRef: "origin/main",
+              });
+      }
+      const layerTest = layerTestFor(state).pipe(
+        Layer.provide(
+          Layer.succeed(VcsStatusBroadcaster.VcsAutoPullPolicy, {
+            isEnabled: () => Effect.succeed(autoPull),
+          }),
+        ),
+      );
+      return Effect.gen(function* () {
+        const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
+        let switched = false;
+        let remoteWritten = false;
+        const writeCompleted = yield* Deferred.make<void>();
+        const localRefresh = yield* Effect.gen(function* () {
+          yield* Deferred.await(writeCompleted);
+          state.currentLocalStatus = { ...baseLocalStatus, refName: "feature/next-status" };
+          yield* broadcaster.refreshLocalStatus("/repo");
+          switched = true;
+        }).pipe(Effect.forkScoped);
+        const scheduler = new Scheduler.MixedScheduler();
+        const shouldYield = scheduler.shouldYield.bind(scheduler);
+        scheduler.shouldYield = (fiber) => (remoteWritten && !switched) || shouldYield(fiber);
+        const tracer = Tracer.make({
+          span: (options) => {
+            const span = new Tracer.NativeSpan(options);
+            const end = span.end.bind(span);
+            span.end = (time, exit) => {
+              end(time, exit);
+              if (
+                options.name !== "VcsStatusBroadcaster.updateCachedRemoteStatus" ||
+                remoteWritten
+              ) {
+                return;
+              }
+              // Yield this reader after its write until the local refresh finishes.
+              remoteWritten = true;
+              Deferred.doneUnsafe(writeCompleted, Effect.void);
+            };
+            return span;
+          },
+        });
+        const status = yield* (
+          operation === "getStatus"
+            ? broadcaster.getStatus({ cwd: "/repo" })
+            : broadcaster.refreshStatus("/repo")
+        ).pipe(Effect.withTracer(tracer), Effect.provideService(Scheduler.Scheduler, scheduler));
+        yield* Fiber.join(localRefresh);
+        assert.isTrue(switched);
+        assert.equal(status.refName, "feature/next-status");
+        assert.isNull(status.pr);
+        assert.equal(status.aheadCount, 0);
+        assert.equal(status.behindCount, 0);
+      }).pipe(Effect.provide(layerTest), Effect.scoped);
+    },
+  );
+
+  it.effect("recovers a discarded branch lookup on the next permitted turn-end refresh", () => {
+    const state: Parameters<typeof layerTestFor>[0] = {
+      currentLocalStatus: baseLocalStatus,
+      currentRemoteStatus: { ...remoteStatusWithPr, aheadCount: 3, behindCount: 5 },
+      localStatusCalls: 0,
+      remoteStatusCalls: 0,
+      localInvalidationCalls: 0,
+      remoteInvalidationCalls: 0,
+    };
+
+    return Effect.gen(function* () {
+      const broadcaster = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
+      const started = yield* Deferred.make<void>();
+      const release = yield* Deferred.make<void>();
+      state.beforeRemoteStatus = Deferred.succeed(started, undefined).pipe(
+        Effect.andThen(Deferred.await(release)),
+      );
+      const lookup = yield* broadcaster.getStatus({ cwd: "/repo" }).pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      state.currentLocalStatus = { ...baseLocalStatus, refName: "feature/next-status" };
+      yield* Deferred.succeed(release, undefined);
+      const discarded = yield* Fiber.join(lookup);
+      assert.equal(discarded.refName, state.currentLocalStatus.refName);
+      assert.isNull(discarded.pr);
+      assert.equal(discarded.aheadCount, 0);
+      assert.equal(discarded.behindCount, 0);
+      const snapshot = Option.getOrThrow(
+        yield* Stream.runHead(broadcaster.streamStatus({ cwd: "/repo", includeRemote: false })),
+      );
+      assert.equal(snapshot._tag, "snapshot");
+      if (snapshot._tag === "snapshot") assert.isNull(snapshot.remote);
+
+      state.beforeRemoteStatus = Effect.void;
+      state.currentRemoteStatus = {
+        ...baseRemoteStatus,
+        aheadCount: 2,
+        pr: { ...remoteStatusWithPr.pr!, number: 2979, headRef: "feature/next-status" },
+      };
+      state.backgroundWorkEnabled = false;
+      yield* broadcaster.refreshPullRequestStatus("/repo");
+      assert.equal(state.remoteStatusCalls, 1);
+      state.backgroundWorkEnabled = true;
+      const recovered = yield* broadcaster.refreshPullRequestStatus("/repo");
+      assert.deepStrictEqual(recovered, state.currentRemoteStatus);
+      const cached = yield* broadcaster.getStatus({ cwd: "/repo" });
+      assert.equal(cached.refName, state.currentLocalStatus.refName);
+      assert.deepStrictEqual(cached.pr, state.currentRemoteStatus.pr);
+      assert.equal(cached.aheadCount, 2);
+      assert.equal(state.remoteStatusCalls, 2);
+    }).pipe(Effect.provide(layerTestFor(state)), Effect.scoped);
+  });
+
   it.effect("releases remote demand while passive observers remain", () => {
     const state = {
       currentLocalStatus: baseLocalStatus,
@@ -636,6 +915,7 @@ describe("VcsStatusBroadcaster", () => {
               state.localStatusCalls += 1;
               return state.currentLocalStatus;
             }),
+          currentBranch: () => Effect.succeed(state.currentLocalStatus.refName),
           remoteStatus: () =>
             Effect.sync(() => {
               state.remoteStatusCalls += 1;
diff --git a/apps/server/src/vcs/VcsStatusBroadcaster.ts b/apps/server/src/vcs/VcsStatusBroadcaster.ts
index 3cbcb3546e9d9..8ce1b225d123d 100644
--- a/apps/server/src/vcs/VcsStatusBroadcaster.ts
+++ b/apps/server/src/vcs/VcsStatusBroadcaster.ts
@@ -130,9 +130,13 @@ interface CachedValue<T> {
   readonly value: T;
 }
 
+interface CachedRemoteStatus extends CachedValue<VcsStatusRemoteResult | null> {
+  readonly branch: string | null;
+}
+
 interface CachedVcsStatus {
   readonly local: CachedValue<VcsStatusLocalResult> | null;
-  readonly remote: CachedValue<VcsStatusRemoteResult | null> | null;
+  readonly remote: CachedRemoteStatus | null;
 }
 
 interface ActiveRemotePoller {
@@ -261,106 +265,51 @@ export const make = Effect.gen(function* () {
 
   const updateCachedLocalStatus = Effect.fn("VcsStatusBroadcaster.updateCachedLocalStatus")(
     function* (cwd: string, local: VcsStatusLocalResult, options?: { publish?: boolean }) {
-      const nextLocal = {
-        fingerprint: fingerprintStatusPart(local),
-        value: local,
-      } satisfies CachedValue<VcsStatusLocalResult>;
-      const shouldPublish = yield* Ref.modify(cacheRef, (cache) => {
+      const nextLocal = { fingerprint: fingerprintStatusPart(local), value: local };
+      const [localChanged, remoteCleared] = yield* Ref.modify(cacheRef, (cache) => {
         const previous = cache.get(cwd) ?? { local: null, remote: null };
-        const nextCache = new Map(cache);
-        nextCache.set(cwd, {
-          ...previous,
-          local: nextLocal,
-        });
-        return [previous.local?.fingerprint !== nextLocal.fingerprint, nextCache] as const;
+        const remote = previous.remote?.branch === local.refName ? previous.remote : null;
+        return [
+          [previous.local?.fingerprint !== nextLocal.fingerprint, previous.remote !== remote],
+          new Map(cache).set(cwd, { local: nextLocal, remote }),
+        ] as const;
       });
-
-      if (options?.publish && shouldPublish) {
+      if (options?.publish && remoteCleared) {
         yield* PubSub.publish(changesPubSub, {
           cwd,
-          event: {
-            _tag: "localUpdated",
-            local,
-          },
+          event: { _tag: "remoteUpdated", remote: null },
+        });
+      }
+      if (options?.publish && localChanged) {
+        yield* PubSub.publish(changesPubSub, {
+          cwd,
+          event: { _tag: "localUpdated", local },
         });
       }
-
       return local;
     },
   );
 
   const updateCachedRemoteStatus = Effect.fn("VcsStatusBroadcaster.updateCachedRemoteStatus")(
-    function* (cwd: string, remote: VcsStatusRemoteResult | null, options?: { publish?: boolean }) {
-      const nextRemote = {
-        fingerprint: fingerprintStatusPart(remote),
-        value: remote,
-      } satisfies CachedValue<VcsStatusRemoteResult | null>;
-      const shouldPublish = yield* Ref.modify(cacheRef, (cache) => {
+    function* (cwd: string, remote: CachedRemoteStatus | null, options?: { publish?: boolean }) {
+      const [changed, value] = yield* Ref.modify(cacheRef, (cache) => {
         const previous = cache.get(cwd) ?? { local: null, remote: null };
-        const nextCache = new Map(cache);
-        nextCache.set(cwd, {
-          ...previous,
-          remote: nextRemote,
-        });
-        return [previous.remote?.fingerprint !== nextRemote.fingerprint, nextCache] as const;
+        const next = remote?.branch === previous.local?.value.refName ? remote : null;
+        return [
+          [previous.remote?.fingerprint !== next?.fingerprint, next?.value ?? null],
+          new Map(cache).set(cwd, { ...previous, remote: next }),
+        ] as const;
       });
-
-      if (options?.publish && shouldPublish) {
+      if (options?.publish && changed) {
         yield* PubSub.publish(changesPubSub, {
           cwd,
-          event: {
-            _tag: "remoteUpdated",
-            remote,
-          },
+          event: { _tag: "remoteUpdated", remote: value },
         });
       }
-
-      return remote;
+      return value;
     },
   );
 
-  const updateCachedStatus = Effect.fn("VcsStatusBroadcaster.updateCachedStatus")(function* (
-    cwd: string,
-    local: VcsStatusLocalResult,
-    remote: VcsStatusRemoteResult | null,
-    options?: { publish?: boolean },
-  ) {
-    const nextLocal = {
-      fingerprint: fingerprintStatusPart(local),
-      value: local,
-    } satisfies CachedValue<VcsStatusLocalResult>;
-    const nextRemote = {
-      fingerprint: fingerprintStatusPart(remote),
-      value: remote,
-    } satisfies CachedValue<VcsStatusRemoteResult | null>;
-    const shouldPublish = yield* Ref.modify(cacheRef, (cache) => {
-      const previous = cache.get(cwd) ?? { local: null, remote: null };
-      const nextCache = new Map(cache);
-      nextCache.set(cwd, {
-        local: nextLocal,
-        remote: nextRemote,
-      });
-      return [
-        previous.local?.fingerprint !== nextLocal.fingerprint ||
-          previous.remote?.fingerprint !== nextRemote.fingerprint,
-        nextCache,
-      ] as const;
-    });
-
-    if (options?.publish && shouldPublish) {
-      yield* PubSub.publish(changesPubSub, {
-        cwd,
-        event: {
-          _tag: "snapshot",
-          local,
-          remote,
-        },
-      });
-    }
-
-    return mergeGitStatusParts(local, remote);
-  });
-
   const loadLocalStatus = Effect.fn("VcsStatusBroadcaster.loadLocalStatus")(function* (
     cwd: string,
   ) {
@@ -378,6 +327,14 @@ export const make = Effect.gen(function* () {
     return yield* loadLocalStatus(cwd);
   });
 
+  const getStatusParts = Effect.fn("VcsStatusBroadcaster.getStatusParts")(function* (cwd: string) {
+    const cached = yield* getCachedStatus(cwd);
+    if (cached?.local) {
+      return { local: cached.local.value, remote: cached.remote?.value ?? null };
+    }
+    return { local: yield* loadLocalStatus(cwd), remote: null };
+  });
+
   const withFileSystem = Effect.provideService(FileSystem.FileSystem, fs);
 
   const getStatus: VcsStatusBroadcaster["Service"]["getStatus"] = Effect.fn(
@@ -388,21 +345,16 @@ export const make = Effect.gen(function* () {
     if (cached?.local && cached.remote) {
       return mergeGitStatusParts(cached.local.value, cached.remote.value);
     }
+    yield* getOrLoadLocalStatus(cwd);
     return yield* withRemoteWriteLock(
       cwd,
       Effect.gen(function* () {
         const latest = yield* getCachedStatus(cwd);
         const refreshUpstream = !Duration.isZero(yield* automaticFetchInterval);
-        const [local, remote] = yield* Effect.all(
-          [
-            latest?.local ? Effect.succeed(latest.local.value) : workflow.localStatus({ cwd }),
-            latest?.remote
-              ? Effect.succeed(latest.remote.value)
-              : workflow.remoteStatus({ cwd }, { refreshUpstream }),
-          ],
-          { concurrency: "unbounded" },
-        );
-        return yield* updateCachedStatus(cwd, local, remote);
+        const remote = latest?.remote ?? (yield* readRemoteStatus(cwd, { refreshUpstream }));
+        yield* updateCachedRemoteStatus(cwd, remote);
+        const parts = yield* getStatusParts(cwd);
+        return mergeGitStatusParts(parts.local, parts.remote);
       }),
     );
   });
@@ -422,11 +374,30 @@ export const make = Effect.gen(function* () {
     return yield* refreshLocalStatusCore(cwd);
   });
 
+  const readRemoteStatus = Effect.fn("VcsStatusBroadcaster.readRemoteStatus")(function* (
+    cwd: string,
+    options?: Parameters<GitWorkflowService.GitWorkflowService["Service"]["remoteStatus"]>[1],
+  ) {
+    const branch = yield* workflow.currentBranch(cwd);
+    // GitManager's remote TTL cache is keyed by cwd, not the checked-out branch.
+    yield* workflow.invalidateRemoteStatus(cwd);
+    const value = yield* workflow.remoteStatus({ cwd }, options);
+    const currentBranch = yield* workflow.currentBranch(cwd);
+    const cached = yield* getCachedStatus(cwd);
+    if (branch !== currentBranch || cached?.local?.value.refName !== currentBranch) {
+      yield* refreshLocalStatusCore(cwd);
+    }
+    return branch === currentBranch
+      ? { branch, value, fingerprint: fingerprintStatusPart(value) }
+      : null;
+  });
+
   const maybeAutoPull = Effect.fn("VcsStatusBroadcaster.maybeAutoPull")(function* (
     cwd: string,
-    remote: VcsStatusRemoteResult | null,
+    remoteRead: CachedRemoteStatus | null,
     policyCwds: ReadonlyArray<string>,
   ) {
+    const remote = remoteRead?.value ?? null;
     let pullAttempted = false;
     return yield* Effect.gen(function* () {
       const autoPullEnabled = (yield* Effect.forEach(policyCwds, autoPullPolicy.isEnabled, {
@@ -444,17 +415,21 @@ export const make = Effect.gen(function* () {
 
       yield* workflow.invalidateLocalStatus(cwd);
       const local = yield* workflow.localStatus({ cwd });
-      if (!local.isRepo || !local.isDefaultRef || local.hasWorkingTreeChanges) return null;
+      if (
+        !local.isRepo ||
+        !local.isDefaultRef ||
+        local.hasWorkingTreeChanges ||
+        local.refName !== remoteRead?.branch
+      )
+        return null;
 
       pullAttempted = true;
       yield* workflow.pullCurrentBranch(cwd);
       yield* workflow.invalidateStatus(cwd);
-      const [refreshedLocal, refreshedRemote] = yield* Effect.all(
-        [workflow.localStatus({ cwd }), workflow.remoteStatus({ cwd }, { refreshUpstream: false })],
-        { concurrency: "unbounded" },
-      );
-      yield* updateCachedStatus(cwd, refreshedLocal, refreshedRemote, { publish: true });
-      return { local: refreshedLocal, remote: refreshedRemote };
+      yield* refreshLocalStatusCore(cwd);
+      const refreshedRemote = yield* readRemoteStatus(cwd, { refreshUpstream: false });
+      yield* updateCachedRemoteStatus(cwd, refreshedRemote, { publish: true });
+      return yield* getStatusParts(cwd);
     }).pipe(
       Effect.catch((error) =>
         Effect.gen(function* () {
@@ -463,11 +438,11 @@ export const make = Effect.gen(function* () {
             errorTag: error._tag,
           });
           if (!pullAttempted) return null;
-          // Pull can change local state before failing; propagate reconciliation failures instead of publishing stale status.
-          yield* workflow.invalidateLocalStatus(cwd);
-          const local = yield* workflow.localStatus({ cwd });
-          yield* updateCachedStatus(cwd, local, remote, { publish: true });
-          return { local, remote };
+          // A pull or its follow-up reads can fail after local state has changed.
+          // Let a failed reconciliation reach the caller instead of publishing old status.
+          yield* refreshLocalStatusCore(cwd);
+          yield* updateCachedRemoteStatus(cwd, remoteRead, { publish: true });
+          return yield* getStatusParts(cwd);
         }),
       ),
     );
@@ -483,15 +458,13 @@ export const make = Effect.gen(function* () {
     return yield* withRemoteWriteLock(
       cwd,
       Effect.gen(function* () {
-        if (options?.refreshUpstream !== false) {
-          yield* workflow.invalidateRemoteStatus(cwd);
-        }
         const previousRemote = (yield* getCachedStatus(cwd))?.remote?.value;
-        const remote = yield* workflow.remoteStatus({ cwd }, options);
+        const remoteRead = yield* readRemoteStatus(cwd, options);
+        const remote = remoteRead?.value;
         const pulled =
           options?.refreshUpstream === false
             ? null
-            : yield* maybeAutoPull(cwd, remote, options?.policyCwds ?? [cwd]);
+            : yield* maybeAutoPull(cwd, remoteRead, options?.policyCwds ?? [cwd]);
         if (pulled !== null) return pulled.remote;
         if (
           remote &&
@@ -502,7 +475,7 @@ export const make = Effect.gen(function* () {
         ) {
           yield* refreshLocalStatusCore(cwd);
         }
-        return yield* updateCachedRemoteStatus(cwd, remote, { publish: true });
+        return yield* updateCachedRemoteStatus(cwd, remoteRead, { publish: true });
       }),
     );
   });
@@ -511,35 +484,41 @@ export const make = Effect.gen(function* () {
     "VcsStatusBroadcaster.refreshStatus",
   )(function* (rawCwd, options) {
     const cwd = yield* withFileSystem(normalizeCwd(rawCwd));
+    const previous = options?.localOnly ? yield* getCachedStatus(cwd) : null;
+    const local = yield* refreshLocalStatusCore(cwd);
     if (options?.localOnly) {
       return yield* withRemoteWriteLock(
         cwd,
         Effect.gen(function* () {
-          yield* workflow.invalidateLocalStatus(cwd);
-          const local = yield* workflow.localStatus({ cwd });
-          const previous = yield* getCachedStatus(cwd);
-          if (previous?.local?.value.refName !== local.refName) {
+          if (previous?.local?.value.refName !== local.refName || !previous?.remote) {
             yield* workflow.invalidateRemoteStatus(cwd);
-            return yield* updateCachedStatus(cwd, local, null, { publish: true });
+            yield* updateCachedRemoteStatus(
+              cwd,
+              { branch: local.refName, fingerprint: fingerprintStatusPart(null), value: null },
+              { publish: true },
+            );
           }
-          yield* updateCachedLocalStatus(cwd, local, { publish: true });
-          return mergeGitStatusParts(local, previous?.remote?.value ?? null);
+          const parts = yield* getStatusParts(cwd);
+          return mergeGitStatusParts(parts.local, parts.remote);
         }),
       );
     }
-    // Full invalidation also bypasses GitManager's slow PR cache.
     return yield* withRemoteWriteLock(
       cwd,
       Effect.gen(function* () {
         const refreshUpstream = !Duration.isZero(yield* automaticFetchInterval);
+        // Bump the PR lookup epoch after earlier remote writers have finished.
         yield* workflow.invalidateStatus(cwd);
-        // Local after remote: the fetch can move the base that the Changes totals compare with.
-        const remote = yield* workflow.remoteStatus({ cwd }, { refreshUpstream });
+        const remoteRead = yield* readRemoteStatus(cwd, { refreshUpstream });
+        // Fetch can move the base used for local Changes totals.
         const local = yield* workflow.localStatus({ cwd });
+        yield* updateCachedLocalStatus(cwd, local, { publish: true });
         // Without a fetch, the cached behind count cannot justify an automatic pull.
-        const pulled = refreshUpstream ? yield* maybeAutoPull(cwd, remote, [rawCwd]) : null;
+        const pulled = refreshUpstream ? yield* maybeAutoPull(cwd, remoteRead, [rawCwd]) : null;
         if (pulled !== null) return mergeGitStatusParts(pulled.local, pulled.remote);
-        return yield* updateCachedStatus(cwd, local, remote, { publish: true });
+        yield* updateCachedRemoteStatus(cwd, remoteRead, { publish: true });
+        const parts = yield* getStatusParts(cwd);
+        return mergeGitStatusParts(parts.local, parts.remote);
       }),
     );
   });
@@ -551,7 +530,7 @@ export const make = Effect.gen(function* () {
         cwd,
         Effect.gen(function* () {
           const cached = yield* getCachedStatus(cwd);
-          if (cached?.remote?.value == null) return null;
+          if (!cached?.local || cached.remote?.value === null) return null;
           const poller = (yield* SynchronizedRef.get(pollersRef)).get(cwd);
           const demandCwds = poller ? [...(yield* Ref.get(poller.demandCwds)).keys()] : [rawCwd];
           const shouldRefresh = (yield* Effect.forEach(
@@ -561,12 +540,11 @@ export const make = Effect.gen(function* () {
             { concurrency: "unbounded" },
           )).some(Boolean);
           if (!shouldRefresh) return null;
-          // Re-resolve the branch; cached PRs may belong to a checkout's previous branch.
-          const remote = yield* workflow.remoteStatus(
-            { cwd },
-            { refreshUpstream: false, refreshMissingPullRequest: true },
-          );
-          return yield* updateCachedRemoteStatus(cwd, remote, { publish: true });
+          const remoteRead = yield* readRemoteStatus(cwd, {
+            refreshUpstream: false,
+            refreshMissingPullRequest: true,
+          });
+          return yield* updateCachedRemoteStatus(cwd, remoteRead, { publish: true });
         }),
       );
     });
diff --git a/apps/server/src/ws.test.ts b/apps/server/src/ws.test.ts
index ac60becc2d78a..bce9450778736 100644
--- a/apps/server/src/ws.test.ts
+++ b/apps/server/src/ws.test.ts
@@ -49,6 +49,7 @@ import * as EnvironmentTheme from "./environmentTheme.ts";
 import * as GitWorkflowService from "./git/GitWorkflowService.ts";
 import * as HostResources from "./resourceTelemetry/HostResources.ts";
 import * as ManagedProjectFolders from "./project/ManagedProjectFolders.ts";
+import * as ScratchThreadPromotion from "./project/ScratchThreadPromotion.ts";
 import * as McpAppRequests from "./mcpApps/McpAppRequests.ts";
 import * as ModelManifest from "./provider/ModelManifest.ts";
 import * as Orchestrator from "./orchestration-v2/Orchestrator.ts";
@@ -593,6 +594,7 @@ it.effect(
           scratchRoot: Effect.succeedNone,
           namedProjectsRoot: process.cwd(),
         }),
+        Layer.mock(ScratchThreadPromotion.ScratchThreadPromotion)({}),
         Layer.mock(ServerEnvironment.ServerEnvironment)({
           getDescriptor: Effect.succeed({
             environmentId: EnvironmentId.make("config-test"),
@@ -769,6 +771,7 @@ it.effect("on-demand clients get provider config without workspace snapshots", (
         scratchRoot: Effect.succeedNone,
         namedProjectsRoot: process.cwd(),
       }),
+      Layer.mock(ScratchThreadPromotion.ScratchThreadPromotion)({}),
       Layer.mock(ServerEnvironment.ServerEnvironment)({
         getDescriptor: Effect.succeed({
           environmentId: EnvironmentId.make("config-test"),
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index e1d6303b23506..8c8509550bc11 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -214,6 +214,7 @@ import * as ProjectEnrichmentService from "./project/ProjectEnrichmentService.ts
 import * as ProjectService from "./project/ProjectService.ts";
 import { threadWorkspaceRoot } from "./project/threadWorkspaceRoot.ts";
 import * as ManagedProjectFolders from "./project/ManagedProjectFolders.ts";
+import * as ScratchThreadPromotion from "./project/ScratchThreadPromotion.ts";
 import { projectMutationOperation } from "./project/ProjectMutation.ts";
 import * as ProjectCloneTracker from "./project/ProjectCloneTracker.ts";
 import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts";
@@ -1238,6 +1239,7 @@ export const layerWsRpc = (
       const projectStore = yield* ProjectStore.ProjectStoreV2;
       const projectService = yield* ProjectService.ProjectService;
       const managedFolders = yield* ManagedProjectFolders.ManagedProjectFolders;
+      const scratchThreadPromotion = yield* ScratchThreadPromotion.ScratchThreadPromotion;
       const eventLoopMonitor = yield* EventLoopMonitor.EventLoopMonitor;
       const threadSearch = yield* ThreadSearch.ThreadSearch;
 
@@ -2716,6 +2718,14 @@ export const layerWsRpc = (
                 (cause) => new OrchestrationDispatchCommandError({ message: cause.message, cause }),
               ),
             ),
+        [WS_METHODS.projectsCreateFromThread]: (input) =>
+          scratchThreadPromotion
+            .promote(input)
+            .pipe(
+              Effect.mapError(
+                (cause) => new OrchestrationDispatchCommandError({ message: cause.message, cause }),
+              ),
+            ),
         [WS_METHODS.projectCloneCancel]: (input) =>
           projectCloneTracker.cancel(input.projectId).pipe(Effect.map((applied) => ({ applied }))),
         [WS_METHODS.projectCloneRetry]: (input) =>
@@ -3020,6 +3030,7 @@ export const layerWsRpc = (
         [WS_METHODS.deviceConfigure]: (input) => deviceService.configure(input),
         [WS_METHODS.deviceTestHost]: (input) => deviceService.testHost(input),
         [WS_METHODS.deviceEasAccount]: (input) => deviceService.easAccount(input),
+        [WS_METHODS.deviceSimlockIdentity]: (input) => deviceService.simlockIdentity(input),
         [WS_METHODS.deviceList]: (input) =>
           input.inspectOnly && !input.updateTool
             ? deviceService.inspect
diff --git a/apps/web/package.json b/apps/web/package.json
index 729d44f8ea6cd..2ee8fe51a06a3 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@t3tools/web",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/apps/web/src/components/ChatMarkdown.browser.test.tsx b/apps/web/src/components/ChatMarkdown.browser.test.tsx
index 345bde84976c3..745e69087cb1e 100644
--- a/apps/web/src/components/ChatMarkdown.browser.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.browser.test.tsx
@@ -328,6 +328,22 @@ describe("ChatMarkdown headings", () => {
   });
 });
 
+describe("ChatMarkdown inline code selection", () => {
+  it("selects the whole inline code span on double-click, but only a word in fenced code", async () => {
+    setup();
+    await using screen = await renderText(
+      "Run `migration-gate --dry-run` first.\n\n```txt\nfenced-block word\n```",
+    );
+    await userEvent.dblClick(screen.getByText("migration-gate --dry-run"));
+    expect(window.getSelection()?.toString()).toBe("migration-gate --dry-run");
+
+    window.getSelection()?.removeAllRanges();
+    const fenced = screen.container.querySelector("pre code")!;
+    await userEvent.dblClick(fenced, { position: { x: 4, y: 4 } });
+    expect(window.getSelection()?.toString()).toBe("fenced");
+  });
+});
+
 describe("ChatMarkdown Windows file links", () => {
   const environmentId = EnvironmentId.make("env-windows");
   const renderWindows = (text: string, parseRawHtml: boolean) =>
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 32f15bcf542d7..6a8f80d6d1071 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -74,6 +74,7 @@ import React, {
   Suspense,
   type ComponentProps,
   type ClipboardEvent as ReactClipboardEvent,
+  type MouseEvent as ReactMouseEvent,
   use,
   memo,
   useLayoutEffect,
@@ -942,6 +943,11 @@ function markdownHeadingRenderer(level: 1 | 2 | 3 | 4 | 5 | 6) {
   };
 }
 
+// Native word selection stops at hyphens and dots, so a double-click takes the whole span.
+function selectInlineCode(event: ReactMouseEvent<HTMLElement>) {
+  window.getSelection()?.selectAllChildren(event.currentTarget);
+}
+
 const CHAT_MARKDOWN_COMPONENTS = {
   h1: markdownHeadingRenderer(1),
   h2: markdownHeadingRenderer(2),
@@ -1334,6 +1340,11 @@ const CHAT_MARKDOWN_COMPONENTS = {
           inlineCodeFilePathCandidate(codeText) ?? codeText.trim(),
         );
       }
+      return (
+        <code {...props} className={className} onDoubleClick={selectInlineCode}>
+          {children}
+        </code>
+      );
     }
     return (
       <code {...props} className={className}>
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 253cc1ea2e84b..665bb2fc5f5cf 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -1,5 +1,6 @@
 import { workspaceAreaProps } from "../lib/workspaceFocus";
 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
+import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
 import { queuedRunEditBlockedReason } from "@t3tools/client-runtime/queued-run-edit";
 import { ScrollToEndButton, WorkspaceFileDropOverlay } from "./chat/TimelineOverlays";
 import { usePasteToFocusComposer } from "./chat/usePasteToFocusComposer";
@@ -189,6 +190,7 @@ import { newMessageId } from "~/lib/utils";
 import {
   NO_PROVIDER_MODEL_SELECTION,
   providerInstanceEntriesFor,
+  resolveProjectDefaultProviderModelSelection,
   shouldShowInstanceBadge,
 } from "../providerInstances";
 import {
@@ -304,7 +306,8 @@ import { useThreadLinkedPullRequest } from "./pullRequest/useThreadLinkedPullReq
 import { useProactivePanels } from "../hooks/useProactivePanels";
 import { useIncrementalTimelineEntries } from "../hooks/useIncrementalTimelineEntries";
 import { useRightPanelSurfaceClose } from "../hooks/useRightPanelSurfaceClose";
-import type { ComposerBannerStackItem } from "./chat/ComposerBannerStack";
+import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/ComposerBannerStack";
+import { modelFallbackBannerItem } from "./chat/ComposerUsageLimits";
 import { ComposerSurface } from "./chat/ComposerSurface";
 import { resolveThreadSyncPhase } from "../threadSync";
 import {
@@ -400,6 +403,8 @@ type ChatViewProps =
       draftId: DraftId;
     };
 
+const DismissedFallbackWindowSchema = Schema.NullOr(Schema.String);
+
 export default function ChatView(props: ChatViewProps) {
   const {
     environmentId,
@@ -586,6 +591,9 @@ export default function ChatView(props: ChatViewProps) {
       ? (draft.modelSelectionByProvider[draft.activeProvider] ?? null)
       : null;
   });
+  const composerModelSelectionExplicit = useComposerDraftStore(
+    (store) => store.getComposerDraft(composerDraftTarget)?.modelSelectionExplicit === true,
+  );
   const composerHasAttachments = useComposerDraftStore((store) => {
     const draft = store.getComposerDraft(composerDraftTarget);
     return (draft?.images.length ?? 0) > 0 || (draft?.files.length ?? 0) > 0;
@@ -751,15 +759,37 @@ export default function ChatView(props: ChatViewProps) {
       });
     }
   }
+  const nowMinute = useNowMinute();
+  const draftDefaultModelSelection = draftThread
+    ? resolveProjectSettings(
+        settings,
+        fallbackDraftProject?.id ?? null,
+        fallbackDraftProject ?? undefined,
+      ).settings.defaultModelSelection
+    : null;
+  const draftModelResolution = draftThread
+    ? resolveNewThreadModelSelection({
+        defaultSelection:
+          draftDefaultModelSelection ??
+          resolveProjectDefaultProviderModelSelection(
+            providersByEnvironment.get(draftThread.environmentId) ?? [],
+            settings,
+            draftThread.projectId,
+          ),
+        fallbackSelection: settings.fallbackModelSelection,
+        providers: providersByEnvironment.get(draftThread.environmentId) ?? [],
+        settings,
+        projectId: draftThread.projectId,
+        now: Date.parse(`${nowMinute}:00Z`),
+      })
+    : null;
+  const draftFallback = draftModelResolution?.fallback ? draftModelResolution : null;
   const localDraftThread = draftThread
     ? buildLocalDraftThread(
         threadId,
         draftThread,
-        resolveProjectSettings(
-          settings,
-          fallbackDraftProject?.id ?? null,
-          fallbackDraftProject ?? undefined,
-        ).settings.defaultModelSelection ?? NO_PROVIDER_MODEL_SELECTION,
+        (draftFallback ? draftFallback.selection : draftDefaultModelSelection) ??
+          NO_PROVIDER_MODEL_SELECTION,
       )
     : undefined;
   const isServerThread = serverThread !== null;
@@ -1052,7 +1082,10 @@ export default function ChatView(props: ChatViewProps) {
   const activeProjectScripts = activeProject ? resolveProjectScripts(settings, activeProject) : [];
   const { projectCloneBannerItem, projectCloneSendBlockReason } =
     useProjectCloneBanner(activeProjectRef);
-  const activeProjectDefaultModelSelection = activeProjectSettings.settings.defaultModelSelection;
+  const activeProjectDefaultModelSelection =
+    !isServerThread && draftFallback
+      ? draftFallback.selection
+      : activeProjectSettings.settings.defaultModelSelection;
   const handleNewThreadInActiveProject = () => {
     startNewThreadForProject(activeProjectRef, handleNewThread);
   };
@@ -1624,6 +1657,11 @@ export default function ChatView(props: ChatViewProps) {
     resumeCompactionPermanentlyDismissed,
     setResumeCompactionPermanentlyDismissed,
   ]);
+  const [dismissedFallbackWindow, setDismissedFallbackWindow] = useLocalStorage(
+    `t3code:fallback-notice-dismissed:${environmentId}`,
+    null,
+    DismissedFallbackWindowSchema,
+  );
   const providerStatusBannerKey = getProviderStatusBannerKey(activeProviderStatus);
   const [dismissedProviderStatusBannerKey, setDismissedProviderStatusBannerKey] = useState<
     string | null
@@ -2308,7 +2346,6 @@ export default function ChatView(props: ChatViewProps) {
     closeRightPanelSurface,
   });
   const pullRequestSurfaceAvailable = supportsPullRequests && pullRequestPanelTarget !== null;
-  const nowMinute = useNowMinute();
   const {
     acknowledgeActiveThreadWoke,
     activeBranchMismatchKey,
@@ -2478,12 +2515,58 @@ export default function ChatView(props: ChatViewProps) {
         })
       : null;
   const composerBannerItems = (() => {
+    const fallbackSelection = draftFallback?.selection;
+    const defaultSelection =
+      draftDefaultModelSelection ??
+      resolveProjectDefaultProviderModelSelection(
+        providerStatuses,
+        settings,
+        draftThread?.projectId ?? null,
+      );
+    const fallback =
+      !isServerThread &&
+      multipleModelSelections === null &&
+      !composerModelSelectionExplicit &&
+      draftFallback?.fallback &&
+      (!composerSelectedModelSelection ||
+        (composerSelectedModelSelection.instanceId === fallbackSelection?.instanceId &&
+          composerSelectedModelSelection.model === fallbackSelection?.model))
+        ? draftFallback.fallback
+        : null;
+    const fallbackWindow = fallback
+      ? `${fallback.provider.instanceId}:${fallback.resetsAt ?? ""}`
+      : null;
+    const fallbackItems: ComposerBannerStackItem[] =
+      fallback &&
+      fallbackSelection &&
+      defaultSelection &&
+      fallbackWindow !== dismissedFallbackWindow
+        ? [
+            modelFallbackBannerItem({
+              fallbackModelName:
+                providerStatuses
+                  .find((provider) => provider.instanceId === fallbackSelection.instanceId)
+                  ?.models.find((model) => model.slug === fallbackSelection.model)?.name ??
+                fallbackSelection.model,
+              defaultProviderName: fallback.provider.displayName ?? fallback.provider.driver,
+              defaultModelName:
+                fallback.provider.models.find((model) => model.slug === defaultSelection.model)
+                  ?.name ?? defaultSelection.model,
+              resetsAt: fallback.resetsAt,
+              timestampFormat,
+              onUseDefault: () =>
+                onProviderModelSelectStable(defaultSelection.instanceId, defaultSelection.model),
+              onDismiss: () => setDismissedFallbackWindow(fallbackWindow),
+            }),
+          ]
+        : [];
     const limitRecoveryItems = limitRecoveryBanner === null ? [] : [limitRecoveryBanner];
     const usageLimitsItems = usageLimitsBanner === null ? [] : [usageLimitsBanner];
     const projectCloneItems = projectCloneBannerItem === null ? [] : [projectCloneBannerItem];
     if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) {
       return [
         ...feedbackBannerItems,
+        ...fallbackItems,
         ...limitRecoveryItems,
         ...usageLimitsItems,
         ...projectCloneItems,
@@ -2492,6 +2575,7 @@ export default function ChatView(props: ChatViewProps) {
     }
     return [
       ...feedbackBannerItems,
+      ...fallbackItems,
       ...limitRecoveryItems,
       ...usageLimitsItems,
       ...projectCloneItems,
@@ -3432,7 +3516,7 @@ export default function ChatView(props: ChatViewProps) {
                                             : projectCloneSendBlockReason
                               }
                               isPreparingWorktree={isPreparingWorktree && !sendQueuesBehindSetup}
-                              bannerItems={composerBannerItems}
+                              bannerItems={isDraftHeroState ? [] : composerBannerItems}
                               resumeCompactionTokens={resumeCompactionTokens}
                               keepFullHistory={keepFullHistory}
                               onToggleKeepFullHistory={toggleKeepFullHistoryStable}
@@ -3598,6 +3682,12 @@ export default function ChatView(props: ChatViewProps) {
                           )}
                         </div>
                       </div>
+                      {isDraftHeroState && composerBannerItems.length > 0 ? (
+                        // Out of flow, like the headline, so a notice never moves the centered composer.
+                        <div className="absolute inset-x-0 top-full flex flex-col gap-1 pt-4">
+                          <ComposerBannerStack items={composerBannerItems} detached />
+                        </div>
+                      ) : null}
                     </ComposerSurface.Shell>
                     <div
                       aria-hidden
@@ -3686,6 +3776,12 @@ export default function ChatView(props: ChatViewProps) {
               onAddProjectScript={saveProjectScriptStable}
               onUpdateProjectScript={updateProjectScriptStable}
               onDeleteProjectScript={deleteProjectScriptStable}
+              usage={{
+                providerInstanceId: activeProviderInstanceId,
+                providers: providerStatuses,
+                sources: serverConfig?.usageLimitSources ?? EMPTY_USAGE_LIMIT_SOURCES,
+                contextWindow: activeContextWindow,
+              }}
             />
 
             <PullRequestThreadDialogHost
diff --git a/apps/web/src/components/ContextChip.tsx b/apps/web/src/components/ContextChip.tsx
index 6ef34db857123..fcd4c9e4fed30 100644
--- a/apps/web/src/components/ContextChip.tsx
+++ b/apps/web/src/components/ContextChip.tsx
@@ -12,8 +12,7 @@ const contextChipVariants = cva(
     variants: {
       kind: {
         neutral: "[--context-chip-accent:currentColor]",
-        image:
-          "rounded-lg border border-(--context-chip-accent)/30 bg-(--context-chip-accent)/10 px-1.5 [--context-chip-accent:var(--context-chip-image)]",
+        image: "[--context-chip-accent:var(--context-chip-image)]",
         video: "[--context-chip-accent:var(--context-chip-video)]",
         file: "[--context-chip-accent:var(--context-chip-file)]",
         mention: "[--context-chip-accent:var(--context-chip-mention)]",
diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsx
index c257d0ea52d34..ddce50db3cfe3 100644
--- a/apps/web/src/components/DiffPanel.tsx
+++ b/apps/web/src/components/DiffPanel.tsx
@@ -12,6 +12,7 @@ import {
   CheckIcon,
   ChevronDownIcon,
   Columns2Icon,
+  FlaskConicalOffIcon,
   FolderTreeIcon,
   PilcrowIcon,
   Rows3Icon,
@@ -37,6 +38,8 @@ import {
   useDiffPanelStore,
 } from "../diffPanelStore";
 import { useLocalStorage } from "../hooks/useLocalStorage";
+import { isTestChangedFile } from "@t3tools/shared/changedFileKind";
+import { useHideTestFiles } from "./diffs/useHideTestFiles";
 import { useRenderedAppearance } from "../hooks/useTheme";
 import { useStableCallback } from "../hooks/useStableCallback";
 import {
@@ -218,6 +221,7 @@ export default function DiffPanel({
     false,
     Schema.Boolean,
   );
+  const [hideTestFiles, setHideTestFiles] = useHideTestFiles();
   const [baseRefQuery, setBaseRefQuery] = useState("");
   const [codeViewRevision, setCodeViewRevision] = useState(0);
 
@@ -539,6 +543,16 @@ export default function DiffPanel({
   const isRefreshingDiff = branchDiffPreview.isPending || areFilePatchesPending;
   const renderableFileEntries = renderableFiles.map(getCachedFileEntry);
   const diffFileKeys = renderableFileEntries.map((file) => file.fileKey);
+  const testFileCount = renderableFiles.filter((file) =>
+    isTestChangedFile(resolveFileDiffPath(file)),
+  ).length;
+  // Hiding is display-only: lazy loading indexes into the full list. A requested file stays visible.
+  const isFileShown = (file: FileDiffMetadata) => {
+    const path = resolveFileDiffPath(file);
+    return !hideTestFiles || path === selectedFilePath || !isTestChangedFile(path);
+  };
+  const shownFileEntries = renderableFileEntries.filter(({ fileDiff }) => isFileShown(fileDiff));
+  const shownFileKeys = shownFileEntries.map((file) => file.fileKey);
   const defaultCollapsedDiffFileKeys = settings.diffFilesCollapsed
     ? new Set(diffFileKeys)
     : EMPTY_COLLAPSED_DIFF_FILE_KEYS;
@@ -561,7 +575,7 @@ export default function DiffPanel({
         count={renderableFiles.length - settledFileCount}
       />
     ) : null;
-  const codeViewFiles = renderableFileEntries
+  const codeViewFiles = shownFileEntries
     .filter(
       ({ fileDiff }) =>
         !lazySource || !readyFilePaths || readyFilePaths.has(resolveFileDiffPath(fileDiff)),
@@ -574,10 +588,12 @@ export default function DiffPanel({
       collapsed:
         collapsedDiffFileKeys.has(fileKey) || fileDiff.cacheKey?.endsWith(":pending") === true,
     }));
-  const pendingFiles = renderableFiles.filter((file) => file.cacheKey?.endsWith(":pending"));
-  const allDiffFilesCollapsed = areAllDiffFilesCollapsed(diffFileKeys, collapsedDiffFileKeys);
+  const pendingFiles = renderableFiles.filter(
+    (file) => file.cacheKey?.endsWith(":pending") && isFileShown(file),
+  );
+  const allDiffFilesCollapsed = areAllDiffFilesCollapsed(shownFileKeys, collapsedDiffFileKeys);
   const diffLineStat = sourceLineStat ?? getDiffLineStat(renderableFiles);
-  const fileTreeEntries = diffFileTreeEntries(renderableFiles);
+  const fileTreeEntries = diffFileTreeEntries(renderableFiles.filter(isFileShown));
   const codeViewReveal = useCodeViewFileReveal();
   const revealDiffFile = (filePath: string) => {
     const index = renderableFileEntries.findIndex(
@@ -661,7 +677,7 @@ export default function DiffPanel({
 
   const toggleDiffFileCollapse = () => {
     setCodeViewRevision((current) => current + 1);
-    updateCollapsedDiffFiles((current) => toggleAllDiffFiles(diffFileKeys, current));
+    updateCollapsedDiffFiles((current) => toggleAllDiffFiles(shownFileKeys, current));
   };
 
   const selectTurn = (runId: RunId) => {
@@ -991,6 +1007,28 @@ export default function DiffPanel({
             {diffIgnoreWhitespace ? "Show whitespace changes" : "Hide whitespace changes"}
           </TooltipPopup>
         </Tooltip>
+        {testFileCount > 0 && (
+          <Tooltip>
+            <TooltipTrigger
+              render={
+                <Toggle
+                  aria-label="Hide test files"
+                  variant="ghost"
+                  size="sm"
+                  pressed={hideTestFiles}
+                  onPressedChange={(pressed) => setHideTestFiles(Boolean(pressed))}
+                />
+              }
+            >
+              <FlaskConicalOffIcon className="size-3.5" />
+            </TooltipTrigger>
+            <TooltipPopup side="top">
+              {hideTestFiles
+                ? `Show ${testFileCount} hidden test ${testFileCount === 1 ? "file" : "files"}`
+                : "Hide test files"}
+            </TooltipPopup>
+          </Tooltip>
+        )}
         {diffFileKeys.length > 0 && (
           <Tooltip>
             <TooltipTrigger
diff --git a/apps/web/src/components/GitActionsControl.tsx b/apps/web/src/components/GitActionsControl.tsx
index 7c017223daf74..cae352e6d6b26 100644
--- a/apps/web/src/components/GitActionsControl.tsx
+++ b/apps/web/src/components/GitActionsControl.tsx
@@ -117,6 +117,8 @@ interface GitActionsControlProps {
   activeThreadRef: ScopedThreadRef | null;
   draftId?: DraftId;
   compact?: boolean;
+  showActions?: boolean;
+  showChanges?: boolean;
   onOpenChanges?: () => void;
 }
 
@@ -926,6 +928,8 @@ export default function GitActionsControl({
   activeThreadRef,
   draftId,
   compact = false,
+  showActions = true,
+  showChanges = true,
   onOpenChanges,
 }: GitActionsControlProps) {
   const panelAnchorRef = useRef<HTMLDivElement | null>(null);
@@ -1476,7 +1480,7 @@ export default function GitActionsControl({
 
   return (
     <>
-      {!isRepo ? (
+      {!showActions ? null : !isRepo ? (
         <ThreadDetailsControl
           size="xs"
           variant="ghost"
@@ -1618,7 +1622,7 @@ export default function GitActionsControl({
         </div>
       )}
 
-      {isRepo && !quietEmptyDraft ? (
+      {showChanges && isRepo && !quietEmptyDraft ? (
         <ThreadDetailsControl
           type="button"
           variant="ghost"
@@ -1826,13 +1830,16 @@ export default function GitActionsControl({
         </DialogPopup>
       </Dialog>
 
-      <PublishRepositoryDialog
-        open={isPublishDialogOpen}
-        onOpenChange={setIsPublishDialogOpen}
-        environmentId={activeEnvironmentId}
-        threadRef={activeThreadRef}
-        gitCwd={gitCwd}
-      />
+      {/* Its discovery query should stop when the Git actions row that opens it is hidden. */}
+      {showActions ? (
+        <PublishRepositoryDialog
+          open={isPublishDialogOpen}
+          onOpenChange={setIsPublishDialogOpen}
+          environmentId={activeEnvironmentId}
+          threadRef={activeThreadRef}
+          gitCwd={gitCwd}
+        />
+      ) : null}
 
       <Dialog
         open={pendingDefaultBranchAction !== null}
diff --git a/apps/web/src/components/ServerUpdateAction.browser.test.tsx b/apps/web/src/components/ServerUpdateAction.browser.test.tsx
index 5f793b3ca90e4..ed3a723652a56 100644
--- a/apps/web/src/components/ServerUpdateAction.browser.test.tsx
+++ b/apps/web/src/components/ServerUpdateAction.browser.test.tsx
@@ -14,6 +14,7 @@ const testState = vi.hoisted(() => ({
   toast: vi.fn(),
   clipboard: vi.fn(),
   sessionAtom: null as unknown,
+  serverVersions: new Map<string, string>(),
 }));
 
 vi.mock(import("~/hooks/useCopyToClipboard"), async (original) => ({
@@ -36,6 +37,16 @@ vi.mock(import("~/state/session"), async (original) => {
     },
   };
 });
+vi.mock(import("~/state/entities"), async (original) => ({
+  ...(await original()),
+  useServerConfigs: (() =>
+    new Map(
+      [...testState.serverVersions].map(([id, serverVersion]) => [
+        id,
+        { environment: { serverVersion } },
+      ]),
+    )) as never,
+}));
 vi.mock(import("~/state/use-atom-command"), async (original) => ({
   ...(await original()),
   useAtomCommand: (() => testState.updateServer) as never,
@@ -84,6 +95,7 @@ function setup(): Disposable {
   testState.updateServer.mockReset();
   testState.toast.mockReset();
   testState.clipboard.mockReset();
+  testState.serverVersions.clear();
   sessionAtom = Atom.make<SessionResult>(AsyncResult.success(currentSession));
   testState.sessionAtom = sessionAtom;
   resetConfirmDialogForTests();
@@ -212,4 +224,17 @@ describe("ServerUpdatesAction", () => {
     );
     expect(button(screen, "Update all")!.disabled).toBe(false);
   });
+
+  it("skips a machine whose update would cross Stable and Nightly", async () => {
+    using _state = setup();
+    testState.serverVersions.set("batch-a", "0.0.30-nightly.20261001.1");
+    testState.updateServer.mockResolvedValue(success());
+    await using screen = await mount();
+    await click(screen, "Update all");
+
+    expect(testState.updateServer).toHaveBeenCalledTimes(1);
+    expect(testState.toast).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "success", title: "Office updated" }),
+    );
+  });
 });
diff --git a/apps/web/src/components/ServerUpdateAction.tsx b/apps/web/src/components/ServerUpdateAction.tsx
index 3f7675cd96631..141f139aefd7b 100644
--- a/apps/web/src/components/ServerUpdateAction.tsx
+++ b/apps/web/src/components/ServerUpdateAction.tsx
@@ -7,6 +7,7 @@ import {
 import type { AsyncResult } from "effect/reactivity";
 import { environmentSession } from "~/state/session";
 import type {
+  DesktopUpdateChannel,
   EnvironmentId,
   ServerInstallation,
   ServerSelfUpdateCapability,
@@ -26,6 +27,8 @@ import { serverEnvironment, updateOutdatedServer } from "~/state/server";
 import { appAtomRegistry } from "~/rpc/atomRegistry";
 import { useAtomCommand } from "~/state/use-atom-command";
 import { manualServerUpdateCommand } from "~/versionSkew";
+import { useServerConfigs } from "~/state/entities";
+import { crossesReleaseTrack } from "@t3tools/shared/cliRelease";
 import { Button } from "./ui/button";
 import { toastManager } from "./ui/toast";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
@@ -41,6 +44,29 @@ export function serverUpdateStageLabel(stage: ServerUpdateStage): string {
   return UPDATE_STAGE_LABELS[stage];
 }
 
+const CROSS_TRACK_NOTE = "Switch tracks in About → Update track";
+
+/** Hosts refuse a Stable/Nightly crossing outside a track switch, which checks the database first. */
+function refusedCrossing(
+  target: {
+    readonly selfUpdate: ServerSelfUpdateCapability | null;
+    readonly targetVersion: string;
+    readonly channel?: DesktopUpdateChannel | undefined;
+  },
+  serverVersion: string | undefined,
+): boolean {
+  return (
+    target.channel === undefined &&
+    target.selfUpdate !== null &&
+    serverVersion !== undefined &&
+    crossesReleaseTrack(serverVersion, target.targetVersion)
+  );
+}
+
+function CrossTrackNote() {
+  return <span className="text-muted-foreground text-xs">{CROSS_TRACK_NOTE}</span>;
+}
+
 function updateFailureMessage(error: unknown): string {
   return error instanceof Error ? error.message : "Server update failed.";
 }
@@ -52,6 +78,12 @@ export interface ServerUpdateTarget {
   readonly installation?: ServerInstallation | undefined;
   readonly desktopAppUpdate?: boolean;
   readonly targetVersion: string;
+  /** Set only by a track switch; the host's desktop app moves to this track. */
+  readonly channel?: DesktopUpdateChannel;
+  /** A track switch's checked release migration; the host re-checks its own database. */
+  readonly targetDatabaseMigration?: number;
+  /** The host already runs its track's newest build and only saves the track. */
+  readonly trackOnly?: boolean;
 }
 
 type UpdateButtonProps = Pick<ComponentProps<typeof Button>, "variant" | "size" | "className"> & {
@@ -79,7 +111,13 @@ export function useServerUpdate() {
     pendingUpdateEnvironmentIds.add(environmentId);
     const result = await updateServer({
       environmentId,
-      input: { targetVersion },
+      input: {
+        targetVersion,
+        ...(target.channel === undefined ? {} : { channel: target.channel }),
+        ...(target.targetDatabaseMigration === undefined
+          ? {}
+          : { targetDatabaseMigration: target.targetDatabaseMigration }),
+      },
     });
     pendingUpdateEnvironmentIds.delete(environmentId);
     if (result._tag === "Failure") {
@@ -118,12 +156,14 @@ export function ServerUpdatesAction({
   readonly targets: ReadonlyArray<ServerUpdateTarget>;
 }) {
   const update = useServerUpdate();
+  const serverConfigs = useServerConfigs();
   const pending = useRef(false);
   const [isPending, setIsPending] = useState(false);
   const eligible = targets.filter(
     (target) =>
       target.selfUpdate !== null &&
-      (target.selfUpdate !== "desktop-managed" || target.desktopAppUpdate),
+      (target.selfUpdate !== "desktop-managed" || target.desktopAppUpdate) &&
+      !refusedCrossing(target, serverConfigs.get(target.environmentId)?.environment.serverVersion),
   );
   const handleUpdate = async () => {
     if (pending.current) return;
@@ -198,6 +238,7 @@ export function ServerUpdateAction({
   installation,
   desktopAppUpdate = false,
   targetVersion,
+  channel,
   label = "Update",
   variant = "outline",
   size = "xs",
@@ -205,6 +246,7 @@ export function ServerUpdateAction({
   appearance = "button",
 }: ServerUpdateTarget & UpdateButtonProps) {
   const isDesktopAppUpdate = selfUpdate === "desktop-managed";
+  const serverVersion = useServerConfigs().get(environmentId)?.environment.serverVersion;
   const sessionStateAtom = environmentSession.sessionStateAtom(environmentId);
   const canUpdate = canUpdateServer(useAtomValue(sessionStateAtom));
   const update = useServerUpdate();
@@ -264,6 +306,10 @@ export function ServerUpdateAction({
     );
   }
 
+  if (refusedCrossing({ selfUpdate, targetVersion, channel }, serverVersion)) {
+    return <CrossTrackNote />;
+  }
+
   const manualCommand =
     selfUpdate === null ? manualServerUpdateCommand(targetVersion, installation) : null;
   const actionLabel =
@@ -351,6 +397,9 @@ export function OutdatedServerUpdateAction({
       description: `Reconnected on t3@${result.value.targetVersion}.`,
     });
   };
+  if (fromVersion !== undefined && crossesReleaseTrack(fromVersion, targetVersion)) {
+    return <CrossTrackNote />;
+  }
   return (
     <Button size="xs" variant="outline" onClick={() => void handleUpdate()}>
       {label}
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index c4ba300a030c3..de16be6d2dcfb 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -115,7 +115,11 @@ import {
   getThreadKeysToDeselectAfterDelete,
   useThreadSelectionStore,
 } from "../threadSelectionStore";
-import { useAcknowledgeThreadWoke, useThreadActions } from "../hooks/useThreadActions";
+import {
+  canTurnThreadIntoProject,
+  useAcknowledgeThreadWoke,
+  useThreadActions,
+} from "../hooks/useThreadActions";
 import { useHandleNewThread } from "../hooks/useHandleNewThread";
 import { useSidebarProjectGroups } from "../hooks/useSidebarProjectGroups";
 import { useTerminalFocus } from "../hooks/useTerminalFocus";
@@ -897,6 +901,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
     unpinThread,
     confirmAndUnpinThread,
     setThreadAutoSettle,
+    turnThreadIntoProject,
     reorderPinnedThread,
     reorderActiveThread,
     markThreadUnread,
@@ -2558,6 +2563,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
               canShareWithGuest: appAtomRegistry.get(
                 canShareWithGuestAtom(threadRef.environmentId),
               ),
+              canTurnIntoProject: canTurnThreadIntoProject(threadRef),
               supports: {
                 settlement: configLoaded,
                 autoSettleOptOut: supportsAutoSettleOptOut,
@@ -2638,6 +2644,26 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
           case "unpin":
             attemptUnpin(threadRef);
             return;
+          case "turn-into-project": {
+            const result = await turnThreadIntoProject(threadRef);
+            if (result._tag === "Success") {
+              toastManager.add({
+                type: "success",
+                title: "Project created",
+                description: thread.title,
+              });
+            } else if (!isAtomCommandInterrupted(result)) {
+              const error = squashAtomCommandFailure(result);
+              toastManager.add(
+                stackedThreadToast({
+                  type: "error",
+                  title: "Could not turn thread into a project",
+                  description: error instanceof Error ? error.message : "An error occurred.",
+                }),
+              );
+            }
+            return;
+          }
           case "auto-settle:enabled":
           case "auto-settle:disabled": {
             const result = await setThreadAutoSettle(
@@ -3371,7 +3397,6 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
                                 className="mt-auto"
                                 label="Working"
                                 count={workingThreads.length}
-                                hostsUndoNotice
                                 toggle={{
                                   expanded: workingShelfExpanded,
                                   onToggle: toggleWorkingShelf,
@@ -3387,7 +3412,6 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
                                 className={cn(workingThreads.length === 0 && "mt-auto")}
                                 label="Snoozed"
                                 count={snoozedThreads.length}
-                                hostsUndoNotice={workingThreads.length === 0}
                                 toggle={{
                                   expanded: snoozedShelfExpanded,
                                   onToggle: toggleSnoozedShelf,
@@ -3405,9 +3429,6 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
                                 )}
                                 label="Settled"
                                 count={settledCount}
-                                hostsUndoNotice={
-                                  workingThreads.length + snoozedThreads.length === 0
-                                }
                                 dragging={from !== null}
                                 isDropTarget={dragTargetSection === "settled"}
                                 toggle={{
@@ -3502,9 +3523,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
           ) : null}
         </SidebarGroup>
       </SidebarContent>
-      <SidebarChromeFooter
-        showUndoNotice={isSearchingThreads || sidebarListItemsFresh.length === 0}
-      />
+      <SidebarChromeFooter />
     </>
   );
 }
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index 57838e598161e..d7878cc29a165 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -241,7 +241,7 @@ import {
   type ThreadShell,
 } from "../../types";
 import { type ComposerPromptHistoryPosition } from "./composerPromptHistory";
-import type { PendingUserInputDraftAnswer } from "../../pendingUserInput";
+import type { PendingUserInputDraftAnswer } from "@t3tools/client-runtime/state/pending-user-input";
 import type {
   LatestProposedPlanState,
   PendingApproval,
diff --git a/apps/web/src/components/chat/ComposerBanner.tsx b/apps/web/src/components/chat/ComposerBanner.tsx
index ef07497171ee2..0710f2534dada 100644
--- a/apps/web/src/components/chat/ComposerBanner.tsx
+++ b/apps/web/src/components/chat/ComposerBanner.tsx
@@ -33,27 +33,36 @@ const variantColors: Record<ComposerBannerVariant, string> = {
     "[--chat-composer-attached-outline:color-mix(in_srgb,var(--warning)_28%,transparent)] [--chat-composer-attached-tint:color-mix(in_srgb,var(--warning)_8%,transparent)]",
 };
 
+/**
+ * An attached surface tucks its bottom under the card below it. A detached one is a whole card
+ * of its own, for a notice that sits apart from the composer.
+ */
 function Surface({
   variant = "default",
+  detached = false,
   className,
   ...props
 }: ComponentProps<"div"> & {
   variant?: ComposerBannerVariant;
+  detached?: boolean;
 }) {
   return (
     <div
-      data-composer-banner-surface="attached"
+      data-composer-banner-surface={detached ? "detached" : "attached"}
       data-variant={variant}
       className={cn(
         surfaceColors,
         "relative isolate border-0 bg-transparent shadow-none [--chat-composer-attached-tint:transparent]",
         variantColors[variant],
-        // Bleed the mask 1px past the seam to cover Chromium's fractional-pixel backdrop loss.
-        "[--chat-composer-attachment-overlap:calc(1rem+1px)] before:rounded-t-2xl before:mask-t-from-transparent before:mask-t-from-4 before:mask-t-to-black before:mask-t-to-4",
+        detached
+          ? "[--chat-composer-attachment-overlap:0px] before:rounded-2xl"
+          : // Bleed the mask 1px past the seam to cover Chromium's fractional-pixel backdrop loss.
+            "[--chat-composer-attachment-overlap:calc(1rem+1px)] before:rounded-t-2xl before:mask-t-from-transparent before:mask-t-from-4 before:mask-t-to-black before:mask-t-to-4",
         "before:pointer-events-none before:absolute before:inset-0 before:-z-1 before:border before:border-(--chat-composer-attached-outline)",
         "before:bg-(--chat-composer-attached-surface)/(--glass-opacity) before:bg-linear-to-b before:from-(--chat-composer-attached-tint) before:to-(--chat-composer-attached-tint) before:backdrop-blur-(--glass-blur) before:backdrop-saturate-(--glass-saturation)",
         "before:shadow-composer dark:before:shadow-composer-dark",
-        "dark:supports-[(backdrop-filter:blur(1px))_or_(-webkit-backdrop-filter:blur(1px))]:before:bg-composer-seam-above",
+        !detached &&
+          "dark:supports-[(backdrop-filter:blur(1px))_or_(-webkit-backdrop-filter:blur(1px))]:before:bg-composer-seam-above",
         "not-supports-[((backdrop-filter:blur(1px))_or_(-webkit-backdrop-filter:blur(1px)))]:before:bg-(--chat-composer-attached-surface)",
         className,
       )}
@@ -108,9 +117,8 @@ function Root({
   variant = "default",
   width = "fill",
   ...props
-}: ComponentProps<"div"> & {
+}: ComponentProps<typeof Surface> & {
   density?: "default" | "comfortable" | "spacious";
-  variant?: ComposerBannerVariant;
   width?: "fill" | "content";
 }) {
   return (
diff --git a/apps/web/src/components/chat/ComposerBannerStack.tsx b/apps/web/src/components/chat/ComposerBannerStack.tsx
index 086826cde86db..755d20ba8c6ae 100644
--- a/apps/web/src/components/chat/ComposerBannerStack.tsx
+++ b/apps/web/src/components/chat/ComposerBannerStack.tsx
@@ -7,7 +7,7 @@ import { ComposerBanner, type ComposerBannerVariant } from "./ComposerBanner";
 import { observeResize } from "~/lib/observeResize";
 
 /**
- * Where a notice sits above the composer. The machine comes first, then what needs you; the
+ * Where a notice sits in the stack. The machine comes first, then what needs you; the
  * order is fixed so rows never trade places as notices come and go.
  */
 export type ComposerBannerGroup = "environment" | "attention";
@@ -27,23 +27,33 @@ export interface ComposerBannerStackItem {
 
 const GROUPS = ["environment", "attention"] as const;
 
+const FADE_IN =
+  "transition-opacity duration-150 ease-out starting:opacity-0 motion-reduce:transition-none";
+
 /**
  * Notices about sending from this composer, each its own attached card. Consecutive cards join
- * edge to edge, and the last joins the composer or the drawer below it.
+ * edge to edge, and the last joins the composer or the drawer below it. Detached cards stand
+ * apart instead, for layouts where the composer must not move when a notice appears.
  */
 export function ComposerBannerStack({
   items,
+  detached = false,
 }: {
   readonly items: ReadonlyArray<ComposerBannerStackItem>;
+  readonly detached?: boolean;
 }) {
-  return GROUPS.flatMap((group) =>
+  const ordered = GROUPS.flatMap((group) =>
     items.filter((item) => (item.group ?? "attention") === group),
-  ).map((item) => (
-    <ComposerBanner.Attachment
-      key={item.id}
-      data-composer-banner-stack="true"
-      className="transition-opacity duration-150 ease-out starting:opacity-0 motion-reduce:transition-none"
-    >
+  );
+  if (detached) {
+    return ordered.map((item) => (
+      <div key={item.id} data-composer-banner-stack="true" className={FADE_IN}>
+        <NoticeCard item={item} detached />
+      </div>
+    ));
+  }
+  return ordered.map((item) => (
+    <ComposerBanner.Attachment key={item.id} data-composer-banner-stack="true" className={FADE_IN}>
       <NoticeCard item={item} />
     </ComposerBanner.Attachment>
   ));
@@ -125,11 +135,18 @@ export function NoticeText({
   );
 }
 
-function NoticeCard({ item }: { readonly item: ComposerBannerStackItem }) {
+function NoticeCard({
+  item,
+  detached = false,
+}: {
+  readonly item: ComposerBannerStackItem;
+  readonly detached?: boolean;
+}) {
   return (
     <ComposerBanner.Root
       role={item.variant === "error" || item.variant === "warning" ? "alert" : undefined}
       variant={item.variant}
+      detached={detached}
       density="comfortable"
       data-chat-composer-collapsed-controls="true"
     >
diff --git a/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx b/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
index 697a0e0bfd6f2..e3e14c4a84005 100644
--- a/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
+++ b/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
@@ -3,10 +3,8 @@ import { memo, use, useEffect, useEffectEvent, useRef, useState } from "react";
 import { BackgroundThreadContext } from "./backgroundThread";
 import { useStableCallback } from "~/hooks/useStableCallback";
 import { type PendingUserInput } from "../../session-logic";
-import {
-  derivePendingUserInputProgress,
-  type PendingUserInputDraftAnswer,
-} from "../../pendingUserInput";
+import type { PendingUserInputDraftAnswer } from "@t3tools/client-runtime/state/pending-user-input";
+import { derivePendingUserInputProgress } from "../../pendingUserInput";
 import { CheckboxMark } from "../ui/checkbox";
 import { Collapsible, CollapsiblePanel, CollapsibleTrigger } from "../ui/collapsible";
 import { Kbd } from "../ui/kbd";
diff --git a/apps/web/src/components/chat/ComposerSurface.tsx b/apps/web/src/components/chat/ComposerSurface.tsx
index 13614b8c9bd4c..213189064ee11 100644
--- a/apps/web/src/components/chat/ComposerSurface.tsx
+++ b/apps/web/src/components/chat/ComposerSurface.tsx
@@ -41,7 +41,7 @@ function Host({ className, ...props }: ComponentProps<"div">) {
         "relative z-10 w-full rounded-2xl shadow-composer after:z-1 dark:shadow-none",
         "group-data-context-row/composer-surface:before:pointer-events-none group-data-context-row/composer-surface:before:absolute group-data-context-row/composer-surface:before:inset-0 group-data-context-row/composer-surface:before:-z-1 group-data-context-row/composer-surface:before:rounded-2xl group-data-context-row/composer-surface:before:bg-(--chat-composer-glass-surface)/(--glass-opacity) group-data-context-row/composer-surface:before:backdrop-blur-(--glass-blur) group-data-context-row/composer-surface:before:backdrop-saturate-(--glass-saturation)",
         outlineClasses,
-        "group-has-data-[composer-banner-surface=attached]/composer-surface:shadow-none group-has-data-[composer-banner-surface=attached]/composer-surface:after:hidden",
+        "group-has-data-[composer-banner-surface=attached]/composer-surface:shadow-none group-has-data-[composer-banner-surface=attached]/composer-surface:before:hidden group-has-data-[composer-banner-surface=attached]/composer-surface:after:hidden",
         className,
       )}
       {...props}
diff --git a/apps/web/src/components/chat/ComposerUsageLimits.tsx b/apps/web/src/components/chat/ComposerUsageLimits.tsx
index 294816c140a29..12c11d213cdf7 100644
--- a/apps/web/src/components/chat/ComposerUsageLimits.tsx
+++ b/apps/web/src/components/chat/ComposerUsageLimits.tsx
@@ -1,8 +1,10 @@
 import type { EnvironmentId, UsageLimitsReport } from "@t3tools/contracts";
+import type { TimestampFormat } from "@t3tools/contracts/settings";
 import { limitsNotice } from "@t3tools/shared/usageLimits";
 import { GaugeIcon } from "lucide-react";
 
 import { ensureLocalApi } from "../../localApi";
+import { formatUpcomingTimestamp } from "../../timestampFormat";
 import { Button } from "../ui/button";
 import { providerClients } from "../settings/providerDriverMeta";
 import { RedactedSensitiveText } from "../settings/RedactedSensitiveText";
@@ -67,6 +69,39 @@ export function usageLimitsBannerItem(
   };
 }
 
+export function modelFallbackBannerItem({
+  fallbackModelName,
+  defaultProviderName,
+  defaultModelName,
+  resetsAt,
+  timestampFormat,
+  onUseDefault,
+  onDismiss,
+}: {
+  readonly fallbackModelName: string;
+  readonly defaultProviderName: string;
+  readonly defaultModelName: string;
+  readonly resetsAt: string | null;
+  readonly timestampFormat: TimestampFormat;
+  readonly onUseDefault: () => void;
+  readonly onDismiss: () => void;
+}): ComposerBannerStackItem {
+  return {
+    id: "fallback-model",
+    variant: "info",
+    icon: <GaugeIcon />,
+    title: `Using ${fallbackModelName}`,
+    description: `${defaultProviderName} is out of usage${resetsAt ? ` · resets ${formatUpcomingTimestamp(resetsAt, timestampFormat)}` : ""}`,
+    actions: (
+      <Button size="xs" variant="ghost" onClick={onUseDefault}>
+        Use {defaultModelName}
+      </Button>
+    ),
+    dismissLabel: "Dismiss fallback model notice",
+    onDismiss,
+  };
+}
+
 function UsageLimitsBannerBody({
   report,
   environmentId,
diff --git a/apps/web/src/components/chat/DraftHeroHeadline.tsx b/apps/web/src/components/chat/DraftHeroHeadline.tsx
index 4a8a894bedbb6..d2e259692204b 100644
--- a/apps/web/src/components/chat/DraftHeroHeadline.tsx
+++ b/apps/web/src/components/chat/DraftHeroHeadline.tsx
@@ -25,7 +25,11 @@ import {
   projectGroupsSpanEnvironments,
 } from "~/sidebarProjectGrouping";
 import { useProjects, useThreadShells } from "~/state/entities";
-import { useEnvironments, usePrimaryEnvironmentId } from "~/state/environments";
+import {
+  useEnvironments,
+  usePrimaryEnvironmentId,
+  useEnvironmentProviders,
+} from "~/state/environments";
 import { ProjectEnvironmentBadge } from "../ProjectEnvironmentBadge";
 import { ProjectFavicon } from "../ProjectFavicon";
 import { sortLogicalProjectsForSidebar } from "../Sidebar.logic";
@@ -45,6 +49,8 @@ import { DraftProjectName } from "./DraftProjectName";
 import { DraftHeroProjectHeading } from "./DraftHeroProjectHeading";
 import { TriageDraftHero } from "./TriageDraftHero";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
+import { resolveProjectDefaultProviderModelSelection } from "../../providerInstances";
+import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
 
 const ADD_PROJECT_VALUE = "add-project";
 
@@ -67,6 +73,7 @@ export function DraftHeroHeadline({
   const projects = useProjects();
   const threads = useThreadShells();
   const { environments } = useEnvironments();
+  const providersByEnvironment = useEnvironmentProviders();
   const primaryEnvironmentId = usePrimaryEnvironmentId();
   const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings);
   const projectSortOrder = useClientSettings((settings) => settings.sidebarProjectSortOrder);
@@ -193,13 +200,33 @@ export function DraftHeroHeadline({
     );
     if (!hasExplicitComposerModelSelection(currentDraft)) {
       applyStickyState(draftId);
-      const environmentSettings = environments.find(
+      const environmentConfig = environments.find(
         (environment) => environment.environmentId === project.environmentId,
-      )?.serverConfig?.settings;
-      const defaultModelSelection = environmentSettings
+      )?.serverConfig;
+      const environmentSettings = environmentConfig?.settings;
+      const defaultSelection = environmentSettings
         ? resolveProjectSettings(environmentSettings, project.id, project).settings
             .defaultModelSelection
         : project.defaultModelSelection;
+      const fallbackResolution = resolveNewThreadModelSelection({
+        defaultSelection:
+          defaultSelection ??
+          (useComposerDraftStore.getState().stickyActiveProvider !== null || !environmentSettings
+            ? null
+            : resolveProjectDefaultProviderModelSelection(
+                providersByEnvironment.get(project.environmentId) ?? [],
+                environmentSettings,
+                project.id,
+              )),
+        fallbackSelection: environmentSettings?.fallbackModelSelection ?? null,
+        providers: providersByEnvironment.get(project.environmentId) ?? [],
+        ...(environmentSettings ? { settings: environmentSettings } : {}),
+        projectId: project.id,
+        now: Date.now(),
+      });
+      const defaultModelSelection = fallbackResolution.fallback
+        ? fallbackResolution.selection
+        : defaultSelection;
       if (defaultModelSelection) {
         setModelSelection(draftId, defaultModelSelection, {
           replaceOptions: true,
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index 3ee079809f14e..8f4b15cc11f91 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -3841,9 +3841,15 @@ it("keeps the working header in place across worktree setup handoff", () => {
 });
 
 describe("failed turn transcript", () => {
-  it.each(["provider_error", "usage_limit"] as const)(
-    "keeps historical %s failures and preceding work visible without disclosures",
-    (failureClass) => {
+  it.each([
+    { position: "historical", failureClass: "provider_error" },
+    { position: "historical", failureClass: "usage_limit" },
+    { position: "latest", failureClass: "usage_limit" },
+  ] as const)(
+    "keeps $position $failureClass failures visible with preceding work grouped appropriately",
+    ({ position, failureClass }) => {
+      const isLatest = position === "latest";
+      const commands = isLatest ? ["pwd", "ls", "false"] : ["pwd"];
       const runId = RunId.make("failed-run");
       const threadId = ThreadId.make("failed-thread");
       const at = DateTime.makeUnsafe("2026-09-20T12:00:00Z");
@@ -3880,23 +3886,24 @@ describe("failed turn transcript", () => {
             attachments: [],
           },
         },
-        {
-          position: 1,
+        ...commands.map((input, index): OrchestrationV2ProjectedTurnItem => ({
+          position: index + 1,
           visibility: "local",
           sourceThreadId: threadId,
-          sourceItemId: TurnItemId.make("command"),
+          sourceItemId: TurnItemId.make(index === 0 ? "command" : `command-${index}`),
           item: {
             ...base,
-            id: TurnItemId.make("command"),
+            id: TurnItemId.make(index === 0 ? "command" : `command-${index}`),
+            ordinal: index + 1,
             type: "command_execution",
             status: "completed",
-            input: "pwd",
+            input,
             output: "",
             exitCode: 0,
           },
-        },
+        })),
         {
-          position: 2,
+          position: commands.length + 1,
           visibility: "local",
           sourceThreadId: threadId,
           sourceItemId: TurnItemId.make("failure"),
@@ -3918,20 +3925,24 @@ describe("failed turn transcript", () => {
         timelineEntries: deriveTimelineEntriesFromVisibleTurnItems({
           visibleTurnItems: items,
           optimisticMessages: [],
-        }).map((entry) => ({
-          ...entry,
-          attempt: {
-            id: RunAttemptId.make("superseded-attempt"),
-            runId,
-            attemptOrdinal: 1,
-            rootNodeId: NodeId.make("superseded-root"),
-            status: "superseded" as const,
-            completedAt: null,
-          },
-        })),
+        }).map((entry) =>
+          isLatest
+            ? entry
+            : {
+                ...entry,
+                attempt: {
+                  id: RunAttemptId.make("superseded-attempt"),
+                  runId,
+                  attemptOrdinal: 1,
+                  rootNodeId: NodeId.make("superseded-root"),
+                  status: "superseded" as const,
+                  completedAt: null,
+                },
+              },
+        ),
         latestRun: {
-          runId: RunId.make("newer-run"),
-          status: "completed",
+          runId: isLatest ? runId : RunId.make("newer-run"),
+          status: isLatest ? "failed" : "completed",
           startedAt: DateTime.formatIso(at),
           completedAt: DateTime.formatIso(at),
         },
@@ -3939,16 +3950,19 @@ describe("failed turn transcript", () => {
         turnDiffSummaries: [],
         supportsConversationRollback: false,
       });
-      expect(
-        rows.some(
-          (row) =>
-            row.kind === "turn-fold" || row.kind === "attempt-fold" || row.kind === "work-toggle",
-        ),
-      ).toBe(false);
+      expect(rows.some((row) => row.kind === "turn-fold" || row.kind === "attempt-fold")).toBe(
+        false,
+      );
       const work = rows.flatMap((row) => (row.kind === "work" ? row.groupedEntries : []));
-      expect(work.map((entry) => entry.id)).toEqual(["command", "failure"]);
+      expect(rows.find((row) => row.kind === "work-toggle")).toEqual(
+        isLatest ? expect.objectContaining({ hiddenCount: 3, expanded: false }) : undefined,
+      );
+      expect(work.map((entry) => entry.id)).toEqual(
+        isLatest ? ["failure"] : ["command", "failure"],
+      );
       expect(work.at(-1)?.detail).toBe("The provider stopped this turn.\nRetry later.");
       expect(work.at(-1)?.createdAt).toBe("2026-09-20T12:00:00.000Z");
+      if (isLatest) return;
       const entriesWithoutTools = deriveTimelineEntriesFromVisibleTurnItems({
         visibleTurnItems: items.filter((row) => row.item.type !== "command_execution"),
         optimisticMessages: [],
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 4ea9e852edfba..c26bcf51a718a 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -973,6 +973,24 @@ function failedTimelineRunIds(
   return failed;
 }
 
+/** Usage-limit pauses keep their tool groups; any other failure itemizes the run's work. */
+function itemizedFailedRunIds(
+  entries: ReadonlyArray<TimelineEntry>,
+  failedRunIds: ReadonlySet<RunId>,
+) {
+  const usageLimited = new Set<RunId>();
+  const otherFailures = new Set<RunId>();
+  for (const entry of entries) {
+    const item = timelineEntryFailedItem(entry);
+    if (item?.runId) {
+      (item.failure.class === "usage_limit" ? usageLimited : otherFailures).add(item.runId);
+    }
+  }
+  return new Set(
+    [...failedRunIds].filter((runId) => !usageLimited.has(runId) || otherFailures.has(runId)),
+  );
+}
+
 function deriveTurnFolds(input: {
   timelineEntries: ReadonlyArray<TimelineEntry>;
   terminalAssistantMessageIds: ReadonlySet<string>;
@@ -1410,6 +1428,7 @@ export function deriveMessagesTimelineRows(input: {
   const nextRows: MessagesTimelineRow[] = [];
   const terminalAssistantMessageIds = deriveTerminalAssistantMessageIds(timelineEntries);
   const failedRunIds = failedTimelineRunIds(timelineEntries, input.latestRun ?? null);
+  const itemizedRunIds = itemizedFailedRunIds(timelineEntries, failedRunIds);
   const liveSubagentEntryIds = liveSubagentCardEntryIds(timelineEntries);
   const completeSupersededReplyIds = completeSupersededReplyEntryIds(timelineEntries);
   const supersededFoldsByAnchorEntryId = deriveSupersededAttemptFolds(
@@ -1436,6 +1455,7 @@ export function deriveMessagesTimelineRows(input: {
     liveSubagentEntryIds,
     completeSupersededReplyEntryIds: completeSupersededReplyIds,
   });
+  const timelineEntryById = new Map(timelineEntries.map((entry) => [entry.id, entry]));
   const collapsedEntryIds = new Set<string>();
   const collapsedFoldMemberIds = new Set<string>();
   for (const fold of foldsByAnchorEntryId.values()) {
@@ -1681,14 +1701,14 @@ export function deriveMessagesTimelineRows(input: {
 
     const turnFold = foldsByAnchorEntryId.get(timelineEntry.id);
     if (turnFold) {
-      const deferredWorkItemIds = timelineEntries.flatMap((entry) =>
-        turnFold.entryIds.has(entry.id) &&
-        entry.kind === "work" &&
-        entry.entry.projectedItem?.item.deferredWork &&
-        !supersededWorkItemIds.has(String(entry.entry.projectedItem.sourceItemId))
+      const deferredWorkItemIds = [...turnFold.entryIds].flatMap((entryId) => {
+        const entry = timelineEntryById.get(entryId);
+        return entry?.kind === "work" &&
+          entry.entry.projectedItem?.item.deferredWork &&
+          !supersededWorkItemIds.has(String(entry.entry.projectedItem.sourceItemId))
           ? [String(entry.entry.projectedItem.sourceItemId)]
-          : [],
-      );
+          : [];
+      });
       nextRows.push({
         kind: "turn-fold",
         id: `turn-fold:${turnFold.runId}`,
@@ -1771,7 +1791,7 @@ export function deriveMessagesTimelineRows(input: {
     if (timelineEntry.kind === "work") {
       if (
         isPendingApproval(timelineEntry.entry) ||
-        (timelineEntry.entry.runId != null && failedRunIds.has(timelineEntry.entry.runId)) ||
+        (timelineEntry.entry.runId != null && itemizedRunIds.has(timelineEntry.entry.runId)) ||
         (timelineEntry.entry.itemType === "error" &&
           timelineEntry.entry.toolLifecycleStatus === "failed") ||
         timelineEntry.entry.tone === "error" ||
@@ -1797,6 +1817,8 @@ export function deriveMessagesTimelineRows(input: {
           !nextEntry ||
           nextEntry.kind !== "work" ||
           nextEntry.entry.sourceActivityKind === "context-compaction" ||
+          (nextEntry.entry.itemType === "error" &&
+            nextEntry.entry.toolLifecycleStatus === "failed") ||
           nextEntry.entry.tone === "error" ||
           nextEntry.entry.sourceActivityKind === "runtime.error" ||
           nextEntry.entry.itemType === "system_notice" ||
diff --git a/apps/web/src/components/chat/ModelPickerContent.tsx b/apps/web/src/components/chat/ModelPickerContent.tsx
index b7430716f96f9..c5a8cdf64c18f 100644
--- a/apps/web/src/components/chat/ModelPickerContent.tsx
+++ b/apps/web/src/components/chat/ModelPickerContent.tsx
@@ -41,6 +41,7 @@ import {
 } from "../ui/combobox";
 import { ModelEsque } from "./providerIconUtils";
 import { isCommandPaletteOpen } from "../../commandPaletteBus";
+import { registerModelPickerContent } from "../../modelPickerVisibility";
 import { primaryServerKeybindingsAtom } from "../../state/server";
 import {
   modelPickerJumpCommandForIndex,
@@ -377,6 +378,8 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: {
   const [searchQuery, setSearchQuery] = useState("");
   const modelListRef = useRef<LegendListRef | null>(null);
   const pickerContentRef = useRef<HTMLDivElement>(null);
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- publishes this picker's mount to global keydown handlers
+  useLayoutEffect(() => registerModelPickerContent(), []);
   const highlightedModelKeyRef = useRef<string | null>(null);
   const { favorites } = useEnvironmentModelPreferences(props.environmentId);
   const activeEntry = props.instanceEntries.find(
diff --git a/apps/web/src/components/chat/OpenInPicker.browser.test.tsx b/apps/web/src/components/chat/OpenInPicker.browser.test.tsx
index b34867b2668f3..720ce4d6c443d 100644
--- a/apps/web/src/components/chat/OpenInPicker.browser.test.tsx
+++ b/apps/web/src/components/chat/OpenInPicker.browser.test.tsx
@@ -189,6 +189,19 @@ describe("host editor access", () => {
   });
 });
 
+describe("remote editor links", () => {
+  it("opens the link from the fallback when the picker is not mounted", async () => {
+    await using fixture = await setup();
+    const { screen, pressOpenFavorite, FavoriteEditorFallback } = fixture;
+    state.remote = { mode: "remote-links", host: { kind: "ssh-alias", host: "sol" } };
+    await act(async () => screen.rerender(<FavoriteEditorFallback />));
+
+    expect((await pressOpenFavorite()).defaultPrevented).toBe(true);
+    expect(state.openUrl).toHaveBeenCalledWith(expect.stringContaining("ssh-remote+sol"));
+    expect(state.run).not.toHaveBeenCalled();
+  });
+});
+
 describe("open in editor announcement", () => {
   it("speaks only after the shortcut opened the editor, from the picker or the fallback", async () => {
     await using fixture = await setup();
diff --git a/apps/web/src/components/chat/OpenInPickerShortcut.ts b/apps/web/src/components/chat/OpenInPickerShortcut.ts
index 8c8249c67b1a0..833c3f3784987 100644
--- a/apps/web/src/components/chat/OpenInPickerShortcut.ts
+++ b/apps/web/src/components/chat/OpenInPickerShortcut.ts
@@ -1,11 +1,16 @@
-import type { EditorId, EnvironmentId, ResolvedKeybindingsConfig } from "@t3tools/contracts";
+import {
+  buildRemoteOpenUrl,
+  type EditorId,
+  type EnvironmentId,
+  type ResolvedKeybindingsConfig,
+} from "@t3tools/contracts";
 import { useEffect } from "react";
 
 import { usePreferredEditor } from "../../editorPreferences";
 import { editorLabelForPlatform } from "../../editorLabels";
 import { isOpenFavoriteEditorShortcut } from "../../keybindings";
 import { announce } from "../../lib/announce";
-import { useRemoteOpenState } from "../../remoteOpen";
+import { openRemoteEditorUrl, useRemoteCapableEditors, useRemoteOpenState } from "../../remoteOpen";
 import { registerCommands } from "../../shortcuts/dispatcher";
 import { shellEnvironment } from "../../state/shell";
 import { useAtomCommand } from "../../state/use-atom-command";
@@ -49,18 +54,39 @@ export function useOpenFavoriteEditorShortcut({
   openInCwd: string | null;
 }) {
   const openInEditorMutation = useAtomCommand(shellEnvironment.openInEditor, "open in editor");
-  const [preferredEditor] = usePreferredEditor(availableEditors);
   const remote = useRemoteOpenState(environmentId);
+  const remoteCapableEditors = useRemoteCapableEditors();
+  // Matches the picker: remote editors run on the viewing machine.
+  const [preferredEditor] = usePreferredEditor(
+    remote.mode === "local-exec" ? availableEditors : remoteCapableEditors,
+  );
 
-  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- subscribes a window keydown listener for the open-in-editor shortcut while enabled locally
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- subscribes a window keydown listener for the open-in-editor shortcut while enabled
   useEffect(() => {
-    if (!enabled || remote.mode !== "local-exec") return;
+    if (!enabled || remote.mode === "remote-unavailable") return;
     const handler = (event: globalThis.KeyboardEvent) => {
-      if (event.defaultPrevented || !isOpenFavoriteEditorShortcut(event, keybindings)) return;
+      if (
+        event.repeat ||
+        event.defaultPrevented ||
+        !isOpenFavoriteEditorShortcut(event, keybindings)
+      )
+        return;
       if (!openInCwd || !preferredEditor) return;
 
       event.preventDefault();
       const label = editorLabelForPlatform(preferredEditor, navigator.platform);
+      if (remote.mode === "remote-links") {
+        const url = buildRemoteOpenUrl({
+          editor: preferredEditor,
+          ...remote.host,
+          absolutePath: openInCwd,
+        });
+        if (url === undefined) return;
+        void openRemoteEditorUrl(url).then((opened) => {
+          if (opened) announce(`Opened in ${label}`);
+        });
+        return;
+      }
       void openInEditorMutation({
         environmentId,
         input: {
@@ -80,6 +106,6 @@ export function useOpenFavoriteEditorShortcut({
     openInCwd,
     openInEditorMutation,
     preferredEditor,
-    remote.mode,
+    remote,
   ]);
 }
diff --git a/apps/web/src/components/chat/ThreadAutomationsPanel.tsx b/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
index 20ecde3272276..ca2497bd20ee8 100644
--- a/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
+++ b/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
@@ -153,12 +153,6 @@ export function ThreadAutomationsPanel(props: {
         </Tooltip>
       }
     >
-      {tasksQuery.error !== null ? (
-        <p className="px-2.5 py-1.5 text-2xs text-destructive">
-          Could not load automations: {tasksQuery.error}
-        </p>
-      ) : null}
-
       <ul className="m-0 list-none p-0">
         {boundTasks.map((task) => (
           <li
@@ -242,6 +236,12 @@ export function ThreadAutomationsPanel(props: {
           </li>
         ))}
       </ul>
+      {/* Kept last: the details card treats a section whose last child is empty as empty. */}
+      {tasksQuery.error !== null ? (
+        <p className="px-2.5 py-1.5 text-2xs text-destructive">
+          Could not load automations: {tasksQuery.error}
+        </p>
+      ) : null}
     </ThreadDetailsSection>
   );
 }
diff --git a/apps/web/src/components/chat/ThreadDetailsCard.browser.test.tsx b/apps/web/src/components/chat/ThreadDetailsCard.browser.test.tsx
index 37110875ed0ea..a8728d7879dd4 100644
--- a/apps/web/src/components/chat/ThreadDetailsCard.browser.test.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsCard.browser.test.tsx
@@ -42,10 +42,13 @@ function Card({
   threadRef,
   inline,
   fixture,
+  rows = 1,
 }: {
   threadRef: ScopedThreadRef;
   inline: boolean;
   fixture: ReturnType<typeof setup>;
+  /** Rows of 100px shown at full density. Compact always takes 50px. */
+  rows?: number;
 }) {
   return (
     // The web root renders in StrictMode, which re-runs ref callbacks on every mount.
@@ -63,8 +66,17 @@ function Card({
           detailsCardPlacement: inline ? placement : null,
         }}
       >
-        <ThreadDetailsCard threadRef={threadRef} anchor={fixture.anchor} handle={fixture.handle}>
-          {() => <p>Details for {threadRef.threadId}</p>}
+        <ThreadDetailsCard
+          threadRef={threadRef}
+          anchor={fixture.anchor}
+          handle={fixture.handle}
+          contentKey={String(rows)}
+        >
+          {(density) => (
+            <p style={{ height: density === "full" ? rows * 100 : 50 }}>
+              Details for {threadRef.threadId}
+            </p>
+          )}
         </ThreadDetailsCard>
       </ChatCanvasContext>
     </StrictMode>
@@ -136,3 +148,13 @@ it("reopens after a normal close", async () => {
   await setOpen(true);
   await expect.element(page.getByText("Details for thread-b")).toBeVisible();
 });
+
+it("returns to full density when hidden items make the content fit", async () => {
+  using fixture = setup();
+  await using screen = await render(<Card threadRef={threadB} inline fixture={fixture} rows={6} />);
+  const card = page.getByRole("region", { name: "Thread details" });
+  await expect.element(card).toHaveAttribute("data-density", "compact");
+
+  await screen.rerender(<Card threadRef={threadB} inline fixture={fixture} rows={2} />);
+  await expect.element(card).toHaveAttribute("data-density", "full");
+});
diff --git a/apps/web/src/components/chat/ThreadDetailsCard.tsx b/apps/web/src/components/chat/ThreadDetailsCard.tsx
index 4add56b80eb08..a5df136f14615 100644
--- a/apps/web/src/components/chat/ThreadDetailsCard.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsCard.tsx
@@ -1,5 +1,11 @@
 import { workspaceAreaProps } from "../../lib/workspaceFocus";
-import { useLayoutEffect, useState, type ReactNode, type RefObject } from "react";
+import {
+  useLayoutEffect,
+  useState,
+  type MouseEventHandler,
+  type ReactNode,
+  type RefObject,
+} from "react";
 import type { ScopedThreadRef } from "@t3tools/contracts";
 import { ScrollArea } from "../ui/scroll-area";
 import { cn } from "../../lib/utils";
@@ -17,11 +23,16 @@ export function ThreadDetailsCard({
   threadRef,
   anchor,
   handle,
+  contentKey,
+  onContextMenu,
   children,
 }: {
   threadRef: ScopedThreadRef;
   anchor: RefObject<Element | null>;
   handle: ReturnType<typeof PopoverCreateHandle>;
+  /** Changes when the set of rendered items changes, so cached heights are measured again. */
+  contentKey: string;
+  onContextMenu?: MouseEventHandler<HTMLDivElement>;
   children: (density: "full" | "compact" | "essential") => ReactNode;
 }) {
   const detailsArea = workspaceAreaProps("details", 3, "Thread details");
@@ -36,7 +47,7 @@ export function ThreadDetailsCard({
   const popoverOpen = useRightPanelStore((state) =>
     selectThreadPanelOpen(state.threadPanelVisibilityByThreadKey, threadRef, "popover"),
   );
-  const measurementKey = `${threadRef.environmentId}:${threadRef.threadId}:${preferredPlacement?.width ?? "popup"}`;
+  const measurementKey = `${threadRef.environmentId}:${threadRef.threadId}:${preferredPlacement?.width ?? "popup"}:${contentKey}`;
   const [measurements, setMeasurements] = useState({
     key: measurementKey,
     heights: { full: 0, compact: 0 },
@@ -109,6 +120,7 @@ export function ThreadDetailsCard({
           "max-h-[min(calc(100dvh-6.5rem),calc(var(--available-height,100dvh)-1rem))]",
       )}
       style={placement ? { maxHeight: height } : undefined}
+      onContextMenu={onContextMenu}
       data-thread-details-card
     >
       <ScrollArea scrollFade className="min-h-0">
diff --git a/apps/web/src/components/chat/ThreadDetailsItemsMenu.tsx b/apps/web/src/components/chat/ThreadDetailsItemsMenu.tsx
new file mode 100644
index 0000000000000..d84c13809eaf6
--- /dev/null
+++ b/apps/web/src/components/chat/ThreadDetailsItemsMenu.tsx
@@ -0,0 +1,45 @@
+import {
+  getClientSettings,
+  updateClientSettings,
+  useClientSettings,
+} from "../../hooks/useSettings";
+import { MenuCheckboxItem, MenuGroup, MenuGroupLabel, MenuItem, MenuSeparator } from "../ui/menu";
+import {
+  isDefaultThreadDetailsVisibility,
+  resolveThreadDetailsVisibility,
+  RESET_THREAD_DETAILS_ITEMS,
+  setThreadDetailsItem,
+  THREAD_DETAILS_ITEMS,
+} from "./threadDetailsItems";
+
+/** Menu body that shows and hides thread details items. The card's context menu and Settings share it. */
+export function ThreadDetailsItemsMenuItems() {
+  const visibility = useClientSettings(resolveThreadDetailsVisibility);
+  return (
+    <>
+      <MenuGroup>
+        <MenuGroupLabel>Show in thread details</MenuGroupLabel>
+        {THREAD_DETAILS_ITEMS.map((item) => (
+          <MenuCheckboxItem
+            key={item.id}
+            checked={visibility[item.id]}
+            onCheckedChange={(checked) =>
+              updateClientSettings({
+                threadDetailsItems: setThreadDetailsItem(getClientSettings(), item, checked),
+              })
+            }
+          >
+            {item.label}
+          </MenuCheckboxItem>
+        ))}
+      </MenuGroup>
+      <MenuSeparator />
+      <MenuItem
+        disabled={isDefaultThreadDetailsVisibility(visibility)}
+        onClick={() => updateClientSettings(RESET_THREAD_DETAILS_ITEMS)}
+      >
+        Reset to default
+      </MenuItem>
+    </>
+  );
+}
diff --git a/apps/web/src/components/chat/ThreadDetailsPanel.tsx b/apps/web/src/components/chat/ThreadDetailsPanel.tsx
index 1463c97f9ff6f..35a954db9d43e 100644
--- a/apps/web/src/components/chat/ThreadDetailsPanel.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsPanel.tsx
@@ -16,13 +16,25 @@ import ProjectScriptsControl, {
   type NewProjectScriptInput,
   type ProjectScriptActionResult,
 } from "../ProjectScriptsControl";
-import { memo, type ComponentProps } from "react";
+import { memo, useState, type ComponentProps } from "react";
 import { ThreadDetailsCard } from "./ThreadDetailsCard";
 import { OpenInPicker } from "./OpenInPicker";
 import { ThreadDetailsSection } from "./ThreadDetailsSection";
 import { ThreadAutomationsPanel } from "./ThreadAutomationsPanel";
 import { ThreadRelationshipsPanel } from "./ThreadRelationshipsControl";
 import { ThreadServersPanel } from "./ThreadServersPanel";
+import { ThreadDetailsUsage, type ThreadDetailsUsageInput } from "./ThreadDetailsUsage";
+import { ThreadDetailsItemsMenuItems } from "./ThreadDetailsItemsMenu";
+import { resolveThreadDetailsVisibility, THREAD_DETAILS_ITEMS } from "./threadDetailsItems";
+import { useClientSettings } from "../../hooks/useSettings";
+import { cn } from "../../lib/utils";
+import { SlidersHorizontalIcon } from "lucide-react";
+import { ThreadDetailsControl } from "./ThreadDetailsControl";
+import {
+  THREAD_DETAILS_PANEL_ICON_CLASS,
+  THREAD_DETAILS_PANEL_LABEL_CLASS,
+} from "./threadDetailsPanelStyles";
+import { Menu, MenuPopup } from "../ui/menu";
 
 const GitActionsControl = memo(BaseGitActionsControl);
 
@@ -67,12 +79,15 @@ interface ThreadDetailsPanelProps extends Pick<
     input: NewProjectScriptInput,
   ) => Promise<ProjectScriptActionResult>;
   onDeleteProjectScript: (scriptId: string) => Promise<ProjectScriptActionResult>;
+  usage: ThreadDetailsUsageInput;
 }
 
 export function ThreadDetailsPanel(props: ThreadDetailsPanelProps) {
+  const visible = useClientSettings(resolveThreadDetailsVisibility);
+  const [menuPosition, setMenuPosition] = useState<{ x: number; y: number } | null>(null);
   const fileScripts = useT3ProjectFileScripts(
     props.environmentId,
-    props.activeProjectScripts ? props.gitCwd : null,
+    props.activeProjectScripts && visible.scripts ? props.gitCwd : null,
   );
   const activeThreadRef = { environmentId: props.environmentId, threadId: props.threadId };
   const branchToolbarProps = {
@@ -106,97 +121,181 @@ export function ThreadDetailsPanel(props: ThreadDetailsPanelProps) {
       threadRef={{ environmentId: props.environmentId, threadId: props.threadId }}
       anchor={props.anchor}
       handle={props.handle}
+      contentKey={THREAD_DETAILS_ITEMS.filter((item) => visible[item.id])
+        .map((item) => item.id)
+        .join(",")}
+      onContextMenu={(event) => {
+        // Popups the card opens bubble here through React; they, fields, links, and selected text
+        // keep their own menus.
+        const target = event.target;
+        const selection = window.getSelection();
+        if (
+          !(target instanceof Element) ||
+          !event.currentTarget.contains(target) ||
+          target.closest("input, textarea, [contenteditable], a[href]") ||
+          (selection &&
+            !selection.isCollapsed &&
+            (event.currentTarget.contains(selection.anchorNode) ||
+              event.currentTarget.contains(selection.focusNode)))
+        )
+          return;
+        event.preventDefault();
+        setMenuPosition({ x: event.clientX, y: event.clientY });
+      }}
     >
-      {(density) => (
-        <>
-          <ThreadDetailsSection
-            headingId="thread-details-workspace-heading"
-            title="Workspace"
-            separated={false}
-            showHeading={false}
-          >
-            <div className="flex flex-col">
-              {density === "full" ? (
-                <BranchToolbar
-                  layout="panel"
-                  panelSection="workspace"
-                  availableEnvironments={props.availableEnvironments}
-                  {...(props.onEnvironmentChange
-                    ? { onEnvironmentChange: props.onEnvironmentChange }
-                    : {})}
-                  autoEnvironmentLabel={props.autoEnvironmentLabel}
-                  onAutoEnvironment={props.onAutoEnvironment}
-                  {...branchToolbarProps}
-                />
+      {(density) => {
+        // Section flags follow the rows that will render, so no empty section steals the divider rule.
+        const show = {
+          environment: density === "full" && visible.environment,
+          openIn: density !== "essential" && visible.openIn && props.showOpenInPicker,
+          scripts: visible.scripts && props.activeProjectScripts !== undefined,
+          branch: props.gitCwd !== null && props.isGitRepo && visible.branch,
+          git:
+            props.gitCwd !== null &&
+            props.activeProjectName !== undefined &&
+            (visible.gitActions || (visible.changes && props.isGitRepo)),
+        };
+        return (
+          <>
+            <div className="group/details-items">
+              {show.environment || show.openIn || show.scripts ? (
+                <ThreadDetailsSection
+                  headingId="thread-details-workspace-heading"
+                  title="Workspace"
+                  separated={false}
+                  showHeading={false}
+                >
+                  <div className="flex flex-col">
+                    {show.environment ? (
+                      <BranchToolbar
+                        layout="panel"
+                        panelSection="workspace"
+                        availableEnvironments={props.availableEnvironments}
+                        {...(props.onEnvironmentChange
+                          ? { onEnvironmentChange: props.onEnvironmentChange }
+                          : {})}
+                        autoEnvironmentLabel={props.autoEnvironmentLabel}
+                        onAutoEnvironment={props.onAutoEnvironment}
+                        {...branchToolbarProps}
+                      />
+                    ) : null}
+
+                    {show.openIn ? (
+                      <OpenInPicker
+                        keybindings={props.keybindings}
+                        environmentId={props.environmentId}
+                        availableEditors={props.availableEditors}
+                        openInCwd={props.gitCwd}
+                        enableShortcut={props.openInShortcutEnabled}
+                        displayMode="panel"
+                      />
+                    ) : null}
+
+                    {show.scripts && props.activeProjectScripts ? (
+                      <ProjectScriptsControl
+                        environmentId={props.environmentId}
+                        displayMode="panel"
+                        scripts={props.activeProjectScripts}
+                        fileScripts={fileScripts}
+                        preferredScriptId={props.preferredScriptId}
+                        onRunScript={props.onRunProjectScript}
+                        onAddScript={props.onAddProjectScript}
+                        onUpdateScript={props.onUpdateProjectScript}
+                        onDeleteScript={props.onDeleteProjectScript}
+                      />
+                    ) : null}
+                  </div>
+                </ThreadDetailsSection>
+              ) : null}
+
+              {props.gitCwd && (show.branch || show.git) ? (
+                <ThreadDetailsSection
+                  headingId="thread-details-version-control-heading"
+                  title="Version Control"
+                  showHeading={false}
+                  separated={density === "full"}
+                >
+                  <div className="flex flex-col">
+                    {show.branch ? (
+                      <BranchToolbar layout="panel" panelSection="branch" {...branchToolbarProps} />
+                    ) : null}
+                    {show.git ? (
+                      <GitActionsControl
+                        compact={density !== "full"}
+                        showActions={visible.gitActions}
+                        showChanges={visible.changes}
+                        gitCwd={props.gitCwd}
+                        activeThreadRef={activeThreadRef}
+                        {...(props.draftId ? { draftId: props.draftId } : {})}
+                        {...(props.onOpenChanges ? { onOpenChanges: props.onOpenChanges } : {})}
+                      />
+                    ) : null}
+                  </div>
+                </ThreadDetailsSection>
+              ) : null}
+
+              {density === "full" && !props.draftId && visible.servers ? (
+                <ThreadServersPanel environmentId={props.environmentId} threadId={props.threadId} />
               ) : null}
 
-              {density !== "essential" && props.showOpenInPicker ? (
-                <OpenInPicker
-                  keybindings={props.keybindings}
+              {density === "full" && !props.draftId && visible.automations ? (
+                <ThreadAutomationsPanel
                   environmentId={props.environmentId}
-                  availableEditors={props.availableEditors}
-                  openInCwd={props.gitCwd}
-                  enableShortcut={props.openInShortcutEnabled}
-                  displayMode="panel"
+                  threadId={props.threadId}
                 />
               ) : null}
 
-              {props.activeProjectScripts ? (
-                <ProjectScriptsControl
+              {density === "full" && !props.draftId && visible.lineage ? (
+                <ThreadRelationshipsPanel
                   environmentId={props.environmentId}
-                  displayMode="panel"
-                  scripts={props.activeProjectScripts}
-                  fileScripts={fileScripts}
-                  preferredScriptId={props.preferredScriptId}
-                  onRunScript={props.onRunProjectScript}
-                  onAddScript={props.onAddProjectScript}
-                  onUpdateScript={props.onUpdateProjectScript}
-                  onDeleteScript={props.onDeleteProjectScript}
+                  threadId={props.threadId}
                 />
               ) : null}
-            </div>
-          </ThreadDetailsSection>
-
-          {props.gitCwd ? (
-            <ThreadDetailsSection
-              headingId="thread-details-version-control-heading"
-              title="Version Control"
-              showHeading={false}
-              separated={density === "full"}
-            >
-              <div className="flex flex-col">
-                {props.isGitRepo ? (
-                  <BranchToolbar layout="panel" panelSection="branch" {...branchToolbarProps} />
-                ) : null}
-                {props.activeProjectName ? (
-                  <GitActionsControl
-                    compact={density !== "full"}
-                    gitCwd={props.gitCwd}
-                    activeThreadRef={activeThreadRef}
-                    {...(props.draftId ? { draftId: props.draftId } : {})}
-                    {...(props.onOpenChanges ? { onOpenChanges: props.onOpenChanges } : {})}
-                  />
-                ) : null}
-              </div>
-            </ThreadDetailsSection>
-          ) : null}
 
-          {density === "full" && !props.draftId ? (
-            <ThreadServersPanel environmentId={props.environmentId} threadId={props.threadId} />
-          ) : null}
+              {visible.usage ? <ThreadDetailsUsage {...props.usage} /> : null}
 
-          {density === "full" && !props.draftId ? (
-            <ThreadAutomationsPanel environmentId={props.environmentId} threadId={props.threadId} />
-          ) : null}
+              {/* Shown only when no section above has content, so an emptied card can be refilled. */}
+              <div className="p-2 group-has-[>section>:last-child:not(:empty)]/details-items:hidden">
+                <ThreadDetailsControl
+                  size="xs"
+                  variant="ghost"
+                  part="row"
+                  panel
+                  onClick={(event) => {
+                    const rect = event.currentTarget.getBoundingClientRect();
+                    setMenuPosition({ x: rect.left, y: rect.bottom });
+                  }}
+                >
+                  <SlidersHorizontalIcon className={THREAD_DETAILS_PANEL_ICON_CLASS} aria-hidden />
+                  <span className={cn("ml-0.5", THREAD_DETAILS_PANEL_LABEL_CLASS)}>
+                    Choose what to show
+                  </span>
+                </ThreadDetailsControl>
+              </div>
+            </div>
 
-          {density === "full" && !props.draftId ? (
-            <ThreadRelationshipsPanel
-              environmentId={props.environmentId}
-              threadId={props.threadId}
-            />
-          ) : null}
-        </>
-      )}
+            <Menu
+              open={menuPosition !== null}
+              onOpenChange={(open) => !open && setMenuPosition(null)}
+            >
+              <MenuPopup
+                anchor={
+                  menuPosition
+                    ? {
+                        getBoundingClientRect: () =>
+                          new DOMRect(menuPosition.x, menuPosition.y, 0, 0),
+                      }
+                    : undefined
+                }
+                align="start"
+                side="bottom"
+              >
+                <ThreadDetailsItemsMenuItems />
+              </MenuPopup>
+            </Menu>
+          </>
+        );
+      }}
     </ThreadDetailsCard>
   );
 }
diff --git a/apps/web/src/components/chat/ThreadDetailsSection.tsx b/apps/web/src/components/chat/ThreadDetailsSection.tsx
index 00aacd5a7b152..de5ce6c63825d 100644
--- a/apps/web/src/components/chat/ThreadDetailsSection.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsSection.tsx
@@ -22,7 +22,12 @@ export function ThreadDetailsSection({
       {...props}
       aria-labelledby={showHeading ? headingId : undefined}
       aria-label={showHeading ? undefined : title}
-      className={cn("px-2 pt-2 pb-2.5", separated && "border-t border-border/65")}
+      // A row can still render nothing (a fresh draft quiets Git actions), so an empty section
+      // collapses, and a divider only follows a section that has content.
+      className={cn(
+        "px-2 pt-2 pb-2.5 has-[>div:last-child:empty]:hidden",
+        separated && "border-border/65 [section:not(:has(>div:last-child:empty))~&]:border-t",
+      )}
     >
       <div
         className={cn(
diff --git a/apps/web/src/components/chat/ThreadDetailsUsage.tsx b/apps/web/src/components/chat/ThreadDetailsUsage.tsx
new file mode 100644
index 0000000000000..e0f5c3afbe845
--- /dev/null
+++ b/apps/web/src/components/chat/ThreadDetailsUsage.tsx
@@ -0,0 +1,228 @@
+import type {
+  ProviderInstanceId,
+  ServerProvider,
+  ServerProviderUsageWindow,
+  UsageLimitSourceSnapshots,
+} from "@t3tools/contracts";
+import {
+  collectProviderUsageLimits,
+  formatDuration,
+  type LimitPace,
+  limitsNotice,
+  paceOf,
+  remainingPercent,
+} from "@t3tools/shared/usageLimits";
+import type { ReactNode } from "react";
+
+import { usePrimarySettings } from "../../hooks/useSettings";
+import { useNowMinute } from "../../hooks/useNowMinute";
+import { type ContextWindowSnapshot, formatContextWindowTokens } from "../../lib/contextWindow";
+import { cn } from "../../lib/utils";
+import { formatUpcomingTimestamp } from "../../timestampFormat";
+import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+import { ThreadDetailsSection } from "./ThreadDetailsSection";
+
+const PACE_LABEL: Record<LimitPace, string> = {
+  ahead: "Ahead of pace",
+  on: "On pace",
+  under: "Under pace",
+};
+
+export interface ThreadDetailsUsageInput {
+  readonly providerInstanceId: ProviderInstanceId | null;
+  readonly providers: readonly ServerProvider[];
+  readonly sources: UsageLimitSourceSnapshots;
+  readonly contextWindow: ContextWindowSnapshot | null;
+}
+
+/**
+ * The selected provider's limit windows and the thread's context window.
+ * Every row reads as room left, so a longer bar always means more headroom.
+ */
+export function ThreadDetailsUsage({
+  providerInstanceId,
+  providers,
+  sources,
+  contextWindow,
+}: ThreadDetailsUsageInput) {
+  const nowMinute = useNowMinute();
+  const now = Date.parse(`${nowMinute}:00Z`);
+  const report =
+    providerInstanceId !== null
+      ? collectProviderUsageLimits(providerInstanceId, providers, sources, now)
+      : null;
+  // Only this instance's data: the report keeps one instance per login, and any other entry may be
+  // a different login or workspace, so fall back to the instance's own snapshot.
+  const limits =
+    report?.accounts.find((entry) => entry.instanceId === providerInstanceId)?.limits ??
+    providers.find((provider) => provider.instanceId === providerInstanceId)?.usageLimits;
+  const notice = limits ? limitsNotice(limits) : null;
+  if (!limits && !contextWindow) return null;
+
+  return (
+    <ThreadDetailsSection
+      headingId="thread-details-usage-heading"
+      title="Usage"
+      showHeading={false}
+    >
+      <div className="grid grid-cols-[auto_minmax(3rem,1fr)_auto] gap-x-3 text-xs">
+        {notice ? (
+          <UsageRow
+            label="Limits"
+            left={null}
+            value="Unavailable"
+            tooltip={<span className="text-foreground">{notice}</span>}
+          />
+        ) : null}
+        {limits && !notice
+          ? limits.windows.map((window) => <LimitRow key={window.id} window={window} now={now} />)
+          : null}
+        {contextWindow ? <ContextRow usage={contextWindow} spaced={limits !== undefined} /> : null}
+      </div>
+    </ThreadDetailsSection>
+  );
+}
+
+function LimitRow({
+  window,
+  now,
+}: {
+  readonly window: ServerProviderUsageWindow;
+  readonly now: number;
+}) {
+  const timestampFormat = usePrimarySettings((settings) => settings.timestampFormat);
+  const left = remainingPercent(window);
+  const pace = paceOf(window, now);
+  const resetsAt = window.resetsAt ? Date.parse(window.resetsAt) : Number.NaN;
+  return (
+    <UsageRow
+      label={window.label}
+      left={left}
+      tooltip={
+        <>
+          <span className="text-foreground">
+            {window.label}: {left}% left
+          </span>
+          {window.resetsAt && resetsAt > now ? (
+            <span className="text-muted-foreground">
+              Resets in {formatDuration(resetsAt - now)} ·{" "}
+              {formatUpcomingTimestamp(window.resetsAt, timestampFormat, now)}
+            </span>
+          ) : null}
+          {pace ? <span className="text-muted-foreground">{PACE_LABEL[pace]}</span> : null}
+        </>
+      }
+    />
+  );
+}
+
+function ContextRow({
+  usage,
+  spaced,
+}: {
+  readonly usage: ContextWindowSnapshot;
+  readonly spaced: boolean;
+}) {
+  const maxTokens = usage.maxTokens ?? null;
+  const left =
+    maxTokens !== null && usage.usedPercentage !== null
+      ? Math.round(100 - Math.max(0, Math.min(100, usage.usedPercentage)))
+      : null;
+  const used = formatContextWindowTokens(usage.usedTokens);
+  return (
+    <UsageRow
+      label="Context"
+      left={left}
+      muted
+      className={cn(spaced && "mt-2")}
+      tooltip={
+        <>
+          {left !== null ? <span className="text-foreground">Context: {left}% left</span> : null}
+          <span className={left !== null ? "text-muted-foreground" : "text-foreground"}>
+            {maxTokens !== null
+              ? `${used} of ${formatContextWindowTokens(maxTokens)} tokens used`
+              : `${used} tokens used`}
+          </span>
+        </>
+      }
+      value={left === null ? used : undefined}
+    />
+  );
+}
+
+/** One label, hairline, and value row; the whole row opens the details tooltip. */
+function UsageRow({
+  label,
+  left,
+  tooltip,
+  value,
+  muted = false,
+  className,
+}: {
+  readonly label: string;
+  readonly left: number | null;
+  readonly tooltip: ReactNode;
+  /** Replaces the percentage when there is none. */
+  readonly value?: string | undefined;
+  readonly muted?: boolean;
+  readonly className?: string | undefined;
+}) {
+  const tone = left === null ? null : left <= 10 ? "error" : left <= 20 ? "warning" : null;
+  return (
+    <Tooltip>
+      <TooltipTrigger
+        render={
+          <div
+            tabIndex={0}
+            aria-label={`${label}: ${value ?? `${left}% left`}`}
+            className={cn(
+              "col-span-3 grid h-6 cursor-default grid-cols-subgrid items-center rounded-lg px-2.5 outline-none hover:bg-black/[0.035] focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring data-popup-open:bg-black/[0.035] dark:hover:bg-white/[0.08] dark:data-popup-open:bg-white/[0.08]",
+              className,
+            )}
+          />
+        }
+      >
+        <span className="max-w-28 truncate text-muted-foreground">{label}</span>
+        {left !== null ? (
+          <span className="relative h-[3px] rounded-full bg-muted-foreground/30 dark:bg-muted-foreground/20">
+            {left > 0 ? (
+              <span
+                className={cn(
+                  "absolute inset-y-0 left-0 rounded-full",
+                  tone === "error"
+                    ? "bg-error"
+                    : tone === "warning"
+                      ? "bg-warning"
+                      : muted
+                        ? "bg-muted-foreground"
+                        : "bg-foreground/80",
+                )}
+                style={{ width: `max(${left}%, 6px)` }}
+              />
+            ) : null}
+          </span>
+        ) : null}
+        <span
+          className={cn(
+            // Text-only rows span the bar column so they never widen the shared value column.
+            "text-end font-medium tabular-nums",
+            left === null && "col-span-2",
+            tone === "error"
+              ? "text-error-foreground"
+              : tone === "warning"
+                ? "text-warning-foreground"
+                : left === null
+                  ? "text-muted-foreground"
+                  : "text-foreground/80",
+          )}
+        >
+          {value ?? `${left}%`}
+        </span>
+      </TooltipTrigger>
+      {/* Rows sit 8px inside the card; clear its edge instead of overlapping it. */}
+      <TooltipPopup side="left" sideOffset={16}>
+        <div className="flex flex-col gap-0.5">{tooltip}</div>
+      </TooltipPopup>
+    </Tooltip>
+  );
+}
diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx
index f02780bed3af1..79a29d293dc49 100644
--- a/apps/web/src/components/chat/TraitsPicker.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.tsx
@@ -616,9 +616,12 @@ export const TraitsPicker = memo(function TraitsPicker({
         )
       : null;
   // Workflow levels such as Ultracode always show their name; the setting names every level.
+  // Traits the bars cannot show, such as an agent mode, appear as words in the composer.
   const effortWord = effortGlyph
     ? (effortGlyph.special ?? (effortDisplay === "label" ? effortGlyph.label : null))
-    : null;
+    : isComposerOwned
+      ? triggerLabel
+      : null;
 
   return (
     <Menu
@@ -697,6 +700,15 @@ export const TraitsPicker = memo(function TraitsPicker({
                 </span>
               ) : null}
             </span>
+          ) : effortWord !== null ? (
+            <>
+              <span data-composer-control-label>{effortWord}</span>
+              <GaugeIcon
+                aria-hidden="true"
+                data-composer-control-compact-icon
+                className="invisible absolute size-3.5"
+              />
+            </>
           ) : isCodexStyle ? (
             <span
               className={cn(
diff --git a/apps/web/src/components/chat/composerProviderState.test.tsx b/apps/web/src/components/chat/composerProviderState.test.tsx
index 54b68286ee315..84c7c3d8cb869 100644
--- a/apps/web/src/components/chat/composerProviderState.test.tsx
+++ b/apps/web/src/components/chat/composerProviderState.test.tsx
@@ -315,6 +315,15 @@ describe("getComposerReasoningStep", () => {
     }
   });
 
+  it("steps Antigravity's thinking_level like other effort controls", () => {
+    expect(
+      step({
+        provider: ProviderDriverKind.make("antigravity"),
+        models: modelWith([selectDescriptor("thinking_level", LEVELS)]),
+      })?.modelOptions,
+    ).toStrictEqual(selections(["thinking_level", "high"]));
+  });
+
   it("adds and strips the Ultrathink prefix while the caret stays on the same character", () => {
     for (const { prompt, modelOptions, direction, expected } of [
       {
diff --git a/apps/web/src/components/chat/threadDetailsItems.test.ts b/apps/web/src/components/chat/threadDetailsItems.test.ts
new file mode 100644
index 0000000000000..0a0787061d287
--- /dev/null
+++ b/apps/web/src/components/chat/threadDetailsItems.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+  resolveThreadDetailsVisibility,
+  setThreadDetailsItem,
+  THREAD_DETAILS_ITEMS,
+} from "./threadDetailsItems";
+
+const usage = THREAD_DETAILS_ITEMS.find((item) => item.id === "usage")!;
+const servers = THREAD_DETAILS_ITEMS.find((item) => item.id === "servers")!;
+
+describe("thread details items", () => {
+  it.each([
+    { legacy: false, items: {}, usage: false },
+    { legacy: true, items: {}, usage: true },
+    { legacy: true, items: { usage: false }, usage: false },
+    { legacy: false, items: { usage: true, retired: false }, usage: true },
+  ])("resolves Usage from overrides and the retired Labs flag: %o", (row) => {
+    const visibility = resolveThreadDetailsVisibility({
+      threadDetailsItems: row.items,
+      threadDetailsUsageEnabled: row.legacy,
+    });
+    expect(visibility.usage).toBe(row.usage);
+    expect(visibility.servers).toBe(true);
+  });
+
+  it("stores only choices that differ from the default", () => {
+    const legacyOn = { threadDetailsItems: {}, threadDetailsUsageEnabled: true };
+    expect(setThreadDetailsItem(legacyOn, usage, false)).toEqual({ usage: false });
+    expect(setThreadDetailsItem(legacyOn, usage, true)).toEqual({});
+
+    const hidden = { threadDetailsItems: { servers: false }, threadDetailsUsageEnabled: false };
+    expect(setThreadDetailsItem(hidden, servers, true)).toEqual({});
+  });
+});
diff --git a/apps/web/src/components/chat/threadDetailsItems.ts b/apps/web/src/components/chat/threadDetailsItems.ts
new file mode 100644
index 0000000000000..7502a4c0b1dce
--- /dev/null
+++ b/apps/web/src/components/chat/threadDetailsItems.ts
@@ -0,0 +1,60 @@
+import type { ClientSettings } from "@t3tools/contracts";
+
+// Ids are stored in client settings, so never rename one.
+export const THREAD_DETAILS_ITEMS = [
+  { id: "environment", label: "Environment and worktree", defaultVisible: true },
+  { id: "openIn", label: "Open in editor", defaultVisible: true },
+  { id: "scripts", label: "Project scripts", defaultVisible: true },
+  { id: "branch", label: "Branch and pull request", defaultVisible: true },
+  { id: "gitActions", label: "Git actions", defaultVisible: true },
+  { id: "changes", label: "Changes", defaultVisible: true },
+  { id: "servers", label: "Servers", defaultVisible: true },
+  { id: "automations", label: "Automations", defaultVisible: true },
+  { id: "lineage", label: "Lineage", defaultVisible: true },
+  { id: "usage", label: "Usage", defaultVisible: false },
+] as const;
+
+export type ThreadDetailsItemId = (typeof THREAD_DETAILS_ITEMS)[number]["id"];
+export type ThreadDetailsVisibility = Readonly<Record<ThreadDetailsItemId, boolean>>;
+
+type ThreadDetailsItem = (typeof THREAD_DETAILS_ITEMS)[number];
+type ThreadDetailsItemSettings = Pick<
+  ClientSettings,
+  "threadDetailsItems" | "threadDetailsUsageEnabled"
+>;
+
+// People who turned on the retired Labs toggle keep Usage until they change it here.
+function defaultVisible(item: ThreadDetailsItem, settings: ThreadDetailsItemSettings) {
+  return item.id === "usage" ? settings.threadDetailsUsageEnabled : item.defaultVisible;
+}
+
+export function resolveThreadDetailsVisibility(
+  settings: ThreadDetailsItemSettings,
+): ThreadDetailsVisibility {
+  return Object.fromEntries(
+    THREAD_DETAILS_ITEMS.map((item) => [
+      item.id,
+      settings.threadDetailsItems[item.id] ?? defaultVisible(item, settings),
+    ]),
+  ) as Record<ThreadDetailsItemId, boolean>;
+}
+
+/** Stores only choices that differ from the default, so a later default change reaches everyone else. */
+export function setThreadDetailsItem(
+  settings: ThreadDetailsItemSettings,
+  item: ThreadDetailsItem,
+  visible: boolean,
+): ClientSettings["threadDetailsItems"] {
+  const { [item.id]: _previous, ...rest } = settings.threadDetailsItems;
+  return visible === defaultVisible(item, settings) ? rest : { ...rest, [item.id]: visible };
+}
+
+export function isDefaultThreadDetailsVisibility(visibility: ThreadDetailsVisibility) {
+  return THREAD_DETAILS_ITEMS.every((item) => visibility[item.id] === item.defaultVisible);
+}
+
+/** Also clears the retired Labs flag, so Usage returns to off. */
+export const RESET_THREAD_DETAILS_ITEMS = {
+  threadDetailsItems: {},
+  threadDetailsUsageEnabled: false,
+} satisfies Partial<ClientSettings>;
diff --git a/apps/web/src/components/chat/usePendingThreadRequests.ts b/apps/web/src/components/chat/usePendingThreadRequests.ts
index 35e4cc5f08551..91c5bd0d6c912 100644
--- a/apps/web/src/components/chat/usePendingThreadRequests.ts
+++ b/apps/web/src/components/chat/usePendingThreadRequests.ts
@@ -27,13 +27,15 @@ import { useStableCallback } from "../../hooks/useStableCallback";
 import { getUploadedAttachments, useAttachmentUploadStore } from "../../lib/attachmentUploadQueue";
 import {
   buildPendingUserInputAnswers,
+  setPendingUserInputCustomAnswer,
+  togglePendingUserInputOptionSelection,
+  type PendingUserInputDraftAnswer,
+} from "@t3tools/client-runtime/state/pending-user-input";
+import {
   carryDisplacedCustomAnswerIntoPrompt,
   derivePendingUserInputProgress,
   projectPendingUserInputAnswer,
-  setPendingUserInputCustomAnswer,
   threadContextsReferencedByAnswer,
-  togglePendingUserInputOptionSelection,
-  type PendingUserInputDraftAnswer,
 } from "../../pendingUserInput";
 import {
   questionAttachmentDraftId,
@@ -98,9 +100,9 @@ function makePendingCustomAnswerSetter(input: {
       [activePendingRequestKey]: {
         ...existing[activePendingRequestKey],
         [questionId]: setPendingUserInputCustomAnswer(
+          question,
           existing[activePendingRequestKey]?.[questionId],
           value,
-          question,
         ),
       },
     }));
diff --git a/apps/web/src/components/coil/UpdateToast.tsx b/apps/web/src/components/coil/UpdateToast.tsx
index 47ae6bb4a838b..effd90196124e 100644
--- a/apps/web/src/components/coil/UpdateToast.tsx
+++ b/apps/web/src/components/coil/UpdateToast.tsx
@@ -282,7 +282,7 @@ function UpdateToastBody({
   );
 }
 
-export function toastPayload(
+function toastPayload(
   view: Exclude<UpdateToastView, { kind: "hidden" }>,
   handlers: {
     readonly onRestart: () => void;
diff --git a/apps/web/src/components/coil/updateToast.logic.ts b/apps/web/src/components/coil/updateToast.logic.ts
index f27d38f36e10a..85f76b8b6c3f1 100644
--- a/apps/web/src/components/coil/updateToast.logic.ts
+++ b/apps/web/src/components/coil/updateToast.logic.ts
@@ -115,7 +115,7 @@ const FORK_ISSUES_NEW_URL = "https://github.com/radroid/t3code/issues/new";
  * the user must see the text before it posts, and this avoids depending on `gh`. Build identity
  * only, since the failing step's message can embed local paths that contain the username.
  */
-export function buildInstallFailureReportUrl(input: {
+function buildInstallFailureReportUrl(input: {
   readonly expectedShortSha: string;
   readonly expectedVersion: string;
   readonly actualShortSha: string | undefined;
diff --git a/apps/web/src/components/device/DeviceControlsRail.tsx b/apps/web/src/components/device/DeviceControlsRail.tsx
index d7ee2cd642356..3ed2b3a4fa544 100644
--- a/apps/web/src/components/device/DeviceControlsRail.tsx
+++ b/apps/web/src/components/device/DeviceControlsRail.tsx
@@ -46,6 +46,8 @@ export function DeviceControlsRail(props: {
   onFloat: () => void;
   onClose: () => void;
   onPowerOff: () => void;
+  /** The host takes input but runs no device commands (Simlock): no rotation, settings, tools, or screenshots. */
+  inputOnly?: boolean;
 }) {
   const { view, handle, controls } = props;
   const popupSide = "left";
@@ -85,115 +87,123 @@ export function DeviceControlsRail(props: {
             >
               <Square />
             </RailButton>
+            {props.inputOnly ? null : (
+              <Menu>
+                <MenuTrigger
+                  render={
+                    <Button
+                      size="icon-sm"
+                      variant="ghost"
+                      aria-label="Rotate device"
+                      disabled={controls.disabled}
+                    />
+                  }
+                >
+                  <RotateCcw />
+                </MenuTrigger>
+                <MenuPopup side={popupSide}>
+                  <MenuItem
+                    onClick={() => void controls.act({ type: "setOrientation", value: "portrait" })}
+                  >
+                    Portrait
+                  </MenuItem>
+                  <MenuItem
+                    onClick={() =>
+                      void controls.act({ type: "setOrientation", value: "landscape_left" })
+                    }
+                  >
+                    Landscape
+                  </MenuItem>
+                </MenuPopup>
+              </Menu>
+            )}
+          </>
+        ) : props.inputOnly ? null : (
+          <RailButton
+            tooltipSide={popupSide}
+            label="Rotate device"
+            disabled={inputDisabled || !!view.keyboard?.attached}
+            onClick={() => handle?.rotate()}
+          >
+            <RotateCcw />
+          </RailButton>
+        )}
+        {props.inputOnly ? null : (
+          <>
+            <RailDivider />
+            <RailButton
+              tooltipSide={popupSide}
+              label={`Switch device to ${nextAppearance} mode`}
+              disabled={controls.disabled || !settings?.appearance}
+              onClick={() => void controls.act({ type: "setAppearance", value: nextAppearance })}
+            >
+              <MorphIcon icon={settings?.appearance === "dark" ? Sun : Moon} />
+            </RailButton>
             <Menu>
               <MenuTrigger
                 render={
                   <Button
                     size="icon-sm"
                     variant="ghost"
-                    aria-label="Rotate device"
-                    disabled={controls.disabled}
+                    aria-label="Device text size"
+                    title="Device text size"
+                    disabled={controls.disabled || !settings?.textSize}
                   />
                 }
               >
-                <RotateCcw />
+                <Type />
               </MenuTrigger>
-              <MenuPopup side={popupSide}>
-                <MenuItem
-                  onClick={() => void controls.act({ type: "setOrientation", value: "portrait" })}
+              <MenuPopup side={popupSide} className="min-w-40">
+                <MenuRadioGroup
+                  value={settings?.textSize ?? ""}
+                  onValueChange={(value) => {
+                    if (
+                      value === "small" ||
+                      value === "default" ||
+                      value === "large" ||
+                      value === "extra-large"
+                    )
+                      void controls.act({ type: "setTextSize", value });
+                  }}
                 >
-                  Portrait
-                </MenuItem>
-                <MenuItem
-                  onClick={() =>
-                    void controls.act({ type: "setOrientation", value: "landscape_left" })
-                  }
-                >
-                  Landscape
-                </MenuItem>
+                  {(
+                    [
+                      ["small", "Small"],
+                      ["default", "Default"],
+                      ["large", "Large"],
+                      ["extra-large", "Extra large"],
+                    ] as const
+                  ).map(([value, label]) => (
+                    <MenuRadioItem key={value} value={value}>
+                      <span className="flex items-center gap-2">
+                        <span className="flex-1">{label}</span>
+                        <MenuRadioItemIndicator />
+                      </span>
+                    </MenuRadioItem>
+                  ))}
+                </MenuRadioGroup>
               </MenuPopup>
             </Menu>
+            <RailButton
+              tooltipSide={popupSide}
+              label="Device tools"
+              pressed={props.toolsOpen}
+              onClick={props.onTools}
+            >
+              <SlidersHorizontal />
+            </RailButton>
           </>
-        ) : (
+        )}
+        {props.inputOnly ? null : (
           <RailButton
             tooltipSide={popupSide}
-            label="Rotate device"
-            disabled={inputDisabled || !!view.keyboard?.attached}
-            onClick={() => handle?.rotate()}
+            label={props.screenshotPending ? "Capturing screenshot" : "Save screenshot"}
+            disabled={!view.streaming || props.screenshotPending}
+            onClick={props.onScreenshot}
           >
-            <RotateCcw />
+            <Camera />
           </RailButton>
         )}
-        <RailDivider />
-        <RailButton
-          tooltipSide={popupSide}
-          label={`Switch device to ${nextAppearance} mode`}
-          disabled={controls.disabled || !settings?.appearance}
-          onClick={() => void controls.act({ type: "setAppearance", value: nextAppearance })}
-        >
-          <MorphIcon icon={settings?.appearance === "dark" ? Sun : Moon} />
-        </RailButton>
-        <Menu>
-          <MenuTrigger
-            render={
-              <Button
-                size="icon-sm"
-                variant="ghost"
-                aria-label="Device text size"
-                title="Device text size"
-                disabled={controls.disabled || !settings?.textSize}
-              />
-            }
-          >
-            <Type />
-          </MenuTrigger>
-          <MenuPopup side={popupSide} className="min-w-40">
-            <MenuRadioGroup
-              value={settings?.textSize ?? ""}
-              onValueChange={(value) => {
-                if (
-                  value === "small" ||
-                  value === "default" ||
-                  value === "large" ||
-                  value === "extra-large"
-                )
-                  void controls.act({ type: "setTextSize", value });
-              }}
-            >
-              {(
-                [
-                  ["small", "Small"],
-                  ["default", "Default"],
-                  ["large", "Large"],
-                  ["extra-large", "Extra large"],
-                ] as const
-              ).map(([value, label]) => (
-                <MenuRadioItem key={value} value={value}>
-                  <span className="flex items-center gap-2">
-                    <span className="flex-1">{label}</span>
-                    <MenuRadioItemIndicator />
-                  </span>
-                </MenuRadioItem>
-              ))}
-            </MenuRadioGroup>
-          </MenuPopup>
-        </Menu>
-        <RailButton
-          tooltipSide={popupSide}
-          label="Device tools"
-          pressed={props.toolsOpen}
-          onClick={props.onTools}
-        >
-          <SlidersHorizontal />
-        </RailButton>
-        <RailButton
-          tooltipSide={popupSide}
-          label={props.screenshotPending ? "Capturing screenshot" : "Save screenshot"}
-          disabled={!view.streaming || props.screenshotPending}
-          onClick={props.onScreenshot}
-        >
-          <Camera />
-        </RailButton>
         <Menu>
           <MenuTrigger
             render={
@@ -219,7 +229,7 @@ export function DeviceControlsRail(props: {
             <MenuSeparator />
             <MenuItem variant="destructive" onClick={props.onPowerOff}>
               <Power />
-              Power off device
+              {props.inputOnly ? "Return device to the pool" : "Power off device"}
             </MenuItem>
           </MenuPopup>
         </Menu>
diff --git a/apps/web/src/components/device/DevicePanel.tsx b/apps/web/src/components/device/DevicePanel.tsx
index 8eb40a82325f7..c8f55665113ac 100644
--- a/apps/web/src/components/device/DevicePanel.tsx
+++ b/apps/web/src/components/device/DevicePanel.tsx
@@ -86,6 +86,9 @@ export function DevicePanel(props: {
         (device) => device.hostId === activeSession.hostId && device.id === activeSession.deviceId,
       )
     : undefined;
+  const activeHost = activeDevice
+    ? state.hosts.find((host) => host.id === activeDevice.hostId)
+    : undefined;
 
   const grouped = groupDevices(state);
 
@@ -234,9 +237,8 @@ export function DevicePanel(props: {
               key={`${environmentId}\u0000${deviceKey(activeDevice)}`}
               environmentId={environmentId}
               device={activeDevice}
-              hostLabel={
-                state.hosts.find((host) => host.id === activeDevice.hostId)?.label ?? "Device host"
-              }
+              hostLabel={activeHost?.label ?? "Device host"}
+              simlock={activeHost?.kind === "simlock"}
               hostDiagnostics={
                 diagnostics.find(({ hostId }) => hostId === activeDevice.hostId)?.detail
               }
diff --git a/apps/web/src/components/device/DeviceSetup.tsx b/apps/web/src/components/device/DeviceSetup.tsx
index d3866129795e8..9d7b30c0456a7 100644
--- a/apps/web/src/components/device/DeviceSetup.tsx
+++ b/apps/web/src/components/device/DeviceSetup.tsx
@@ -19,9 +19,9 @@ import { cn } from "~/lib/utils";
 
 const platformName = (platform: DevicePlatform) => (platform === "ios" ? "iOS" : "Android");
 
-export const deviceHubDescription =
+const deviceHubDescription =
   "Enable this environment to open simulators and emulators, whether they run here or on a remote device host.";
-export const agentDeviceDescription =
+const agentDeviceDescription =
   "Allow new agent sessions in this environment to start and control local and remote devices, with required tools set up automatically.";
 
 export const isAndroidDiscoveryUncertain = (state: DeviceServiceState) =>
@@ -57,7 +57,7 @@ function deviceHostDiagnostics(
   });
 }
 
-export function DeviceHostDiagnostics(props: {
+function DeviceHostDiagnostics(props: {
   readonly hosts: ReadonlyArray<Pick<DeviceServiceState["hosts"][number], "id" | "label">>;
   readonly hostStatuses: DeviceServiceState["hostStatuses"];
   readonly className?: string;
@@ -360,7 +360,7 @@ export function AgentDeviceSetupStatus(props: {
   return null;
 }
 
-export function PlatformStatus(props: {
+function PlatformStatus(props: {
   readonly platform: string;
   readonly status: { readonly ready: boolean; readonly message: string };
   readonly compact?: boolean;
diff --git a/apps/web/src/components/device/DeviceStreamView.tsx b/apps/web/src/components/device/DeviceStreamView.tsx
index 22ae466acb0ed..4b0b5c84ca5b9 100644
--- a/apps/web/src/components/device/DeviceStreamView.tsx
+++ b/apps/web/src/components/device/DeviceStreamView.tsx
@@ -93,6 +93,8 @@ export function DeviceStreamView(props: {
   readonly axOverlay?: boolean;
   /** Lets a parent read this view's own stream state, such as its screen size. */
   readonly viewId?: string;
+  /** The host serves only serve-sim's stream and input socket (Simlock). */
+  readonly serveSimOnly?: boolean;
 }) {
   const model = deviceModel(props.platform, props.deviceName ?? "");
   const isDuo = model?.id === "iphone-duo";
@@ -118,6 +120,7 @@ export function DeviceStreamView(props: {
           platform: props.platform,
           deviceId: props.deviceId,
           access,
+          serveSimOnly: props.serveSimOnly === true,
           viewId,
         })
       : NO_SESSION_ATOM,
diff --git a/apps/web/src/components/device/DeviceWorkspace.tsx b/apps/web/src/components/device/DeviceWorkspace.tsx
index b8d329bc0dfbf..b57adae023269 100644
--- a/apps/web/src/components/device/DeviceWorkspace.tsx
+++ b/apps/web/src/components/device/DeviceWorkspace.tsx
@@ -16,6 +16,8 @@ export function DeviceWorkspace(props: {
   environmentId: EnvironmentId;
   device: DeviceSummary;
   hostLabel: string;
+  /** Leased from a Simlock pool: serve-sim input, no host commands. */
+  simlock?: boolean;
   hostDiagnostics: string | undefined;
   visible: boolean;
   onFloat: () => void;
@@ -80,6 +82,7 @@ export function DeviceWorkspace(props: {
             deviceId={props.device.id}
             hostId={props.device.hostId}
             visible={props.visible}
+            serveSimOnly={props.simlock === true}
             axOverlay={axOverlay}
             allowPhoneView
             renderControls={(view) => (
@@ -95,6 +98,7 @@ export function DeviceWorkspace(props: {
                 onFloat={props.onFloat}
                 onClose={props.onClose}
                 onPowerOff={props.onPowerOff}
+                inputOnly={props.simlock === true}
               />
             )}
           />
diff --git a/apps/web/src/components/device/deviceStreamSession.ts b/apps/web/src/components/device/deviceStreamSession.ts
index 813a4f3fd8e89..27fc79c97b03c 100644
--- a/apps/web/src/components/device/deviceStreamSession.ts
+++ b/apps/web/src/components/device/deviceStreamSession.ts
@@ -43,6 +43,8 @@ export interface DeviceStreamKey {
   readonly platform: DevicePlatform;
   readonly deviceId: string;
   readonly access: DeviceHubAccess;
+  /** See `DeviceStreamTarget.serveSimOnly`. */
+  readonly serveSimOnly: boolean;
   /** Each mounted view owns its own client: one canvas cannot be in two places. */
   readonly viewId: string;
 }
@@ -89,7 +91,12 @@ export const deviceStreamSessionAtom = Atom.family((key: DeviceStreamKey) =>
       get.setSelf(session);
     };
     const client = createDeviceStreamClient(
-      { platform: key.platform, deviceId: key.deviceId, access: key.access },
+      {
+        platform: key.platform,
+        deviceId: key.deviceId,
+        access: key.access,
+        serveSimOnly: key.serveSimOnly,
+      },
       createCanvasFrameSink(canvas, () => frameListener?.()),
       {
         onDuoControl: (duoControl) => {
diff --git a/apps/web/src/components/diffs/diffFileTree.logic.test.ts b/apps/web/src/components/diffs/diffFileTree.logic.test.ts
index 757ab3f83de42..dea4b9981c8a6 100644
--- a/apps/web/src/components/diffs/diffFileTree.logic.test.ts
+++ b/apps/web/src/components/diffs/diffFileTree.logic.test.ts
@@ -1,7 +1,11 @@
 import type { FileDiffMetadata } from "@pierre/diffs";
 import { describe, expect, it } from "vite-plus/test";
 
-import { buildDiffFileTreeUpdates, diffFileTreeEntries } from "./diffFileTree.logic";
+import {
+  buildDiffFileTreeUpdates,
+  diffFileTreeEntries,
+  orderDiffFilesLikeTree,
+} from "./diffFileTree.logic";
 
 function file(type: FileDiffMetadata["type"], name: string, prevName = name): FileDiffMetadata {
   return { type, name, prevName } as FileDiffMetadata;
@@ -24,6 +28,26 @@ describe("diffFileTreeEntries", () => {
   });
 });
 
+describe("orderDiffFilesLikeTree", () => {
+  it("pulls a test listed last into its directory, keeping the first-seen order", () => {
+    expect(
+      orderDiffFilesLikeTree([
+        file("change", "server/device/Host.ts"),
+        file("change", "web/settings.ts"),
+        file("change", "server/ws.ts"),
+        file("change", "server/device/Host.test.ts"),
+        file("change", "web/settings.test.ts"),
+      ]).map((entry) => entry.name),
+    ).toEqual([
+      "server/device/Host.ts",
+      "server/device/Host.test.ts",
+      "server/ws.ts",
+      "web/settings.ts",
+      "web/settings.test.ts",
+    ]);
+  });
+});
+
 describe("buildDiffFileTreeUpdates", () => {
   it("adds a new file's directories before the file", () => {
     expect(buildDiffFileTreeUpdates(["README.md"], ["README.md", "src/lib/a.ts"])).toEqual([
diff --git a/apps/web/src/components/diffs/diffFileTree.logic.ts b/apps/web/src/components/diffs/diffFileTree.logic.ts
index abb3a00c7689b..41d2a5e676e70 100644
--- a/apps/web/src/components/diffs/diffFileTree.logic.ts
+++ b/apps/web/src/components/diffs/diffFileTree.logic.ts
@@ -98,6 +98,36 @@ export function diffFileTreePositions(paths: ReadonlyArray<string>): ReadonlyMap
   return positions;
 }
 
+// A flat list in tree order: each directory stays contiguous, siblings ranked as
+// compareDiffFileTreeEntries ranks them, so the list never disagrees with the tree.
+export function orderDiffFilesLikeTree(
+  files: ReadonlyArray<FileDiffMetadata>,
+): ReadonlyArray<FileDiffMetadata> {
+  const paths = files.map(resolveFileDiffPath);
+  const positions = diffFileTreePositions(paths);
+  const keys = paths.map((path) => {
+    const key: number[] = [];
+    let directory = "";
+    for (const segment of path.split("/").slice(0, -1)) {
+      directory += `${segment}/`;
+      key.push(positions.get(directory)!);
+    }
+    key.push(positions.get(path)!);
+    return key;
+  });
+  return files
+    .map((file, index) => ({ file, key: keys[index]! }))
+    .toSorted((left, right) => {
+      const length = Math.min(left.key.length, right.key.length);
+      for (let index = 0; index < length; index++) {
+        const difference = left.key[index]! - right.key[index]!;
+        if (difference !== 0) return difference;
+      }
+      return left.key.length - right.key.length;
+    })
+    .map(({ file }) => file);
+}
+
 export function compareDiffFileTreeEntries(
   getPositions: () => ReadonlyMap<string, number>,
 ): FileTreeSortComparator {
diff --git a/apps/web/src/components/diffs/useHideTestFiles.ts b/apps/web/src/components/diffs/useHideTestFiles.ts
new file mode 100644
index 0000000000000..a1f806ecb467d
--- /dev/null
+++ b/apps/web/src/components/diffs/useHideTestFiles.ts
@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+
+import { useLocalStorage } from "~/hooks/useLocalStorage";
+
+const HIDE_TEST_FILES_STORAGE_KEY = "t3code.diffHideTestFiles";
+
+export function useHideTestFiles() {
+  return useLocalStorage(HIDE_TEST_FILES_STORAGE_KEY, false, Schema.Boolean);
+}
diff --git a/apps/web/src/components/preview/ThreadPreviewMiniPlayer.tsx b/apps/web/src/components/preview/ThreadPreviewMiniPlayer.tsx
index 26ed49fba0fa5..50b5ae47c449b 100644
--- a/apps/web/src/components/preview/ThreadPreviewMiniPlayer.tsx
+++ b/apps/web/src/components/preview/ThreadPreviewMiniPlayer.tsx
@@ -366,8 +366,8 @@ function DeviceMiniPlayer({
   const device = deviceState.devices.find(
     (entry) => entry.hostId === source.hostId && entry.id === source.deviceId,
   );
-  const hostLabel =
-    deviceState.hosts.find((host) => host.id === source.hostId)?.label ?? "Device host";
+  const host = deviceState.hosts.find((entry) => entry.id === source.hostId);
+  const hostLabel = host?.label ?? "Device host";
   const cornerRadius = (player: PreviewMiniPlayerSize) =>
     resolveDeviceMiniPlayerCornerRadius(source.platform, player);
 
@@ -404,6 +404,7 @@ function DeviceMiniPlayer({
             deviceDescription={`${hostLabel} · ${device?.version ?? source.platform}`}
             visible
             viewId={viewId}
+            serveSimOnly={host?.kind === "simlock"}
           />
         </div>
       )}
diff --git a/apps/web/src/components/pullRequest/PullRequestActionsMenu.browser.test.tsx b/apps/web/src/components/pullRequest/PullRequestActionsMenu.browser.test.tsx
new file mode 100644
index 0000000000000..521d9c47f316e
--- /dev/null
+++ b/apps/web/src/components/pullRequest/PullRequestActionsMenu.browser.test.tsx
@@ -0,0 +1,212 @@
+import "~/index.css";
+import { EnvironmentId, ProjectId } from "@t3tools/contracts";
+import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
+import { Cause } from "effect";
+import { expect, it, vi } from "vite-plus/test";
+import { page } from "vite-plus/test/browser";
+
+const mocks = vi.hoisted(() => ({
+  update:
+    vi.fn<(input: unknown) => Promise<{ _tag: "Success" } | { _tag: "Failure"; cause: unknown }>>(),
+  notify: vi.fn(),
+}));
+vi.mock(
+  import("~/state/pullRequests"),
+  () => ({ pullRequestEnvironment: { update: {} } }) as never,
+);
+vi.mock(
+  import("~/state/use-atom-command"),
+  () => ({ useAtomCommand: () => mocks.update }) as never,
+);
+
+vi.mock(import("../ui/toast"), () => ({ toastManager: { add: mocks.notify } }) as never);
+vi.mock(import("~/state/server"), async () => {
+  const { Atom } = await import("effect/reactivity");
+  return { primaryServerKeybindingsAtom: Atom.make([]) } as never;
+});
+vi.mock(import("./PullRequestThreadLinks"), () => ({ PullRequestThreadLinks: () => null }));
+vi.mock(
+  import("./PullRequestDetailActions"),
+  () => ({ ActOnEnvironmentPicker: () => null }) as never,
+);
+
+import { render } from "../../../test/render";
+import { PullRequestActionsMenu } from "./PullRequestActionsMenu";
+
+const reference = { projectId: ProjectId.make("project"), repository: "owner/repo", number: 7 };
+const environmentId = EnvironmentId.make("environment");
+
+type Detail = Parameters<typeof PullRequestActionsMenu>[0]["detail"];
+
+const openDetail: Detail = {
+  url: "https://github.com/owner/repo/pull/7",
+  state: "open",
+  isDraft: false,
+  headBranch: "feature",
+  maintainerCanModify: true,
+  observedAt: 1,
+  capabilities: {
+    diff: true,
+    comment: true,
+    actions: [],
+    mergeMethods: [],
+    search: true,
+    review: { inlineComment: true, reply: true, resolve: true, verdicts: [] },
+    reviewers: { request: true, listCandidates: true },
+    edit: { changeRequest: true, comment: true, maintainerEdits: true },
+  },
+  viewerPermissions: {
+    actions: [],
+    comment: true,
+    resolve: true,
+    verdicts: [],
+    requestReviewers: true,
+    maintainerEdits: true,
+  },
+};
+
+function setup() {
+  mocks.update.mockReset().mockResolvedValue({ _tag: "Success" });
+  mocks.notify.mockReset();
+  return (detail: Detail = openDetail) => (
+    <PullRequestActionsMenu
+      environmentId={environmentId}
+      reference={reference}
+      pullRequestKey="owner/repo/7"
+      detail={detail}
+      terminology={sourceControlClients.get("github").changeRequest}
+      linkThreadRef={null}
+      onThreadPickerOpenChange={() => {}}
+      refreshing={false}
+      refreshFromHost={async () => {}}
+      handoff={null}
+      attachesToComposer={false}
+      askAboutPullRequest={() => {}}
+      explainPullRequest={() => {}}
+      canFixFindings={false}
+      startFixFindings={() => {}}
+      handoffLabels={{ fixFindings: "Fix review findings" }}
+      canWriteGuide={false}
+      guideRunning={false}
+      guideWritten={false}
+      writeGuide={() => {}}
+      pickableEnvironments={[]}
+      actingEnvironmentId={environmentId}
+      onActingEnvironmentChange={() => {}}
+      can={() => false}
+      autoMergeArmed={false}
+      showsDraftToggle={false}
+      showsMergeNow={false}
+      showsAutoMerge={false}
+      showsMergeMethods={false}
+      allowedMergeMethods={[]}
+      selectedMergeMethod="squash"
+      onSelectMergeMethod={() => {}}
+      showsDeleteBranch={false}
+      environmentConnected={true}
+      canWriteSourceControl={true}
+      onMaintainerEditsSaved={() => {}}
+      confirmDeleteBranch={async () => {}}
+      pendingAction={null}
+      perform={async () => true}
+      openOnHostText="Open on GitHub"
+      copyReference={() => {}}
+    />
+  );
+}
+
+it("saves maintainer edits, locks while saving, and restores the saved value when a save fails", async () => {
+  const control = setup();
+  await using screen = await render(control());
+  await screen.getByRole("button", { name: "More pull request actions" }).click();
+  const checkbox = page.getByRole("menuitemcheckbox", { name: "Allow edits from maintainers" });
+  await expect.element(checkbox).toBeChecked();
+  await checkbox.click();
+  await expect.element(page.getByRole("status")).not.toBeInTheDocument();
+  expect(mocks.update).toHaveBeenCalledExactlyOnceWith({
+    environmentId,
+    input: { ...reference, maintainerCanModify: false },
+  });
+
+  let settle!: (value: { _tag: "Failure"; cause: unknown }) => void;
+  mocks.update.mockReturnValueOnce(
+    new Promise((resolve) => {
+      settle = resolve;
+    }),
+  );
+  await checkbox.click();
+  await expect.element(checkbox).toBeChecked();
+  await expect.element(checkbox).toBeDisabled();
+  await expect.element(page.getByRole("status")).toHaveTextContent("Saving…");
+  settle({
+    _tag: "Failure",
+    cause: Cause.fail(new Error("Resource not accessible by integration")),
+  });
+  await expect.element(checkbox).not.toBeChecked();
+  expect(mocks.notify).toHaveBeenCalledExactlyOnceWith(
+    expect.objectContaining({
+      type: "error",
+      title: "Could not save maintainer access",
+      description: "Resource not accessible by integration",
+    }),
+  );
+});
+
+it("keeps a saved choice through a stale refresh, then follows the host", async () => {
+  const control = setup();
+  await using screen = await render(control());
+  await screen.getByRole("button", { name: "More pull request actions" }).click();
+  const checkbox = page.getByRole("menuitemcheckbox", { name: "Allow edits from maintainers" });
+  let settle!: (value: { _tag: "Success" }) => void;
+  mocks.update.mockReturnValueOnce(
+    new Promise((resolve) => {
+      settle = resolve;
+    }),
+  );
+  await checkbox.click();
+  await screen.rerender(control({ ...openDetail, observedAt: 2 }));
+  settle({ _tag: "Success" });
+  await expect.element(page.getByRole("status")).not.toBeInTheDocument();
+  await screen.rerender(control({ ...openDetail, observedAt: 2 }));
+  await expect.element(checkbox).not.toBeChecked();
+  await screen.rerender(control({ ...openDetail, maintainerCanModify: false, observedAt: 3 }));
+  await expect.element(checkbox).not.toBeChecked();
+  await screen.rerender(control({ ...openDetail, maintainerCanModify: true, observedAt: 4 }));
+  await expect.element(checkbox).toBeChecked();
+});
+
+it("follows the host's first reading after a save, even when it matches the old value", async () => {
+  const control = setup();
+  await using screen = await render(control());
+  await screen.getByRole("button", { name: "More pull request actions" }).click();
+  const checkbox = page.getByRole("menuitemcheckbox", { name: "Allow edits from maintainers" });
+  await checkbox.click();
+  await expect.element(page.getByRole("status")).not.toBeInTheDocument();
+  await expect.element(checkbox).not.toBeChecked();
+  await screen.rerender(control({ ...openDetail, observedAt: 2 }));
+  await expect.element(checkbox).toBeChecked();
+});
+
+it.each<[string, Detail]>([
+  ["closed", { ...openDetail, state: "closed" }],
+  [
+    "not authored by the viewer",
+    {
+      ...openDetail,
+      viewerPermissions: { ...openDetail.viewerPermissions, maintainerEdits: false },
+    },
+  ],
+  [
+    "on a host without maintainer edits",
+    {
+      ...openDetail,
+      capabilities: { ...openDetail.capabilities, edit: { changeRequest: true, comment: true } },
+    },
+  ],
+])("hides maintainer edits on a pull request that is %s", async (_, detail) => {
+  const control = setup();
+  await using screen = await render(control(detail));
+  await screen.getByRole("button", { name: "More pull request actions" }).click();
+  await expect.element(page.getByRole("menuitem", { name: "Open on GitHub" })).toBeVisible();
+  expect(document.querySelector('[role="menuitemcheckbox"]')).toBeNull();
+});
diff --git a/apps/web/src/components/pullRequest/PullRequestActionsMenu.tsx b/apps/web/src/components/pullRequest/PullRequestActionsMenu.tsx
index c920bbd3e19ff..df402185ce350 100644
--- a/apps/web/src/components/pullRequest/PullRequestActionsMenu.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestActionsMenu.tsx
@@ -1,5 +1,11 @@
 import { useAtomValue } from "@effect/atom-react";
+import {
+  canEditPullRequestMaintainerEdits,
+  maintainerEditsChoiceInForce,
+  type MaintainerEditsChoice,
+} from "@t3tools/client-runtime/pull-request-editing";
 import type { ChangeRequestTerminology } from "@t3tools/client-runtime/source-control-clients";
+import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import type {
   EnvironmentId,
   PullRequestAction,
@@ -20,13 +26,17 @@ import {
   SparklesIcon,
   Trash2Icon,
 } from "lucide-react";
+import { useId, useState } from "react";
 
 import { shortcutLabelForCommand } from "~/keybindings";
 import { readLocalApi } from "~/localApi";
+import { pullRequestEnvironment } from "~/state/pullRequests";
 import { primaryServerKeybindingsAtom } from "~/state/server";
+import { useAtomCommand } from "~/state/use-atom-command";
 import { Button } from "../ui/button";
 import {
   Menu,
+  MenuCheckboxItem,
   MenuItem,
   MenuPopup,
   MenuRadioGroup,
@@ -36,11 +46,13 @@ import {
   MenuTrigger,
 } from "../ui/menu";
 import { RefreshIcon } from "../ui/refresh-icon";
+import { toastManager } from "../ui/toast";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
 import { ActOnEnvironmentPicker, type PerformPullRequestAction } from "./PullRequestDetailActions";
 import {
   PULL_REQUEST_MERGE_METHOD_LABELS,
   pullRequestActionMenuHasGroup,
+  readableFailure,
 } from "./pullRequestDetail.logic";
 import { PullRequestGlyph } from "./pullRequestIcons";
 import type { PickableEnvironment } from "./pullRequestProjectAssignment.logic";
@@ -83,6 +95,8 @@ export function PullRequestActionsMenu({
   onSelectMergeMethod,
   showsDeleteBranch,
   environmentConnected,
+  canWriteSourceControl,
+  onMaintainerEditsSaved,
   confirmDeleteBranch,
   pendingAction,
   perform,
@@ -92,7 +106,17 @@ export function PullRequestActionsMenu({
   environmentId: EnvironmentId;
   reference: PullRequestRef;
   pullRequestKey: string;
-  detail: Pick<PullRequestDetail, "url" | "state" | "isDraft" | "headBranch">;
+  detail: Pick<
+    PullRequestDetail,
+    | "url"
+    | "state"
+    | "isDraft"
+    | "headBranch"
+    | "capabilities"
+    | "viewerPermissions"
+    | "maintainerCanModify"
+    | "observedAt"
+  >;
   terminology: ChangeRequestTerminology;
   linkThreadRef: ScopedThreadRef | null;
   onThreadPickerOpenChange: (open: boolean) => void;
@@ -123,6 +147,8 @@ export function PullRequestActionsMenu({
   onSelectMergeMethod: (method: PullRequestMergeMethod) => void;
   showsDeleteBranch: boolean;
   environmentConnected: boolean;
+  canWriteSourceControl: boolean;
+  onMaintainerEditsSaved: () => void;
   confirmDeleteBranch: () => Promise<void>;
   pendingAction: PullRequestAction | null;
   perform: PerformPullRequestAction;
@@ -132,6 +158,47 @@ export function PullRequestActionsMenu({
   const keybindings = useAtomValue(primaryServerKeybindingsAtom);
   const inlineConfirm = useInlineActionConfirm(pullRequestKey);
   const actionPending = pendingAction !== null;
+  const maintainerEditsHintId = useId();
+  const updatePullRequest = useAtomCommand(pullRequestEnvironment.update, {
+    reportFailure: false,
+  });
+  const [maintainerEditsChoice, setMaintainerEditsChoice] = useState<MaintainerEditsChoice | null>(
+    null,
+  );
+  const [maintainerEditsSaving, setMaintainerEditsSaving] = useState(false);
+  const maintainerEditsChoiceKept = maintainerEditsChoiceInForce(
+    maintainerEditsChoice,
+    pullRequestKey,
+    detail.observedAt,
+    maintainerEditsSaving,
+  );
+  if (maintainerEditsChoiceKept !== maintainerEditsChoice) {
+    setMaintainerEditsChoice(maintainerEditsChoiceKept);
+  }
+  const maintainerCanModify = maintainerEditsChoiceKept?.value ?? detail.maintainerCanModify;
+  const canSaveMaintainerEdits =
+    canWriteSourceControl && environmentConnected && !maintainerEditsSaving;
+  const saveMaintainerEdits = async (value: boolean) => {
+    if (!canSaveMaintainerEdits) return;
+    const previousChoice = maintainerEditsChoice;
+    setMaintainerEditsChoice({ key: pullRequestKey, observedAt: detail.observedAt, value });
+    setMaintainerEditsSaving(true);
+    const result = await updatePullRequest({
+      environmentId,
+      input: { ...reference, maintainerCanModify: value },
+    });
+    setMaintainerEditsSaving(false);
+    if (result._tag === "Failure") {
+      setMaintainerEditsChoice(previousChoice);
+      toastManager.add({
+        type: "error",
+        title: "Could not save maintainer access",
+        description: readableFailure(squashAtomCommandFailure(result), "Try again."),
+      });
+      return;
+    }
+    onMaintainerEditsSaved();
+  };
   return (
     <Menu>
       <Tooltip>
@@ -218,6 +285,33 @@ export function PullRequestActionsMenu({
           />
         ) : null}
         <MenuSeparator />
+        {canEditPullRequestMaintainerEdits(detail) ? (
+          <>
+            <MenuCheckboxItem
+              variant="icon"
+              checked={maintainerCanModify === true}
+              disabled={!canSaveMaintainerEdits}
+              closeOnClick={false}
+              aria-label="Allow edits from maintainers"
+              aria-describedby={maintainerEditsHintId}
+              onCheckedChange={(value) => void saveMaintainerEdits(value)}
+            >
+              <span className="flex max-w-xs flex-col gap-0.5">
+                <span>Allow edits from maintainers</span>
+                <span id={maintainerEditsHintId} className="text-xs text-muted-foreground">
+                  Maintainers can push to this branch. If your fork has workflows, this can also
+                  give access to its secrets.
+                </span>
+                {maintainerEditsSaving ? (
+                  <span role="status" className="text-xs text-muted-foreground">
+                    Saving…
+                  </span>
+                ) : null}
+              </span>
+            </MenuCheckboxItem>
+            <MenuSeparator />
+          </>
+        ) : null}
         {detail.state === "open" ? (
           <>
             {showsDraftToggle ? (
diff --git a/apps/web/src/components/pullRequest/PullRequestCodeTab.tsx b/apps/web/src/components/pullRequest/PullRequestCodeTab.tsx
index d1b165c62147b..94f4ccda82558 100644
--- a/apps/web/src/components/pullRequest/PullRequestCodeTab.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestCodeTab.tsx
@@ -19,6 +19,7 @@ import {
   ChevronDownIcon,
   ChevronRightIcon,
   Columns2Icon,
+  FlaskConicalOffIcon,
   FolderTreeIcon,
   InfoIcon,
   MessageSquareOffIcon,
@@ -51,6 +52,7 @@ import {
   canEditPullRequestComment,
   canResolvePullRequestThread,
 } from "@t3tools/client-runtime/pull-request-editing";
+import { isTestChangedFile } from "@t3tools/shared/changedFileKind";
 import { orderDiffFiles } from "./pullRequestFileOrder.logic";
 import {
   buildFileDiffRenderKey,
@@ -80,7 +82,8 @@ import { useDiffWorkerPool } from "../DiffWorkerPoolProvider";
 import { DiffCommentAnnotation } from "../diffs/DiffCommentAnnotation";
 import { DiffFileTree } from "../diffs/DiffFileTree";
 import { useCodeViewFileReveal } from "../diffs/useCodeViewFileReveal";
-import { diffFileTreeEntries } from "../diffs/diffFileTree.logic";
+import { useHideTestFiles } from "../diffs/useHideTestFiles";
+import { diffFileTreeEntries, orderDiffFilesLikeTree } from "../diffs/diffFileTree.logic";
 import { StyledDiffCodeView } from "../diffs/StyledDiffCodeView";
 import { Button } from "../ui/button";
 import { MorphIcon } from "~/components/MorphIcon";
@@ -307,6 +310,7 @@ function PullRequestCodeTab({
     false,
     Schema.Boolean,
   );
+  const [hideTestFiles, setHideTestFiles] = useHideTestFiles();
   const [selectedLines, setSelectedLines] = useState<{
     id: string;
     range: SelectedLineRange;
@@ -496,9 +500,22 @@ function PullRequestCodeTab({
       ignoreWhitespace,
     ),
   );
-  const files = parsedSlices.flatMap((parsed) =>
-    parsed?.kind === "files" ? orderDiffFiles(parsed.files) : [],
+  const loadedFiles = orderDiffFilesLikeTree(
+    parsedSlices.flatMap((parsed) =>
+      parsed?.kind === "files" ? orderDiffFiles(parsed.files) : [],
+    ),
   );
+  const testFileCount = loadedFiles.filter((file) =>
+    isTestChangedFile(resolveFileDiffPath(file)),
+  ).length;
+  // A requested file stays visible so a jump to a hidden test still lands.
+  const files = hideTestFiles
+    ? loadedFiles.filter((file) => {
+        const path = resolveFileDiffPath(file);
+        return path === revealRequest?.path || !isTestChangedFile(path);
+      })
+    : loadedFiles;
+  const hiddenTestFileCount = loadedFiles.length - files.length;
   const filePaths = files.map((file) => resolveFileDiffPath(file));
   const omittedFileStats = new Map(
     loadedSlices.flatMap((slice) =>
@@ -1071,6 +1088,11 @@ function PullRequestCodeTab({
             {files.length} {files.length === 1 ? "file" : "files"}
             {nextCursor === null ? "" : "+"}
           </span>
+          {hiddenTestFileCount > 0 ? (
+            <Button type="button" size="xs" variant="link" onClick={() => setHideTestFiles(false)}>
+              {hiddenTestFileCount} test {hiddenTestFileCount === 1 ? "file" : "files"} hidden
+            </Button>
+          ) : null}
           {filesViewed.enabled && files.length > 0 ? (
             <span className="flex min-w-0 items-center gap-1 tabular-nums">
               <span className="shrink-0">
@@ -1283,6 +1305,26 @@ function PullRequestCodeTab({
             </TooltipPopup>
           </Tooltip>
         ) : null}
+        {testFileCount > 0 ? (
+          <Tooltip>
+            <TooltipTrigger
+              render={
+                <Toggle
+                  aria-label="Hide test files"
+                  variant="ghost"
+                  size="sm"
+                  pressed={hideTestFiles}
+                  onPressedChange={(pressed) => setHideTestFiles(Boolean(pressed))}
+                />
+              }
+            >
+              <FlaskConicalOffIcon className="size-3.5" />
+            </TooltipTrigger>
+            <TooltipPopup side="top">
+              {hideTestFiles ? "Show test files" : "Hide test files"}
+            </TooltipPopup>
+          </Tooltip>
+        ) : null}
         {fileKeys.length > 0 ? (
           <Tooltip>
             <TooltipTrigger
diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
index 45a070b9806b1..135ae2970ceb9 100644
--- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
@@ -1381,6 +1381,8 @@ export function PullRequestDetailPanel({
                 onSelectMergeMethod={selectMergeMethod}
                 showsDeleteBranch={showsDeleteBranch}
                 environmentConnected={environmentConnected}
+                canWriteSourceControl={canWriteSourceControl}
+                onMaintainerEditsSaved={refreshDetail}
                 confirmDeleteBranch={confirmDeleteBranch}
                 pendingAction={pendingAction}
                 perform={perform}
diff --git a/apps/web/src/components/settings/AppearanceSettingsPanel.tsx b/apps/web/src/components/settings/AppearanceSettingsPanel.tsx
index f47ee3f52c793..1c5812a2bda0d 100644
--- a/apps/web/src/components/settings/AppearanceSettingsPanel.tsx
+++ b/apps/web/src/components/settings/AppearanceSettingsPanel.tsx
@@ -34,6 +34,7 @@ import { searchableSetting } from "./settingsSearch";
 import { AdvancedSettings } from "./AdvancedSettings";
 import { PanelAnimationsPreview } from "./PanelAnimationsPreview";
 import { TypographySection } from "./TypographySettings";
+import { ThreadDetailsItemsRow } from "./ThreadDetailsItemsRow";
 
 const ENVIRONMENT_IDENTIFICATION_LABELS: Record<EnvironmentIdentificationMode, string> = {
   artwork: "Artwork",
@@ -273,6 +274,7 @@ export function AppearanceSettingsPanel() {
             </div>
           }
         />
+        <ThreadDetailsItemsRow />
         <SettingsRow
           {...searchableSetting("effort-display")}
           description="Show reasoning effort in the composer as its name, such as High, or as bars."
diff --git a/apps/web/src/components/settings/DeviceHostsSettings.tsx b/apps/web/src/components/settings/DeviceHostsSettings.tsx
deleted file mode 100644
index fb5a1b2517e78..0000000000000
--- a/apps/web/src/components/settings/DeviceHostsSettings.tsx
+++ /dev/null
@@ -1,593 +0,0 @@
-import { DeviceToolVersions } from "../device/DeviceToolVersions";
-import { DeviceHostAvailability } from "../device/DeviceHostAvailability";
-import { useAtomValue } from "@effect/atom-react";
-import * as Option from "effect/Option";
-import { AsyncResult } from "effect/reactivity";
-import { AuthSettingsWriteScope } from "@t3tools/contracts";
-import { readEnvironmentScope, useEnvironmentScope } from "../../state/session";
-import { Tooltip, TooltipTrigger, TooltipPopup } from "../ui/tooltip";
-import { AppleIcon, AndroidIcon } from "../Icons";
-import { Spinner } from "../ui/spinner";
-import type { EnvironmentId, SshDeviceHostConfig } from "@t3tools/contracts";
-import { randomUUID } from "../../lib/utils";
-import { useState } from "react";
-import { deviceEnvironment } from "../../state/device";
-import { environmentAtomList, environmentIdsKey } from "../../state/environmentAtomList";
-import { serverEnvironment } from "../../state/server";
-import { useAtomCommand } from "../../state/use-atom-command";
-import { Button, InlineButton } from "../ui/button";
-import {
-  CheckIcon,
-  ChevronDownIcon,
-  CircleIcon,
-  MoreVertical,
-  PlusIcon,
-  TriangleAlertIcon,
-} from "lucide-react";
-import { Collapsible, CollapsiblePanel, CollapsibleTrigger } from "../ui/collapsible";
-import { Menu, MenuTrigger, MenuPopup, MenuItem } from "../ui/menu";
-import { SettingsRow } from "./settingsLayout";
-
-import { useSettingsScope } from "./SettingsScopeContext";
-import { toastManager } from "../ui/toast";
-import {
-  groupDeviceHosts,
-  updateDeviceHosts,
-  type DeviceHostEnvironment,
-  type DeviceHostGroup,
-} from "./deviceHostsSettings.logic";
-import { FoldedSettingsSection } from "./FoldedSettingsSection";
-import { DeviceHostEditor } from "./DeviceHostEditor";
-import { useHostConnectionChecks } from "./useHostConnectionChecks";
-import { deviceHostConnectionKey } from "./deviceHostConnectionChecks";
-import { settingsScopeEnvironmentLabel, settingsScopeEnvironmentLabels } from "./settingsScopeAxis";
-import { DeviceHostDiagnostics } from "../device/DeviceSetup";
-
-export function DeviceHostsSettings(props: { environmentId: EnvironmentId | null }) {
-  const { scope, environments, connectedEnvironments } = useSettingsScope();
-  const canConfigure = useEnvironmentScope(props.environmentId, AuthSettingsWriteScope);
-  const projectScope = scope.kind === "project" || scope.kind === "checkout";
-  const update = useAtomCommand(serverEnvironment.updateSettings, { reportFailure: false });
-  const [editing, setEditing] = useState<SshDeviceHostConfig | null>(null);
-  const [originalHost, setOriginalHost] = useState<SshDeviceHostConfig | null>(null);
-  const [busy, setBusy] = useState(false);
-  const targets = environments.map((environment) => ({
-    environmentId: environment.environmentId,
-    label: settingsScopeEnvironmentLabel(environment, environments),
-    connected: environment.connection.phase === "connected",
-  }));
-  const { checks, testConnection } = useHostConnectionChecks(targets);
-  const hostEnvironments = connectedEnvironments.map((environment) => ({
-    environmentId: environment.environmentId,
-    label: environment.label,
-    labels: settingsScopeEnvironmentLabels(environment, connectedEnvironments),
-    hosts: environment.serverConfig?.settings.deviceHosts ?? [],
-  }));
-  const groupedHosts = groupDeviceHosts(hostEnvironments);
-  const save = async (host: SshDeviceHostConfig, remove = false, original = host) => {
-    if (!props.environmentId || projectScope) return;
-    setBusy(true);
-    const results = await Promise.allSettled(
-      environments.map(async (environment) => {
-        if (environment.connection.phase !== "connected" || !environment.serverConfig) {
-          throw new Error("Environment disconnected");
-        }
-        if (!readEnvironmentScope(environment.environmentId, AuthSettingsWriteScope)) {
-          throw new Error("This connection cannot change device settings.");
-        }
-        return update({
-          environmentId: environment.environmentId,
-          input: {
-            patch: {
-              deviceHosts: updateDeviceHosts(
-                environment.serverConfig.settings.deviceHosts,
-                host,
-                remove,
-                original,
-              ),
-            },
-          },
-        });
-      }),
-    );
-    setBusy(false);
-    const failed = environments.filter((_, index) => {
-      const result = results[index];
-      return result?.status !== "fulfilled" || result.value._tag === "Failure";
-    });
-    if (failed.length === 0) {
-      setEditing(null);
-    } else {
-      toastManager.add({
-        type: "error",
-        title: "Device hosts not saved on all environments",
-        description: `Could not update ${failed.map((environment) => environment.label).join(", ")}.`,
-      });
-    }
-  };
-  const listActions = {
-    busy: !canConfigure || projectScope || busy,
-    checks,
-    testConnection: async (host: SshDeviceHostConfig) => {
-      const results = await testConnection(host);
-      if (!results) return;
-      const failed = targets.filter((target) => results[target.environmentId]?.status === "failed");
-      toastManager.add({
-        type: failed.length ? "error" : "success",
-        title: failed.length
-          ? `${host.label}: ${failed.length} of ${targets.length} environments failed`
-          : `${host.label}: connection checks passed`,
-        description: failed.length
-          ? `Could not connect from ${failed.map((target) => target.label).join(", ")}.`
-          : "Connected or already available locally on each selected environment.",
-      });
-      return results;
-    },
-    onEdit: (host: SshDeviceHostConfig) => {
-      setOriginalHost(host);
-      setEditing(host);
-    },
-    onRemove: (host: SshDeviceHostConfig) => void save(host, true),
-  };
-  return (
-    <SettingsRow
-      id="device-hosts"
-      title="Device hosts"
-      serverScoped
-      settingKeys={["deviceHosts"]}
-      description="Add remote machines with simulator or emulator runtimes installed, and the selected environments will connect over SSH and set up device tools automatically."
-      control={
-        <Button
-          size="sm"
-          variant="outline"
-          disabled={
-            !canConfigure || projectScope || busy || !props.environmentId || editing !== null
-          }
-          onClick={() => {
-            setOriginalHost(null);
-            setEditing({ kind: "ssh", id: randomUUID(), label: "", target: "" });
-          }}
-        >
-          <PlusIcon className="size-3.5" /> Add host
-        </Button>
-      }
-    >
-      <div className="pt-3 pb-2">
-        {!props.environmentId ? (
-          <p className="text-sm text-muted-foreground">
-            Connect a selected environment to manage device hosts.
-          </p>
-        ) : (
-          <>
-            {hostEnvironments.length > 1 && groupedHosts === null ? (
-              <div className="space-y-2">
-                {hostEnvironments.map((environment) => (
-                  <FoldedSettingsSection
-                    key={environment.environmentId}
-                    id={`device-hosts-${environment.environmentId}`}
-                    title={
-                      <>
-                        <span className="block max-w-64 truncate">
-                          {environment.labels.primary}
-                        </span>
-                        {environment.labels.secondary ? (
-                          <span className="block max-w-64 truncate text-xs font-normal text-muted-foreground">
-                            {environment.labels.secondary}
-                          </span>
-                        ) : null}
-                      </>
-                    }
-                    summary={
-                      summarizeLabels(environment.hosts.map((host) => host.label)) ||
-                      "No device hosts"
-                    }
-                  >
-                    <div className="px-3 sm:px-4 [&>div:first-child]:border-t-0">
-                      <DeviceHostList environments={[environment]} {...listActions} />
-                    </div>
-                  </FoldedSettingsSection>
-                ))}
-              </div>
-            ) : (
-              <DeviceHostList
-                environments={hostEnvironments}
-                groups={groupedHosts ?? undefined}
-                compact={hostEnvironments.length > 1}
-                {...listActions}
-              />
-            )}
-            {editing ? (
-              <DeviceHostEditor
-                key={editing.id}
-                host={editing}
-                isNew={originalHost === null}
-                targets={targets}
-                busy={busy}
-                onSave={(host) => void save(host, false, originalHost ?? host)}
-                onClose={() => setEditing(null)}
-              />
-            ) : null}
-          </>
-        )}
-      </div>
-    </SettingsRow>
-  );
-}
-
-const deviceHostStatesAtom = environmentAtomList("web-device-host-states", (environmentId) =>
-  deviceEnvironment.state({ environmentId, input: {} }),
-);
-
-function DeviceHostList({
-  environments,
-  groups,
-  compact = false,
-  busy,
-  onEdit,
-  onRemove,
-  checks,
-  testConnection,
-}: {
-  environments: ReadonlyArray<DeviceHostEnvironment>;
-  groups?: ReadonlyArray<DeviceHostGroup> | undefined;
-  compact?: boolean;
-  busy: boolean;
-  onEdit: (host: SshDeviceHostConfig) => void;
-  onRemove: (host: SshDeviceHostConfig) => void;
-  checks: ReturnType<typeof useHostConnectionChecks>["checks"];
-  testConnection: ReturnType<typeof useHostConnectionChecks>["testConnection"];
-}) {
-  const { environments: scopeEnvironments } = useSettingsScope();
-  const environmentLabels = new Map(
-    scopeEnvironments.map((environment) => [
-      environment.environmentId,
-      settingsScopeEnvironmentLabels(environment, scopeEnvironments),
-    ]),
-  );
-  const environmentIds = environments.map(({ environmentId }) => environmentId);
-  const results = useAtomValue(deviceHostStatesAtom(environmentIdsKey(environmentIds)));
-  const states = new Map(
-    environmentIds.map(
-      (environmentId, index) =>
-        [environmentId, Option.getOrUndefined(AsyncResult.value(results[index]!))] as const,
-    ),
-  );
-  const retry = useAtomCommand(deviceEnvironment.list);
-  const [retrying, setRetrying] = useState<string | null>(null);
-  const retryHost = (environmentId: EnvironmentId, hostId: string, key = hostId) => {
-    setRetrying(key);
-    void retry({ environmentId, input: { retryHostId: hostId } }).finally(() => setRetrying(null));
-  };
-  const rows =
-    groups ??
-    environments.flatMap((environment) =>
-      environment.hosts.map((host) => ({
-        host,
-        members: [{ environmentId: environment.environmentId, label: environment.label, host }],
-      })),
-    );
-  return (
-    <>
-      {rows.length === 0 ? (
-        <p className="py-2 text-sm text-muted-foreground">No device hosts.</p>
-      ) : null}
-      {rows.map(({ host, members }) => {
-        const hostChecks = checks[deviceHostConnectionKey(host)];
-        const checkedMembers = scopeEnvironments.flatMap((environment) =>
-          hostChecks?.[environment.environmentId] &&
-          !members.some((member) => member.environmentId === environment.environmentId)
-            ? [{ environmentId: environment.environmentId, label: environment.label, host }]
-            : [],
-        );
-        const results = [...members, ...checkedMembers].map((member) => {
-          const state = states.get(member.environmentId);
-          const status = state?.hostStatuses[member.host.id];
-          const check = hostChecks?.[member.environmentId];
-          const summary = state?.hosts.find((value) => value.id === member.host.id);
-          const label = environmentLabels.get(member.environmentId)?.primary ?? member.label;
-          const address = environmentLabels.get(member.environmentId)?.secondary;
-          const error =
-            check?.status === "failed"
-              ? check.error
-              : check?.status === "local"
-                ? undefined
-                : status?.status === "failed"
-                  ? status.detail
-                  : undefined;
-          return {
-            ...member,
-            label,
-            address,
-            name: [label, address].filter(Boolean).join(" · "),
-            state,
-            status,
-            check,
-            summary,
-            error,
-            versions: (
-              <DeviceToolVersions
-                owner={label}
-                error={summary?.toolInspectionError}
-                tools={summary?.tools ?? (check?.status === "connected" ? check.tools : undefined)}
-              />
-            ),
-          };
-        });
-        const first = results[0];
-        if (!first) return null;
-        const { environmentId, status, check, summary, error } = first;
-        const platforms =
-          (check?.status === "connected" ? check.platforms : undefined) ?? summary?.platforms ?? [];
-        const progress =
-          check?.status === "pending"
-            ? "Checking connection…"
-            : status?.status === "installing"
-              ? "Installing device support…"
-              : status?.status === "starting"
-                ? "Connecting…"
-                : null;
-        const failed = results.filter(
-          (result) =>
-            result.check?.status === "failed" ||
-            (result.check?.status !== "local" && result.status?.status === "failed"),
-        );
-        const pending = results.some(
-          (result) =>
-            result.check?.status === "pending" ||
-            result.status?.status === "installing" ||
-            result.status?.status === "starting",
-        );
-        const ready = results.every(
-          (result) =>
-            result.check?.status === "connected" ||
-            result.check?.status === "local" ||
-            result.status?.status === "ready",
-        );
-        const retryable = results.filter(
-          (result) =>
-            result.status?.status === "failed" &&
-            result.state?.supportsHostRetry &&
-            result.state.hostStatus !== "disabled",
-        );
-        const canRetry = !compact && retryable.includes(first);
-        const indicators = compact
-          ? [
-              {
-                key: "connection",
-                label: failed.length
-                  ? "Connection failed"
-                  : pending
-                    ? "Checking connections"
-                    : ready
-                      ? "Connected"
-                      : "Connection not checked",
-                warning: failed.length > 0,
-                icon: failed.length ? (
-                  <TriangleAlertIcon className="size-3.5" />
-                ) : pending ? (
-                  <Spinner size="xs" />
-                ) : ready ? (
-                  <CheckIcon className="size-3.5" />
-                ) : (
-                  <CircleIcon className="size-3.5" />
-                ),
-                detail: failed.length ? (
-                  <div className="space-y-1">
-                    {failed.map((result) => (
-                      <p key={result.environmentId}>
-                        {result.name}: {result.error || "Connection failed"}
-                      </p>
-                    ))}
-                  </div>
-                ) : pending ? (
-                  "Checking connections…"
-                ) : ready ? (
-                  "Connected or available locally on each listed machine"
-                ) : (
-                  "Test the connection to check access from each machine"
-                ),
-              },
-            ]
-          : platforms
-              .filter((platform) => platform.available)
-              .map((platform) => ({
-                key: platform.platform,
-                label: platform.platform === "ios" ? "iOS available" : "Android available",
-                warning: false,
-                icon:
-                  platform.platform === "ios" ? (
-                    // The Apple mark is bottom-heavy; lift it so it does not dip under the label.
-                    <AppleIcon className="size-3.5 -translate-y-px" />
-                  ) : (
-                    <AndroidIcon className="size-3.5" />
-                  ),
-              }));
-        return (
-          <div key={host.id} className="flex items-center gap-2 border-t border-border/50 py-2.5">
-            <div className="min-w-0 flex-1">
-              <div className="flex min-w-0 items-center gap-2">
-                <p className="truncate text-sm font-medium">{host.label}</p>
-                {indicators.map((indicator) => (
-                  <Tooltip key={indicator.key}>
-                    <TooltipTrigger
-                      render={
-                        <span
-                          tabIndex={0}
-                          role="img"
-                          aria-label={indicator.label}
-                          className={
-                            indicator.warning
-                              ? "shrink-0 text-warning"
-                              : "shrink-0 text-muted-foreground"
-                          }
-                        />
-                      }
-                    >
-                      {indicator.icon}
-                    </TooltipTrigger>
-                    <TooltipPopup>
-                      {"detail" in indicator ? indicator.detail : indicator.label}
-                    </TooltipPopup>
-                  </Tooltip>
-                ))}
-              </div>
-              <p className="truncate text-xs text-muted-foreground">{host.target}</p>
-              {results
-                .filter(
-                  (result) =>
-                    result.status?.status === "ready" && result.status.androidDiscoveryIncomplete,
-                )
-                .map((result) => (
-                  <p key={result.environmentId} role="status" className="mt-1 text-xs text-warning">
-                    {compact ? `${result.label}: ` : ""}
-                    {result.status?.detail ??
-                      "The Android device list may be incomplete. Refresh devices to try again."}
-                  </p>
-                ))}
-              {compact ? (
-                <Collapsible>
-                  <div className="min-w-0 text-xs [--inline-button-white-space:normal]">
-                    <CollapsibleTrigger
-                      aria-label={`${host.label} machine details`}
-                      render={<InlineButton tone="muted" />}
-                    >
-                      <span className="line-clamp-1 break-all text-left">
-                        {summarizeLabels(results.map((result) => result.name))}
-                      </span>
-                      <ChevronDownIcon className="size-3 shrink-0" />
-                    </CollapsibleTrigger>
-                  </div>
-                  <CollapsiblePanel>
-                    <div className="mt-2 space-y-2">
-                      {results.map((result) => (
-                        <div key={result.environmentId}>
-                          <p className="text-xs text-muted-foreground">{result.label}</p>
-                          {result.address ? (
-                            <p className="truncate text-xs text-muted-foreground">
-                              {result.address}
-                            </p>
-                          ) : null}
-                          {result.error ? (
-                            <p role="status" className="text-xs text-destructive">
-                              {result.error}
-                            </p>
-                          ) : null}
-                          {result.state ? (
-                            <DeviceHostDiagnostics
-                              hosts={[result.host]}
-                              hostStatuses={result.state.hostStatuses}
-                            />
-                          ) : null}
-                          {result.versions}
-                          {result.check?.status === "local" ? (
-                            <p className="text-xs text-muted-foreground">
-                              Already available locally
-                            </p>
-                          ) : (
-                            <DeviceHostAvailability
-                              platforms={
-                                (result.check?.status === "connected"
-                                  ? result.check.platforms
-                                  : result.summary?.platforms) ?? []
-                              }
-                            />
-                          )}
-                        </div>
-                      ))}
-                    </div>
-                  </CollapsiblePanel>
-                </Collapsible>
-              ) : (
-                first.versions
-              )}
-              {!compact && check?.status === "local" ? (
-                <p className="mt-1 text-xs text-muted-foreground">Already available locally</p>
-              ) : null}
-              {!compact && error ? (
-                <div className="mt-1" role="status">
-                  <details className="text-xs text-destructive">
-                    <summary>Connection failed</summary>
-                    <p className="mt-1 whitespace-pre-wrap break-words">{error}</p>
-                  </details>
-                </div>
-              ) : null}
-              {!compact
-                ? results.map((result) =>
-                    result.state ? (
-                      <DeviceHostDiagnostics
-                        key={result.environmentId}
-                        className="mt-1"
-                        hosts={[result.host]}
-                        hostStatuses={result.state.hostStatuses}
-                      />
-                    ) : null,
-                  )
-                : null}
-            </div>
-            {!compact && progress ? (
-              <span
-                role="status"
-                className="inline-flex items-center gap-1.5 text-xs text-muted-foreground"
-              >
-                <Spinner size="xs" />
-                {progress}
-              </span>
-            ) : null}
-            <Menu>
-              <MenuTrigger
-                render={
-                  <Button
-                    size="icon-sm"
-                    variant="ghost-muted"
-                    disabled={busy}
-                    aria-label={host.label + " options"}
-                  />
-                }
-              >
-                <MoreVertical />
-              </MenuTrigger>
-              <MenuPopup align="end">
-                <MenuItem onClick={() => onEdit(host)}>Edit</MenuItem>
-                <MenuItem variant="destructive" onClick={() => onRemove(host)}>
-                  Remove
-                </MenuItem>
-                {compact
-                  ? retryable.map((result) => (
-                      <MenuItem
-                        key={result.environmentId}
-                        disabled={retrying !== null}
-                        onClick={() =>
-                          retryHost(result.environmentId, result.host.id, result.environmentId)
-                        }
-                      >
-                        {retrying === result.environmentId ? "Retrying" : "Retry"} from{" "}
-                        {result.label}
-                        {result.address ? ` (${result.address})` : null}
-                      </MenuItem>
-                    ))
-                  : null}
-              </MenuPopup>
-            </Menu>
-            <Button
-              size="sm"
-              variant="outline"
-              disabled={
-                busy || (canRetry ? retrying !== null : compact ? pending : progress !== null)
-              }
-              onClick={() => {
-                if (canRetry) retryHost(environmentId, host.id);
-                else void testConnection(host);
-              }}
-            >
-              {canRetry ? (retrying === host.id ? "Retrying…" : "Retry") : "Test connection"}
-            </Button>
-          </div>
-        );
-      })}
-    </>
-  );
-}
-
-function summarizeLabels(labels: ReadonlyArray<string>) {
-  return `${labels.slice(0, 2).join(", ")}${labels.length > 2 ? ` +${labels.length - 2}` : ""}`;
-}
diff --git a/apps/web/src/components/settings/DeviceSourcesSettings.tsx b/apps/web/src/components/settings/DeviceSourcesSettings.tsx
new file mode 100644
index 0000000000000..09ccc32fd61b9
--- /dev/null
+++ b/apps/web/src/components/settings/DeviceSourcesSettings.tsx
@@ -0,0 +1,802 @@
+import { useAtomValue } from "@effect/atom-react";
+import { Fragment, useState, type ReactNode } from "react";
+import * as Cause from "effect/Cause";
+import * as Option from "effect/Option";
+import { AsyncResult } from "effect/reactivity";
+import {
+  AuthSettingsWriteScope,
+  type DevicePlatform,
+  type DevicePlatformAvailability,
+  type DeviceServiceState,
+  type EasDeviceHostConfig,
+  type EnvironmentId,
+  type ServerSettingsPatch,
+  type SimlockDeviceHostConfig,
+  type SshDeviceHostConfig,
+} from "@t3tools/contracts";
+import { ChevronDownIcon, MoreVertical, PlusIcon } from "lucide-react";
+
+import { cn, randomUUID } from "../../lib/utils";
+import { deviceEnvironment } from "../../state/device";
+import { environmentAtomList, environmentIdsKey } from "../../state/environmentAtomList";
+import { serverEnvironment } from "../../state/server";
+import { readEnvironmentScope } from "../../state/session";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { AndroidIcon, AppleIcon } from "../Icons";
+import { Button, InlineButton } from "../ui/button";
+import { Menu, MenuItem, MenuPopup, MenuTrigger } from "../ui/menu";
+import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
+import { Spinner } from "../ui/spinner";
+import { toastManager } from "../ui/toast";
+import { DeviceHostEditor } from "./DeviceHostEditor";
+import { updateDeviceHosts, groupDeviceHosts } from "./deviceHostsSettings.logic";
+import { EasDeviceHostEditor } from "./EasDeviceHostEditor";
+import {
+  easSessionLimits,
+  newEasDeviceHost,
+  updateEasDeviceHosts,
+} from "./easDeviceHostsSettings.logic";
+import { useSettingsScope } from "./SettingsScopeContext";
+import { SettingsSection } from "./settingsLayout";
+import { settingsScopeEnvironmentLabel } from "./settingsScopeAxis";
+import { SimlockDeviceHostEditor } from "./SimlockDeviceHostEditor";
+import {
+  newSimlockDeviceHost,
+  planSimlockDeviceHostSave,
+  simlockLeaseLimits,
+  updateSimlockDeviceHosts,
+  type SimlockTokenEntry,
+} from "./simlockDeviceHostsSettings.logic";
+import { useHostConnectionChecks } from "./useHostConnectionChecks";
+
+const deviceHostStatesAtom = environmentAtomList("web-device-host-states", (environmentId) =>
+  deviceEnvironment.state({ environmentId, input: {} }),
+);
+
+const failureMessage = (cause: Cause.Cause<unknown>) => {
+  const error = Cause.squash(cause);
+  return error instanceof Error ? error.message : String(error);
+};
+
+/** Something on one environment that is in progress or needs a fix; a working source has none. */
+interface SourceStatus {
+  readonly tone: "pending" | "warning" | "error";
+  readonly label: string;
+  readonly detail?: string | undefined;
+  readonly action?: { readonly label: string; readonly run: () => void } | undefined;
+}
+
+/** A source on one environment whose devices are on. */
+interface SourceEnvironment {
+  readonly environmentId: EnvironmentId;
+  readonly label: string;
+  readonly added: boolean;
+  readonly status?: SourceStatus | undefined;
+  /** Unknown until the environment's hub has reached the source. */
+  readonly platforms?: ReadonlyArray<DevicePlatformAvailability> | undefined;
+}
+
+interface SourceRow {
+  readonly key: string;
+  readonly title: string;
+  readonly kind?: string;
+  readonly description: ReactNode;
+  readonly environments: ReadonlyArray<SourceEnvironment>;
+  /**
+   * One machine or account every environment reaches the same way (an SSH host, EAS, a Simlock
+   * pool), so its platforms are the same for all of them. Local simulators differ per machine.
+   */
+  readonly shared: boolean;
+  readonly actions?: ReactNode;
+}
+
+type Editing =
+  | {
+      readonly kind: "ssh";
+      readonly host: SshDeviceHostConfig;
+      readonly original: SshDeviceHostConfig | null;
+      /** Limits the save to these environments, for a host that differs between them. */
+      readonly only?: ReadonlySet<EnvironmentId>;
+    }
+  | {
+      readonly kind: "eas";
+      readonly host: EasDeviceHostConfig;
+      readonly isNew: boolean;
+      /** Where the editor checks the Expo account: an environment that holds the host. */
+      readonly environmentId: EnvironmentId;
+    }
+  | { readonly kind: "simlock"; readonly host: SimlockDeviceHostConfig; readonly isNew: boolean };
+
+/** What a configured host is doing on one environment, when it is not simply working. */
+function hostStatus(
+  state: DeviceServiceState | undefined,
+  hostId: string,
+): SourceStatus | undefined {
+  if (!state) return { tone: "pending", label: "Loading" };
+  const status = state.hostStatuses[hostId];
+  switch (status?.status) {
+    case "ready":
+      return status.androidDiscoveryIncomplete
+        ? { tone: "warning", label: "Android list may be incomplete", detail: status.detail }
+        : undefined;
+    case "installing":
+    case "starting":
+      return { tone: "pending", label: "Starting", detail: status.detail };
+    case "failed":
+      return { tone: "error", label: "Failed", detail: status.detail };
+    default:
+      return undefined;
+  }
+}
+
+const hostPlatforms = (state: DeviceServiceState | undefined, hostId: string) =>
+  state?.hosts.find((host) => host.id === hostId)?.platforms;
+
+/**
+ * Every device source the selected environments can open, one row each. A source configured on
+ * several environments is one row; how it stands on each lives in the row's breakdown.
+ */
+export function DeviceSourcesSettings(props: {
+  readonly supportsEas: boolean;
+  readonly supportsSimlock: boolean;
+}) {
+  const { scope, environments, connectedEnvironments, environment: primary } = useSettingsScope();
+  const projectScope = scope.kind === "project" || scope.kind === "checkout";
+  const update = useAtomCommand(serverEnvironment.updateSettings, { reportFailure: false });
+  const list = useAtomCommand(deviceEnvironment.list, { reportFailure: false });
+  const [editing, setEditing] = useState<Editing | null>(null);
+  const [busy, setBusy] = useState(false);
+  const label = (environment: (typeof environments)[number]) =>
+    settingsScopeEnvironmentLabel(environment, environments);
+  const targets = environments.map((environment) => ({
+    environmentId: environment.environmentId,
+    label: label(environment),
+    connected: environment.connection.phase === "connected",
+  }));
+  const { testConnection } = useHostConnectionChecks(targets);
+  const ids = connectedEnvironments.map((environment) => environment.environmentId);
+  const results = useAtomValue(deviceHostStatesAtom(environmentIdsKey(ids)));
+  const members = connectedEnvironments.map((environment, index) => {
+    const result = results[index];
+    return {
+      environmentId: environment.environmentId,
+      label: label(environment),
+      settings: environment.serverConfig?.settings,
+      state: result ? Option.getOrUndefined(AsyncResult.value(result)) : undefined,
+    };
+  });
+  // Environments with devices off are left out: the switch above already says so.
+  const active = members.filter((member) => member.settings?.enableDeviceSupport);
+  const simlockEnabled = members.some((member) => member.settings?.simlockDeviceHostsEnabled);
+  // Like every scoped setting, a change reaches the connected environments and skips the rest.
+  const disabled = projectScope || busy || members.length === 0;
+
+  /** Writes one settings patch per environment; reports the environments it could not change. */
+  const write = async (
+    patches: ReadonlyArray<{ environmentId: EnvironmentId; patch: ServerSettingsPatch }>,
+    failedTitle: string,
+  ) => {
+    if (projectScope) return false;
+    const name = (environmentId: EnvironmentId) =>
+      members.find((member) => member.environmentId === environmentId)?.label ?? environmentId;
+    const unwritable = patches.filter(
+      (patch) => !readEnvironmentScope(patch.environmentId, AuthSettingsWriteScope),
+    );
+    if (unwritable.length > 0) {
+      toastManager.add({
+        type: "error",
+        title: failedTitle,
+        description: `This connection cannot change settings on ${unwritable.map((patch) => name(patch.environmentId)).join(", ")}.`,
+      });
+      return false;
+    }
+    setBusy(true);
+    const outcomes = await Promise.all(
+      patches.map((patch) =>
+        update({ environmentId: patch.environmentId, input: { patch: patch.patch } }),
+      ),
+    );
+    setBusy(false);
+    const failed = patches.flatMap((patch, index) => {
+      const outcome = outcomes[index];
+      return outcome && outcome._tag === "Failure"
+        ? [`${name(patch.environmentId)}: ${failureMessage(outcome.cause)}`]
+        : [];
+    });
+    if (failed.length === 0) return true;
+    toastManager.add({ type: "error", title: failedTitle, description: failed.join("\n") });
+    return false;
+  };
+
+  const saveSsh = async (
+    host: SshDeviceHostConfig,
+    remove: boolean,
+    original = host,
+    only?: ReadonlySet<EnvironmentId>,
+  ) => {
+    try {
+      const saved = await write(
+        members
+          .filter((member) => !only || only.has(member.environmentId))
+          .map((member) => ({
+            environmentId: member.environmentId,
+            patch: {
+              deviceHosts: updateDeviceHosts(
+                member.settings?.deviceHosts ?? [],
+                host,
+                remove,
+                original,
+              ),
+            },
+          })),
+        remove ? "Device host not removed everywhere" : "Device host not saved everywhere",
+      );
+      if (saved) setEditing(null);
+    } catch (error) {
+      toastManager.add({
+        type: "error",
+        title: "Device host not saved",
+        description: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+
+  const saveEas = async (
+    host: EasDeviceHostConfig,
+    remove: boolean,
+    previous?: EasDeviceHostConfig,
+  ) => {
+    const keepToken = previous !== undefined && host.accessToken === previous.accessToken;
+    const saved = await write(
+      members.map((member) => ({
+        environmentId: member.environmentId,
+        patch: {
+          easDeviceHosts: updateEasDeviceHosts(
+            member.settings?.easDeviceHosts ?? [],
+            host,
+            remove,
+            keepToken,
+          ),
+        },
+      })),
+      remove ? "EAS host not removed everywhere" : "EAS host not saved everywhere",
+    );
+    if (saved) setEditing(null);
+  };
+
+  const simlockEnvironments = members.map((member) => ({
+    environmentId: member.environmentId,
+    label: member.label,
+    hosts: member.settings?.simlockDeviceHosts ?? [],
+  }));
+  const saveSimlock = async (
+    host: SimlockDeviceHostConfig,
+    tokens: ReadonlyMap<EnvironmentId, SimlockTokenEntry>,
+  ) => {
+    const plan = planSimlockDeviceHostSave(simlockEnvironments, host, tokens);
+    if ("problem" in plan) return;
+    const saved = await write(
+      plan.patches.map((patch) => ({
+        environmentId: patch.environmentId,
+        patch: { simlockDeviceHosts: patch.hosts },
+      })),
+      "Simlock host not saved everywhere",
+    );
+    if (saved) setEditing(null);
+  };
+  const removeSimlock = (host: SimlockDeviceHostConfig) =>
+    void write(
+      simlockEnvironments
+        .filter((environment) => environment.hosts.some((candidate) => candidate.id === host.id))
+        .map((environment) => ({
+          environmentId: environment.environmentId,
+          patch: { simlockDeviceHosts: updateSimlockDeviceHosts(environment.hosts, host, true) },
+        })),
+      "Simlock host not removed everywhere",
+    );
+
+  const [testing, setTesting] = useState<ReadonlySet<string>>(new Set());
+  const testSsh = async (host: SshDeviceHostConfig) => {
+    setTesting((current) => new Set(current).add(host.id));
+    const checked = await testConnection(host).finally(() =>
+      setTesting((current) => {
+        const next = new Set(current);
+        next.delete(host.id);
+        return next;
+      }),
+    );
+    if (!checked) return;
+    const failed = targets.filter((target) => checked[target.environmentId]?.status === "failed");
+    toastManager.add({
+      type: failed.length ? "error" : "success",
+      title: failed.length
+        ? `${host.label}: ${failed.length} of ${targets.length} environments failed`
+        : `${host.label}: connection checks passed`,
+      description: failed.length
+        ? failed
+            .map((target) => {
+              const result = checked[target.environmentId];
+              return `${target.label}: ${result?.status === "failed" ? result.error : "failed"}`;
+            })
+            .join("\n")
+        : "Connected or already available locally on each selected environment.",
+    });
+  };
+
+  const retry = (environmentId: EnvironmentId, hostId: string) =>
+    void list({ environmentId, input: { retryHostId: hostId } });
+
+  const rowActions = (onEdit: () => void, onRemove: () => void, extra?: ReactNode) => (
+    <>
+      <Button size="sm" variant="outline" disabled={disabled} onClick={onEdit}>
+        Edit
+      </Button>
+      <Menu>
+        <MenuTrigger
+          render={
+            <Button size="icon-sm" variant="ghost-muted" disabled={disabled} aria-label="More" />
+          }
+        >
+          <MoreVertical />
+        </MenuTrigger>
+        <MenuPopup align="end">
+          {extra}
+          <MenuItem variant="destructive" onClick={onRemove}>
+            Remove
+          </MenuItem>
+        </MenuPopup>
+      </Menu>
+    </>
+  );
+
+  const rows: SourceRow[] = [];
+
+  rows.push({
+    key: "local",
+    shared: false,
+    title: "Local simulators",
+    description:
+      members.length > 1
+        ? "Simulators and emulators installed on each environment's own machine."
+        : "Simulators and emulators installed on this environment's machine.",
+    environments: active.map((member) => {
+      const local = member.state?.hosts.find((host) => host.kind === "local");
+      const status = local ? hostStatus(member.state, local.id) : hostStatus(member.state, "");
+      return {
+        environmentId: member.environmentId,
+        label: member.label,
+        added: true,
+        platforms: local?.platforms,
+        status:
+          status?.tone === "error"
+            ? {
+                ...status,
+                action: {
+                  label: "Refresh",
+                  run: () => void list({ environmentId: member.environmentId, input: {} }),
+                },
+              }
+            : status,
+      };
+    }),
+  });
+
+  const grouped = groupDeviceHosts(
+    members.map((member) => ({
+      environmentId: member.environmentId,
+      label: member.label,
+      hosts: member.settings?.deviceHosts ?? [],
+    })),
+  );
+  const sshGroups =
+    grouped ??
+    // Hosts that cannot be matched across environments stay one row per environment.
+    members.flatMap((member) =>
+      (member.settings?.deviceHosts ?? []).map((host) => ({
+        host,
+        members: [{ environmentId: member.environmentId, label: member.label, host }],
+      })),
+    );
+  for (const group of sshGroups) {
+    const host = group.host;
+    const holders = new Set(group.members.map((member) => member.environmentId));
+    rows.push({
+      key: `ssh:${host.id}:${group.members.map((member) => member.environmentId).join(",")}`,
+      shared: true,
+      title: host.label,
+      kind: "SSH",
+      description: host.target,
+      environments: active.map((member) => {
+        const held = group.members.find(
+          (candidate) => candidate.environmentId === member.environmentId,
+        );
+        if (!held)
+          return { environmentId: member.environmentId, label: member.label, added: false };
+        const status = testing.has(host.id)
+          ? ({ tone: "pending", label: "Testing connection" } as const)
+          : hostStatus(member.state, held.host.id);
+        return {
+          environmentId: member.environmentId,
+          label: member.label,
+          added: true,
+          platforms: hostPlatforms(member.state, held.host.id),
+          status:
+            status?.tone === "error" && member.state?.supportsHostRetry
+              ? {
+                  ...status,
+                  label: "Can't connect",
+                  action: { label: "Retry", run: () => retry(member.environmentId, held.host.id) },
+                }
+              : status,
+        };
+      }),
+      actions: rowActions(
+        () =>
+          setEditing({ kind: "ssh", host, original: host, ...(grouped ? {} : { only: holders }) }),
+        () => void saveSsh(host, true, host, holders),
+        <MenuItem onClick={() => void testSsh(host)}>Test connection</MenuItem>,
+      ),
+    });
+  }
+
+  if (props.supportsEas) {
+    const easHosts = new Map<string, EasDeviceHostConfig>();
+    for (const member of members)
+      for (const host of member.settings?.easDeviceHosts ?? [])
+        if (!easHosts.has(host.id)) easHosts.set(host.id, host);
+    for (const host of easHosts.values()) {
+      const holders = members.filter((member) =>
+        (member.settings?.easDeviceHosts ?? []).some((candidate) => candidate.id === host.id),
+      );
+      const [firstHolder] = holders;
+      if (!firstHolder) continue;
+      const checkOn = (
+        holders.find((member) => member.environmentId === primary?.environmentId) ?? firstHolder
+      ).environmentId;
+      rows.push({
+        key: `eas:${host.id}`,
+        shared: true,
+        title: host.label,
+        kind: "EAS",
+        description: easSessionLimits(host),
+        environments: active.map((member) => {
+          const added = (member.settings?.easDeviceHosts ?? []).some(
+            (candidate) => candidate.id === host.id,
+          );
+          return {
+            environmentId: member.environmentId,
+            label: member.label,
+            added,
+            ...(added
+              ? {
+                  status: hostStatus(member.state, host.id),
+                  platforms: hostPlatforms(member.state, host.id),
+                }
+              : {}),
+          };
+        }),
+        actions: rowActions(
+          () => setEditing({ kind: "eas", host, isNew: false, environmentId: checkOn }),
+          () => void saveEas(host, true),
+        ),
+      });
+    }
+  }
+
+  if (props.supportsSimlock && simlockEnabled) {
+    const simlockHosts = new Map<string, SimlockDeviceHostConfig>();
+    for (const environment of simlockEnvironments)
+      for (const host of environment.hosts)
+        if (!simlockHosts.has(host.id)) simlockHosts.set(host.id, host);
+    for (const host of simlockHosts.values()) {
+      const edit = () => setEditing({ kind: "simlock", host, isNew: false });
+      rows.push({
+        key: `simlock:${host.id}`,
+        shared: true,
+        title: host.label,
+        kind: "Simlock",
+        description: `${host.gatewayUrl.replace(/^https?:\/\//, "")} · ${simlockLeaseLimits(host)}`,
+        environments: active.map((member) => {
+          const held = (member.settings?.simlockDeviceHosts ?? []).find(
+            (candidate) => candidate.id === host.id,
+          );
+          if (!held)
+            return { environmentId: member.environmentId, label: member.label, added: false };
+          return {
+            environmentId: member.environmentId,
+            label: member.label,
+            added: true,
+            platforms: hostPlatforms(member.state, host.id),
+            // A blank token can still resolve to the machine's own, so the host's answer decides.
+            status: hostStatus(member.state, host.id),
+          };
+        }),
+        actions: rowActions(edit, () => removeSimlock(host)),
+      });
+    }
+  }
+
+  const addMenu = (
+    <Menu>
+      <MenuTrigger
+        render={<Button size="sm" variant="outline" disabled={disabled || editing !== null} />}
+      >
+        <PlusIcon className="size-3.5" /> Add source
+        <ChevronDownIcon className="size-3.5" />
+      </MenuTrigger>
+      <MenuPopup align="end">
+        <MenuItem
+          onClick={() =>
+            setEditing({
+              kind: "ssh",
+              host: { kind: "ssh", id: randomUUID(), label: "", target: "" },
+              original: null,
+            })
+          }
+        >
+          Machine over SSH
+        </MenuItem>
+        {props.supportsEas ? (
+          <MenuItem
+            onClick={() =>
+              primary &&
+              setEditing({
+                kind: "eas",
+                host: newEasDeviceHost(randomUUID()),
+                isNew: true,
+                environmentId: primary.environmentId,
+              })
+            }
+          >
+            EAS Simulator
+          </MenuItem>
+        ) : null}
+        {props.supportsSimlock && simlockEnabled ? (
+          <MenuItem
+            onClick={() =>
+              setEditing({ kind: "simlock", host: newSimlockDeviceHost(randomUUID()), isNew: true })
+            }
+          >
+            Simlock pool (alpha)
+          </MenuItem>
+        ) : null}
+      </MenuPopup>
+    </Menu>
+  );
+
+  return (
+    <SettingsSection id="device-sources" title="Device sources" headerAction={addMenu}>
+      {rows.map((row) => (
+        <DeviceSourceRow key={row.key} row={row} />
+      ))}
+      {editing?.kind === "ssh" ? (
+        <DeviceHostEditor
+          key={editing.host.id}
+          host={editing.host}
+          isNew={editing.original === null}
+          targets={targets}
+          busy={busy}
+          onSave={(host) => void saveSsh(host, false, editing.original ?? host, editing.only)}
+          onClose={() => setEditing(null)}
+        />
+      ) : editing?.kind === "eas" ? (
+        <EasDeviceHostEditor
+          key={editing.host.id}
+          environmentId={editing.environmentId}
+          host={editing.host}
+          isNew={editing.isNew}
+          busy={busy}
+          onSave={(host) => void saveEas(host, false, editing.isNew ? undefined : editing.host)}
+          onClose={() => setEditing(null)}
+        />
+      ) : editing?.kind === "simlock" ? (
+        <SimlockDeviceHostEditor
+          key={editing.host.id}
+          host={editing.host}
+          isNew={editing.isNew}
+          environments={simlockEnvironments}
+          busy={busy}
+          onSave={(host, tokens) => void saveSimlock(host, tokens)}
+          onClose={() => setEditing(null)}
+        />
+      ) : null}
+    </SettingsSection>
+  );
+}
+
+const PLATFORMS = [
+  { platform: "ios", label: "iOS", Icon: AppleIcon },
+  { platform: "android", label: "Android", Icon: AndroidIcon },
+] as const satisfies ReadonlyArray<{ platform: DevicePlatform; label: string; Icon: unknown }>;
+
+/** The platforms a source offers: one icon each, solid where available, muted where not. */
+function SourcePlatforms(props: { row: SourceRow }) {
+  const added = props.row.environments.filter((environment) => environment.added);
+  const known = added.filter((environment) => environment.platforms !== undefined);
+  return PLATFORMS.filter(({ platform }) =>
+    known.some((environment) =>
+      environment.platforms?.some((candidate) => candidate.platform === platform),
+    ),
+  ).map((entry) => <PlatformIcon key={entry.platform} {...entry} row={props.row} known={known} />);
+}
+
+function PlatformIcon(props: {
+  platform: DevicePlatform;
+  label: string;
+  Icon: (typeof PLATFORMS)[number]["Icon"];
+  row: SourceRow;
+  known: ReadonlyArray<SourceEnvironment>;
+}) {
+  const availability = (environment: SourceEnvironment) =>
+    environment.platforms?.find((candidate) => candidate.platform === props.platform);
+  const availableOn = props.known.filter((environment) => availability(environment)?.available);
+  const several = props.row.environments.length > 1;
+  const available = availableOn.length > 0;
+  const partial = available && availableOn.length < props.known.length;
+  // A shared source usually answers the same everywhere, so its answer is given once. Each
+  // environment still signs in to it on its own, which is where they can differ.
+  const sharedAnswer = props.known.map(availability).find(Boolean);
+  const uniform = props.known.every(
+    (environment) =>
+      availability(environment)?.available === sharedAnswer?.available &&
+      availability(environment)?.reason === sharedAnswer?.reason,
+  );
+  const unavailableOn = props.known.filter((environment) => !availability(environment)?.available);
+  const connected = props.row.environments.filter((environment) => environment.added);
+  const notAdded = props.row.environments.filter((environment) => !environment.added);
+  return (
+    <Popover>
+      <PopoverTrigger
+        openOnHover
+        delay={150}
+        closeDelay={100}
+        render={
+          <button
+            type="button"
+            aria-label={`${props.row.title}: ${props.label} ${available ? "available" : "not available"}`}
+            className={cn(
+              "relative grid size-6 shrink-0 place-items-center rounded-md outline-hidden hover:bg-accent focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+              available ? "text-foreground" : "text-muted-foreground/45",
+            )}
+          />
+        }
+      >
+        <props.Icon className={cn("size-3.5", props.platform === "ios" && "-translate-y-px")} />
+        {partial ? (
+          <span
+            aria-hidden
+            className="absolute top-0.5 right-0.5 size-1.5 rounded-full bg-warning ring-2 ring-background"
+          />
+        ) : null}
+      </PopoverTrigger>
+      <PopoverPopup side="top" align="end" width="sm">
+        <p className="text-sm font-medium">
+          {props.label}{" "}
+          {available ? (partial ? "available on some" : "available") : "not available"}
+        </p>
+        {props.row.shared ? (
+          <>
+            {uniform && !available && sharedAnswer?.reason ? (
+              <p className="mt-1 text-xs text-muted-foreground">{sharedAnswer.reason}</p>
+            ) : null}
+            {several ? (
+              <dl className="mt-2 space-y-1.5 text-xs">
+                {(
+                  [
+                    ...(uniform
+                      ? ([["Connected", connected]] as const)
+                      : ([
+                          ["Available", availableOn],
+                          ["Not available", unavailableOn],
+                        ] as const)),
+                    ["Not added", notAdded],
+                  ] as const
+                ).map(([heading, environments]) =>
+                  environments.length > 0 ? (
+                    <div key={heading}>
+                      <dt className="text-muted-foreground">{heading}</dt>
+                      {environments.map((environment) => {
+                        const reason =
+                          heading === "Not available"
+                            ? availability(environment)?.reason
+                            : undefined;
+                        return (
+                          <dd key={environment.environmentId}>
+                            <span className="block truncate">{environment.label}</span>
+                            {reason ? (
+                              <span className="block text-muted-foreground">{reason}</span>
+                            ) : null}
+                          </dd>
+                        );
+                      })}
+                    </div>
+                  ) : null,
+                )}
+              </dl>
+            ) : null}
+          </>
+        ) : several ? (
+          <dl className="mt-2 grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 text-xs">
+            {props.known.map((environment) => {
+              const entry = availability(environment);
+              return (
+                <Fragment key={environment.environmentId}>
+                  <dt className="text-muted-foreground">{environment.label}</dt>
+                  <dd className={entry?.available ? "" : "text-muted-foreground"}>
+                    {entry?.available ? "Available" : (entry?.reason ?? "Not available")}
+                  </dd>
+                </Fragment>
+              );
+            })}
+          </dl>
+        ) : !available ? (
+          <p className="mt-1 text-xs text-muted-foreground">
+            {availability(props.known[0]!)?.reason ?? "Not set up on this machine."}
+          </p>
+        ) : null}
+      </PopoverPopup>
+    </Popover>
+  );
+}
+
+function DeviceSourceRow(props: { row: SourceRow }) {
+  const { row } = props;
+  const several = row.environments.length > 1;
+  const issues = row.environments.filter(
+    (environment): environment is SourceEnvironment & { status: SourceStatus } =>
+      environment.status !== undefined,
+  );
+  const problems = issues.filter((environment) => environment.status.tone !== "pending");
+  const pending = issues.find((environment) => environment.status.tone === "pending");
+  return (
+    <div className="flex items-center gap-3 border-t border-border/60 px-3 py-3 first:border-t-0 sm:px-4">
+      <div className="min-w-0 flex-1">
+        <div className="flex min-w-0 items-center gap-1.5">
+          <p className="truncate text-sm font-medium">{row.title}</p>
+          {row.kind ? (
+            <span className="shrink-0 rounded border border-border px-1 text-3xs uppercase tracking-wide text-muted-foreground">
+              {row.kind}
+            </span>
+          ) : null}
+        </div>
+        <p className="truncate text-xs text-muted-foreground">{row.description}</p>
+        {problems.map((environment) => (
+          <p
+            key={environment.environmentId}
+            role="status"
+            className={cn(
+              "mt-1 flex flex-wrap items-center gap-1.5 text-xs",
+              environment.status.tone === "error" ? "text-destructive" : "text-warning",
+            )}
+          >
+            <span className="min-w-0 break-words">
+              {several ? `${environment.label}: ` : ""}
+              {!several && environment.status.detail
+                ? environment.status.detail
+                : environment.status.label}
+            </span>
+            {environment.status.action ? (
+              <InlineButton onClick={environment.status.action.run}>
+                {environment.status.action.label}
+              </InlineButton>
+            ) : null}
+          </p>
+        ))}
+      </div>
+      {pending ? (
+        <span
+          role="status"
+          className="flex shrink-0 items-center gap-1.5 text-xs text-muted-foreground"
+        >
+          <Spinner size="xs" />
+          {pending.status.label}
+        </span>
+      ) : (
+        <div className="flex shrink-0 items-center gap-0.5">
+          <SourcePlatforms row={row} />
+        </div>
+      )}
+      {row.actions ? <div className="flex shrink-0 items-center gap-1">{row.actions}</div> : null}
+    </div>
+  );
+}
diff --git a/apps/web/src/components/settings/EasDeviceHostsSettings.tsx b/apps/web/src/components/settings/EasDeviceHostEditor.tsx
similarity index 72%
rename from apps/web/src/components/settings/EasDeviceHostsSettings.tsx
rename to apps/web/src/components/settings/EasDeviceHostEditor.tsx
index 43c80cdb740c0..220f5ffa3269b 100644
--- a/apps/web/src/components/settings/EasDeviceHostsSettings.tsx
+++ b/apps/web/src/components/settings/EasDeviceHostEditor.tsx
@@ -3,17 +3,13 @@ import { useId, useRef, useState } from "react";
 import * as Cause from "effect/Cause";
 import * as Option from "effect/Option";
 import {
-  AuthSettingsWriteScope,
   type DeviceEasAccount,
   type EasDeviceHostConfig,
   type EnvironmentId,
 } from "@t3tools/contracts";
-import { CloudIcon, PlusIcon, XIcon } from "lucide-react";
+import { XIcon } from "lucide-react";
 
-import { randomUUID } from "../../lib/utils";
 import { deviceEasAccountCheck, deviceEnvironment } from "../../state/device";
-import { serverEnvironment } from "../../state/server";
-import { readEnvironmentScope, useEnvironmentScope } from "../../state/session";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { Button } from "../ui/button";
 import {
@@ -28,16 +24,8 @@ import {
 import { Input } from "../ui/input";
 import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
 import { Spinner } from "../ui/spinner";
-import { toastManager } from "../ui/toast";
-import {
-  easSessionLimits,
-  newEasDeviceHost,
-  parseEasDeviceHostDraft,
-  updateEasDeviceHosts,
-} from "./easDeviceHostsSettings.logic";
+import { parseEasDeviceHostDraft } from "./easDeviceHostsSettings.logic";
 import { SecretInput } from "./SecretInput";
-import { useSettingsScope } from "./SettingsScopeContext";
-import { SettingsRow } from "./settingsLayout";
 
 const FROM_THREAD_PROJECT = "thread-project";
 
@@ -52,116 +40,13 @@ const failureMessage = (cause: Cause.Cause<unknown>) => {
   return error instanceof Error ? error.message : String(error);
 };
 
-/** EAS hosts belong to one environment: its server holds the Expo credential and runs the sessions. */
-export function EasDeviceHostsSettings(props: { environmentId: EnvironmentId | null }) {
-  const { scope, connectedEnvironments } = useSettingsScope();
-  const canConfigure = useEnvironmentScope(props.environmentId, AuthSettingsWriteScope);
-  const projectScope = scope.kind === "project" || scope.kind === "checkout";
-  const update = useAtomCommand(serverEnvironment.updateSettings, { reportFailure: false });
-  const environment = connectedEnvironments.find(
-    (candidate) => candidate.environmentId === props.environmentId,
-  );
-  const hosts = environment?.serverConfig?.settings.easDeviceHosts ?? [];
-  const [editing, setEditing] = useState<{ host: EasDeviceHostConfig; isNew: boolean } | null>(
-    null,
-  );
-  const [busy, setBusy] = useState(false);
-  const disabled = !canConfigure || projectScope || busy || !props.environmentId;
-
-  const save = async (host: EasDeviceHostConfig, remove: boolean) => {
-    if (!props.environmentId || !readEnvironmentScope(props.environmentId, AuthSettingsWriteScope))
-      return;
-    setBusy(true);
-    const result = await update({
-      environmentId: props.environmentId,
-      input: { patch: { easDeviceHosts: updateEasDeviceHosts(hosts, host, remove) } },
-    });
-    setBusy(false);
-    if (result._tag === "Success") setEditing(null);
-    else
-      toastManager.add({
-        type: "error",
-        title: remove ? "EAS host not removed" : "EAS host not saved",
-        description: failureMessage(result.cause),
-      });
-  };
-
-  return (
-    <SettingsRow
-      id="eas-device-hosts"
-      title="EAS Simulator"
-      serverScoped
-      settingKeys={["easDeviceHosts"]}
-      description="Run iOS Simulators in Expo's cloud from this environment. Sessions bill the Expo account until they stop, so each host limits how many run and for how long. Editing or removing a host stops its running sessions."
-      control={
-        <Button
-          size="sm"
-          variant="outline"
-          disabled={disabled || editing !== null}
-          onClick={() => setEditing({ host: newEasDeviceHost(randomUUID()), isNew: true })}
-        >
-          <PlusIcon className="size-3.5" /> Add EAS host
-        </Button>
-      }
-    >
-      <div className="pt-3 pb-2">
-        {hosts.length === 0 ? (
-          <p className="text-sm text-muted-foreground">No EAS hosts.</p>
-        ) : (
-          <ul className="divide-y divide-border/40">
-            {hosts.map((host) => (
-              <li key={host.id} className="flex items-center justify-between gap-3 py-2.5 text-sm">
-                <div className="min-w-0">
-                  <p className="flex items-center gap-1.5 truncate font-medium">
-                    <CloudIcon className="size-3.5 shrink-0" /> {host.label}
-                  </p>
-                  <p className="truncate text-xs text-muted-foreground">{easSessionLimits(host)}</p>
-                </div>
-                <div className="flex shrink-0 gap-1">
-                  <Button
-                    size="sm"
-                    variant="ghost"
-                    disabled={disabled}
-                    onClick={() => setEditing({ host, isNew: false })}
-                  >
-                    Edit
-                  </Button>
-                  <Button
-                    size="sm"
-                    variant="ghost-destructive"
-                    disabled={disabled}
-                    onClick={() => void save(host, true)}
-                  >
-                    Remove
-                  </Button>
-                </div>
-              </li>
-            ))}
-          </ul>
-        )}
-        {editing && props.environmentId ? (
-          <EasDeviceHostEditor
-            key={editing.host.id}
-            environmentId={props.environmentId}
-            host={editing.host}
-            isNew={editing.isNew}
-            busy={busy}
-            onSave={(host) => void save(host, false)}
-            onClose={() => setEditing(null)}
-          />
-        ) : null}
-      </div>
-    </SettingsRow>
-  );
-}
-
 type AccountCheck =
   | { status: "idle" }
   | { status: "checking" }
   | { status: "signed-in"; account: DeviceEasAccount }
   | { status: "failed"; error: string };
 
-function EasDeviceHostEditor(props: {
+export function EasDeviceHostEditor(props: {
   environmentId: EnvironmentId;
   host: EasDeviceHostConfig;
   isNew: boolean;
diff --git a/apps/web/src/components/settings/IntegrationsSettings.tsx b/apps/web/src/components/settings/IntegrationsSettings.tsx
index 58e5d6877c827..5239f57bfdc37 100644
--- a/apps/web/src/components/settings/IntegrationsSettings.tsx
+++ b/apps/web/src/components/settings/IntegrationsSettings.tsx
@@ -2,8 +2,7 @@ import { DeviceHostUpdates } from "../device/DeviceHostUpdates";
 import { DeviceToolVersions } from "../device/DeviceToolVersions";
 import { useScopedSettings, useUpdateScopedSettings } from "./useScopedSettings";
 import { ScopedSwitch } from "./ScopedSwitch";
-import { DeviceHostsSettings } from "./DeviceHostsSettings";
-import { EasDeviceHostsSettings } from "./EasDeviceHostsSettings";
+import { DeviceSourcesSettings } from "./DeviceSourcesSettings";
 import {
   AuthSettingsWriteScope,
   BrowserImportFailureReason,
@@ -42,7 +41,6 @@ import { MoreVertical, Plus as PlusIcon } from "lucide-react";
 import { useRef, useState } from "react";
 
 import { ScreenRotationIcon } from "~/browser/ScreenRotationIcon";
-import { AnimatedHeight } from "~/components/AnimatedHeight";
 import { resolveEnvironmentOptionLabel } from "~/components/BranchToolbar.logic";
 import { previewBridge } from "~/components/preview/previewBridge";
 import { cn, randomUUID } from "~/lib/utils";
@@ -58,11 +56,6 @@ import {
   AgentDeviceSetupStatus,
   DeviceHubSetupStatus,
   deviceHubReadiness,
-  PlatformStatus,
-  platformSetupStatus,
-  deviceHubDescription,
-  agentDeviceDescription,
-  DeviceHostDiagnostics,
 } from "~/components/device/DeviceSetup";
 import { isElectron } from "../../env";
 
@@ -797,15 +790,23 @@ function DeviceIntegrationSettings() {
   const connected = selected?.connection.phase === "connected" && selected.serverConfig !== null;
   const environmentId = connected ? selected.environmentId : null;
 
+  const { state } = useDeviceState(environmentId);
+
   return (
-    <SettingsSection id="devices" title="Devices">
-      <DeviceIntegrationControls
-        key={`${environmentId}:${JSON.stringify(search)}`}
-        environmentId={environmentId}
-        enabled={settings.enableDeviceSupport}
-        agentAccessEnabled={settings.enableAgentDeviceAccess}
+    <>
+      <SettingsSection id="devices" title="Devices">
+        <DeviceIntegrationControls
+          key={`${environmentId}:${JSON.stringify(search)}`}
+          environmentId={environmentId}
+          enabled={settings.enableDeviceSupport}
+          agentAccessEnabled={settings.enableAgentDeviceAccess}
+        />
+      </SettingsSection>
+      <DeviceSourcesSettings
+        supportsEas={state.supportsEasHosts === true}
+        supportsSimlock={state.supportsSimlockHosts === true}
       />
-    </SettingsSection>
+    </>
   );
 }
 
@@ -831,20 +832,7 @@ function DeviceIntegrationControls({
   const [pending, setPending] = useState<
     "hub" | "check" | "agent" | "update-hub" | "update-agent" | null
   >(null);
-  const { ready: hubReady, busy } = deviceHubReadiness(state);
-  const localPlatformsUnavailable = state.hosts.some(
-    (host) => host.kind === "local" && !host.platforms.some((platform) => platform.available),
-  );
-  const [platformsRevealed, setPlatformsRevealed] = useState(false);
-  if (platformsRevealed && !enabled) setPlatformsRevealed(false);
-  if (
-    enabled &&
-    !platformsRevealed &&
-    (hubReady || localPlatformsUnavailable) &&
-    pending !== "hub"
-  ) {
-    setPlatformsRevealed(true);
-  }
+  const { busy } = deviceHubReadiness(state);
 
   const update = async (
     kind: NonNullable<typeof pending>,
@@ -941,14 +929,18 @@ function DeviceIntegrationControls({
         {...searchableSetting("device-hub")}
         serverScoped
         settingKeys={["enableDeviceSupport"]}
-        description={deviceHubDescription}
-        control={
+        description={
           <>
+            Open simulators and emulators in the Device panel. Hub:{" "}
             <DeviceToolVersions
               action={versionActions("hub")}
               kind="hub"
               tools={state.hosts.find((host) => host.kind === "local")?.tools}
             />
+          </>
+        }
+        control={
+          <>
             {pending === "hub" ? <DeviceHubSetupStatus state={state} pending compact /> : null}
             <ScopedSwitch
               settingKeys={["enableDeviceSupport"]}
@@ -972,65 +964,22 @@ function DeviceIntegrationControls({
           </>
         }
       />
-      <AnimatedHeight>
-        {platformsRevealed ? (
-          <SettingsRow
-            {...searchableSetting("device-platform-support")}
-            description={
-              connectedEnvironments.length > 1
-                ? `Status for ${connectedEnvironments.find((environment) => environment.environmentId === environmentId)?.label}. Select an environment to inspect its simulator support.`
-                : undefined
-            }
-            status={
-              <div className="space-y-2">
-                <div className="flex flex-wrap gap-x-5 gap-y-2">
-                  <PlatformStatus
-                    compact
-                    platform="iOS"
-                    status={platformSetupStatus(state, "ios")}
-                  />
-                  <PlatformStatus
-                    compact
-                    platform="Android"
-                    status={platformSetupStatus(state, "android")}
-                  />
-                </div>
-                {/* Remote hosts report their own warnings in the device host list below. */}
-                <DeviceHostDiagnostics
-                  hosts={state.hosts.filter((host) => host.kind === "local")}
-                  hostStatuses={state.hostStatuses}
-                />
-              </div>
-            }
-            control={
-              <Button
-                size="sm"
-                variant="outline"
-                disabled={!environmentId || !enabled || busy || pending !== null}
-                onClick={() => {
-                  if (!environmentId) return;
-                  setPending("check");
-                  void list({ environmentId, input: {} }).finally(() => setPending(null));
-                }}
-              >
-                {pending === "check" ? "Checking…" : "Refresh"}
-              </Button>
-            }
-          />
-        ) : null}
-      </AnimatedHeight>
       <SettingsRow
         {...searchableSetting("agent-device-access")}
         serverScoped
         settingKeys={["enableAgentDeviceAccess"]}
-        description={agentDeviceDescription}
-        control={
+        description={
           <>
+            New agent sessions can open and drive these devices. agent-device:{" "}
             <DeviceToolVersions
               action={versionActions("agent")}
               kind="agent"
               tools={state.hosts.find((host) => host.kind === "local")?.tools}
             />
+          </>
+        }
+        control={
+          <>
             {pending === "agent" ? <AgentDeviceSetupStatus state={state} pending compact /> : null}
             <ScopedSwitch
               settingKeys={["enableAgentDeviceAccess"]}
@@ -1057,8 +1006,6 @@ function DeviceIntegrationControls({
           environmentId={environmentId}
         />
       ) : null}
-      <DeviceHostsSettings environmentId={environmentId} />
-      {state.supportsEasHosts ? <EasDeviceHostsSettings environmentId={environmentId} /> : null}
     </>
   );
 }
diff --git a/apps/web/src/components/settings/LabsSettingsPanel.tsx b/apps/web/src/components/settings/LabsSettingsPanel.tsx
index 15c943728f144..ce3f68eac49d0 100644
--- a/apps/web/src/components/settings/LabsSettingsPanel.tsx
+++ b/apps/web/src/components/settings/LabsSettingsPanel.tsx
@@ -21,6 +21,7 @@ export function LabsSettingsPanel() {
         {/* Clerk is only mounted when this build has T3 Connect. */}
         {hasCloudPublicConfig() ? <GuestLinksRowWithSignIn /> : <GuestLinksRow />}
         <LinkedEnvironmentsRow />
+        <SimlockHostsRow />
       </SettingsSection>
       <LegacyFeaturesSection />
     </SettingsPageContainer>
@@ -148,3 +149,43 @@ function LinkedEnvironmentsRow() {
     />
   );
 }
+
+function SimlockHostsRow() {
+  const settings = useScopedSettings();
+  const updateSettings = useUpdateScopedSettings();
+  return (
+    <SettingsRow
+      serverScoped
+      {...searchableSetting("simlock-hosts")}
+      settingKeys={["simlockDeviceHostsEnabled"]}
+      description={
+        <>
+          Let the Device panel lease simulators and emulators from your own{" "}
+          <a
+            href="https://incubator.callstack.com/simlock/"
+            target="_blank"
+            rel="noreferrer"
+            className="underline underline-offset-2"
+          >
+            Simlock
+          </a>{" "}
+          pool, added in{" "}
+          <Link to="/settings/devices" className="underline underline-offset-2">
+            Devices
+          </Link>
+          . An alpha that may change or break. T3 Code never installs Simlock.
+        </>
+      }
+      control={
+        <ScopedSwitch
+          settingKeys={["simlockDeviceHostsEnabled"]}
+          checked={settings.simlockDeviceHostsEnabled}
+          onCheckedChange={(checked) =>
+            updateSettings({ simlockDeviceHostsEnabled: Boolean(checked) })
+          }
+          aria-label="Simlock device hosts"
+        />
+      }
+    />
+  );
+}
diff --git a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
index 0bfa19498f6d9..43c4419962a02 100644
--- a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
+++ b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
@@ -77,6 +77,14 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
   );
   const activeEntry = entries.find((entry) => entry.instanceId === selection?.instanceId);
   const mixedModel = useScopedSettingsMixed(["defaultModelSelection"]);
+  const mixedFallback = useScopedSettingsMixed(["fallbackModelSelection"]);
+  const fallbackSelection = settings.fallbackModelSelection ?? selection;
+  const fallbackModelOptions = getCustomModelOptionsByInstance(
+    settings,
+    providers,
+    fallbackSelection?.instanceId,
+    fallbackSelection?.model,
+  );
   const mixedPermissions = useScopedSettingsMixed(["defaultRuntimeMode"]);
   const PermissionIcon = runtimeModeConfig[settings.defaultRuntimeMode].icon;
   const mixedWorkspace = useScopedSettingsMixed(["defaultThreadEnvMode"]);
@@ -216,6 +224,59 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
     />
   );
 
+  const fallbackRow = !isProjectScope ? (
+    <SettingsRow
+      serverScoped
+      settingKeys={["fallbackModelSelection"]}
+      mixed={mixedFallback}
+      id="fallback-model"
+      title="Fallback model"
+      description="Used for new threads when the default model's provider is out of usage."
+      resetAction={
+        mixedFallback || settings.fallbackModelSelection !== null ? (
+          <SettingResetButton
+            label="fallback model"
+            onClick={() => updateSettings({ fallbackModelSelection: null })}
+          />
+        ) : null
+      }
+      control={
+        fallbackSelection ? (
+          <ProviderModelPicker
+            environmentId={representative?.environmentId ?? null}
+            activeInstanceId={fallbackSelection.instanceId}
+            model={fallbackSelection.model}
+            lockedProvider={null}
+            instanceEntries={entries}
+            modelOptionsByInstance={fallbackModelOptions}
+            triggerClassName={SETTINGS_PICKER_TRIGGER_CLASSNAME}
+            triggerAriaLabel="Fallback model"
+            {...(mixedFallback
+              ? { triggerLabel: "Mixed" }
+              : settings.fallbackModelSelection === null
+                ? { triggerLabel: "None" }
+                : {})}
+            getModelDisabledReason={modelDisabledReason}
+            onInstanceModelChange={(instanceId, model) => {
+              const reason = modelDisabledReason(instanceId, model);
+              if (reason) {
+                toastManager.add({
+                  type: "error",
+                  title: "Fallback model not saved",
+                  description: reason,
+                });
+                return;
+              }
+              updateSettings({ fallbackModelSelection: createModelSelection(instanceId, model) });
+            }}
+          />
+        ) : (
+          <span className="text-sm text-muted-foreground">No providers available</span>
+        )
+      }
+    />
+  ) : null;
+
   return (
     <SettingsSection
       id={category === "source-control" ? "source-control-defaults" : "project-defaults"}
@@ -224,11 +285,13 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
       {category === "project" ? (
         <>
           {modelRow}
+          {fallbackRow}
           {workspaceRow}
         </>
       ) : category === "general" ? (
         <>
           {modelRow}
+          {fallbackRow}
           <SettingsRow
             serverScoped
             settingKeys={["defaultRuntimeMode"]}
diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx
index 0cb00b86ac352..c4e3d27a07fa7 100644
--- a/apps/web/src/components/settings/SettingsPanels.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.tsx
@@ -1,3 +1,4 @@
+import { useAtomValue } from "@effect/atom-react";
 import { NotificationSettings } from "./NotificationSettings";
 import { PRIVACY_POLICY_URL } from "../../legalLinks";
 import { CheckIcon } from "lucide-react";
@@ -20,6 +21,7 @@ import {
   type QuitConfirmationMode,
   SidebarProjectSortOrder,
 } from "@t3tools/contracts/settings";
+import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
 import { createModelSelection } from "@t3tools/shared/model";
 import * as Equal from "effect/Equal";
 import * as Schema from "effect/Schema";
@@ -64,7 +66,7 @@ import {
 import { providerInstanceEntriesFor } from "../../providerInstances";
 import { ensureLocalApi, readLocalApi } from "../../localApi";
 import { isMacPlatform } from "../../lib/utils";
-import { useEnvironmentProviders } from "../../state/environments";
+import { useEnvironmentProviders, useEnvironments } from "../../state/environments";
 import { EMPTY_SERVER_PROVIDERS } from "../../state/server";
 import { Button } from "../ui/button";
 import { DraftInput } from "../ui/draft-input";
@@ -95,6 +97,13 @@ import { BackgroundActivitySettingsRow } from "./BackgroundActivitySettings";
 import { AdvancedSettings } from "./AdvancedSettings";
 import { PullRequestLinksOpenInAppSetting } from "./IntegrationsSettings";
 import { StorageCleanupSections } from "./StorageSettings";
+import { UpdateTrackSwitchDialog } from "./UpdateTrackSwitchDialog";
+import { environmentIdsKey } from "~/state/environmentAtomList";
+import { environmentSessionStatesAtom } from "~/state/session";
+import { canUpdateServer } from "../ServerUpdateAction";
+import { useUpdateEverythingRun } from "../sidebar/updateEverythingRun";
+import { awaitsTrackSwitch, channelSwitchLabel } from "../sidebar/updateEverything.logic";
+import { isHostedByThisApp } from "../sidebar/useUpdateEverything";
 
 const RESPONSE_STREAMING_MODE_LABELS: Record<ResponseStreamingMode, string> = {
   turn: "Wait for the full response",
@@ -142,39 +151,38 @@ function AboutVersionTitle() {
 
 function AboutVersionSection() {
   const updateState = useDesktopUpdateState();
-  const [isChangingUpdateChannel, setIsChangingUpdateChannel] = useState(false);
+  const [switchChannel, setSwitchChannel] = useState<DesktopUpdateChannel | null>(null);
   const [isUpdateActionPending, setIsUpdateActionPending] = useState(false);
+  const { environments } = useEnvironments();
+  const sessionStates = useAtomValue(
+    environmentSessionStatesAtom(
+      environmentIdsKey(environments.map(({ environmentId }) => environmentId)),
+    ),
+  );
+  // A second run would replace the first run's progress and local download.
+  const updateRun = useUpdateEverythingRun();
 
   const hasDesktopBridge = typeof window !== "undefined" && Boolean(window.desktopBridge);
   const selectedUpdateChannel = updateState?.channel ?? "latest";
   const selectedHostedAppChannel = hasDesktopBridge ? null : HOSTED_APP_CHANNEL;
-
-  const handleUpdateChannelChange = (channel: DesktopUpdateChannel) => {
-    const bridge = window.desktopBridge;
-    if (
-      !bridge ||
-      typeof bridge.setUpdateChannel !== "function" ||
-      channel === selectedUpdateChannel
-    ) {
-      return;
-    }
-
-    setIsChangingUpdateChannel(true);
-    void bridge
-      .setUpdateChannel(channel)
-      .catch((error: unknown) => {
-        toastManager.add(
-          stackedThreadToast({
-            type: "error",
-            title: "Could not change update track",
-            description: error instanceof Error ? error.message : "Update track change failed.",
-          }),
-        );
-      })
-      .finally(() => {
-        setIsChangingUpdateChannel(false);
-      });
-  };
+  // A switch that failed part way leaves this app or a server on the other track.
+  // With its updater off, a switch cannot move this app, so it is not counted.
+  const appOffTrack =
+    updateState?.enabled !== false && desktopUpdateChannelOf(APP_VERSION) !== selectedUpdateChannel;
+  const unswitchedMachines =
+    (appOffTrack ? 1 : 0) +
+    environments.filter(
+      (environment, index) =>
+        environment.connection.phase === "connected" &&
+        canUpdateServer(sessionStates[index]!) &&
+        awaitsTrackSwitch(
+          {
+            serverConfig: environment.serverConfig,
+            hostedByThisApp: isHostedByThisApp(environment),
+          },
+          selectedUpdateChannel,
+        ),
+    ).length;
 
   const handleButtonClick = async () => {
     const bridge = window.desktopBridge;
@@ -272,7 +280,8 @@ function AboutVersionSection() {
   const statusLabel: Record<string, string> = {
     checking: "Checking…",
     downloading: "Downloading…",
-    "up-to-date": "Up to Date",
+    // Off its track, "up to date" only means no switch is pending; Review moves it.
+    ...(appOffTrack ? {} : { "up-to-date": "Up to Date" }),
   };
   const buttonLabel =
     actionLabel[action] ?? statusLabel[updateState?.status ?? ""] ?? "Check for Updates";
@@ -308,23 +317,43 @@ function AboutVersionSection() {
       {hasDesktopBridge ? (
         <SettingsRow
           {...searchableSetting("update-track")}
-          description="Use stable releases or nightly builds. Switch back anytime."
+          description={
+            unswitchedMachines > 0 ? (
+              <>
+                {unswitchedMachines === 1
+                  ? "1 machine still runs"
+                  : `${unswitchedMachines} machines still run`}{" "}
+                {channelSwitchLabel(selectedUpdateChannel === "nightly" ? "latest" : "nightly")}.{" "}
+                {/* The dialog moves what it can and says why it skips the rest. */}
+                <Button
+                  size="xs"
+                  variant="link"
+                  disabled={updateRun !== null}
+                  onClick={() => setSwitchChannel(selectedUpdateChannel)}
+                >
+                  Review
+                </Button>
+              </>
+            ) : (
+              "Switches this app and every connected machine whose database the target release supports."
+            )
+          }
           control={
             <Select
               value={selectedUpdateChannel}
               onValueChange={(value) => {
-                handleUpdateChannelChange(value as DesktopUpdateChannel);
+                if (value !== selectedUpdateChannel) {
+                  setSwitchChannel(value as DesktopUpdateChannel);
+                }
               }}
             >
               <SelectTrigger
                 size="sm"
                 className="w-full sm:w-40"
                 aria-label="Update track"
-                disabled={isChangingUpdateChannel}
+                disabled={switchChannel !== null || updateRun !== null}
               >
-                <SelectValue>
-                  {selectedUpdateChannel === "nightly" ? "Nightly" : "Stable"}
-                </SelectValue>
+                <SelectValue>{channelSwitchLabel(selectedUpdateChannel)}</SelectValue>
               </SelectTrigger>
               <SelectPopup align="end" alignItemWithTrigger={false}>
                 <SelectItem hideIndicator value="latest">
@@ -367,6 +396,9 @@ function AboutVersionSection() {
         />
       ) : null}
       {hasDesktopBridge ? <CliCommandSettingsRow /> : null}
+      {switchChannel === null ? null : (
+        <UpdateTrackSwitchDialog channel={switchChannel} onClose={() => setSwitchChannel(null)} />
+      )}
     </>
   );
 }
diff --git a/apps/web/src/components/settings/SimlockDeviceHostEditor.tsx b/apps/web/src/components/settings/SimlockDeviceHostEditor.tsx
new file mode 100644
index 0000000000000..3498492d59cec
--- /dev/null
+++ b/apps/web/src/components/settings/SimlockDeviceHostEditor.tsx
@@ -0,0 +1,303 @@
+import { useAtomValue } from "@effect/atom-react";
+import { useId, useState, type ReactNode } from "react";
+import type { EnvironmentId, SimlockDeviceHostConfig } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
+import * as Option from "effect/Option";
+import { AsyncResult, Atom } from "effect/reactivity";
+import { XIcon } from "lucide-react";
+
+import { deviceSimlockIdentityCheck } from "../../state/device";
+import { environmentAtomList, environmentIdsKey } from "../../state/environmentAtomList";
+
+import { Button } from "../ui/button";
+import {
+  Dialog,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogPanel,
+  DialogPopup,
+  DialogTitle,
+} from "../ui/dialog";
+import { Input } from "../ui/input";
+import { Spinner } from "../ui/spinner";
+import { SecretInput } from "./SecretInput";
+import {
+  planSimlockDeviceHostSave,
+  simlockDeviceHostProblem,
+  type SimlockHostEnvironment,
+  type SimlockTokenEntry,
+} from "./simlockDeviceHostsSettings.logic";
+
+const failureMessage = (cause: Cause.Cause<unknown>) => {
+  const error = Cause.squash(cause);
+  return error instanceof Error ? error.message : String(error);
+};
+
+/** The gateway each environment's own agent-device points at, if any. */
+const machineGatewaysAtom = environmentAtomList("web-simlock-machine-gateways", (environmentId) =>
+  deviceSimlockIdentityCheck({ environmentId, input: {} }),
+);
+
+const NO_CHECK = Atom.make(AsyncResult.initial()).pipe(Atom.withLabel("simlock-identity:none"));
+
+/** Shared fields once, then one agent token per environment: Simlock counts leases per token. */
+export function SimlockDeviceHostEditor(props: {
+  host: SimlockDeviceHostConfig;
+  isNew: boolean;
+  environments: ReadonlyArray<SimlockHostEnvironment>;
+  busy: boolean;
+  onSave: (
+    host: SimlockDeviceHostConfig,
+    tokens: ReadonlyMap<EnvironmentId, SimlockTokenEntry>,
+  ) => void;
+  onClose: () => void;
+}) {
+  const [draft, setDraft] = useState(props.host);
+  const [urlEdited, setUrlEdited] = useState(false);
+  const machineGateways = useAtomValue(
+    machineGatewaysAtom(
+      environmentIdsKey(
+        props.isNew ? props.environments.map((environment) => environment.environmentId) : [],
+      ),
+    ),
+  );
+  // A new host starts at the gateway an environment's agent-device already uses.
+  const detectedUrl = machineGateways
+    .map((result) => Option.getOrUndefined(AsyncResult.value(result))?.gatewayUrl)
+    .find(Boolean);
+  const gatewayUrl = urlEdited || draft.gatewayUrl ? draft.gatewayUrl : (detectedUrl ?? "");
+  const savedToken = (environment: SimlockHostEnvironment) =>
+    environment.hosts.some((host) => host.id === props.host.id && host.agentToken !== "");
+  const [tokens, setTokens] = useState<ReadonlyMap<EnvironmentId, SimlockTokenEntry>>(
+    () =>
+      new Map(
+        props.environments.map((environment) => [
+          environment.environmentId,
+          savedToken(environment) ? { kind: "saved" } : { kind: "cleared" },
+        ]),
+      ),
+  );
+  const next: SimlockDeviceHostConfig = {
+    ...draft,
+    label: draft.label.trim(),
+    gatewayUrl: gatewayUrl.trim(),
+  };
+  const checkUrl = simlockDeviceHostProblem(next) === null ? next.gatewayUrl : null;
+  const plan = planSimlockDeviceHostSave(props.environments, next, tokens);
+  const problem = "problem" in plan ? plan.problem : null;
+  const several = props.environments.length > 1;
+
+  const limit = (
+    field: "maxLeases" | "maxLeaseMinutes",
+    label: string,
+    min: number,
+    max: number,
+  ) => (
+    <label className="block space-y-1.5">
+      <span>{label}</span>
+      <Input
+        type="number"
+        min={min}
+        max={max}
+        value={draft[field]}
+        disabled={props.busy}
+        onChange={(event) => {
+          const value = Number(event.target.value);
+          setDraft((current) => ({ ...current, [field]: value }));
+        }}
+      />
+    </label>
+  );
+
+  return (
+    <Dialog
+      open
+      onOpenChange={(open) => {
+        if (!open && !props.busy) props.onClose();
+      }}
+    >
+      <DialogPopup showCloseButton={!props.busy}>
+        <form
+          className="flex min-h-0 flex-col"
+          onSubmit={(event) => {
+            event.preventDefault();
+            if (problem === null && !props.busy) props.onSave(next, tokens);
+          }}
+        >
+          <DialogHeader>
+            <DialogTitle>{props.isNew ? "Add Simlock host" : "Edit Simlock host"}</DialogTitle>
+            <DialogDescription>
+              {several
+                ? "Each selected environment's server leases devices from your Simlock gateway with its own agent token, and releases them when they close."
+                : "The environment's server leases devices from your Simlock gateway and releases them when they close."}
+            </DialogDescription>
+          </DialogHeader>
+          <DialogPanel>
+            <label className="block space-y-1.5 text-sm">
+              <span>Name</span>
+              <Input
+                autoFocus
+                required
+                value={draft.label}
+                disabled={props.busy}
+                onChange={(event) => {
+                  const label = event.target.value;
+                  setDraft((current) => ({ ...current, label }));
+                }}
+              />
+            </label>
+            <label className="block space-y-1.5 text-sm">
+              <span>Gateway URL</span>
+              <Input
+                required
+                type="url"
+                placeholder="https://gateway.example.ts.net:4700"
+                value={gatewayUrl}
+                disabled={props.busy}
+                onChange={(event) => {
+                  const gatewayUrl = event.target.value;
+                  setUrlEdited(true);
+                  setDraft((current) => ({ ...current, gatewayUrl }));
+                }}
+              />
+            </label>
+            <div className="space-y-3">
+              {props.environments.map((environment) => (
+                <SimlockTokenField
+                  key={environment.environmentId}
+                  environmentId={environment.environmentId}
+                  hostId={props.isNew ? null : props.host.id}
+                  gatewayUrl={checkUrl}
+                  label={several ? `Agent token · ${environment.label}` : "Agent token"}
+                  token={tokens.get(environment.environmentId) ?? { kind: "cleared" }}
+                  hasSaved={savedToken(environment)}
+                  busy={props.busy}
+                  onChange={(token) =>
+                    setTokens((current) => new Map(current).set(environment.environmentId, token))
+                  }
+                />
+              ))}
+              <p className="text-xs text-muted-foreground">
+                Leases, drives, and streams devices. Create one{several ? " per environment" : ""}{" "}
+                with <code>simlock --gateway token create --role agent</code>, or leave it blank to
+                add it later. A blank token uses the machine's{" "}
+                <code>AGENT_DEVICE_DAEMON_AUTH_TOKEN</code> when its{" "}
+                <code>AGENT_DEVICE_DAEMON_BASE_URL</code> is this gateway.
+              </p>
+            </div>
+            <div className="grid grid-cols-2 gap-3 text-sm">
+              {limit("maxLeases", "Devices at once", 1, 20)}
+              {limit("maxLeaseMinutes", "Lease minutes", 5, 240)}
+            </div>
+            <p className="text-xs text-muted-foreground">
+              A lease ends after the lease minutes even while in use.
+              {props.isNew ? null : " Saving restarts this host, which releases its devices."}
+            </p>
+            {problem === null || !gatewayUrl ? null : (
+              <p className="text-xs text-destructive" role="alert">
+                {problem}
+              </p>
+            )}
+          </DialogPanel>
+          <DialogFooter>
+            <Button type="button" variant="ghost" disabled={props.busy} onClick={props.onClose}>
+              Cancel
+            </Button>
+            <Button type="submit" disabled={props.busy || problem !== null}>
+              {props.busy ? <Spinner size="xs" /> : null} Save host
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogPopup>
+    </Dialog>
+  );
+}
+
+function SimlockTokenField(props: {
+  environmentId: EnvironmentId;
+  hostId: string | null;
+  gatewayUrl: string | null;
+  label: ReactNode;
+  token: SimlockTokenEntry;
+  hasSaved: boolean;
+  busy: boolean;
+  onChange: (token: SimlockTokenEntry) => void;
+}) {
+  const id = useId();
+  const entered = props.token.kind === "new" ? props.token.value.trim() : "";
+  // A cleared field asks about the machine's own token, which a blank one falls back to.
+  const check = useAtomValue(
+    props.gatewayUrl === null
+      ? NO_CHECK
+      : deviceSimlockIdentityCheck({
+          environmentId: props.environmentId,
+          input: {
+            gatewayUrl: props.gatewayUrl,
+            ...(entered
+              ? { agentToken: entered }
+              : props.token.kind === "saved" && props.hostId !== null
+                ? { hostId: props.hostId }
+                : {}),
+          },
+        }),
+  );
+  const identity = AsyncResult.isSuccess(check) ? check.value : null;
+  const status =
+    props.gatewayUrl === null ? null : check._tag === "Initial" || check.waiting ? (
+      <span className="text-muted-foreground">Checking…</span>
+    ) : identity ? (
+      <span className="text-muted-foreground">
+        {identity.tokenSource === "env"
+          ? `Using this machine's agent-device token (${identity.signedInAs}).`
+          : `Accepted as ${identity.signedInAs}.`}
+      </span>
+    ) : AsyncResult.isFailure(check) ? (
+      <span
+        className={props.token.kind === "cleared" ? "text-muted-foreground" : "text-destructive"}
+      >
+        {failureMessage(check.cause)}
+      </span>
+    ) : null;
+  return (
+    <div className="space-y-1.5 text-sm">
+      <label htmlFor={id} className="block">
+        {props.label}
+      </label>
+      <div className="flex items-center gap-2">
+        <SecretInput
+          id={id}
+          className="min-w-0 flex-1"
+          configured={props.token.kind === "saved"}
+          value={props.token.kind === "new" ? props.token.value : ""}
+          disabled={props.busy}
+          onChange={(event) => {
+            const value = event.target.value;
+            // Emptying the field is not clearing the saved token; the Clear
+            // button is, so a saved token comes back here.
+            props.onChange(
+              value
+                ? { kind: "new", value }
+                : props.hasSaved
+                  ? { kind: "saved" }
+                  : { kind: "cleared" },
+            );
+          }}
+        />
+        {props.token.kind !== "cleared" ? (
+          <Button
+            type="button"
+            size="icon-sm"
+            variant="ghost-destructive"
+            aria-label="Clear agent token"
+            disabled={props.busy}
+            onClick={() => props.onChange({ kind: "cleared" })}
+          >
+            <XIcon className="size-3.5" />
+          </Button>
+        ) : null}
+      </div>
+      {status ? <p className="text-xs">{status}</p> : null}
+    </div>
+  );
+}
diff --git a/apps/web/src/components/settings/ThreadDetailsItemsRow.tsx b/apps/web/src/components/settings/ThreadDetailsItemsRow.tsx
new file mode 100644
index 0000000000000..a142155d0357d
--- /dev/null
+++ b/apps/web/src/components/settings/ThreadDetailsItemsRow.tsx
@@ -0,0 +1,53 @@
+import { ChevronDownIcon } from "lucide-react";
+
+import { updateClientSettings, useClientSettings } from "../../hooks/useSettings";
+import { ThreadDetailsItemsMenuItems } from "../chat/ThreadDetailsItemsMenu";
+import {
+  isDefaultThreadDetailsVisibility,
+  resolveThreadDetailsVisibility,
+  RESET_THREAD_DETAILS_ITEMS,
+  THREAD_DETAILS_ITEMS,
+} from "../chat/threadDetailsItems";
+import { Button } from "../ui/button";
+import { Menu, MenuPopup, MenuTrigger } from "../ui/menu";
+import { SettingResetButton, SettingsRow } from "./settingsLayout";
+import { searchableSetting } from "./settingsSearch";
+
+export function ThreadDetailsItemsRow() {
+  const visibility = useClientSettings(resolveThreadDetailsVisibility);
+  const enabled = THREAD_DETAILS_ITEMS.filter((item) => visibility[item.id]).length;
+  return (
+    <SettingsRow
+      {...searchableSetting("thread-details-items")}
+      description="Choose what the thread details card shows. You can also right-click the card."
+      resetAction={
+        isDefaultThreadDetailsVisibility(visibility) ? null : (
+          <SettingResetButton
+            label="thread details"
+            onClick={() => updateClientSettings(RESET_THREAD_DETAILS_ITEMS)}
+          />
+        )
+      }
+      control={
+        <Menu>
+          <MenuTrigger
+            render={
+              <Button
+                variant="outline"
+                size="sm"
+                className="w-full justify-between sm:w-40"
+                aria-label={`Thread details: ${enabled} of ${THREAD_DETAILS_ITEMS.length} on`}
+              />
+            }
+          >
+            {enabled} of {THREAD_DETAILS_ITEMS.length} on
+            <ChevronDownIcon aria-hidden />
+          </MenuTrigger>
+          <MenuPopup align="end">
+            <ThreadDetailsItemsMenuItems />
+          </MenuPopup>
+        </Menu>
+      }
+    />
+  );
+}
diff --git a/apps/web/src/components/settings/UpdateTrackSwitchDialog.tsx b/apps/web/src/components/settings/UpdateTrackSwitchDialog.tsx
new file mode 100644
index 0000000000000..f746cff28c270
--- /dev/null
+++ b/apps/web/src/components/settings/UpdateTrackSwitchDialog.tsx
@@ -0,0 +1,178 @@
+import { useAtomValue } from "@effect/atom-react";
+import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
+import type { DesktopUpdateChannel } from "@t3tools/contracts";
+import { acceptsTrackSwitchRelease, desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
+import { isMacPlatform } from "@t3tools/shared/keybindings";
+import { useState } from "react";
+import { AsyncResult } from "effect/reactivity";
+
+import { APP_VERSION } from "~/branding";
+import { useDesktopUpdateState } from "~/state/desktopUpdate";
+import { useEnvironments } from "~/state/environments";
+import { npmReleaseAtom } from "~/state/npmRelease";
+import { downloadLocalUpdate, installLocalUpdate } from "../sidebar/SidebarUpdatePill";
+import { UpdateEverythingDialog } from "../sidebar/UpdateEverythingDialog";
+import {
+  channelSwitchLabel,
+  localSwitchBlockReason,
+  type ChannelSwitchRelease,
+} from "../sidebar/updateEverything.logic";
+import { isHostedByThisApp, useUpdateEverything } from "../sidebar/useUpdateEverything";
+import { prepareLocalTrackSwitch } from "./updateTrackSwitch.logic";
+import {
+  AlertDialog,
+  AlertDialogClose,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogPopup,
+  AlertDialogTitle,
+} from "../ui/alert-dialog";
+import { Button } from "../ui/button";
+import { stackedThreadToast, toastManager } from "../ui/toast";
+
+/** Moves this app and every connected machine to `channel`. */
+export function UpdateTrackSwitchDialog({
+  channel,
+  onClose,
+}: {
+  readonly channel: DesktopUpdateChannel;
+  readonly onClose: () => void;
+}) {
+  // npm dist-tags match the desktop channel names.
+  const release = useAtomValue(npmReleaseAtom(channel));
+  if (AsyncResult.isSuccess(release) && release.value !== null) {
+    return <SwitchPlan release={{ channel, ...release.value }} onClose={onClose} />;
+  }
+  const label = channelSwitchLabel(channel);
+  return (
+    <AlertDialog open onOpenChange={(open) => !open && onClose()}>
+      <AlertDialogPopup>
+        <AlertDialogHeader>
+          <AlertDialogTitle>Switch to {label}</AlertDialogTitle>
+          <AlertDialogDescription>
+            {AsyncResult.isFailure(release) || AsyncResult.isSuccess(release)
+              ? `Could not find the latest ${label} release on npm. Try again later.`
+              : "Checking releases…"}
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter>
+          <AlertDialogClose render={<Button variant="outline" />}>Cancel</AlertDialogClose>
+        </AlertDialogFooter>
+      </AlertDialogPopup>
+    </AlertDialog>
+  );
+}
+
+function SwitchPlan({
+  release,
+  onClose,
+}: {
+  readonly release: ChannelSwitchRelease;
+  readonly onClose: () => void;
+}) {
+  const updateState = useDesktopUpdateState();
+  const { environments } = useEnvironments();
+  const crossesLocal = desktopUpdateChannelOf(APP_VERSION) !== release.channel;
+  // With its updater off (a .deb install, or no feed) this app stays put and only remotes move.
+  const updatesOff = updateState?.enabled === false;
+  // After a partial switch this app may already be on the track; then only remotes move.
+  const switchesLocal = crossesLocal && !updatesOff;
+  const [checking, setChecking] = useState(false);
+  const everything = useUpdateEverything(switchesLocal ? release.version : null, release);
+  const label = channelSwitchLabel(release.channel);
+  // This app's reinstall restarts every server it hosts, so each of their databases must allow it.
+  const localBlocked = localSwitchBlockReason(
+    APP_VERSION,
+    release,
+    environments.filter(isHostedByThisApp).map((environment) => ({
+      connected: environment.connection.phase === "connected",
+      databaseMigration: environment.serverConfig?.environment.databaseMigration,
+    })),
+    window.desktopBridge?.getLocalEnvironmentBootstraps().length ?? 0,
+  );
+
+  const run = async () => {
+    const bridge = window.desktopBridge;
+    if (!bridge) return;
+    // Stay open while the feed is checked; the run's own progress takes over after.
+    setChecking(true);
+    const fail = (description: string) =>
+      toastManager.add(
+        stackedThreadToast({ type: "error", title: `Could not switch to ${label}`, description }),
+      );
+    const prepared = await prepareLocalTrackSwitch(bridge, {
+      channel: release.channel,
+      version: release.version,
+      reinstall: switchesLocal,
+    });
+    onClose();
+    if (!prepared.ok) {
+      fail(prepared.message);
+      return;
+    }
+    const { local } = prepared;
+    const result = await settlePromise(() =>
+      everything.run(
+        local === null
+          ? {}
+          : {
+              ...(local.status === "available"
+                ? {
+                    downloadLocal: (reportError) =>
+                      downloadLocalUpdate(bridge, { notifyDownloaded: false, reportError }),
+                  }
+                : {}),
+              // Install only a build the database check covers, pinned so nothing replaces it.
+              installLocal: async (reportError) => {
+                const { downloadedVersion } = await bridge.getUpdateState();
+                if (
+                  downloadedVersion === null ||
+                  !acceptsTrackSwitchRelease(downloadedVersion, release.channel, release.version)
+                ) {
+                  reportError(
+                    "Could not install update",
+                    `This app downloaded ${downloadedVersion ?? "nothing"}, not ${release.version} or newer.`,
+                  );
+                  return false;
+                }
+                return installLocalUpdate(bridge, reportError, downloadedVersion);
+              },
+            },
+      ),
+    );
+    if (result._tag === "Failure") {
+      const error = squashAtomCommandFailure(result);
+      fail(error instanceof Error ? error.message : "An unexpected error occurred.");
+    }
+  };
+
+  return (
+    <UpdateEverythingDialog
+      open
+      onOpenChange={(open) => !open && !checking && onClose()}
+      title={`Switch to ${label}?`}
+      version={release.version}
+      providerCount={0}
+      rows={everything.rows}
+      notes={[
+        ...(everything.rows.length === 0 && !crossesLocal
+          ? [`Every connected machine is already on ${label}. This only saves the track.`]
+          : []),
+        ...(crossesLocal && updatesOff
+          ? ["This app's updates are off here, so reinstall it yourself to switch."]
+          : []),
+        ...(switchesLocal && isMacPlatform(navigator.platform)
+          ? ["If T3 Code does not reopen after it restarts, open it again."]
+          : []),
+      ]}
+      restarts={everything.restarts}
+      confirmLabel={checking ? "Checking…" : `Switch to ${label}`}
+      busy={checking}
+      disabledReason={
+        !switchesLocal || localBlocked === null ? null : `This app cannot switch: ${localBlocked}.`
+      }
+      onConfirm={() => void run()}
+    />
+  );
+}
diff --git a/apps/web/src/components/settings/easDeviceHostsSettings.logic.test.ts b/apps/web/src/components/settings/easDeviceHostsSettings.logic.test.ts
index 545d1ac212ec7..c3105b115e21f 100644
--- a/apps/web/src/components/settings/easDeviceHostsSettings.logic.test.ts
+++ b/apps/web/src/components/settings/easDeviceHostsSettings.logic.test.ts
@@ -1,7 +1,11 @@
 import { describe, expect, it } from "vite-plus/test";
 import * as Option from "effect/Option";
 
-import { newEasDeviceHost, parseEasDeviceHostDraft } from "./easDeviceHostsSettings.logic";
+import {
+  newEasDeviceHost,
+  parseEasDeviceHostDraft,
+  updateEasDeviceHosts,
+} from "./easDeviceHostsSettings.logic";
 
 describe("EAS device host settings", () => {
   it("rejects limits EAS does not allow", () => {
@@ -18,4 +22,15 @@ describe("EAS device host settings", () => {
       true,
     );
   });
+
+  it("keeps each environment's own token when a save leaves the token unchanged", () => {
+    const edited = { ...newEasDeviceHost("eas"), label: "Renamed", accessToken: "" };
+    const elsewhere = { ...newEasDeviceHost("eas"), accessToken: "••••••" };
+    expect(updateEasDeviceHosts([elsewhere], edited, false, true)).toEqual([
+      { ...edited, accessToken: "••••••" },
+    ]);
+    expect(updateEasDeviceHosts([], { ...edited, accessToken: "••••••" }, false, true)).toEqual([
+      { ...edited, accessToken: "" },
+    ]);
+  });
 });
diff --git a/apps/web/src/components/settings/easDeviceHostsSettings.logic.ts b/apps/web/src/components/settings/easDeviceHostsSettings.logic.ts
index 418a15d0064e1..d91fe45bb9205 100644
--- a/apps/web/src/components/settings/easDeviceHostsSettings.logic.ts
+++ b/apps/web/src/components/settings/easDeviceHostsSettings.logic.ts
@@ -17,15 +17,22 @@ export const newEasDeviceHost = (id: string): EasDeviceHostConfigType => ({
 });
 
 /** Adds, replaces, or removes one EAS host. */
+/**
+ * With `keepToken`, the environment keeps the token it holds: a saved token arrives redacted, and
+ * one environment's token says nothing about another's. One new to the host uses its own Expo login.
+ */
 export function updateEasDeviceHosts(
   hosts: ReadonlyArray<EasDeviceHostConfigType>,
   host: EasDeviceHostConfigType,
   remove: boolean,
+  keepToken = false,
 ): ReadonlyArray<EasDeviceHostConfigType> {
   if (remove) return hosts.filter((candidate) => candidate.id !== host.id);
-  return hosts.some((candidate) => candidate.id === host.id)
-    ? hosts.map((candidate) => (candidate.id === host.id ? host : candidate))
-    : [...hosts, host];
+  const existing = hosts.find((candidate) => candidate.id === host.id);
+  const next = keepToken ? { ...host, accessToken: existing?.accessToken ?? "" } : host;
+  return existing
+    ? hosts.map((candidate) => (candidate.id === host.id ? next : candidate))
+    : [...hosts, next];
 }
 
 export function easSessionLimits(host: EasDeviceHostConfigType) {
diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts
index 325d0c1ba75e2..1d5c13e72a061 100644
--- a/apps/web/src/components/settings/settingsSearch.ts
+++ b/apps/web/src/components/settings/settingsSearch.ts
@@ -315,6 +315,14 @@ export const SETTINGS_SEARCH_ITEMS = [
     to: "/settings/appearance",
     searchTerms: ["wide full width column layout messages composer monitor"],
   },
+  {
+    id: "thread-details-items",
+    title: "Thread details",
+    to: "/settings/appearance",
+    searchTerms: [
+      "customize show hide panel card environment editor scripts branch pull request git changes servers automations lineage usage limits 5 hour weekly quota tokens context window",
+    ],
+  },
   {
     id: "effort-display",
     title: "Effort display",
@@ -451,6 +459,13 @@ export const SETTINGS_SEARCH_ITEMS = [
     scope: "environment",
     searchTerms: ["beta link another machine vps peer agents work there delegate"],
   },
+  {
+    id: "simlock-hosts",
+    title: "Simlock device hosts (alpha)",
+    to: "/settings/labs",
+    scope: "environment",
+    searchTerms: ["beta alpha simlock callstack simulator emulator ios android pool lease gateway"],
+  },
   {
     id: "auto-settle-inactive-threads",
     title: "Auto-settle inactive threads",
@@ -806,31 +821,33 @@ export const SETTINGS_SEARCH_ITEMS = [
     searchTerms: ["allow disable enable open drive preview tools sessions project override"],
   },
   {
-    id: "device-hosts",
-    title: "Device hosts",
+    id: "device-sources",
+    title: "Device sources",
     to: "/settings/devices",
-    searchTerms: ["ssh remote simulator emulator ios android mac mini identity key connection"],
+    searchTerms: [
+      "device hosts ssh remote mac mini identity key connection eas expo cloud simlock pool gateway local simulators",
+    ],
   },
   {
     id: "agent-device-access",
-    title: "Agent device access",
+    title: "Agents can use devices",
     to: "/settings/devices",
     targetId: "devices",
     searchTerms: ["allow simulator emulator ios android drive tools sessions"],
   },
   {
     id: "device-hub",
-    title: "Device hub",
+    title: "Use devices",
     to: "/settings/devices",
     targetId: "devices",
-    searchTerms: ["simulator emulator ios android install start"],
+    searchTerms: ["device hub simulator emulator ios android install start version"],
   },
   {
     id: "device-platform-support",
-    title: "Simulator support",
+    title: "Local simulators",
     to: "/settings/devices",
-    targetId: "devices",
-    searchTerms: ["xcode android studio sdk avd runtime"],
+    targetId: "device-sources",
+    searchTerms: ["simulator support xcode android studio sdk avd runtime"],
   },
   {
     id: "browser-profiles",
diff --git a/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.test.ts b/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.test.ts
new file mode 100644
index 0000000000000..2efe3c78c24eb
--- /dev/null
+++ b/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import type { EnvironmentId } from "@t3tools/contracts";
+
+import {
+  newSimlockDeviceHost,
+  planSimlockDeviceHostSave,
+  simlockDeviceHostProblem,
+  updateSimlockDeviceHosts,
+} from "./simlockDeviceHostsSettings.logic";
+
+const host = {
+  ...newSimlockDeviceHost("simlock"),
+  gatewayUrl: "https://gateway.example.ts.net:4700",
+  agentToken: "agent",
+};
+
+describe("Simlock device host settings", () => {
+  it("names what keeps a draft from saving", () => {
+    expect(simlockDeviceHostProblem(host)).toBeNull();
+    expect(simlockDeviceHostProblem({ ...host, label: " " })).toBe("Give the host a label.");
+    expect(simlockDeviceHostProblem({ ...host, gatewayUrl: "gateway:4700" })).toMatch(/origin/);
+    expect(
+      simlockDeviceHostProblem({ ...host, gatewayUrl: "https://gateway.example/api" }),
+    ).toMatch(/origin/);
+    expect(simlockDeviceHostProblem({ ...host, maxLeases: 21 })).toMatch(/ranges/);
+    expect(simlockDeviceHostProblem({ ...host, maxLeaseMinutes: 4 })).toMatch(/ranges/);
+  });
+
+  it("adds, replaces, and removes one host", () => {
+    const other = { ...host, id: "other", label: "Other" };
+    const added = updateSimlockDeviceHosts([other], host, false);
+    expect(added.map((candidate) => candidate.id)).toEqual(["other", "simlock"]);
+    const renamed = updateSimlockDeviceHosts(added, { ...host, label: "Renamed" }, false);
+    expect(renamed.map((candidate) => candidate.label)).toEqual(["Other", "Renamed"]);
+    expect(updateSimlockDeviceHosts(renamed, host, true)).toEqual([other]);
+  });
+
+  it("saves the shared fields everywhere and each environment's own token, if it has one", () => {
+    const mbp = "mbp" as EnvironmentId;
+    const cups = "cups" as EnvironmentId;
+    const environments = [
+      { environmentId: mbp, label: "mbp", hosts: [{ ...host, agentToken: "<redacted>" }] },
+      { environmentId: cups, label: "cups", hosts: [] },
+    ];
+    const draft = { ...host, label: "Pool", agentToken: "" };
+
+    expect(
+      planSimlockDeviceHostSave(environments, draft, new Map([[mbp, { kind: "saved" }]])),
+    ).toEqual({
+      patches: [
+        { environmentId: mbp, hosts: [{ ...draft, agentToken: "<redacted>" }] },
+        { environmentId: cups, hosts: [{ ...draft, agentToken: "" }] },
+      ],
+    });
+    expect(
+      planSimlockDeviceHostSave(
+        environments,
+        draft,
+        new Map([
+          [mbp, { kind: "saved" }],
+          [cups, { kind: "new", value: " cups-token " }],
+        ]),
+      ),
+    ).toEqual({
+      patches: [
+        { environmentId: mbp, hosts: [{ ...draft, agentToken: "<redacted>" }] },
+        { environmentId: cups, hosts: [{ ...draft, agentToken: "cups-token" }] },
+      ],
+    });
+  });
+});
diff --git a/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.ts b/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.ts
new file mode 100644
index 0000000000000..a4ef1e1bb90b1
--- /dev/null
+++ b/apps/web/src/components/settings/simlockDeviceHostsSettings.logic.ts
@@ -0,0 +1,93 @@
+import {
+  SimlockDeviceHostConfig,
+  type EnvironmentId,
+  type SimlockDeviceHostConfig as SimlockDeviceHostConfigType,
+} from "@t3tools/contracts";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+const parseSimlockDeviceHostDraft = Schema.decodeUnknownOption(SimlockDeviceHostConfig);
+
+export const newSimlockDeviceHost = (id: string): SimlockDeviceHostConfigType => ({
+  kind: "simlock",
+  id,
+  label: "Simlock",
+  gatewayUrl: "",
+  agentToken: "",
+  maxLeases: 2,
+  maxLeaseMinutes: 60,
+});
+
+/** Adds, replaces, or removes one Simlock host. */
+export function updateSimlockDeviceHosts(
+  hosts: ReadonlyArray<SimlockDeviceHostConfigType>,
+  host: SimlockDeviceHostConfigType,
+  remove: boolean,
+): ReadonlyArray<SimlockDeviceHostConfigType> {
+  if (remove) return hosts.filter((candidate) => candidate.id !== host.id);
+  return hosts.some((candidate) => candidate.id === host.id)
+    ? hosts.map((candidate) => (candidate.id === host.id ? host : candidate))
+    : [...hosts, host];
+}
+
+/** Why the shared fields keep a draft from saving, or null; tokens are checked per environment. */
+export function simlockDeviceHostProblem(host: SimlockDeviceHostConfigType): string | null {
+  const withToken = { ...host, agentToken: "token" };
+  if (Option.isSome(parseSimlockDeviceHostDraft(withToken))) return null;
+  if (!host.label.trim()) return "Give the host a label.";
+  // With in-range limits, a draft that still fails has a bad gateway URL.
+  return Option.isNone(
+    parseSimlockDeviceHostDraft({ ...withToken, maxLeases: 1, maxLeaseMinutes: 60 }),
+  )
+    ? "Enter the gateway's origin, such as https://gateway.example.ts.net:4700."
+    : "Keep the limits within the ranges shown.";
+}
+
+export function simlockLeaseLimits(host: SimlockDeviceHostConfigType) {
+  const devices = host.maxLeases === 1 ? "1 device" : `${host.maxLeases} devices`;
+  return `Up to ${devices} at once, each released after ${host.maxLeaseMinutes} min`;
+}
+
+export interface SimlockHostEnvironment {
+  readonly environmentId: EnvironmentId;
+  readonly label: string;
+  readonly hosts: ReadonlyArray<SimlockDeviceHostConfigType>;
+}
+
+/** A token field: the environment's saved token, a replacement, or none. */
+export type SimlockTokenEntry =
+  | { kind: "saved" }
+  | { kind: "new"; value: string }
+  | { kind: "cleared" };
+
+/**
+ * The host list each environment saves: the shared fields everywhere, and each environment's own
+ * token, which may stay blank until later. Saved tokens arrive redacted; sending one back keeps it.
+ */
+export function planSimlockDeviceHostSave(
+  environments: ReadonlyArray<SimlockHostEnvironment>,
+  draft: SimlockDeviceHostConfigType,
+  tokens: ReadonlyMap<EnvironmentId, SimlockTokenEntry>,
+):
+  | { readonly problem: string }
+  | {
+      readonly patches: ReadonlyArray<{
+        environmentId: EnvironmentId;
+        hosts: ReadonlyArray<SimlockDeviceHostConfigType>;
+      }>;
+    } {
+  const shared = simlockDeviceHostProblem(draft);
+  if (shared) return { problem: shared };
+  const patches = [];
+  for (const environment of environments) {
+    const saved = environment.hosts.find((host) => host.id === draft.id)?.agentToken ?? "";
+    const entry = tokens.get(environment.environmentId) ?? { kind: "cleared" };
+    const agentToken =
+      entry.kind === "saved" ? saved : entry.kind === "new" ? entry.value.trim() : "";
+    patches.push({
+      environmentId: environment.environmentId,
+      hosts: updateSimlockDeviceHosts(environment.hosts, { ...draft, agentToken }, false),
+    });
+  }
+  return { patches };
+}
diff --git a/apps/web/src/components/settings/updateTrackSwitch.logic.test.ts b/apps/web/src/components/settings/updateTrackSwitch.logic.test.ts
new file mode 100644
index 0000000000000..63c4422f28a64
--- /dev/null
+++ b/apps/web/src/components/settings/updateTrackSwitch.logic.test.ts
@@ -0,0 +1,76 @@
+import type { DesktopUpdateChannel, DesktopUpdateState } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import { prepareLocalTrackSwitch } from "./updateTrackSwitch.logic";
+
+const STABLE = "0.1.3";
+
+/** Like the desktop app, saving a track re-checks the feed and reports what it offers. */
+function fakeBridge(offer: string | null | Error) {
+  const saved: DesktopUpdateChannel[] = [];
+  const base: DesktopUpdateState = {
+    enabled: true,
+    status: "up-to-date",
+    channel: "nightly",
+    currentVersion: "0.1.4-nightly.20261027.3796",
+    hostArch: "x64",
+    appArch: "x64",
+    runningUnderArm64Translation: false,
+    availableVersion: null,
+    downloadedVersion: null,
+    releaseNotes: [],
+    omittedReleaseCount: 0,
+    downloadPercent: null,
+    checkedAt: null,
+    message: null,
+    errorContext: null,
+    canRetry: false,
+  };
+  return {
+    saved,
+    bridge: {
+      setUpdateChannel: async (channel: DesktopUpdateChannel) => {
+        saved.push(channel);
+        if (offer instanceof Error) throw offer;
+        return {
+          ...base,
+          channel,
+          status: offer === null ? ("up-to-date" as const) : ("available" as const),
+          availableVersion: offer,
+        };
+      },
+    },
+  };
+}
+
+const prepare = (bridge: ReturnType<typeof fakeBridge>["bridge"], reinstall = true) =>
+  prepareLocalTrackSwitch(bridge, { channel: "latest", version: STABLE, reinstall });
+
+describe("prepareLocalTrackSwitch", () => {
+  it("installs the checked release or a newer one on the track, never an older one", async () => {
+    expect(await prepare(fakeBridge(STABLE).bridge)).toMatchObject({ ok: true });
+    // A newer Stable knows every migration the checked one does.
+    expect(await prepare(fakeBridge("0.1.4").bridge)).toMatchObject({ ok: true });
+
+    const stale = fakeBridge("0.1.2");
+    expect(await prepare(stale.bridge)).toEqual({
+      ok: false,
+      message: "This app found 0.1.2, which is older than 0.1.3. Try again in a few minutes.",
+    });
+    // The saved track is intent; "Switch them" retries without re-picking it.
+    expect(stale.saved).toEqual(["latest"]);
+  });
+
+  it("reports a track that could not be saved", async () => {
+    expect(await prepare(fakeBridge(new Error("feed check failed")).bridge)).toEqual({
+      ok: false,
+      message: "feed check failed",
+    });
+  });
+
+  it("only saves the track when this app is already on it", async () => {
+    const undo = fakeBridge(null);
+    expect(await prepare(undo.bridge, false)).toEqual({ ok: true, local: null });
+    expect(undo.saved).toEqual(["latest"]);
+  });
+});
diff --git a/apps/web/src/components/settings/updateTrackSwitch.logic.ts b/apps/web/src/components/settings/updateTrackSwitch.logic.ts
new file mode 100644
index 0000000000000..6e7e49898df0b
--- /dev/null
+++ b/apps/web/src/components/settings/updateTrackSwitch.logic.ts
@@ -0,0 +1,50 @@
+import type { DesktopBridge, DesktopUpdateChannel, DesktopUpdateState } from "@t3tools/contracts";
+import { acceptsTrackSwitchRelease } from "@t3tools/shared/cliRelease";
+
+type TrackSwitchBridge = Pick<DesktopBridge, "setUpdateChannel">;
+
+/** Saves the track, then, when this app must reinstall, finds a build the database check covers.
+ * The saved track is the user's intent and stays even when no such build is ready yet: a track
+ * saved toward Stable never offers an older build outside a guarded switch, and "Switch them"
+ * retries. Saving when nothing reinstalls lets picking the old track undo a partial switch. */
+export async function prepareLocalTrackSwitch(
+  bridge: TrackSwitchBridge,
+  input: {
+    readonly channel: DesktopUpdateChannel;
+    readonly version: string;
+    readonly reinstall: boolean;
+  },
+): Promise<
+  | { readonly ok: true; readonly local: DesktopUpdateState | null }
+  | { readonly ok: false; readonly message: string }
+> {
+  let local: DesktopUpdateState;
+  try {
+    // A build on another track re-checks the feed, older releases allowed down to the checked one.
+    local = await bridge.setUpdateChannel(
+      input.channel,
+      input.reinstall ? input.version : undefined,
+    );
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : "The update track did not change.",
+    };
+  }
+  if (!input.reinstall) return { ok: true, local: null };
+  const found = local.downloadedVersion ?? local.availableVersion;
+  if (
+    (local.status === "available" || local.status === "downloaded") &&
+    found !== null &&
+    acceptsTrackSwitchRelease(found, input.channel, input.version)
+  ) {
+    return { ok: true, local };
+  }
+  return {
+    ok: false,
+    message:
+      found !== null
+        ? `This app found ${found}, which is older than ${input.version}. Try again in a few minutes.`
+        : (local.message ?? `This app found no build of ${input.version} to install.`),
+  };
+}
diff --git a/apps/web/src/components/sidebar/SidebarChrome.tsx b/apps/web/src/components/sidebar/SidebarChrome.tsx
index ec161e9998548..e233a4144d435 100644
--- a/apps/web/src/components/sidebar/SidebarChrome.tsx
+++ b/apps/web/src/components/sidebar/SidebarChrome.tsx
@@ -223,19 +223,15 @@ const SidebarUtilityMenu = memo(function SidebarUtilityMenu() {
           />
         </>
       )}
+      <SidebarThreadUndoNotice />
       <SidebarUpdatePill />
     </SidebarMenu>
   );
 });
 
-export const SidebarChromeFooter = memo(function SidebarChromeFooter({
-  showUndoNotice = false,
-}: {
-  showUndoNotice?: boolean;
-}) {
+export const SidebarChromeFooter = memo(function SidebarChromeFooter() {
   return (
     <SidebarFooter>
-      {showUndoNotice ? <SidebarThreadUndoNotice /> : null}
       <SidebarProviderUpdatePill />
       <SidebarUpdateArchitectureWarning />
       <SidebarUtilityMenu />
diff --git a/apps/web/src/components/sidebar/SidebarListMarkers.tsx b/apps/web/src/components/sidebar/SidebarListMarkers.tsx
index 30a6776837eeb..104bda5582b4d 100644
--- a/apps/web/src/components/sidebar/SidebarListMarkers.tsx
+++ b/apps/web/src/components/sidebar/SidebarListMarkers.tsx
@@ -1,7 +1,7 @@
 import { CollapsibleSectionHeader } from "../ui/collapsible-section-header";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
-import { type ReactNode } from "react";
+import { type ReactNode, useLayoutEffect } from "react";
 import { cn } from "~/lib/utils";
 import {
   animateSidebarLayoutChanges,
@@ -9,19 +9,25 @@ import {
   type SidebarListMarker,
 } from "../Sidebar.logic";
 import { SIDEBAR_SORTABLE_DRAG_DISABLED } from "./SidebarThreadRow";
-import { SidebarThreadUndoNotice } from "./SidebarThreadUndoNotice";
 
 function SortableSidebarMarker(props: {
   marker: SidebarListMarker;
   className?: string;
   children?: ReactNode;
+  revealOverflow?: boolean;
   "data-testid"?: string;
 }) {
-  const { setNodeRef, transform, transition } = useSortable({
+  const { node, setNodeRef, transform, transition } = useSortable({
     id: sidebarMarkerId(props.marker),
     disabled: SIDEBAR_SORTABLE_DRAG_DISABLED,
     animateLayoutChanges: animateSidebarLayoutChanges,
   });
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- keeps the projected drop box inside the scroll viewport as drag transforms move it
+  useLayoutEffect(() => {
+    if (props.revealOverflow && transform?.y !== undefined) {
+      node.current?.firstElementChild?.scrollIntoView({ block: "nearest", inline: "nearest" });
+    }
+  }, [node, props.revealOverflow, transform?.y]);
   return (
     <li
       ref={setNodeRef}
@@ -50,6 +56,7 @@ export function SidebarSectionPlaceholder(props: {
       marker={props.marker}
       data-testid={`sidebar-${props.marker}`}
       className="relative mx-0.5 -mb-px h-0"
+      revealOverflow={props.marker === "settled-placeholder" && props.showHint}
     >
       {props.showHint ? (
         <div
@@ -109,8 +116,6 @@ export function SidebarSectionHeader(props: {
   dragging?: boolean;
   isDropTarget?: boolean;
   toggle: { expanded: boolean; onToggle: () => void };
-  /** The first shelf at the bottom of the list hosts the undo notice just above itself. */
-  hostsUndoNotice?: boolean;
 }) {
   const shelf =
     props.marker === "working-header"
@@ -124,9 +129,6 @@ export function SidebarSectionHeader(props: {
       data-testid={`sidebar-${props.marker}`}
       className={cn("relative mx-0.5 h-8", props.className)}
     >
-      {props.hostsUndoNotice ? (
-        <SidebarThreadUndoNotice className="absolute inset-x-0 bottom-full bg-sidebar surface-grain" />
-      ) : null}
       <CollapsibleSectionHeader
         role="treeitem"
         tabIndex={-1}
diff --git a/apps/web/src/components/sidebar/SidebarThreadUndoNotice.tsx b/apps/web/src/components/sidebar/SidebarThreadUndoNotice.tsx
index 72b5754a1936d..9cf7dc9e2ef53 100644
--- a/apps/web/src/components/sidebar/SidebarThreadUndoNotice.tsx
+++ b/apps/web/src/components/sidebar/SidebarThreadUndoNotice.tsx
@@ -3,18 +3,24 @@ import { useState } from "react";
 
 import {
   threadUndoLabel,
-  threadUndoNoticeSummary,
   undoLatestThreadAction,
   useThreadUndoNotice,
 } from "../../hooks/showThreadUndoNotice";
 import { cn } from "../../lib/utils";
 import { primaryServerKeybindingsAtom } from "../../state/server";
 import { InlineButton } from "../ui/button";
+import { SidebarMenuItem } from "../ui/sidebar";
 
-export function SidebarThreadUndoNotice({ className }: { className?: string }) {
+/** Fills the free space in the sidebar footer's utility row, so it never moves or covers the list. */
+export function SidebarThreadUndoNotice() {
   const notice = useThreadUndoNotice((state) => state.notice);
   const keybindings = useAtomValue(primaryServerKeybindingsAtom);
-  const summary = notice ? threadUndoNoticeSummary(notice) : null;
+  // Short enough to fit beside the utility icons; screen readers hear the full summary.
+  const summary = notice
+    ? notice.count === 1
+      ? notice.action
+      : `${notice.action} ${notice.count}`
+    : null;
 
   // Keeps the last text on screen while it fades out, then unmounts on transitionend.
   const [shownSummary, setShownSummary] = useState(summary);
@@ -23,21 +29,23 @@ export function SidebarThreadUndoNotice({ className }: { className?: string }) {
   if (!text) return null;
 
   return (
-    <div
-      role="group"
-      aria-hidden={!summary}
-      inert={!summary}
-      onTransitionEnd={(event) => {
-        if (!summary && event.target === event.currentTarget) setShownSummary(null);
-      }}
-      className={cn(
-        "flex gap-1 px-2 text-2xs leading-6 text-sidebar-muted-foreground transition-opacity duration-200 ease-out starting:opacity-0",
-        !summary && "opacity-0",
-        className,
-      )}
-    >
-      <span className="min-w-0 truncate">{text},</span>
-      <InlineButton onClick={undoLatestThreadAction}>{threadUndoLabel(keybindings)}</InlineButton>
-    </div>
+    // No min-w-0: the undo button sets this item's minimum, so a shared row squeezes its neighbour.
+    <SidebarMenuItem className="flex flex-1" aria-hidden={!summary} inert={!summary}>
+      <div
+        onTransitionEnd={(event) => {
+          if (!summary && event.target === event.currentTarget) setShownSummary(null);
+        }}
+        // Reversed wrap: a summary that does not fit beside the undo button drops to a
+        // second line that overflow hides, instead of truncating mid-word. Browse mode
+        // reads the button first; the live announcement carries the full sentence.
+        className={cn(
+          "flex h-6 min-w-0 flex-1 flex-row-reverse flex-wrap gap-x-1 overflow-hidden text-2xs leading-6 whitespace-nowrap text-sidebar-muted-foreground transition-opacity duration-200 ease-out starting:opacity-0",
+          !summary && "opacity-0",
+        )}
+      >
+        <InlineButton onClick={undoLatestThreadAction}>{threadUndoLabel(keybindings)}</InlineButton>
+        <span>{text},</span>
+      </div>
+    </SidebarMenuItem>
   );
 }
diff --git a/apps/web/src/components/sidebar/SidebarUpdatePill.browser.test.tsx b/apps/web/src/components/sidebar/SidebarUpdatePill.browser.test.tsx
index 714d1564bac0a..18ebd70c6162c 100644
--- a/apps/web/src/components/sidebar/SidebarUpdatePill.browser.test.tsx
+++ b/apps/web/src/components/sidebar/SidebarUpdatePill.browser.test.tsx
@@ -81,7 +81,7 @@ function publish(update: DesktopUpdateState | null) {
   });
 }
 
-const releaseNotes = () => document.querySelector('[aria-label="Nightly update release notes"]');
+const releaseNotes = () => document.querySelector('[aria-label="Update release notes"]');
 
 describe("SidebarUpdatePill release notes", () => {
   it("closes when the release notes stop applying", async () => {
diff --git a/apps/web/src/components/sidebar/SidebarUpdatePill.tsx b/apps/web/src/components/sidebar/SidebarUpdatePill.tsx
index ecfeb4d664a3b..7e0ee498cece5 100644
--- a/apps/web/src/components/sidebar/SidebarUpdatePill.tsx
+++ b/apps/web/src/components/sidebar/SidebarUpdatePill.tsx
@@ -53,7 +53,7 @@ function shouldUseSidebarUpdateReleaseNotesPopover(
   showUpdateDetails: boolean,
   state: DesktopUpdateState | null,
 ): boolean {
-  return showUpdateDetails && state?.channel === "nightly" && state.releaseNotes.length > 0;
+  return showUpdateDetails && (state?.releaseNotes.length ?? 0) > 0;
 }
 
 function handleSidebarUpdateReleaseNotesPopoverOpenChange(
@@ -134,7 +134,7 @@ const toastUpdateError: ReportLocalUpdateError = (title, description) => {
   toastManager.add(stackedThreadToast({ type: "error", title, description }));
 };
 
-async function downloadLocalUpdate(
+export async function downloadLocalUpdate(
   bridge: DesktopBridge,
   {
     notifyDownloaded,
@@ -160,12 +160,13 @@ async function downloadLocalUpdate(
   }
 }
 
-async function installLocalUpdate(
+export async function installLocalUpdate(
   bridge: DesktopBridge,
   reportError: ReportLocalUpdateError = toastUpdateError,
+  expectedVersion?: string,
 ): Promise<boolean> {
   try {
-    const result = await bridge.installUpdate();
+    const result = await bridge.installUpdate(expectedVersion);
     if (!result.accepted) {
       showDesktopUpdateDownloadedToast(bridge, result.state);
       return false;
@@ -541,7 +542,7 @@ function SidebarUpdateControl() {
         {showReleaseNotesPopover && state ? (
           <PopoverPopup
             align="center"
-            aria-label="Nightly update release notes"
+            aria-label="Update release notes"
             initialFocus={false}
             onKeyDownCapture={(event) => {
               if (
diff --git a/apps/web/src/components/sidebar/SidebarUpdateReleaseNotes.tsx b/apps/web/src/components/sidebar/SidebarUpdateReleaseNotes.tsx
index b9f29741bfa63..974f81c8d76b3 100644
--- a/apps/web/src/components/sidebar/SidebarUpdateReleaseNotes.tsx
+++ b/apps/web/src/components/sidebar/SidebarUpdateReleaseNotes.tsx
@@ -5,8 +5,8 @@ import {
   getDesktopUpdateReleaseHistoryUrl,
   getDesktopUpdateReleaseUrl,
 } from "../desktopUpdate.logic";
+import { formatRelativeTimeLabel } from "../../timestampFormat";
 import { openDesktopUpdateReleaseNotes } from "../desktopUpdate.toast";
-import { Separator } from "../ui/separator";
 
 type DesktopUpdateShell = Pick<DesktopBridge, "openExternal">;
 
@@ -19,6 +19,18 @@ function keyReleaseNoteItems(items: ReadonlyArray<string>) {
   });
 }
 
+/** Feed times read "3h ago"; build days from a prerelease version read "today" or "2d ago". */
+function formatReleaseAge(releasedAt: string): string {
+  const day = /^(\d{4})-(\d{2})-(\d{2})$/.exec(releasedAt);
+  if (!day) return formatRelativeTimeLabel(releasedAt);
+  const now = new Date();
+  const today = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+  const days = Math.round(
+    (today - Date.UTC(Number(day[1]), Number(day[2]) - 1, Number(day[3]))) / 86_400_000,
+  );
+  return days <= 0 ? "today" : `${days}d ago`;
+}
+
 function ReleaseLink({
   children,
   releaseUrl,
@@ -30,7 +42,7 @@ function ReleaseLink({
 }) {
   return (
     <a
-      className="mt-2 inline-flex items-center gap-1 rounded-sm text-xs leading-5 text-muted-foreground underline decoration-dotted underline-offset-4 outline-none transition-colors hover:text-foreground focus-visible:text-foreground focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+      className="mt-1 inline-flex items-center gap-1 rounded-sm text-xs leading-5 text-muted-foreground underline-offset-2 outline-none transition-colors hover:text-foreground hover:underline focus-visible:text-foreground focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
       href={releaseUrl}
       onClick={(event) => {
         event.preventDefault();
@@ -38,7 +50,7 @@ function ReleaseLink({
       }}
     >
       {children}
-      <ExternalLinkIcon aria-hidden className="size-3 shrink-0" strokeWidth={2.25} />
+      <ExternalLinkIcon aria-hidden className="size-3 shrink-0" strokeWidth={2} />
     </a>
   );
 }
@@ -52,12 +64,15 @@ export function SidebarUpdateReleaseNotes({
   readonly state: DesktopUpdateState;
   readonly tooltip: string;
 }) {
-  if (state.channel !== "nightly" || state.releaseNotes.length === 0) {
+  if (state.releaseNotes.length === 0) {
     return <>{tooltip}</>;
   }
+  const releasedAt = state.releaseNotes.find(
+    (releaseNote) => releaseNote.version === state.availableVersion,
+  )?.releasedAt;
 
   return (
-    <div className="flex max-h-[calc(var(--available-height)-0.5rem)] min-h-0 w-fit max-w-[min(24rem,calc(100vw-2rem))] flex-col text-left">
+    <div className="flex max-h-[calc(var(--available-height)-0.5rem)] min-h-0 w-fit max-w-[min(24rem,calc(100vw-2rem))] flex-col text-left text-pretty">
       <div className="shrink-0 px-1">
         {state.status === "available" ? (
           <div>
@@ -66,7 +81,9 @@ export function SidebarUpdateReleaseNotes({
             </div>
             {state.availableVersion ? (
               <div className="mt-0.5 text-xs leading-4 text-muted-foreground">
-                {state.availableVersion}
+                {releasedAt
+                  ? `${state.availableVersion} · ${formatReleaseAge(releasedAt)}`
+                  : state.availableVersion}
               </div>
             ) : null}
           </div>
@@ -74,18 +91,40 @@ export function SidebarUpdateReleaseNotes({
           <div className="text-sm leading-5 font-medium">{tooltip}</div>
         )}
       </div>
-      <div className="min-h-0 max-h-[min(28rem,calc(100vh-6rem))] overflow-y-auto px-1 pt-4 pb-1">
+      <div className="min-h-0 max-h-[min(28rem,calc(100vh-6rem))] overflow-y-auto px-1 pt-3 pb-1">
         {state.releaseNotes.map((releaseNote, index) => {
           const releaseUrl = getDesktopUpdateReleaseUrl(releaseNote.version);
           const omittedItemCount = Math.max(0, releaseNote.totalItems - releaseNote.items.length);
           const linkLabel =
-            omittedItemCount === 0
+            releaseNote.stats ??
+            (omittedItemCount === 0
               ? "View release on GitHub"
-              : `${omittedItemCount} more ${omittedItemCount === 1 ? "change" : "changes"} on GitHub`;
+              : `${omittedItemCount} more ${omittedItemCount === 1 ? "change" : "changes"} on GitHub`);
+
+          if (releaseNote.intro !== undefined) {
+            return (
+              <section className={index > 0 ? "mt-4" : undefined} key={releaseNote.version}>
+                {releaseNote.version !== state.availableVersion ? (
+                  <h3 className="mb-1 text-xs leading-4 font-medium text-muted-foreground">
+                    {releaseNote.releasedAt
+                      ? `${releaseNote.version} · ${formatReleaseAge(releaseNote.releasedAt)}`
+                      : releaseNote.version}
+                  </h3>
+                ) : null}
+                <p className="break-words text-xs leading-5 text-popover-foreground">
+                  {releaseNote.intro}
+                </p>
+                {releaseUrl ? (
+                  <ReleaseLink releaseUrl={releaseUrl} shell={shell}>
+                    {releaseNote.stats ?? "View release on GitHub"}
+                  </ReleaseLink>
+                ) : null}
+              </section>
+            );
+          }
 
           return (
-            <div key={releaseNote.version}>
-              {index > 0 && <Separator className="my-3" />}
+            <div className={index > 0 ? "mt-4" : undefined} key={releaseNote.version}>
               <section>
                 <h3 className="text-foreground text-xs leading-4 font-semibold">
                   {index === 0 ? "What's changed" : `Changes in ${releaseNote.version}`}
@@ -107,8 +146,7 @@ export function SidebarUpdateReleaseNotes({
           );
         })}
         {state.omittedReleaseCount > 0 ? (
-          <div>
-            <Separator className="my-3" />
+          <div className="mt-3">
             <ReleaseLink releaseUrl={getDesktopUpdateReleaseHistoryUrl()} shell={shell}>
               {`${state.omittedReleaseCount} older ${state.omittedReleaseCount === 1 ? "release" : "releases"} on GitHub`}
             </ReleaseLink>
diff --git a/apps/web/src/components/sidebar/UpdateEverythingDialog.tsx b/apps/web/src/components/sidebar/UpdateEverythingDialog.tsx
index 8cd5c5ca777d5..9bf101b6fa4e7 100644
--- a/apps/web/src/components/sidebar/UpdateEverythingDialog.tsx
+++ b/apps/web/src/components/sidebar/UpdateEverythingDialog.tsx
@@ -47,6 +47,14 @@ interface UpdateEverythingDialogProps {
   readonly rows: ReadonlyArray<UpdateEverythingRow>;
   readonly restarts: ReadonlyArray<RestartingMachine>;
   readonly onConfirm: () => void;
+  /** Overrides the "Update N machines?" title, for an update-track switch. */
+  readonly title?: string;
+  readonly confirmLabel?: string;
+  readonly notes?: ReadonlyArray<string>;
+  /** Shown in place of running-thread counts; disables the confirm button. */
+  readonly disabledReason?: string | null;
+  /** The confirmed work is starting; it cannot be cancelled from here. */
+  readonly busy?: boolean;
 }
 
 type UpdateEverythingDialogContentProps = Omit<
@@ -89,6 +97,11 @@ function UpdateEverythingDialogContent({
   restarts,
   onConfirm,
   cancelRef,
+  title,
+  confirmLabel = "Update",
+  notes = [],
+  disabledReason = null,
+  busy = false,
 }: UpdateEverythingDialogContentProps) {
   const stopped = useAtomValue(
     runningThreadCountAtom(
@@ -116,7 +129,7 @@ function UpdateEverythingDialogContent({
     <>
       <AlertDialogHeader className="shrink-0">
         <AlertDialogTitle>
-          Update {updating.length} {updating.length === 1 ? "machine" : "machines"}?
+          {title ?? `Update ${updating.length} ${updating.length === 1 ? "machine" : "machines"}?`}
         </AlertDialogTitle>
         <AlertDialogDescription>
           {version !== null ? (
@@ -132,6 +145,11 @@ function UpdateEverythingDialogContent({
       </AlertDialogHeader>
       <ScrollArea scrollFade>
         <div className="flex flex-col gap-3 px-6 pb-4">
+          {notes.map((note) => (
+            <p key={note} className="text-muted-foreground text-sm">
+              {note}
+            </p>
+          ))}
           {/* Machine names truncate first. Provider lists wrap between names, never inside one. */}
           <div className="grid grid-cols-[minmax(4rem,max-content)_max-content_minmax(min-content,1fr)_max-content] gap-x-4 text-sm">
             <div className="col-span-full grid grid-cols-subgrid border-b pb-1.5 text-muted-foreground text-xs">
@@ -196,7 +214,11 @@ function UpdateEverythingDialogContent({
         </div>
       </ScrollArea>
       <AlertDialogFooter>
-        {running > 0 ? (
+        {disabledReason !== null ? (
+          <p className="self-center text-sm max-sm:order-1 max-sm:text-center sm:mr-auto">
+            {disabledReason}
+          </p>
+        ) : running > 0 ? (
           <p className="self-center text-muted-foreground text-sm max-sm:order-1 max-sm:text-center sm:mr-auto">
             {stopped === 0
               ? `${threads} will be interrupted and can resume after the restart.`
@@ -205,10 +227,12 @@ function UpdateEverythingDialogContent({
                 : `${threads} will be interrupted. ${continuing} can resume after the restart.`}
           </p>
         ) : null}
-        <AlertDialogClose ref={cancelRef} render={<Button variant="outline" />}>
+        <AlertDialogClose ref={cancelRef} render={<Button variant="outline" disabled={busy} />}>
           Cancel
         </AlertDialogClose>
-        <Button onClick={onConfirm}>Update</Button>
+        <Button disabled={disabledReason !== null || busy} onClick={onConfirm}>
+          {confirmLabel}
+        </Button>
       </AlertDialogFooter>
     </>
   );
diff --git a/apps/web/src/components/sidebar/updateEverything.logic.test.ts b/apps/web/src/components/sidebar/updateEverything.logic.test.ts
index 3739308f7b1c7..62aef93572c4d 100644
--- a/apps/web/src/components/sidebar/updateEverything.logic.test.ts
+++ b/apps/web/src/components/sidebar/updateEverything.logic.test.ts
@@ -2,8 +2,11 @@ import { EnvironmentId, type ServerSelfUpdateCapability } from "@t3tools/contrac
 import { describe, expect, it } from "vite-plus/test";
 
 import {
+  collectChannelSwitchTargets,
   collectRestartingMachines,
+  localSwitchBlockReason,
   collectServerUpdateTargets,
+  describeUpdateCapsule,
   describeUpdateEverything,
   runUpdateEverything,
   type UpdateEverythingMachine,
@@ -27,7 +30,9 @@ function machine(
         capabilities: {
           repositoryIdentity: true,
           ...(selfUpdate ? { serverSelfUpdate: selfUpdate } : {}),
-          ...(selfUpdate === "desktop-managed" ? { desktopAppUpdate: true } : {}),
+          ...(selfUpdate === "desktop-managed"
+            ? { desktopAppUpdate: true, desktopAppChannelSwitch: true }
+            : {}),
         },
       },
       settings: { continueThreadsAfterServerUpdate: false },
@@ -64,6 +69,7 @@ describe("collectServerUpdateTargets", () => {
         machine("manual", "0.0.40", undefined),
       ],
       "0.0.50",
+      true,
     );
 
     expect(targets.map((target) => [target.serverLabel, target.targetVersion])).toEqual([
@@ -79,6 +85,154 @@ describe("collectServerUpdateTargets", () => {
       ["manual", "needs a manual update"],
     ]);
   });
+
+  it("waits for npm only for hosts that install from it or when the release may lack archives", () => {
+    const hosts = [
+      machine("archive-service", "0.0.41-nightly.20260914.1700", "boot-service"),
+      machine("npm-service", "0.0.41-nightly.20260914.1699", "boot-service"),
+      machine("legacy-respawn", "0.1.4-nightly.20261027.3796", "respawn"),
+      machine("desktop", "0.1.4-nightly.20261027.3796", "desktop-managed"),
+    ];
+    const waits = (releaseArchivesPublished: boolean) =>
+      collectServerUpdateTargets(
+        hosts,
+        "0.1.5-nightly.20261029.3873",
+        releaseArchivesPublished,
+      ).waitForNpm.map((target) => target.serverLabel);
+
+    expect(waits(true)).toEqual(["npm-service", "legacy-respawn"]);
+    expect(waits(false)).toEqual(["archive-service", "npm-service", "legacy-respawn"]);
+  });
+});
+
+describe("collectChannelSwitchTargets", () => {
+  const NIGHTLY = "0.1.4-nightly.20261027.3796";
+  const OLD_NIGHTLY = "0.1.3-nightly.20261001.3500";
+  const NEWER_NIGHTLY = "0.1.4-nightly.20261020.3700";
+  // What each server reports as its database's highest migration.
+  const host = (
+    base: UpdateEverythingMachine,
+    databaseMigration: number | undefined,
+    os: "linux" | "darwin" = "linux",
+  ): UpdateEverythingMachine => ({
+    ...base,
+    serverConfig: {
+      ...base.serverConfig!,
+      environment: {
+        ...base.serverConfig!.environment,
+        platform: { os, arch: "x64" },
+        ...(databaseMigration === undefined ? {} : { databaseMigration }),
+      },
+    },
+  });
+
+  it("moves nightly hosts to stable only when stable knows their database", () => {
+    const stable = { channel: "latest" as const, version: "0.1.3", databaseMigration: 69 };
+    const { targets, skipped } = collectChannelSwitchTargets(
+      [
+        host(machine("this-app", NIGHTLY, "desktop-managed", { hostedByThisApp: true }), 72),
+        host(machine("old-service", OLD_NIGHTLY, "boot-service"), 69),
+        // Service launchers refuse older versions, even when the database allows it.
+        host(machine("newer-service", NEWER_NIGHTLY, "boot-service"), 69),
+        host(machine("linux-desktop", OLD_NIGHTLY, "desktop-managed"), 69),
+        host(machine("new-service", NIGHTLY, "boot-service"), 72),
+        host(machine("old-server", "0.1.2-nightly.20260901.3000", "boot-service"), undefined),
+        host(machine("mac-desktop", OLD_NIGHTLY, "desktop-managed"), 69, "darwin"),
+        host(machine("preview", "0.1.3-preview.20261026.3702", "boot-service"), 69),
+        host(machine("stable", "0.1.3", "boot-service"), 69),
+        host(machine("stable-desktop", "0.1.2", "desktop-managed"), 68),
+        // Already current, but its saved track may still say Nightly.
+        host(machine("current-desktop", "0.1.3", "desktop-managed"), 69, "darwin"),
+      ],
+      stable,
+    );
+
+    expect(
+      targets.map((target) => [
+        target.serverLabel,
+        target.targetVersion,
+        target.channel,
+        target.trackOnly ?? false,
+      ]),
+    ).toEqual([
+      ["old-service", "0.1.3", undefined, false],
+      ["linux-desktop", "0.1.3", "latest", false],
+      ["stable-desktop", "0.1.3", "latest", false],
+      ["current-desktop", "0.1.3", "latest", true],
+    ]);
+    expect(targets.every((target) => target.targetDatabaseMigration === 69)).toBe(true);
+    expect(skipped.map((entry) => [entry.label, entry.reason])).toEqual([
+      ["newer-service", "run `t3 update --channel stable --allow-downgrade` there"],
+      [
+        "new-service",
+        "its database has changes 0.1.3 does not support yet; stay on Nightly until Stable has them",
+      ],
+      ["old-server", "its server predates database checks; update it on Nightly first"],
+      ["mac-desktop", "switch the Mac app on that Mac"],
+      ["preview", "runs a preview build"],
+    ]);
+  });
+
+  it("moves stable hosts to nightly only when nightly knows their database", () => {
+    const nightly = { channel: "nightly" as const, version: NIGHTLY, databaseMigration: 72 };
+    const { targets, skipped } = collectChannelSwitchTargets(
+      [
+        host(machine("service", "0.1.2", "boot-service"), 70),
+        // A Stable tag built a migration the latest Nightly does not have yet.
+        host(machine("ahead", "0.1.3", "boot-service"), 73),
+        machine("old-desktop", "0.1.2", "desktop-managed", {
+          serverConfig: {
+            ...machine("old-desktop", "0.1.2", "desktop-managed").serverConfig!,
+            environment: {
+              ...machine("old-desktop", "0.1.2", "desktop-managed").serverConfig!.environment,
+              capabilities: { repositoryIdentity: true, serverSelfUpdate: "desktop-managed" },
+            },
+          },
+        }),
+        machine("current", NIGHTLY, "boot-service"),
+      ],
+      nightly,
+    );
+
+    expect(targets.map((target) => [target.serverLabel, target.targetVersion])).toEqual([
+      ["service", NIGHTLY],
+    ]);
+    expect(skipped.map((entry) => [entry.label, entry.reason])).toEqual([
+      [
+        "ahead",
+        `its database has changes ${NIGHTLY} does not support yet; stay on Stable until Nightly has them`,
+      ],
+      ["old-desktop", "needs a newer desktop app"],
+    ]);
+  });
+});
+
+describe("localSwitchBlockReason", () => {
+  it("checks every server this app hosts, and only while connected", () => {
+    const stable = { channel: "latest" as const, version: "0.1.3", databaseMigration: 69 };
+    const nightly = "0.1.4-nightly.20261027.3796";
+
+    const windows = { connected: true, databaseMigration: 69 };
+    expect(localSwitchBlockReason(nightly, stable, [windows], 1)).toBeNull();
+    // A WSL server's newer migration blocks the reinstall that would restart it.
+    expect(
+      localSwitchBlockReason(
+        nightly,
+        stable,
+        [windows, { connected: true, databaseMigration: 72 }],
+        2,
+      ),
+    ).toContain("does not support yet");
+    // A WSL backend still starting has no client entry, so its database is unchecked.
+    expect(localSwitchBlockReason(nightly, stable, [windows], 2)).toBe(
+      "its server is not connected, so its database cannot be checked",
+    );
+    // A cached head from a disconnected server proves nothing.
+    expect(
+      localSwitchBlockReason(nightly, stable, [{ connected: false, databaseMigration: 69 }], 1),
+    ).toBe("its server is not connected, so its database cannot be checked");
+    expect(localSwitchBlockReason("0.1.3", stable, [], 1)).toBeNull();
+  });
 });
 
 describe("collectRestartingMachines", () => {
@@ -177,3 +331,33 @@ describe("describeUpdateEverything", () => {
     ]);
   });
 });
+
+describe("describeUpdateCapsule", () => {
+  it("sends failed track switches back through the planner instead of retrying their target", () => {
+    const failed = {
+      machine: {
+        environmentId: EnvironmentId.make("remote"),
+        label: "remote",
+        updatesProviders: false,
+        server: {
+          environmentId: EnvironmentId.make("remote"),
+          serverLabel: "remote",
+          selfUpdate: "boot-service" as const,
+          targetVersion: "0.1.3",
+        },
+        handedOffVersion: null,
+        startedAt: 0,
+        result: "failed" as const,
+        failure: "offline",
+        providerFailure: null,
+      },
+      status: "failed" as const,
+    };
+    const run = { localVersion: null, phase: "servers" as const, restartAt: null, machines: [] };
+
+    expect(describeUpdateCapsule(run, [failed], null, 0).action).toBe("retry");
+    expect(describeUpdateCapsule({ ...run, trackSwitch: true }, [failed], null, 0).action).toBe(
+      "dismiss",
+    );
+  });
+});
diff --git a/apps/web/src/components/sidebar/updateEverything.logic.ts b/apps/web/src/components/sidebar/updateEverything.logic.ts
index 469e5a0faf674..de21c535f517c 100644
--- a/apps/web/src/components/sidebar/updateEverything.logic.ts
+++ b/apps/web/src/components/sidebar/updateEverything.logic.ts
@@ -1,6 +1,12 @@
 import type { ServerUpdateState } from "@t3tools/client-runtime/state/server";
-import type { EnvironmentId, ServerConfig } from "@t3tools/contracts";
-import { cliReleaseChannelOf } from "@t3tools/shared/cliRelease";
+import type {
+  DesktopUpdateChannel,
+  EnvironmentId,
+  ServerConfig,
+  ServerSelfUpdateCapability,
+} from "@t3tools/contracts";
+import { cliReleaseChannelOf, desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
+import { compareSemverVersions } from "@t3tools/shared/semver";
 
 import {
   resolveServerSelfUpdateCapability,
@@ -57,14 +63,25 @@ export interface SkippedMachine {
   readonly reason: string;
 }
 
+/** Boot services before this build installed the server from npm, not from release archives. */
+const RELEASE_ARCHIVE_SELF_UPDATE_SINCE = "0.0.41-nightly.20260914.1700";
+
 /** Skip current and app-hosted servers; the latter update with the app and would relaunch mid-run.
- * Desktop-managed servers use their own feed. */
+ * Desktop-managed servers use their own feed. `waitForNpm` lists targets that need
+ * `t3@<targetVersion>` on npm first. `releaseArchivesPublished` means the version came from the
+ * desktop feed: its GitHub Release goes public with the CLI archives that boot services download. */
 export function collectServerUpdateTargets(
   machines: ReadonlyArray<UpdateEverythingMachine>,
   targetVersion: string,
-): { readonly targets: ServerUpdateTarget[]; readonly skipped: SkippedMachine[] } {
+  releaseArchivesPublished: boolean,
+): {
+  readonly targets: ServerUpdateTarget[];
+  readonly skipped: SkippedMachine[];
+  readonly waitForNpm: ServerUpdateTarget[];
+} {
   const targets: ServerUpdateTarget[] = [];
   const skipped: SkippedMachine[] = [];
+  const waitForNpm: ServerUpdateTarget[] = [];
   for (const machine of machines) {
     const config = machine.serverConfig;
     if (machine.hostedByThisApp) continue;
@@ -76,16 +93,9 @@ export function collectServerUpdateTargets(
     }
     const skip = (reason: string) =>
       skipped.push({ environmentId: machine.environmentId, label: machine.label, reason });
-    if (config === null || !machine.connected) {
-      skip("not connected");
-      continue;
-    }
-    if (!machine.canMaintain) {
-      skip("no permission");
-      continue;
-    }
-    if (machine.updateState.status === "running") {
-      skip("already updating");
+    const unavailable = unavailableReason(machine);
+    if (config === null || unavailable !== null) {
+      skip(unavailable ?? "not connected");
       continue;
     }
     const selfUpdate = resolveServerSelfUpdateCapability(config);
@@ -106,18 +116,213 @@ export function collectServerUpdateTargets(
       skip(`on the ${cliReleaseChannelOf(serverVersion)} channel`);
       continue;
     }
-    targets.push({
+    const target: ServerUpdateTarget = {
       environmentId: machine.environmentId,
       serverLabel: machine.label,
       selfUpdate,
       installation: config.environment.capabilities.serverInstallation,
       desktopAppUpdate,
       targetVersion,
+    };
+    targets.push(target);
+    if (
+      selfUpdate !== "desktop-managed" &&
+      (!releaseArchivesPublished ||
+        selfUpdate === "respawn" ||
+        compareSemverVersions(serverVersion, RELEASE_ARCHIVE_SELF_UPDATE_SINCE) < 0)
+    ) {
+      waitForNpm.push(target);
+    }
+  }
+  return { targets, skipped, waitForNpm };
+}
+
+function unavailableReason(machine: UpdateEverythingMachine): string | null {
+  if (machine.serverConfig === null || !machine.connected) return "not connected";
+  if (!machine.canMaintain) return "no permission";
+  if (machine.updateState.status === "running") return "already updating";
+  return null;
+}
+
+/** The latest release on the track a fleet switches to, as npm reports it. */
+export interface ChannelSwitchRelease {
+  readonly channel: DesktopUpdateChannel;
+  readonly version: string;
+  readonly databaseMigration: number | undefined;
+}
+
+export const channelSwitchLabel = (channel: DesktopUpdateChannel) =>
+  channel === "nightly" ? "Nightly" : "Stable";
+
+/** Stable and Nightly each build their own commits, so either can hold migrations the other lacks.
+ * Crossing tracks needs proof that the target release knows every migration the database holds. */
+const crossesTrack = (fromVersion: string, release: ChannelSwitchRelease) =>
+  desktopUpdateChannelOf(fromVersion) !== release.channel;
+
+function channelSwitchBlockReason(
+  fromVersion: string,
+  release: ChannelSwitchRelease,
+  currentMigration: number | undefined,
+): string | null {
+  if (!crossesTrack(fromVersion, release)) return null;
+  const from = channelSwitchLabel(desktopUpdateChannelOf(fromVersion));
+  // Servers and releases from before this check report no migration number.
+  if (currentMigration === undefined) {
+    return `its server predates database checks; update it on ${from} first`;
+  }
+  if (release.databaseMigration === undefined) {
+    return `${release.version} predates database checks; wait for a newer ${channelSwitchLabel(release.channel)} release`;
+  }
+  return currentMigration > release.databaseMigration
+    ? `its database has changes ${release.version} does not support yet; stay on ${from} until ${channelSwitchLabel(release.channel)} has them`
+    : null;
+}
+
+/** This app's reinstall restarts every server it hosts, so each of their databases must allow the
+ * switch. `backendCount` is the desktop's own inventory: a backend still starting has no client
+ * entry yet. A cached config can outlive its connection, so only a connected server's head counts. */
+export function localSwitchBlockReason(
+  appVersion: string,
+  release: ChannelSwitchRelease,
+  hosted: ReadonlyArray<{
+    readonly connected: boolean;
+    readonly databaseMigration: number | undefined;
+  }>,
+  backendCount: number,
+): string | null {
+  if (!crossesTrack(appVersion, release)) return null;
+  if (
+    hosted.length === 0 ||
+    hosted.length < backendCount ||
+    hosted.some((server) => !server.connected)
+  ) {
+    return "its server is not connected, so its database cannot be checked";
+  }
+  return (
+    hosted
+      .map((server) => channelSwitchBlockReason(appVersion, release, server.databaseMigration))
+      .find((reason) => reason !== null) ?? null
+  );
+}
+
+/** Servers move to the release; desktop-managed hosts reinstall their app on its track. A desktop
+ * host already current gets a track-only request, since its saved track may still differ. */
+export function collectChannelSwitchTargets(
+  machines: ReadonlyArray<UpdateEverythingMachine>,
+  release: ChannelSwitchRelease,
+): { readonly targets: ServerUpdateTarget[]; readonly skipped: SkippedMachine[] } {
+  const targets: ServerUpdateTarget[] = [];
+  const skipped: SkippedMachine[] = [];
+  for (const machine of machines) {
+    const config = machine.serverConfig;
+    if (machine.hostedByThisApp) continue;
+    const skip = (reason: string) =>
+      skipped.push({ environmentId: machine.environmentId, label: machine.label, reason });
+    const target = (
+      selfUpdate: ServerSelfUpdateCapability,
+      targetVersion: string,
+    ): ServerUpdateTarget => ({
+      environmentId: machine.environmentId,
+      serverLabel: machine.label,
+      selfUpdate,
+      installation: config?.environment.capabilities.serverInstallation,
+      desktopAppUpdate: config !== null && supportsDesktopAppUpdate(config),
+      targetVersion,
+      ...(selfUpdate === "desktop-managed" ? { channel: release.channel } : {}),
+      ...(release.databaseMigration === undefined
+        ? {}
+        : { targetDatabaseMigration: release.databaseMigration }),
     });
+    const serverVersion = config?.environment.serverVersion;
+    const sameTrack = serverVersion !== undefined && isOnTrack(serverVersion, release.channel);
+    if (
+      config !== null &&
+      sameTrack &&
+      resolveVersionMismatch(serverVersion, release.version) === null
+    ) {
+      const move = trackSwitchMove(config, true);
+      if (
+        !("skip" in move) &&
+        move.selfUpdate === "desktop-managed" &&
+        unavailableReason(machine) === null
+      ) {
+        targets.push({ ...target(move.selfUpdate, serverVersion), trackOnly: true });
+      }
+      continue;
+    }
+    const unavailable = unavailableReason(machine);
+    if (config === null || serverVersion === undefined || unavailable !== null) {
+      skip(unavailable ?? "not connected");
+      continue;
+    }
+    const move = trackSwitchMove(config, sameTrack);
+    if ("skip" in move) {
+      skip(move.skip);
+      continue;
+    }
+    const blocked = channelSwitchBlockReason(
+      serverVersion,
+      release,
+      config.environment.databaseMigration,
+    );
+    if (blocked !== null) {
+      skip(blocked);
+      continue;
+    }
+    // Service launchers only accept newer versions, so leaving for an older release is manual.
+    if (
+      move.selfUpdate === "boot-service" &&
+      compareSemverVersions(release.version, serverVersion) <= 0
+    ) {
+      skip(
+        `run \`t3 update --channel ${release.channel === "nightly" ? "nightly" : "stable"} --allow-downgrade\` there`,
+      );
+      continue;
+    }
+    targets.push(target(move.selfUpdate, release.version));
   }
   return { targets, skipped };
 }
 
+/** A remote host on the other track that a switch can still move, for retrying a partial switch. */
+export function awaitsTrackSwitch(
+  machine: Pick<UpdateEverythingMachine, "serverConfig" | "hostedByThisApp">,
+  channel: DesktopUpdateChannel,
+): boolean {
+  const config = machine.serverConfig;
+  return (
+    !machine.hostedByThisApp &&
+    config !== null &&
+    !isOnTrack(config.environment.serverVersion, channel) &&
+    !("skip" in trackSwitchMove(config, false))
+  );
+}
+
+function isOnTrack(version: string, channel: DesktopUpdateChannel): boolean {
+  return cliReleaseChannelOf(version) !== "preview" && desktopUpdateChannelOf(version) === channel;
+}
+
+/** How a switch moves a host, or why it never can from here, whatever the release. */
+function trackSwitchMove(
+  config: NonNullable<UpdateEverythingMachine["serverConfig"]>,
+  sameTrack: boolean,
+): { readonly selfUpdate: ServerSelfUpdateCapability } | { readonly skip: string } {
+  if (cliReleaseChannelOf(config.environment.serverVersion) === "preview") {
+    return { skip: "runs a preview build" };
+  }
+  const selfUpdate = resolveServerSelfUpdateCapability(config);
+  if (selfUpdate === null) return { skip: "needs a manual update" };
+  if (selfUpdate !== "desktop-managed") return { selfUpdate };
+  if (config.environment.capabilities.desktopAppChannelSwitch !== true) {
+    return { skip: "needs a newer desktop app" };
+  }
+  // Squirrel.Mac renames the bundle for the new track and then cannot relaunch it.
+  if (!sameTrack && config.environment.platform.os === "darwin") {
+    return { skip: "switch the Mac app on that Mac" };
+  }
+  return { selfUpdate };
+}
+
 export interface UpdateEverythingSteps<Providers, Servers> {
   readonly downloadLocal?: () => Promise<boolean>;
   readonly updateProviders: () => Promise<Providers>;
@@ -163,6 +368,8 @@ export interface UpdateRunMachine {
 }
 
 export interface UpdateEverythingRun {
+  /** Track switches retry through their planner, which re-checks each database. */
+  readonly trackSwitch?: boolean;
   readonly localVersion: string | null;
   readonly phase: "providers" | "servers" | "countdown" | "installing";
   readonly restartAt: number | null;
@@ -265,7 +472,10 @@ export function describeUpdateCapsule(
     return {
       tone: "failed",
       label: failed.length === 1 ? `${failed[0]!.machine.label} failed` : `${failed.length} failed`,
-      action: failed.some(({ machine }) => machine.server !== null) ? "retry" : "dismiss",
+      action:
+        !run.trackSwitch && failed.some(({ machine }) => machine.server !== null)
+          ? "retry"
+          : "dismiss",
     };
   }
   return { tone: "default", label: `${done} of ${machines.length} updated`, action: null };
diff --git a/apps/web/src/components/sidebar/useUpdateEverything.ts b/apps/web/src/components/sidebar/useUpdateEverything.ts
index af38bbf5d4bc4..d8ab3a5bce710 100644
--- a/apps/web/src/components/sidebar/useUpdateEverything.ts
+++ b/apps/web/src/components/sidebar/useUpdateEverything.ts
@@ -13,7 +13,9 @@ import { getProviderUpdateRunOutcome } from "../ProviderUpdateLaunchNotification
 import { useProviderUpdates } from "../ProviderUpdatesAction";
 import { canUpdateServer, type ServerUpdateOutcome, useServerUpdate } from "../ServerUpdateAction";
 import {
+  type ChannelSwitchRelease,
   closeFinishedUpdateRun,
+  collectChannelSwitchTargets,
   collectRestartingMachines,
   collectServerUpdateTargets,
   collectUpdateEverythingResult,
@@ -34,9 +36,24 @@ import {
 
 const UPDATE_RESTART_DELAY_MS = 5_000;
 
+/** Servers this desktop app runs; they update with it. */
+export function isHostedByThisApp(
+  environment: ReturnType<typeof useEnvironments>["environments"][number],
+) {
+  return (
+    isElectron &&
+    (environment.entry.target._tag === "PrimaryConnectionTarget" ||
+      isDesktopLocalConnectionTarget(environment.entry.target))
+  );
+}
+
 export type ReportLocalUpdateError = (title: string, description: string) => void;
 
-export function useUpdateEverything(localUpdateVersion: string | null) {
+/** `channelSwitch` makes the run move the fleet to that release's track instead of updating it. */
+export function useUpdateEverything(
+  localUpdateVersion: string | null,
+  channelSwitch?: ChannelSwitchRelease,
+) {
   const targetVersion = localUpdateVersion ?? APP_VERSION;
   const { environments } = useEnvironments();
   const environmentIds = environmentIdsKey(environments.map(({ environmentId }) => environmentId));
@@ -47,23 +64,22 @@ export function useUpdateEverything(localUpdateVersion: string | null) {
     label: environment.label,
     serverConfig: environment.serverConfig,
     connected: environment.connection.phase === "connected",
-    hostedByThisApp:
-      isElectron &&
-      (environment.entry.target._tag === "PrimaryConnectionTarget" ||
-        isDesktopLocalConnectionTarget(environment.entry.target)),
+    hostedByThisApp: isHostedByThisApp(environment),
     canMaintain: canUpdateServer(sessionStates[index]!),
     updateState: updateStates[index]!,
   }));
-  const { targets: behindServers, skipped: unreachable } = collectServerUpdateTargets(
-    machines,
-    targetVersion,
-  );
-  // Desktop-managed servers use their app feed; only npm installs need to wait for publication.
-  const needsNpm = behindServers.some((server) => server.selfUpdate !== "desktop-managed");
-  const published = useNpmReleasePublished(needsNpm ? targetVersion : null);
+  // A track switch's target came from npm already.
+  const {
+    targets: behindServers,
+    skipped: unreachable,
+    waitForNpm,
+  } = channelSwitch
+    ? { ...collectChannelSwitchTargets(machines, channelSwitch), waitForNpm: [] }
+    : collectServerUpdateTargets(machines, targetVersion, localUpdateVersion !== null);
+  const published = useNpmReleasePublished(waitForNpm.length > 0 ? targetVersion : null);
   const servers = published
     ? behindServers
-    : behindServers.filter((server) => server.selfUpdate === "desktop-managed");
+    : behindServers.filter((server) => !waitForNpm.includes(server));
   const skipped: ReadonlyArray<SkippedMachine> = [
     ...unreachable,
     ...behindServers
@@ -74,14 +90,18 @@ export function useUpdateEverything(localUpdateVersion: string | null) {
         reason: `t3@${targetVersion} is not on npm yet`,
       })),
   ];
-  const restarts = collectRestartingMachines(machines, servers, localUpdateVersion !== null);
-  const providers = useProviderUpdates();
+  // Track-only hosts save a setting and restart nothing, so they are neither listed nor counted.
+  const moving = servers.filter((server) => server.trackOnly !== true);
+  const restarts = collectRestartingMachines(machines, moving, localUpdateVersion !== null);
+  const providerUpdates = useProviderUpdates();
+  // A track switch moves app and servers only; provider updates stay a separate choice.
+  const providers = channelSwitch ? { machines: [], updateAll: async () => [] } : providerUpdates;
   const updateServer = useServerUpdate();
 
   const view = describeUpdateEverything({
     localVersion: localUpdateVersion,
     localMachines: machines.filter((machine) => machine.hostedByThisApp),
-    servers,
+    servers: moving,
     skipped,
     providerMachines: providers.machines.map((machine) => ({
       environmentId: machine.environmentId,
@@ -138,6 +158,7 @@ export function useUpdateEverything(localUpdateVersion: string | null) {
       }
       const localVersion = installLocal ? localUpdateVersion : null;
       setUpdateEverythingRun(() => ({
+        ...(channelSwitch ? { trackSwitch: true } : {}),
         localVersion,
         phase: "providers",
         restartAt: null,
diff --git a/apps/web/src/components/threadActionMenu.logic.test.ts b/apps/web/src/components/threadActionMenu.logic.test.ts
index 039c684dcdc36..bd9dfdcdcc4b6 100644
--- a/apps/web/src/components/threadActionMenu.logic.test.ts
+++ b/apps/web/src/components/threadActionMenu.logic.test.ts
@@ -65,10 +65,13 @@ describe("buildThreadActionMenuItems", () => {
     },
   );
 
-  it("disables archive while the thread is running", () => {
-    const archiveItem = buildThreadActionMenuItems({ ...baseState, isRunning: true }).find(
-      (item) => item.id === "archive",
-    );
-    expect(archiveItem?.disabled).toBe(true);
+  it("disables archive and turning into a project while the thread is running", () => {
+    const items = buildThreadActionMenuItems({
+      ...baseState,
+      isRunning: true,
+      canTurnIntoProject: true,
+    });
+    expect(items.find((item) => item.id === "archive")?.disabled).toBe(true);
+    expect(items.find((item) => item.id === "turn-into-project")?.disabled).toBe(true);
   });
 });
diff --git a/apps/web/src/components/threadActionMenu.logic.ts b/apps/web/src/components/threadActionMenu.logic.ts
index 7779a9db4c3ed..3c4626c1ea1ad 100644
--- a/apps/web/src/components/threadActionMenu.logic.ts
+++ b/apps/web/src/components/threadActionMenu.logic.ts
@@ -4,6 +4,7 @@ import type { SnoozePreset } from "@t3tools/client-runtime/state/thread-settled"
 export type ThreadActionMenuId =
   | "new-thread-on-branch"
   | "filter-by-project"
+  | "turn-into-project"
   | "project-settings"
   | "pin"
   | "unpin"
@@ -90,6 +91,8 @@ export interface ThreadActionMenuState {
   readonly snoozePresets: ReadonlyArray<SnoozePreset>;
   /** Guest links need their own grant, so the caller checks it instead of `canOperate`. */
   readonly canShareWithGuest?: boolean;
+  /** A No project thread with its own folder, on a server that can promote it. */
+  readonly canTurnIntoProject?: boolean;
 }
 
 /** Local navigation, read markers, and copying remain available to read-only clients. */
@@ -183,6 +186,16 @@ export function buildThreadActionMenuItems(
           },
         ]
       : []),
+    ...(state.canTurnIntoProject
+      ? [
+          {
+            id: "turn-into-project" as const,
+            label: "Turn into project",
+            icon: "folder-plus",
+            disabled: state.isRunning,
+          },
+        ]
+      : []),
     ...(state.supports.autoSettleOptOut
       ? [
           {
diff --git a/apps/web/src/components/ui/menu.tsx b/apps/web/src/components/ui/menu.tsx
index 287c871beb8b0..95c459b8f8e8f 100644
--- a/apps/web/src/components/ui/menu.tsx
+++ b/apps/web/src/components/ui/menu.tsx
@@ -163,7 +163,7 @@ function MenuCheckboxItem({
   variant = "default",
   ...props
 }: MenuPrimitive.CheckboxItem.Props & {
-  variant?: "default" | "switch";
+  variant?: "default" | "icon" | "switch";
 }) {
   return (
     <MenuPrimitive.CheckboxItem
@@ -173,6 +173,7 @@ function MenuCheckboxItem({
         variant === "switch"
           ? "grid-cols-[1fr_auto] gap-4 pe-1.5"
           : "grid-cols-[1rem_minmax(0,1fr)] pe-4",
+        variant === "icon" && "grid-cols-[0.625rem_minmax(0,1fr)]",
         className,
       )}
       data-slot="menu-checkbox-item"
@@ -190,8 +191,11 @@ function MenuCheckboxItem({
         </>
       ) : (
         <>
-          <MenuPrimitive.CheckboxItemIndicator className="col-start-1">
+          <MenuPrimitive.CheckboxItemIndicator
+            className={cn("col-start-1", variant === "icon" && "-mx-0.5")}
+          >
             <svg
+              className={variant === "icon" ? "size-3.5" : undefined}
               fill="none"
               height="24"
               stroke="currentColor"
diff --git a/apps/web/src/composer-list-continuation.test.ts b/apps/web/src/composer-list-continuation.test.ts
index e96a3fb52794a..12774bae205c0 100644
--- a/apps/web/src/composer-list-continuation.test.ts
+++ b/apps/web/src/composer-list-continuation.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vite-plus/test";
 
-import { listContinuationForEnter, nextOrderedMarkerText } from "./composer-list-continuation";
+import {
+  listContinuationForEnter,
+  listIndentForTab,
+  nextOrderedMarkerText,
+} from "./composer-list-continuation";
 
 function applyEdit(value: string, edit: { start: number; end: number; replacement: string }) {
   return value.slice(0, edit.start) + edit.replacement + value.slice(edit.end);
@@ -31,6 +35,25 @@ describe("composer list continuation", () => {
     expect(applyEdit("- [ ] ", listContinuationForEnter("- [ ] ", 6)!)).toBe("");
   });
 
+  it("lifts an empty nested item one level per press before leaving the list", () => {
+    let value = "1. parent\n   1. child\n      1. ";
+    for (const expected of [
+      "1. parent\n   1. child\n   2. ",
+      "1. parent\n   1. child\n2. ",
+      "1. parent\n   1. child\n",
+    ]) {
+      value = applyEdit(value, listContinuationForEnter(value, value.length)!);
+      expect(value).toBe(expected);
+    }
+  });
+
+  it("renumbers the parent list after lifting an empty nested item", () => {
+    const value = "1. a\n   1. \n2. b";
+    const edit = listContinuationForEnter(value, value.indexOf("\n2."))!;
+    expect(applyEdit(value, edit)).toBe("1. a\n2. \n3. b");
+    expect(edit.cursorAfter).toBe("1. a\n2. ".length);
+  });
+
   it("refuses to split a supplementary currency skill chip", () => {
     const value = "1. 𑿝review go";
     const cursor = value.indexOf(" go") - 1;
@@ -44,6 +67,27 @@ describe("composer list continuation", () => {
   });
 });
 
+describe("composer list indentation", () => {
+  // regression: #17124 Tab must nest a numbered item at its parent's content column
+  it.each([
+    ["1. parent\n2. child", "1. parent\n   1. child"],
+    ["10. parent\n11. child", "10. parent\n    1. child"],
+    ["1.\tparent\n2. child", "1.\tparent\n    1. child"],
+    ['1. @"file\n   9. name"\n2. child', '1. @"file\n   9. name"\n   1. child'],
+  ])("nests %j as a first child and keeps the caret on its text", (value, expected) => {
+    const cursor = value.lastIndexOf("child") + 2;
+    const edit = listIndentForTab(value, cursor, cursor)!;
+    expect(applyEdit(value, edit)).toBe(expected);
+    expect(edit.cursorAfter).toBe(expected.lastIndexOf("child") + 2);
+  });
+
+  it("continues the numbering of an existing nested sibling", () => {
+    const value = "1. parent\n   1. first\n2. second";
+    const edit = listIndentForTab(value, value.length, value.length)!;
+    expect(applyEdit(value, edit)).toBe("1. parent\n   1. first\n   2. second");
+  });
+});
+
 describe("nextOrderedMarkerText", () => {
   it.each([
     ["1.", "2."],
diff --git a/apps/web/src/composer-list-continuation.ts b/apps/web/src/composer-list-continuation.ts
index 1c2de5a482433..583cf1bd04a92 100644
--- a/apps/web/src/composer-list-continuation.ts
+++ b/apps/web/src/composer-list-continuation.ts
@@ -13,39 +13,60 @@ type ListMarker =
   | { kind: "task"; indent: string; space: string }
   | { kind: "bullet"; indent: string; bullet: string; space: string };
 
-function parseListMarker(line: string): { marker: ListMarker; markerEnd: number } | null {
+interface ParsedListMarker {
+  marker: ListMarker;
+  markerEnd: number;
+  /** Column a nested item must reach to belong to this item. */
+  contentColumn: number;
+}
+
+function parseListMarker(line: string): ParsedListMarker | null {
   const indent = line.match(/^[ \t]*/)?.[0] ?? "";
   const rest = line.slice(indent.length);
   const ordered = rest.match(/^(\d+)([.)])((?:[ \t]+)|\s*$)/);
   if (ordered && ordered[1] !== undefined && ordered[2] !== undefined) {
+    const space = ordered[3] ?? "";
     return {
       marker: {
         kind: "ordered",
         indent,
         numberText: ordered[1],
         delimiter: ordered[2] === ")" ? ")" : ".",
-        space: ordered[3] ?? "",
+        space,
       },
       markerEnd: indent.length + ordered[0].length,
+      contentColumn: contentColumn(indent, ordered[1].length + 1, space),
     };
   }
-  const task = rest.match(/^-\s\[[ xX]\]((?:[ \t]+)|\s*$)/);
-  if (task) {
+  // The checkbox is item content, so a task's content starts after "- ".
+  const task = rest.match(/^-(\s)\[[ xX]\]((?:[ \t]+)|\s*$)/);
+  if (task && task[1] !== undefined) {
     return {
-      marker: { kind: "task", indent, space: task[1] ?? "" },
+      marker: { kind: "task", indent, space: task[2] ?? "" },
       markerEnd: indent.length + task[0].length,
+      contentColumn: contentColumn(indent, 1, task[1]),
     };
   }
   const bullet = rest.match(/^([-*+])((?:[ \t]+)|\s*$)/);
   if (bullet && bullet[1] !== undefined) {
+    const space = bullet[2] ?? "";
     return {
-      marker: { kind: "bullet", indent, bullet: bullet[1], space: bullet[2] ?? "" },
+      marker: { kind: "bullet", indent, bullet: bullet[1], space },
       markerEnd: indent.length + bullet[0].length,
+      contentColumn: contentColumn(indent, 1, space),
     };
   }
   return null;
 }
 
+// CommonMark content follows 1-4 columns of padding; wider padding is code, so the content
+// column sits one column past the marker.
+function contentColumn(indent: string, markerWidth: number, padding: string): number {
+  const markerEnd = indentWidth(indent) + markerWidth;
+  const space = indentWidth(padding, markerEnd);
+  return markerEnd + (space >= 1 && space <= 4 ? space : 1);
+}
+
 export function nextOrderedMarkerText(marker: string): string {
   const numberText = marker.slice(0, -1);
   const delimiter = marker.slice(-1);
@@ -67,14 +88,14 @@ function nextMarkerText(marker: ListMarker): string {
 }
 
 // Markdown tabs advance to the next four-column stop.
-function indentWidth(line: string): number {
-  let width = 0;
+function indentWidth(line: string, fromColumn = 0): number {
+  let column = fromColumn;
   for (const char of line) {
-    if (char === " ") width += 1;
-    else if (char === "\t") width += 4 - (width % 4);
+    if (char === " ") column += 1;
+    else if (char === "\t") column += 4 - (column % 4);
     else break;
   }
-  return width;
+  return column - fromColumn;
 }
 
 function renumberFollowingItems(
@@ -149,6 +170,55 @@ function currentLine(value: string, cursor: number): { start: number; end: numbe
   return { start, end, text: value.slice(start, end) };
 }
 
+function* listMarkersAbove(
+  value: string,
+  lineStart: number,
+  tokens: ReturnType<typeof inlineTokenRanges>,
+): Generator<ParsedListMarker> {
+  let tokenIndex = tokens.length - 1;
+  while (lineStart > 0) {
+    const lineEnd = lineStart - 1;
+    lineStart = value.lastIndexOf("\n", lineEnd - 1) + 1;
+    // A newline inside a chip does not start a list item.
+    for (let token = tokens[tokenIndex]; token; token = tokens[tokenIndex]) {
+      if (token.start >= lineStart) tokenIndex -= 1;
+      else if (token.end > lineStart) lineStart = value.lastIndexOf("\n", token.start - 1) + 1;
+      else break;
+    }
+    const parsed = parseListMarker(value.slice(lineStart, lineEnd));
+    if (!parsed) return;
+    yield parsed;
+  }
+}
+
+function parentMarker(
+  value: string,
+  lineStart: number,
+  marker: ListMarker,
+  tokens: ReturnType<typeof inlineTokenRanges>,
+): ListMarker | null {
+  const width = indentWidth(marker.indent);
+  for (const above of listMarkersAbove(value, lineStart, tokens)) {
+    if (indentWidth(above.marker.indent) < width) return above.marker;
+  }
+  return null;
+}
+
+function nestedNumber(
+  marker: ListMarker,
+  previousChild: ListMarker | undefined,
+): { replacedLength: number; text: string } {
+  if (marker.kind !== "ordered") return { replacedLength: 0, text: "" };
+  const continues =
+    previousChild?.kind === "ordered" && previousChild.delimiter === marker.delimiter;
+  return {
+    replacedLength: marker.numberText.length,
+    text: continues
+      ? nextOrderedMarkerText(`${previousChild.numberText}${marker.delimiter}`).slice(0, -1)
+      : "1",
+  };
+}
+
 export function listContinuationForEnter(value: string, cursor: number): ComposerListEdit | null {
   if (!Number.isInteger(cursor) || cursor < 0 || cursor > value.length) return null;
   const line = currentLine(value, cursor);
@@ -159,12 +229,21 @@ export function listContinuationForEnter(value: string, cursor: number): Compose
   const tokens = inlineTokenRanges(value);
   if (isInsideInlineToken(tokens, cursor)) return null;
   if (value.slice(markerEnd, line.end).trim() === "") {
-    return {
-      start: line.start,
-      end: Math.max(cursor, markerEnd),
-      replacement: "",
-      cursorAfter: line.start,
-    };
+    const parent = parentMarker(value, line.start, parsed.marker, tokens);
+    const replacement = parent ? nextMarkerText(parent) : "";
+    const cursorAfter = line.start + replacement.length;
+    const end = Math.max(cursor, markerEnd);
+    const renumbered =
+      parent?.kind === "ordered" ? renumberFollowingItems(value, line.end, parent, tokens) : null;
+    if (renumbered) {
+      return {
+        start: line.start,
+        end: renumbered.end,
+        replacement: replacement + value.slice(end, line.end) + renumbered.text,
+        cursorAfter,
+      };
+    }
+    return { start: line.start, end, replacement, cursorAfter };
   }
   const insertion = `\n${nextMarkerText(parsed.marker)}`;
   const cursorAfter = cursor + insertion.length;
@@ -190,7 +269,36 @@ export function listIndentForTab(
 ): ComposerListEdit | null {
   if (!Number.isInteger(start) || start !== end || start < 0 || start > value.length) return null;
   const line = currentLine(value, start);
-  if (!parseListMarker(line.text)) return null;
-  if (isInsideInlineToken(inlineTokenRanges(value), start)) return null;
+  const parsed = parseListMarker(line.text);
+  if (!parsed) return null;
+  const tokens = inlineTokenRanges(value);
+  if (isInsideInlineToken(tokens, start)) return null;
+  const { marker } = parsed;
+  const width = indentWidth(marker.indent);
+  let previousChild: ListMarker | undefined;
+  for (const above of listMarkersAbove(value, line.start, tokens)) {
+    const aboveWidth = indentWidth(above.marker.indent);
+    if (aboveWidth < width) break;
+    if (aboveWidth > width) {
+      if (!previousChild || aboveWidth < indentWidth(previousChild.indent)) {
+        previousChild = above.marker;
+      }
+      continue;
+    }
+    const indent =
+      previousChild?.indent ?? above.marker.indent + " ".repeat(above.contentColumn - aboveWidth);
+    const number = nestedNumber(marker, previousChild);
+    const replacedEnd = line.start + marker.indent.length + number.replacedLength;
+    const replacement = indent + number.text;
+    return {
+      start: line.start,
+      end: replacedEnd,
+      replacement,
+      cursorAfter:
+        start < replacedEnd
+          ? line.start + indent.length
+          : start - replacedEnd + line.start + replacement.length,
+    };
+  }
   return { start: line.start, end: line.start, replacement: "  ", cursorAfter: start + 2 };
 }
diff --git a/apps/web/src/contextMenuFallback.ts b/apps/web/src/contextMenuFallback.ts
index 56e85545e6f1e..eece920cba664 100644
--- a/apps/web/src/contextMenuFallback.ts
+++ b/apps/web/src/contextMenuFallback.ts
@@ -124,6 +124,16 @@ const ICON_PATHS: Record<string, ReadonlyArray<{ tag: string; attrs: Record<stri
     { tag: "line", attrs: { x1: "19", x2: "19", y1: "8", y2: "14" } },
     { tag: "line", attrs: { x1: "22", x2: "16", y1: "11", y2: "11" } },
   ],
+  "folder-plus": [
+    { tag: "path", attrs: { d: "M12 10v6" } },
+    { tag: "path", attrs: { d: "M9 13h6" } },
+    {
+      tag: "path",
+      attrs: {
+        d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
+      },
+    },
+  ],
   "folder-tree": [
     {
       tag: "path",
diff --git a/apps/web/src/hooks/showThreadUndoNotice.ts b/apps/web/src/hooks/showThreadUndoNotice.ts
index 5b6b68826fdea..977dcd68d1ab7 100644
--- a/apps/web/src/hooks/showThreadUndoNotice.ts
+++ b/apps/web/src/hooks/showThreadUndoNotice.ts
@@ -28,7 +28,7 @@ type UndoNotice = {
 
 export const useThreadUndoNotice = create<{ notice: UndoNotice | null }>(() => ({ notice: null }));
 
-export function threadUndoNoticeSummary(notice: Pick<UndoNotice, "action" | "count">): string {
+function threadUndoNoticeSummary(notice: Pick<UndoNotice, "action" | "count">): string {
   const noun = notice.action === "Discarded" ? "draft" : "thread";
   return `${notice.action} ${notice.count} ${noun}${notice.count === 1 ? "" : "s"}`;
 }
diff --git a/apps/web/src/hooks/useHandleNewThread.test.ts b/apps/web/src/hooks/useHandleNewThread.test.ts
index 9e28306500466..6faf5bd76d73d 100644
--- a/apps/web/src/hooks/useHandleNewThread.test.ts
+++ b/apps/web/src/hooks/useHandleNewThread.test.ts
@@ -200,6 +200,7 @@ vi.mock("../lib/chatThreadActions", async (importOriginal) => ({
   hasExplicitComposerModelSelection: () => false,
   resolveNewThreadModelSelectionOverride: () => null,
 }));
+vi.mock("../providerInstances", () => ({ resolveDefaultProviderModelSelection: () => null }));
 vi.mock("../lib/t3ProjectFileDefaults", () => ({
   readT3ProjectFile: () => testState.projectFileRead,
 }));
diff --git a/apps/web/src/hooks/useHandleNewThread.ts b/apps/web/src/hooks/useHandleNewThread.ts
index 235dc557bab63..e95a2d0d799bd 100644
--- a/apps/web/src/hooks/useHandleNewThread.ts
+++ b/apps/web/src/hooks/useHandleNewThread.ts
@@ -44,6 +44,8 @@ import { legacyProjectCwdPreferenceKey, useUiStateStore } from "../uiStateStore"
 import { getClientSettings } from "./useSettings";
 import { useThreadRouteTarget } from "./useThreadRouteTarget";
 import { readUnloadedThreadCount } from "../state/olderSettledShelf";
+import { resolveProjectDefaultProviderModelSelection } from "../providerInstances";
+import { resolveNewThreadModelSelection } from "@t3tools/shared/usageLimits";
 
 interface NewThreadWorkspaceOptions {
   branch?: string | null;
@@ -144,7 +146,26 @@ export function createNewThreadHandler(router: AnyRouter) {
       project?.id ?? null,
       project,
     );
-    const projectDefaultModelSelection = projectSettings.settings.defaultModelSelection;
+    const configuredDefaultModelSelection = projectSettings.settings.defaultModelSelection ?? null;
+    const fallbackResolution = resolveNewThreadModelSelection({
+      defaultSelection:
+        configuredDefaultModelSelection ??
+        (carryModelSelection || useComposerDraftStore.getState().stickyActiveProvider !== null
+          ? null
+          : resolveProjectDefaultProviderModelSelection(
+              environmentServerConfigs.get(projectRef.environmentId)?.providers ?? [],
+              targetServerSettings,
+              projectRef.projectId,
+            )),
+      fallbackSelection: targetServerSettings.fallbackModelSelection ?? null,
+      providers: environmentServerConfigs.get(projectRef.environmentId)?.providers ?? [],
+      settings: targetServerSettings,
+      projectId: projectRef.projectId,
+      now: Date.now(),
+    });
+    const projectDefaultModelSelection = fallbackResolution.fallback
+      ? fallbackResolution.selection
+      : configuredDefaultModelSelection;
     const defaultRuntimeMode = projectSettings.settings.defaultRuntimeMode;
     const resolveModelSelectionOverride = (destinationDraftId: DraftId) =>
       resolveNewThreadModelSelectionOverride({
diff --git a/apps/web/src/hooks/useThreadActionMenu.test.ts b/apps/web/src/hooks/useThreadActionMenu.test.ts
index 4fe9ad45ad53b..e87092d59c37e 100644
--- a/apps/web/src/hooks/useThreadActionMenu.test.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.test.ts
@@ -119,6 +119,7 @@ vi.mock("./useSettings", () => ({
     }),
 }));
 vi.mock("./useThreadActions", () => ({
+  canTurnThreadIntoProject: () => false,
   useThreadActions: () =>
     Object.fromEntries(
       [
diff --git a/apps/web/src/hooks/useThreadActionMenu.ts b/apps/web/src/hooks/useThreadActionMenu.ts
index b7bec9d5e988d..0e25cebeef878 100644
--- a/apps/web/src/hooks/useThreadActionMenu.ts
+++ b/apps/web/src/hooks/useThreadActionMenu.ts
@@ -45,7 +45,7 @@ import { threadRuntimeCanArchive } from "@t3tools/client-runtime/state/models";
 import { useCopyToClipboard } from "./useCopyToClipboard";
 import { useNewThreadHandler } from "./useHandleNewThread";
 import { useClientSettings } from "./useSettings";
-import { useThreadActions } from "./useThreadActions";
+import { canTurnThreadIntoProject, useThreadActions } from "./useThreadActions";
 
 function failureToast(title: string, error: unknown) {
   toastManager.add(
@@ -84,6 +84,7 @@ export function useThreadActionMenu(input: {
     archiveThread,
     deleteThread,
     markThreadUnread,
+    turnThreadIntoProject,
   } = useThreadActions();
   const updateThreadMetadata = useOrchestrationCommand(threadEnvironment.updateMetadata, {
     reportFailure: false,
@@ -144,6 +145,7 @@ export function useThreadActionMenu(input: {
         supports,
         snoozePresets,
         canShareWithGuest,
+        canTurnIntoProject: canTurnThreadIntoProject(threadRef),
       });
       const clicked = await settlePromise(() => api.contextMenu.show(items, position));
       if (clicked._tag === "Failure" || clicked.value === null) return;
@@ -254,6 +256,19 @@ export function useThreadActionMenu(input: {
         case "share-guest":
           openGuestShareDialog(threadRef);
           return;
+        case "turn-into-project": {
+          const result = await turnThreadIntoProject(threadRef);
+          if (result._tag === "Success") {
+            toastManager.add({
+              type: "success",
+              title: "Project created",
+              description: thread.title,
+            });
+          } else if (!isAtomCommandInterrupted(result)) {
+            failureToast("Could not turn thread into a project", squashAtomCommandFailure(result));
+          }
+          return;
+        }
         case "copy-path": {
           const workspacePath = thread.worktreePath ?? projectCwd;
           if (!workspacePath) {
diff --git a/apps/web/src/hooks/useThreadActions.ts b/apps/web/src/hooks/useThreadActions.ts
index 211dc1bef67ef..32020316496ed 100644
--- a/apps/web/src/hooks/useThreadActions.ts
+++ b/apps/web/src/hooks/useThreadActions.ts
@@ -29,6 +29,7 @@ import { appAtomRegistry } from "../rpc/atomRegistry";
 import { environmentServerConfigsAtom } from "../state/server";
 import { isScratchProject } from "@t3tools/client-runtime/state/projects";
 import { orchestrationEnvironment } from "../state/orchestration";
+import { projectEnvironment } from "../state/projects";
 import { threadEnvironment } from "../state/threads";
 import { vcsEnvironment } from "../state/vcs";
 import { useNewThreadHandler } from "./useHandleNewThread";
@@ -228,6 +229,20 @@ export function useAcknowledgeThreadWoke() {
   };
 }
 
+/** A No project thread that already has its own folder, on a server that can promote it. */
+export function canTurnThreadIntoProject(threadRef: ScopedThreadRef): boolean {
+  const thread = readThreadShell(threadRef);
+  const config = appAtomRegistry.get(environmentServerConfigsAtom).get(threadRef.environmentId);
+  if (!thread?.worktreePath || config?.environment.capabilities.threadProjectFromScratch !== true) {
+    return false;
+  }
+  const project = readProject({
+    environmentId: threadRef.environmentId,
+    projectId: thread.projectId,
+  });
+  return project !== null && isScratchProject(project, config.scratchWorkspaceRoot);
+}
+
 function threadOperationFailure(target: ScopedThreadRef) {
   return readEnvironmentScope(target.environmentId, AuthOrchestrationOperateScope)
     ? null
@@ -279,6 +294,9 @@ export function useThreadActions() {
     reportFailure: false,
   });
   const markThreadUnread = useMarkThreadUnread();
+  const createProjectFromThread = useAtomCommand(projectEnvironment.createFromThread, {
+    reportFailure: false,
+  });
   const stopThreadSession = useOrchestrationCommand(threadEnvironment.stopSession);
   const removeWorktree = useAtomCommand(vcsEnvironment.removeWorktree, {
     reportFailure: false,
@@ -925,5 +943,10 @@ export function useThreadActions() {
     reorderActiveThread,
     markThreadUnread,
     setThreadAutoSettle,
+    turnThreadIntoProject: (target: ScopedThreadRef) =>
+      createProjectFromThread({
+        environmentId: target.environmentId,
+        input: { threadId: target.threadId },
+      }),
   };
 }
diff --git a/apps/web/src/modelPickerVisibility.ts b/apps/web/src/modelPickerVisibility.ts
index a8177fe83b5c6..17de95380fb87 100644
--- a/apps/web/src/modelPickerVisibility.ts
+++ b/apps/web/src/modelPickerVisibility.ts
@@ -1,8 +1,13 @@
-const MODEL_PICKER_CONTENT_SELECTOR = "[data-model-picker-content]";
+// Keydown handlers read this on every key, so a mount count replaces a document query.
+let mountedModelPickers = 0;
+
+export function registerModelPickerContent(): () => void {
+  mountedModelPickers += 1;
+  return () => {
+    mountedModelPickers -= 1;
+  };
+}
 
 export function isModelPickerOpen(): boolean {
-  return (
-    typeof document !== "undefined" &&
-    document.querySelector(MODEL_PICKER_CONTENT_SELECTOR) !== null
-  );
+  return mountedModelPickers > 0;
 }
diff --git a/apps/web/src/pendingUserInput.test.ts b/apps/web/src/pendingUserInput.test.ts
index 69800be4b7574..1178c91043052 100644
--- a/apps/web/src/pendingUserInput.test.ts
+++ b/apps/web/src/pendingUserInput.test.ts
@@ -5,14 +5,10 @@ import { threadContextReference } from "./lib/composerContextRecords";
 import { threadContextRecord } from "@t3tools/shared/composerContextReferences";
 
 import {
-  buildPendingUserInputAnswers,
   carryDisplacedCustomAnswerIntoPrompt,
   derivePendingUserInputProgress,
   projectPendingUserInputAnswer,
-  resolvePendingUserInputAnswer,
-  setPendingUserInputCustomAnswer,
   threadContextsReferencedByAnswer,
-  togglePendingUserInputOptionSelection,
 } from "./pendingUserInput";
 
 describe("projectPendingUserInputAnswer", () => {
@@ -68,128 +64,6 @@ const singleSelectQuestion = {
   multiSelect: false,
 } as const;
 
-const nativeChoiceQuestion = {
-  id: "result",
-  header: "Result",
-  question: "Which result should be used?",
-  options: [
-    { value: " first\t", label: "Result", description: "First result" },
-    { value: "second", label: "Result", description: "Second result" },
-  ],
-  allowCustomAnswer: false,
-  multiSelect: false,
-} as const;
-
-describe("resolvePendingUserInputAnswer", () => {
-  it("preserves exact editor text, including a deliberately cleared answer", () => {
-    const question = { ...singleSelectQuestion, initialAnswer: "  Proposed message\n" };
-    expect(resolvePendingUserInputAnswer(question, { customAnswer: question.initialAnswer })).toBe(
-      question.initialAnswer,
-    );
-    expect(resolvePendingUserInputAnswer(question, { customAnswer: "  Edited message\n\n" })).toBe(
-      "  Edited message\n\n",
-    );
-    expect(resolvePendingUserInputAnswer(question, { customAnswer: "" })).toBe("");
-    expect(resolvePendingUserInputAnswer(question, { customAnswer: " \n" })).toBe(" \n");
-    expect(
-      setPendingUserInputCustomAnswer(
-        { selectedOptionValues: ["Orchestration-first"] },
-        "",
-        question,
-      ),
-    ).toEqual({ customAnswer: "" });
-    const drafts = { scope: { customAnswer: "" } };
-    expect(derivePendingUserInputProgress([question], drafts, 0)).toMatchObject({
-      customAnswer: "",
-      resolvedAnswer: "",
-      canAdvance: true,
-      isComplete: true,
-    });
-  });
-
-  it("prefers a custom answer over selected options", () => {
-    expect(
-      resolvePendingUserInputAnswer(singleSelectQuestion, {
-        selectedOptionValues: ["Orchestration-first"],
-        customAnswer: "Keep the existing envelope for one release",
-      }),
-    ).toBe("Keep the existing envelope for one release");
-  });
-
-  it("does not replace a required choice with a custom answer", () => {
-    expect(
-      resolvePendingUserInputAnswer(nativeChoiceQuestion, {
-        selectedOptionValues: ["second"],
-        customAnswer: "Use another result",
-      }),
-    ).toBe("second");
-  });
-
-  it("does not submit labels or unknown values when an option has a value", () => {
-    expect(
-      resolvePendingUserInputAnswer(nativeChoiceQuestion, {
-        selectedOptionValues: ["Result", "unknown"],
-      }),
-    ).toBeNull();
-  });
-});
-
-describe("togglePendingUserInputOptionSelection", () => {
-  it("selects and removes options with the same label independently", () => {
-    const question = { ...nativeChoiceQuestion, multiSelect: true };
-    const firstSelected = togglePendingUserInputOptionSelection(question, undefined, " first\t");
-    const bothSelected = togglePendingUserInputOptionSelection(question, firstSelected, "second");
-
-    expect(buildPendingUserInputAnswers([question], { result: bothSelected })).toEqual({
-      result: [" first\t", "second"],
-    });
-
-    const secondSelected = togglePendingUserInputOptionSelection(
-      question,
-      bothSelected,
-      " first\t",
-    );
-    expect(buildPendingUserInputAnswers([question], { result: secondSelected })).toEqual({
-      result: ["second"],
-    });
-  });
-});
-
-describe("buildPendingUserInputAnswers", () => {
-  it("returns a canonical answer map for complete prompts", () => {
-    expect(
-      buildPendingUserInputAnswers(
-        [
-          singleSelectQuestion,
-          {
-            id: "compat",
-            header: "Compat",
-            question: "How strict should compatibility be?",
-            options: [
-              {
-                label: "Keep current envelope",
-                description: "Preserve current wire format",
-              },
-            ],
-            multiSelect: false,
-          },
-        ],
-        {
-          scope: {
-            selectedOptionValues: ["Orchestration-first"],
-          },
-          compat: {
-            customAnswer: "Keep the current envelope for one release window",
-          },
-        },
-      ),
-    ).toEqual({
-      scope: "Orchestration-first",
-      compat: "Keep the current envelope for one release window",
-    });
-  });
-});
-
 describe("pending user input question progress", () => {
   const questions = [
     singleSelectQuestion,
@@ -207,6 +81,17 @@ describe("pending user input question progress", () => {
     },
   ] as const;
 
+  it("counts a deliberately cleared answer as answered", () => {
+    const question = { ...singleSelectQuestion, initialAnswer: "  Proposed message\n" };
+    const drafts = { scope: { customAnswer: "" } };
+    expect(derivePendingUserInputProgress([question], drafts, 0)).toMatchObject({
+      customAnswer: "",
+      resolvedAnswer: "",
+      canAdvance: true,
+      isComplete: true,
+    });
+  });
+
   it("derives the active question and advancement state", () => {
     expect(
       derivePendingUserInputProgress(
@@ -232,25 +117,6 @@ describe("pending user input question progress", () => {
   });
 });
 
-it("accepts attachment-only answers after every upload finishes", () => {
-  const questions = [
-    { id: "spec", header: "Spec", question: "Provide a spec", options: [], multiSelect: false },
-  ];
-  expect(buildPendingUserInputAnswers(questions, { spec: { attachmentCount: 1 } })).toEqual({
-    spec: "",
-  });
-  expect(
-    buildPendingUserInputAnswers(questions, {
-      spec: { attachmentCount: 1, attachmentsBlocked: true },
-    }),
-  ).toBeNull();
-  expect(
-    buildPendingUserInputAnswers([{ ...questions[0]!, allowCustomAnswer: false }], {
-      spec: { attachmentCount: 1 },
-    }),
-  ).toBeNull();
-});
-
 describe("carryDisplacedCustomAnswerIntoPrompt", () => {
   // regression: #12577 clicking a question option discarded typed text
   it("keeps the thread draft when nothing was typed into the answer", () => {
diff --git a/apps/web/src/pendingUserInput.ts b/apps/web/src/pendingUserInput.ts
index f8f9d6d52b5ba..17998eaf8010c 100644
--- a/apps/web/src/pendingUserInput.ts
+++ b/apps/web/src/pendingUserInput.ts
@@ -1,6 +1,13 @@
 import type { ThreadContextRecord, UserInputQuestion } from "@t3tools/contracts";
 import { replaceComposerContextReferences } from "@t3tools/shared/composerContextReferences";
 import { formatThreadLink } from "@t3tools/shared/threadLinks";
+import {
+  buildPendingUserInputAnswers,
+  normalizeSelectedOptionValues,
+  resolvePendingUserInputAnswer,
+  type PendingUserInputAnswer,
+  type PendingUserInputDraftAnswer,
+} from "@t3tools/client-runtime/state/pending-user-input";
 
 import { collectInlineContextIds } from "./lib/composerContextReferences";
 
@@ -25,20 +32,13 @@ export function threadContextsReferencedByAnswer(
   return threadContexts.filter((record) => referencedIds.has(record.contextId));
 }
 
-export interface PendingUserInputDraftAnswer {
-  selectedOptionValues?: string[];
-  customAnswer?: string;
-  attachmentCount?: number;
-  attachmentsBlocked?: boolean;
-}
-
 export interface PendingUserInputProgress {
   questionIndex: number;
   activeQuestion: UserInputQuestion | null;
   activeDraft: PendingUserInputDraftAnswer | undefined;
-  selectedOptionValues: string[];
+  selectedOptionValues: ReadonlyArray<string>;
   customAnswer: string;
-  resolvedAnswer: string | string[] | null;
+  resolvedAnswer: PendingUserInputAnswer | null;
   usingCustomAnswer: boolean;
   answeredQuestionCount: number;
   isLastQuestion: boolean;
@@ -46,72 +46,6 @@ export interface PendingUserInputProgress {
   canAdvance: boolean;
 }
 
-function normalizeDraftAnswer(value: string | undefined): string | null {
-  if (typeof value !== "string") {
-    return null;
-  }
-
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function normalizeSelectedOptionValues(value: string[] | undefined): string[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-
-  // Provider option IDs must stay unchanged, including whitespace.
-  return Array.from(new Set(value.filter((entry) => typeof entry === "string")));
-}
-
-export function resolvePendingUserInputAnswer(
-  question: UserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-): string | string[] | null {
-  if (draft?.attachmentsBlocked) return null;
-  const customAnswer =
-    question.allowCustomAnswer === false
-      ? null
-      : question.initialAnswer !== undefined
-        ? (draft?.customAnswer ?? null)
-        : normalizeDraftAnswer(draft?.customAnswer);
-  if (customAnswer !== null && customAnswer.length > 0) {
-    return customAnswer;
-  }
-
-  const selectedOptionValues = normalizeSelectedOptionValues(draft?.selectedOptionValues).filter(
-    (value) => question.options.some((option) => (option.value ?? option.label) === value),
-  );
-  if (question.multiSelect) {
-    return selectedOptionValues.length > 0
-      ? selectedOptionValues
-      : (customAnswer ??
-          (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null));
-  }
-
-  return (
-    selectedOptionValues[0] ??
-    customAnswer ??
-    (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null)
-  );
-}
-
-export function setPendingUserInputCustomAnswer(
-  draft: PendingUserInputDraftAnswer | undefined,
-  customAnswer: string,
-  question?: Pick<UserInputQuestion, "initialAnswer">,
-): PendingUserInputDraftAnswer {
-  const selectedOptionValues =
-    question?.initialAnswer !== undefined || customAnswer.trim().length > 0
-      ? undefined
-      : normalizeSelectedOptionValues(draft?.selectedOptionValues);
-
-  return {
-    customAnswer,
-    ...(selectedOptionValues && selectedOptionValues.length > 0 ? { selectedOptionValues } : {}),
-  };
-}
-
 const DISPLACED_ANSWER_SEPARATOR = "\n\n";
 
 export function carryDisplacedCustomAnswerIntoPrompt(
@@ -128,48 +62,6 @@ export function carryDisplacedCustomAnswerIntoPrompt(
   return `${prompt.trimEnd()}${DISPLACED_ANSWER_SEPARATOR}${displaced}`;
 }
 
-export function togglePendingUserInputOptionSelection(
-  question: UserInputQuestion,
-  draft: PendingUserInputDraftAnswer | undefined,
-  optionValue: string,
-): PendingUserInputDraftAnswer {
-  if (question.multiSelect) {
-    const selectedOptionValues = normalizeSelectedOptionValues(draft?.selectedOptionValues);
-    const nextSelectedOptionValues = selectedOptionValues.includes(optionValue)
-      ? selectedOptionValues.filter((value) => value !== optionValue)
-      : [...selectedOptionValues, optionValue];
-
-    return {
-      customAnswer: "",
-      ...(nextSelectedOptionValues.length > 0
-        ? { selectedOptionValues: nextSelectedOptionValues }
-        : {}),
-    };
-  }
-
-  return {
-    customAnswer: "",
-    selectedOptionValues: [optionValue],
-  };
-}
-
-export function buildPendingUserInputAnswers(
-  questions: ReadonlyArray<UserInputQuestion>,
-  draftAnswers: Record<string, PendingUserInputDraftAnswer>,
-): Record<string, string | string[]> | null {
-  const answers: Record<string, string | string[]> = {};
-
-  for (const question of questions) {
-    const answer = resolvePendingUserInputAnswer(question, draftAnswers[question.id]);
-    if (answer === null) {
-      return null;
-    }
-    answers[question.id] = answer;
-  }
-
-  return answers;
-}
-
 function countAnsweredPendingUserInputQuestions(
   questions: ReadonlyArray<UserInputQuestion>,
   draftAnswers: Record<string, PendingUserInputDraftAnswer>,
@@ -203,7 +95,9 @@ export function derivePendingUserInputProgress(
     questionIndex: normalizedQuestionIndex,
     activeQuestion,
     activeDraft,
-    selectedOptionValues: normalizeSelectedOptionValues(activeDraft?.selectedOptionValues),
+    selectedOptionValues: activeQuestion
+      ? normalizeSelectedOptionValues(activeQuestion, activeDraft?.selectedOptionValues)
+      : [],
     customAnswer,
     resolvedAnswer,
     usingCustomAnswer:
diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.ts
index a3364df9a15d6..f9e711c40e7fc 100644
--- a/apps/web/src/providerInstances.ts
+++ b/apps/web/src/providerInstances.ts
@@ -240,3 +240,19 @@ export function resolveDefaultProviderModelSelection(
   const model = getDefaultProviderInstanceModel(providers, instanceId);
   return model ? { instanceId, model } : null;
 }
+
+export function resolveProjectDefaultProviderModelSelection(
+  providers: ReadonlyArray<ServerProvider>,
+  settings: ServerSettings,
+  projectId: ProjectId | null,
+): ModelSelection | null {
+  const entries = providerInstanceEntriesFor(providers, settings, projectId);
+  // Matches resolveComposerProviderSelection: the first driver group wins before any other.
+  const entry =
+    resolveSelectableProviderInstanceEntry(
+      entries.filter((candidate) => candidate.driverKind === entries[0]?.driverKind),
+      undefined,
+    ) ?? resolveSelectableProviderInstanceEntry(entries, undefined);
+  const model = entry ? getDefaultProviderInstanceModel(providers, entry.instanceId) : undefined;
+  return entry && model ? { instanceId: entry.instanceId, model } : null;
+}
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
index f905376dc341a..9c4e38c30e510 100644
--- a/apps/web/src/session-logic.test.ts
+++ b/apps/web/src/session-logic.test.ts
@@ -1472,6 +1472,51 @@ describe("incremental v2 timeline entries", () => {
       expect(next.entries[index]).toBe(entry);
   });
 
+  it("re-derives only the work entry whose tool item changed", () => {
+    const fixture = makeStreamingTimelineFixture("Partial");
+    const visibleTurnItems = fixture.visibleTurnItems.map((row) =>
+      row.item.id === "live-work"
+        ? { ...row, item: { ...row.item, status: "running" as const, completedAt: null } }
+        : row,
+    );
+    const input = { visibleTurnItems, optimisticMessages: [] };
+    const previous = deriveTimelineEntriesFromVisibleTurnItemsWithState(input);
+    const nextInput = { ...input, visibleTurnItems: fixture.visibleTurnItems };
+    const next = deriveTimelineEntriesFromVisibleTurnItemsWithState(nextInput, previous);
+    expect(next.entries).toEqual(deriveTimelineEntriesFromVisibleTurnItems(nextInput));
+    for (const [index, entry] of previous.entries.entries()) {
+      if (entry.id === "live-work") expect(next.entries[index]).not.toBe(entry);
+      else expect(next.entries[index]).toBe(entry);
+    }
+
+    const anchoredInput = {
+      ...nextInput,
+      anchoredMessages: [
+        {
+          id: MessageId.make("feedback"),
+          runId: null,
+          role: "assistant" as const,
+          text: "Feedback received",
+          streaming: false,
+          createdAt: fixture.time(6),
+          updatedAt: fixture.time(6),
+        },
+      ],
+    };
+    const anchored = deriveTimelineEntriesFromVisibleTurnItemsWithState(anchoredInput);
+    const movedInput = {
+      ...anchoredInput,
+      visibleTurnItems: anchoredInput.visibleTurnItems.map((row) =>
+        row.item.id === "live-work"
+          ? { ...row, item: { ...row.item, startedAt: DateTime.makeUnsafe(fixture.time(8)) } }
+          : row,
+      ),
+    };
+    expect(
+      deriveTimelineEntriesFromVisibleTurnItemsWithState(movedInput, anchored).entries,
+    ).toEqual(deriveTimelineEntriesFromVisibleTurnItems(movedInput));
+  });
+
   it.each(["completion", "provenance", "ordering", "attachment", "run"] as const)(
     "rebuilds entries for a %s change instead of retaining stale v2 metadata",
     (change) => {
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index 37d7ad27be5a7..7b79dea6f7401 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -903,6 +903,27 @@ export function isStreamingTurnItemTextUpdate(
   return Equal.equals(previousMetadata, nextMetadata);
 }
 
+/**
+ * A changed tool or work item maps to exactly one entry with the item's id.
+ * Messages and question answers take part in cross-entry dedupe, and anchored
+ * messages are placed by createdAt, so those changes rebuild.
+ */
+function canRederiveInPlace(
+  input: TimelineEntriesInput,
+  previousItem: OrchestrationV2ProjectedTurnItem,
+  item: OrchestrationV2ProjectedTurnItem,
+): boolean {
+  return (
+    item.item.id === previousItem.item.id &&
+    item.item.type === previousItem.item.type &&
+    item.item.type !== "user_message" &&
+    item.item.type !== "assistant_message" &&
+    item.item.type !== "user_input_request" &&
+    ((input.anchoredMessages?.length ?? 0) === 0 ||
+      projectedItemCreatedAt(item) === projectedItemCreatedAt(previousItem))
+  );
+}
+
 function reuseTimelineEntries(
   input: TimelineEntriesInput,
   previous: TimelineEntriesProjection,
@@ -943,15 +964,45 @@ function reuseTimelineEntries(
     OrchestrationV2ProjectedTurnItem,
     OrchestrationV2ProjectedTurnItem
   >();
+  const changedItems: OrchestrationV2ProjectedTurnItem[] = [];
   for (let index = 0; index < before.visibleTurnItems.length; index += 1) {
     const previousItem = before.visibleTurnItems[index]!;
     const item = input.visibleTurnItems[index]!;
     if (item === previousItem) continue;
-    if (!isStreamingTurnItemTextUpdate(previousItem, item)) return null;
-    replacements.set(previousItem, item);
+    if (isStreamingTurnItemTextUpdate(previousItem, item)) {
+      replacements.set(previousItem, item);
+      continue;
+    }
+    if (!canRederiveInPlace(input, previousItem, item)) return null;
+    changedItems.push(item);
   }
-  if (replacements.size === 0 && !appended) return previous.entries;
+  // One batch keeps the attempt/node/plan lookups to a single build.
+  const rederived =
+    changedItems.length === 0
+      ? []
+      : deriveTimelineEntriesFromVisibleTurnItems({
+          ...input,
+          visibleTurnItems: changedItems,
+          optimisticMessages: [],
+          anchoredMessages: [],
+        });
+  if (
+    rederived.length !== changedItems.length ||
+    rederived.some((entry, index) => entry.id !== changedItems[index]!.item.id)
+  ) {
+    return null;
+  }
+  const rederivedEntries = new Map(rederived.map((entry) => [entry.id, entry]));
+  if (replacements.size === 0 && rederivedEntries.size === 0 && !appended) {
+    return previous.entries;
+  }
+  let rederivedCount = 0;
   const entries = previous.entries.map((entry): TimelineEntry => {
+    const rederivedEntry = rederivedEntries.get(entry.id);
+    if (rederivedEntry !== undefined) {
+      rederivedCount += 1;
+      return rederivedEntry;
+    }
     const row =
       entry.kind === "message" && entry.projectedItem !== undefined
         ? replacements.get(entry.projectedItem)
@@ -967,6 +1018,7 @@ function reuseTimelineEntries(
       },
     };
   });
+  if (rederivedCount !== rederivedEntries.size) return null;
   if (appended) {
     entries.push(
       ...deriveTimelineEntriesFromVisibleTurnItems({
diff --git a/apps/web/src/state/device.ts b/apps/web/src/state/device.ts
index fcd4bb4b8f2ec..da19cc7d5a2b9 100644
--- a/apps/web/src/state/device.ts
+++ b/apps/web/src/state/device.ts
@@ -171,3 +171,14 @@ export const deviceEasAccountCheck = createEnvironmentRpcQueryAtomFamily(connect
   staleTimeMs: 0,
   idleTtlMs: 0,
 });
+
+/** Who a Simlock token is, checked as the host editor's URL and token fields change. */
+export const deviceSimlockIdentityCheck = createEnvironmentRpcQueryAtomFamily(
+  connectionAtomRuntime,
+  {
+    label: "environment-data:device:simlock-identity-check",
+    tag: WS_METHODS.deviceSimlockIdentity,
+    staleTimeMs: 0,
+    idleTtlMs: 0,
+  },
+);
diff --git a/apps/web/src/state/npmRelease.ts b/apps/web/src/state/npmRelease.ts
index 4436a42c29e4b..09db3b68c0691 100644
--- a/apps/web/src/state/npmRelease.ts
+++ b/apps/web/src/state/npmRelease.ts
@@ -1,31 +1,51 @@
 import { useAtomValue } from "@effect/atom-react";
+import { npmReleaseDatabaseMigration } from "@t3tools/shared/cliRelease";
 import * as Effect from "effect/Effect";
 import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/http";
 import { AsyncResult, Atom } from "effect/reactivity";
 
-export const npmReleasePublishedAtom = Atom.family((version: string) =>
+export interface NpmRelease {
+  readonly version: string;
+  /** Absent on releases published before npm manifests carried it. */
+  readonly databaseMigration: number | undefined;
+}
+
+/** `spec` is an exact version or a dist-tag such as `nightly`. Null when npm has no such release.
+ * Refreshes only while mounted; the published check below keeps its own versions alive. */
+export const npmReleaseAtom = Atom.family((spec: string) =>
   Atom.make(
     Effect.gen(function* () {
       const response = yield* HttpClient.get(
-        `https://registry.npmjs.org/t3/${encodeURIComponent(version)}`,
+        `https://registry.npmjs.org/t3/${encodeURIComponent(spec)}`,
       );
-      if (response.status === 404) return false;
+      if (response.status === 404) return null;
       const body = yield* HttpClientResponse.filterStatusOk(response).pipe(
         Effect.flatMap((ok) => ok.json),
       );
-      return typeof body === "object" && body !== null && "version" in body
-        ? body.version === version
-        : false;
+      if (
+        typeof body !== "object" ||
+        body === null ||
+        !("version" in body) ||
+        typeof body.version !== "string"
+      ) {
+        return null;
+      }
+      return {
+        version: body.version,
+        databaseMigration: npmReleaseDatabaseMigration(body),
+      } satisfies NpmRelease;
     }).pipe(
       // Tracing headers would make the browser send a CORS preflight, which npm rejects.
       Effect.provideService(HttpClient.TracerPropagationEnabled, false),
       Effect.provide(FetchHttpClient.layer),
     ),
-  ).pipe(
-    Atom.withRefresh("5 minutes"),
-    Atom.keepAlive,
-    Atom.withLabel(`npm-release-published:${version}`),
-  ),
+  ).pipe(Atom.withRefresh("5 minutes"), Atom.withLabel(`npm-release:${spec}`)),
+);
+
+export const npmReleasePublishedAtom = Atom.family((version: string) =>
+  Atom.make((get) =>
+    get.result(npmReleaseAtom(version)).pipe(Effect.map((release) => release?.version === version)),
+  ).pipe(Atom.keepAlive, Atom.withLabel(`npm-release-published:${version}`)),
 );
 
 const NO_VERSION_ATOM = Atom.make(AsyncResult.success(false)).pipe(
diff --git a/docs/internals/devices.md b/docs/internals/devices.md
index c50cb504a84e7..5273f7942e9e0 100644
--- a/docs/internals/devices.md
+++ b/docs/internals/devices.md
@@ -44,6 +44,27 @@ clients never hold it. Agent config files are written per device
 device before targeting it. Device settings run `simctl` on the simulator's
 machine, which EAS does not expose, so they are unavailable there.
 
+## Simlock hosts lease through the agent-device front
+
+A [Simlock host](../../apps/server/src/device/SimlockDeviceHost.ts) (alpha) opens a
+device by running T3's own agent-device CLI against the gateway's agent-device
+front (`connect proxy`, then `open`), not with Simlock's lease HTTP API:
+agent-device cannot adopt a lease it did not allocate. The lease is bound to
+that one agent-device session and to the directory `open` ran in, so
+`agentEndpoint` hands every thread the same session, a `stateDir` holding its
+connection record, and no `--udid`/`--serial` (the gateway refuses selectors).
+Installs work only from that directory; `device_open` names it.
+
+Simlock serves a lease's screen and input to its holder in serve-sim's formats
+on both platforms: AVCC envelopes at `/v1/leases/<id>/stream` and serve-sim's
+input messages at `/v1/leases/<id>/input`, both with the agent token. Clients
+therefore treat a Simlock Android lease like iOS (`serveSimOnly` in the stream
+client), and `upstream` maps serve-sim's `stream.avcc` and `helper/ws` paths to
+those routes. Simlock has no MJPEG, screenshot, or host command routes, so the
+panel offers only input there.
+Leases are renewed while tracked and released at the host's age limit; one a
+crashed server left behind ends on its own one TTL later, so there is no ledger.
+
 ## The hub is never exposed
 
 serve-sim has a shell-exec route whose token is readable from its own
diff --git a/docs/internals/remote.md b/docs/internals/remote.md
index d88d2973f4e44..0c328c50317c5 100644
--- a/docs/internals/remote.md
+++ b/docs/internals/remote.md
@@ -73,7 +73,7 @@ A [peer link](../../apps/server/src/peer/PeerLinks.ts) lets one environment's
 agents work in another. The linking environment signs in to the other's `/mcp`
 as an outside MCP client, with a pairing code from it, and keeps that session's
 token in its own secret store. The other environment needs nothing new: it
-sees one more OAuth client, lists it in Connections, and revokes it there.
+sees one more OAuth client, lists it in Sharing & access, and revokes it there.
 Unlinking on the linking side only forgets the token.
 
 - **The Linked environments beta (`linkedEnvironmentsEnabled`) gates both
diff --git a/docs/operations/development.md b/docs/operations/development.md
index 211041c22a24e..3307dbc22b969 100644
--- a/docs/operations/development.md
+++ b/docs/operations/development.md
@@ -163,7 +163,9 @@ for the security model.
 
 `vp run check:changed` runs CI's fast checks for your branch's changes: format and lint of the
 changed files, `knip:check` when code or a manifest changes, the generated GraphQL checks, typecheck
-of the affected packages and their dependents, and the test files beside the changed files. It maps
+of the affected packages and their dependents, and the test files beside the changed files. It also
+runs the checks that read other files: the agent context budget when the server is affected, and
+React Compiler coverage for only the changed web and mobile files. It maps
 files to packages with [ci-changes.cjs](../../.github/scripts/ci-changes.cjs), as CI does. It
 compares against the merge base with `origin/main`, or with a ref you pass. CI still runs the full
 test suites and the jobs the summary lists, so a local pass does not promise a green CI run.
diff --git a/docs/operations/release.md b/docs/operations/release.md
index 39f4f63ddd91b..18daadc5f2787 100644
--- a/docs/operations/release.md
+++ b/docs/operations/release.md
@@ -42,6 +42,7 @@ the version.
   - Only plain stable `X.Y.Z` releases are marked as the repository's latest release.
   - Nightly runs are always GitHub prereleases and never marked latest.
   - Automatically generated release notes are pinned to the previous tag in the same channel, so stable compares to the previous stable tag and nightly compares to the previous nightly tag.
+  - The release job's **Write release notes** step (`scripts/generate-release-notes.ts`) builds the body: a computed header line, a short summary from `gpt-6.1-terra`, and GitHub's generated list folded under `<details>`. It needs the `OPENAI_API_KEY` secret. The summary leaves out commits whose scopes are all mobile; the header counts every commit. The desktop update popover, on every channel, shows the highlights paragraph and the header counts as a short note per release, with the offered release's age from the update feed's `releaseDate`. The nightly Discord post shows the part above `<details>`. If the step fails or there is nothing to summarize, it writes no file and the release uses GitHub's generated notes as before.
 - Includes Electron auto-update metadata (for example `latest*.yml`, `nightly*.yml`, and `*.blockmap`) in release assets.
 - Builds a self-contained CLI archive per platform (`t3-<version>-<platform>-<arch>.tar.gz`, `.zip` on Windows) in the same job as that target's desktop artifact and attaches them to the GitHub Release with a `SHA256SUMS` file, on every channel, for five targets: macOS arm64, Linux x64 and arm64, Windows x64 and arm64. Every archive is smoke-tested on hardware of its own architecture, and every one but the Windows archives is also built and signed there. There is no macOS x64 archive: Node single-executables are unsupported on x64 macOS (the SEA docs list macOS as arm64 only) and the binary segfaults on start; the x64 desktop app is Electron and unaffected.
   - The archive holds the server as a Node single-executable (`scripts/build-cli-archive.ts`), so unpacking it needs neither Node, npm, nor a compiler. It is the only form in which T3 Code manages a runtime: the desktop's SSH environments, the boot service, `t3 update`, and the install scripts all download and verify this archive against `SHA256SUMS`. The `t3` npm package exists for people who run `npx t3` or `npm install -g t3` themselves, and it downloads this same archive too; nothing in the product installs from npm. The `curl | sh` installers are `scripts/install.sh` and `scripts/install.ps1`; the marketing site copies them into its `public/` at build time (`apps/marketing/scripts/stage-install-scripts.mjs`) and serves them at `t3.codes/install.sh` and `/install.ps1`.
@@ -430,7 +431,11 @@ release archives, and then its npm launcher, available before users can receive
 
 The workflow enforces this ordering:
 
-1. `release` publishes the GitHub Release with the CLI archives and `SHA256SUMS`.
+1. `release` publishes the GitHub Release with the CLI archives and `SHA256SUMS`. Every channel
+   uploads to a draft and publishes only after all assets are attached, so a new version in the
+   desktop update feed already has its archives. **Update everything** relies on this to update
+   background-service hosts before npm has the version. Rerunning `release` after publication
+   replaces assets in a public release, so service updates can fail until the upload finishes.
 2. `publish_cli` publishes the `t3@<version>` launcher, which downloads from that release, on every
    channel.
 3. `deploy_web` depends on both before moving the hosted channel to the new client.
diff --git a/docs/orchestration-v2/orchestrator-mcp-server.md b/docs/orchestration-v2/orchestrator-mcp-server.md
index befaca4c077c8..6bd4dea35d7c5 100644
--- a/docs/orchestration-v2/orchestrator-mcp-server.md
+++ b/docs/orchestration-v2/orchestrator-mcp-server.md
@@ -398,7 +398,10 @@ delegated to a linked environment name that environment. Clients open only that
 environment's thread and show its current title; a link to a thread they do not
 know renders as a label that opens nothing. Older `t3-thread://v1/<threadId>`
 links name no environment: clients resolve them in the message's environment,
-then by a unique match in another enabled environment.
+then by a unique match in another enabled environment. An outside OAuth client,
+one that is not a linked environment, cannot render `t3-thread://` links, so it
+gets a web URL on the origin it reached, `<origin>/<environmentId>/<threadId>`,
+for threads in this environment.
 
 List and read results report `snoozed` and `snoozedUntil`, and
 `t3_thread_list` filters on `snoozed`. The server's `isSnoozed` follows the
diff --git a/docs/user/composer.md b/docs/user/composer.md
index e0d1f541851f0..714572dfd5005 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -22,7 +22,8 @@ block. What you typed is what the agent receives, markers and numbering
 included, and `#1234` without a space still looks up a pull request.
 
 Enter sends. In a list or quote, **Shift+Enter** continues it, and Shift+Enter
-on an empty line leaves it; **Tab** nests a list item. In a code block, Enter
+on an empty line moves out one level, then leaves it; **Tab** nests a list item
+under the one above. In a code block, Enter
 starts a new line at the current indentation, **Tab** and **Shift+Tab** indent
 the selected lines, and a closing ` ``` ` followed by Enter, or two blank lines
 at the end, leave the block. **Backspace** at the start of a code block turns it
diff --git a/docs/user/devices.md b/docs/user/devices.md
index 42c0db4b27afa..ce5a7d8d06d05 100644
--- a/docs/user/devices.md
+++ b/docs/user/devices.md
@@ -22,7 +22,7 @@ Choose **Float device over chat** in the toolbar to keep watching and tapping th
 device in a small window while the right panel shows something else; drag the
 window by its handle, resize it from any edge, and use **Open in right panel**
 to bring it back.
-Turn off the device hub in **Settings → Devices** to stop the
+Turn off **Use devices** in **Settings → Devices** to stop the
 helper processes; simulators and emulators keep running until you power them
 off.
 
@@ -80,12 +80,12 @@ viewer stops streaming and leaves the device available to the agent. Device
 activity also appears in the thread timeline.
 
 Agents drive the device through the `agent-device` command line. T3
-Code installs and starts it only after **Agent device access** is enabled. iOS
+Code installs and starts it only after **Agents can use devices** is on. iOS
 taps build a small test runner on first use, which takes a couple of minutes
 once per server. Restart an existing agent session after granting access so it
 receives the device CLI environment.
 
-To keep agents away from simulators, turn off **Agent device access** in
+To keep agents away from simulators, turn off **Agents can use devices** in
 **Settings → Devices**. This hides the device tools from agents
 started from then on; your own Device panel is unaffected.
 
@@ -99,12 +99,12 @@ still-image stream and Android cannot show video.
 ## SSH device hosts
 
 In Settings → Devices, choose the environments that should use
-the host and add it under **Device hosts**. Enter an SSH alias or `user@host`, with
+the host and choose **Add source → Machine over SSH**. Enter an SSH alias or `user@host`, with
 an optional identity file and port. These resolve on the environment server,
 so use the SSH configuration and keys available there. Password prompts are
 not supported.
 
-**Test connection** checks SSH, Node, npm, and platform tools without installing
+**Test connection**, in the host's menu, checks SSH, Node, npm, and platform tools without installing
 anything, with a result for each selected environment. Targets that resolve to
 the environment’s own machine are skipped, since its devices are already local.
 The first device listing installs pinned device tools on the host.
@@ -123,8 +123,45 @@ installation, and connectivity to development servers such as Metro separately.
 A simulator on another machine cannot reach Metro through your environment's
 localhost without forwarding or another reachable address.
 
+## Simlock hosts (alpha)
+
+[Simlock](https://incubator.callstack.com/simlock/) pools iOS simulators and
+Android emulators across machines. If you run a Simlock gateway, T3 can lease
+devices from it. Simlock is new and unreleased, so this integration is an
+alpha: it may change or stop working with a newer Simlock. T3 does not install
+or manage Simlock; set up the gateway and its workers yourself. It needs a
+gateway and workers built from Simlock's `main` at
+[6316e10](https://github.com/callstackincubator/simlock/commit/6316e10) or
+later, the first with a lease holder's screen and input.
+
+Turn on **Settings → Labs → Simlock device hosts (alpha)** and **Use devices**
+in Settings → Devices, then choose **Add source → Simlock pool** with an **agent token**
+(`simlock --gateway token create --role agent`). Give each T3 server its own
+token: Simlock counts every lease made with one token against the same
+requester, and allows one at a time unless the gateway's
+`lease.maxPerRequester` is raised to the host's **Devices at once**. The token
+leases devices and reaches only its own leases, but commands on a leased device
+run on its worker, so treat it like shell access to your workers. T3 sends it
+with every request, so use an HTTPS gateway URL, or plain HTTP only over an
+encrypted network such as Tailscale. The gateway
+and workers need `capabilities.stream.enabled` and `capabilities.input.enabled`
+for the live screen and for input.
+
+The picker lists the models your workers can make. Opening one takes a lease;
+closing it with **Return device to the pool**, or removing the host, returns it
+wiped. The panel keeps a watched device leased up to the host's lease limit.
+You can tap, swipe, type, and press Home, and Back and Recents on Android.
+Rotation, appearance, text size, device tools, and screenshots are not offered
+for Simlock devices; agents can still do them through `device_open`. On iOS 27
+simulators, typing on your keyboard does nothing; tap the on-screen keyboard
+instead. Workers must run the same agent-device
+version as T3 (see Device tool updates), and agent-device accepts app installs
+for a lease only from the folder it was opened from, which `device_open`
+names. A device cannot reach development servers on your machine through
+localhost; use an address its worker can reach.
+
 ## Device tool updates
 
-The connected T3 server manages the device hub and agent tools on its own machine and configured SSH hosts. Required versions install automatically the next time those tools are used. Settings → Devices → Check versions reads installed versions without installing tools or starting devices.
+The connected T3 server manages the device hub and agent tools on its own machine and configured SSH hosts. Required versions install automatically the next time those tools are used. In Settings → Devices, select a version and choose **Check versions** to read installed versions without installing tools or starting devices.
 
 To receive newer tool versions on a remote environment, update that environment's T3 server. Updating only the browser or mobile app does not update the remote server. An offline host keeps its installed files, but an update needs network access before device support can start; T3 does not fall back to an older version. Reconnect the host and use Retry if installation fails. Existing device and agent-access settings are preserved.
diff --git a/docs/user/faq.md b/docs/user/faq.md
index bb4713b5f25e8..62a5e1a8446d1 100644
--- a/docs/user/faq.md
+++ b/docs/user/faq.md
@@ -45,7 +45,7 @@ Get the [iOS](https://apps.apple.com/us/app/t3-code-remote-claude-more/id6787819
 
 ## Why does T3 Connect keep disconnecting?
 
-T3 Connect is our built-in alternative to Tailscale for remote connections. If it keeps dropping, open **Settings > Connections**, find the machine, and select **Details**. The first part marked as failed is the cause. I will not be disappointed if you set up Tailscale as a fallback (I do this personally). [T3 Connect troubleshooting](./t3-connect-troubleshooting.md)
+T3 Connect is our built-in alternative to Tailscale for remote connections. If it keeps dropping, open **Settings > Environments**, find the machine, and select **Details**. The first part marked as failed is the cause. I will not be disappointed if you set up Tailscale as a fallback (I do this personally). [T3 Connect troubleshooting](./t3-connect-troubleshooting.md)
 
 ## Will I get banned for using my subscription?
 
diff --git a/docs/user/install.md b/docs/user/install.md
index 3edf46d80ee39..1e1693d0b32ee 100644
--- a/docs/user/install.md
+++ b/docs/user/install.md
@@ -65,18 +65,41 @@ update it with `git pull` and a rebuild.
 Download a release from [GitHub Releases](https://github.com/pingdotgg/t3code/releases),
 or use a package manager:
 
-| Platform           | Install                            |
-| ------------------ | ---------------------------------- |
-| Windows            | `winget install T3Tools.T3Code`    |
-| macOS              | `brew install --cask t3-code`      |
-| Debian, Ubuntu     | `sudo apt install ./T3-Code-*.deb` |
-| Arch Linux         | `yay -S t3code-bin`                |
-| Arch Linux nightly | `yay -S t3code-nightly-bin`        |
+| Platform           | Install                                                      |
+| ------------------ | ------------------------------------------------------------ |
+| Windows            | `winget install T3Tools.T3Code`                              |
+| macOS              | `brew install --cask t3-code`                                |
+| Debian, Ubuntu     | `sudo apt install ./T3-Code-*.deb`                           |
+| Arch Linux         | `yay -S t3code-bin`                                          |
+| Arch Linux nightly | `yay -S t3code-nightly-bin`                                  |
+| Nix                | `nix profile add github:NixOS/nixpkgs/nixos-unstable#t3code` |
 
 The `.deb` updates itself like the other desktop builds. It asks for your
 password to install each update. If your desktop has no password prompt, the
 update fails. Download the new `.deb` and install it the same way.
 
+### Nix (nixpkgs)
+
+T3 Code is maintained in [nixpkgs](https://github.com/NixOS/nixpkgs/tree/nixos-unstable/pkgs/by-name/t3/t3code).
+The command above installs from `nixos-unstable` and requires Nix 2.30 or later with
+`nix-command` and `flakes` enabled. Launch the desktop app with `t3code-desktop`;
+the package also includes the `t3` command.
+
+On NixOS, you can instead add the package to your system configuration, using
+a nixpkgs revision that includes `t3code`:
+
+```nix
+environment.systemPackages = [ pkgs.t3code ];
+```
+
+Apply the change with `sudo nixos-rebuild switch`. For Home Manager, add
+`pkgs.t3code` to `home.packages` and run `home-manager switch`.
+
+Update a profile installation with `nix profile upgrade t3code`. For NixOS or
+Home Manager, update your configuration's nixpkgs input or channel and rebuild.
+Nix manages both the desktop app and the bundled
+`t3` command; use Nix to update them instead of the in-app updater or `t3 update`.
+
 ### The `t3` command
 
 The desktop app includes the `t3` command-line tool. To run it from any
diff --git a/docs/user/providers-antigravity.md b/docs/user/providers-antigravity.md
index 0b1cd2f2c6da1..76bbc8266a941 100644
--- a/docs/user/providers-antigravity.md
+++ b/docs/user/providers-antigravity.md
@@ -68,9 +68,15 @@ Leave the field blank to use the managed runtime, or a compatible executable on
 
 ## Models and threads
 
-The model list comes from your Antigravity account and can differ from other
-Antigravity apps. A resumed thread keeps its selected model. If access to that
-model ends, select another available model before continuing.
+The model list comes from your Antigravity account, including Claude and GPT models
+when your plan has them. Pick a thinking level in the composer's effort menu; it
+shows only the levels the selected model supports. A resumed thread keeps its
+selected model. If access to that model ends, select another available model
+before continuing.
+
+Antigravity creates empty `.gemini/skills` and `.agents/skills` folders in the
+workspace when a session starts. Git does not track empty folders, so they never
+appear in commits.
 
 Use Antigravity's native `/plan` command for planning. T3 Code's separate Plan mode
 is unavailable. Tool approvals follow [Permission modes](./permission-modes.md).
diff --git a/docs/user/remote-access.md b/docs/user/remote-access.md
index b8f9553d95beb..eca8907e87e14 100644
--- a/docs/user/remote-access.md
+++ b/docs/user/remote-access.md
@@ -7,7 +7,7 @@ machine. That machine must stay running and reachable while you work.
 
 T3 Connect makes an environment available to your other devices without setting
 up router forwarding. In the desktop app on the host, open **Settings →
-Connections**, sign in, and enable **T3 Connect** for that environment.
+Sharing & access**, sign in, and enable **T3 Connect** for that environment.
 
 For a command-line host, run:
 
@@ -280,12 +280,12 @@ off on either machine, agents start nothing over a link between them. A task
 already running on the other machine still finishes, and if that machine has it
 off, its result arrives once it is back on.
 
-On the machine you will work from, open **Settings → Connections → Linked environments**,
+On the machine you will work from, open **Settings → Environments → Linked environments**,
 choose **Link**, and pick the other machine or enter its address. The list
 holds the machines this app knows and those on your T3 Connect account. If this
 app is connected to that machine with a session that manages access there, it
 makes the pairing code itself; otherwise paste one from that machine's
-**Settings → Connections**. From a terminal, use
+**Settings → Sharing & access**. From a terminal, use
 `t3 environment link <address> --pairing-code <code> --access <mode>`.
 
 You can also ask an agent to link a machine by name, such as "delegate this to
@@ -299,7 +299,7 @@ and the access, then approve.
   access, the link's agents can change only threads it started, not that
   machine's own threads, projects or settings, and they skip its project setup
   scripts.
-- The link shows up in that machine's **Settings → Connections** like any
+- The link shows up in that machine's **Settings → Sharing & access** like any
   outside agent. Revoke it there to end it. **Forget** on this machine only
   removes it here.
 - Links last 30 days. Link again with a new pairing code to renew one.
diff --git a/docs/user/thread-sidebar.md b/docs/user/thread-sidebar.md
index ce16b9df0374b..fb5e12b08372b 100644
--- a/docs/user/thread-sidebar.md
+++ b/docs/user/thread-sidebar.md
@@ -37,6 +37,12 @@ folder, so the files the agent wrote stay until you delete them. Branch, worktre
 these folders are not Git repositories. This is unavailable when the data
 directory itself sits inside a Git checkout.
 
+When the work grows into something real, pick **Turn into project** from the
+thread's menu. The thread's folder becomes a project where it is, so nothing
+moves and the agent keeps working in the same place. Other threads in that folder
+move with it. Rename the project in its settings, and use **Initialize Git** to
+get branch and diff controls.
+
 ### Start in the background
 
 In a desktop browser or the desktop app, press `Cmd+Enter` on macOS or `Ctrl+Enter`
@@ -271,6 +277,11 @@ Select a server to open it in the browser panel. **Stop** ends the server's job
 and keeps the agent, the terminal, and T3 Code running. Stop needs terminal
 access to the environment and is not available on Windows.
 
+To choose what the thread details card shows, right-click the card or open
+**Settings → Appearance → Thread details**. Hidden rows keep their keyboard
+shortcuts, such as Open in editor and project scripts. **Reset to default** brings
+back the standard rows.
+
 ## Snooze until later
 
 To change the choices in the snooze menu, open **Settings → Threads → Snooze options**.
diff --git a/docs/user/updating.md b/docs/user/updating.md
index ad5d93b5759a2..cfe746c187338 100644
--- a/docs/user/updating.md
+++ b/docs/user/updating.md
@@ -22,10 +22,11 @@ restart from the update button when you are ready. A server still restarting
 finishes on its own, and the button keeps showing it after the desktop app
 restarts.
 
-Server updates appear only after that version is published to npm. Remote
-desktop apps do not wait for npm. The confirmation lists each machine it skips
-and why, such as a machine that is offline or needs a manual update. Use
-**Settings → Environments** for those.
+Remote desktop apps never wait for npm. When the desktop app offers the update,
+background services update right away too. Other servers, including older
+background services, update only after that version is published to npm. The
+confirmation lists each machine it skips and why, such as a machine that is
+offline or needs a manual update. Use **Settings → Environments** for those.
 
 If a desktop app restarts on its old version, T3 Code tells you the update did
 not apply. It does not install that version again on its own, even when another
@@ -35,6 +36,29 @@ The confirmation counts the running threads that the restarts will interrupt,
 and how many can resume afterwards. See **Continue threads after restarts**
 below.
 
+## Switch between Stable and Nightly
+
+In the desktop app, change **Settings → About → Update track**. T3 Code shows each
+connected machine it will move and each one it skips, then moves them in one
+step. Remote servers install the latest release on the new track. Remote desktop
+apps reinstall on the new track. This app reinstalls last. Your threads,
+settings, and data stay.
+
+A background service cannot move to an older release remotely. When Stable is
+older than its Nightly, run `t3 update --channel stable --allow-downgrade` on
+that machine.
+
+A switch is blocked for a machine whose database already has changes the
+target release does not support, or when T3 Code cannot confirm that it does.
+The dialog says why: update a machine on its current track first when its
+release is too old to check, or wait until the target track includes the
+changes. A Mac running the desktop app must switch on that Mac.
+
+Each machine keeps the new track even if its switch did not finish, but it
+moves to that track only through a switch. **Update track** shows how many
+machines still run the other track. **Review** opens the same dialog with fresh
+checks.
+
 ## Before you update
 
 Server updates restart the connection and can interrupt active agents and
diff --git a/docs/user/usage.md b/docs/user/usage.md
index e41e60ca73d76..155175351c550 100644
--- a/docs/user/usage.md
+++ b/docs/user/usage.md
@@ -116,6 +116,12 @@ current model's limits without leaving the conversation. The result opens above
 closes when you dismiss it or send your next message. It uses the same snapshot as **Usage → Limits**, so it does not run the agent or refresh
 anything. The command is offered only for providers that appear under **Usage → Limits**.
 
+To keep them in view on web and desktop, turn on **Usage** in **Settings → Appearance → Thread details**, or right-click the thread details card.
+The bottom of the thread details card then shows how much is left in each limit window of the
+current provider account and in the thread's context window. Some windows, such as a weekly Opus
+limit, count only one model. Hover a row to see when it resets, your pace, or
+the token count.
+
 OpenCode Go reports its session, weekly, and monthly allowance when OpenCode runs locally in
 the environment. T3 cannot report limits for external OpenCode servers because their credentials
 belong to the remote server. Limits need an OpenCode Go API key, or an OpenCode Console connected
diff --git a/infra/relay/README.md b/infra/relay/README.md
index 4b5ac35e438bd..e80428074e7d0 100644
--- a/infra/relay/README.md
+++ b/infra/relay/README.md
@@ -1,7 +1,7 @@
 # T3 Connect Relay
 
 > [!NOTE]
-> Sign in to T3 Connect from the app under Settings > Connections.
+> Sign in to T3 Connect from the app under Settings > Sharing & access.
 
 The relay is the hosted control plane for T3 Connect. It helps clients discover and connect to
 remote environments, manages the cloud-side records needed for those connections, and delivers
diff --git a/knip.jsonc b/knip.jsonc
index c2093737fd942..1a3101ceda527 100644
--- a/knip.jsonc
+++ b/knip.jsonc
@@ -13,6 +13,8 @@
         ".coderabbit.config.ts",
         ".github/scripts/thread-transfer-report.cjs",
       ],
+      // coil: only retired upstream workflows ran this (scripts/coil/sync-upstream.sh).
+      "ignore": [".github/scripts/mirror-play-apk.cjs"],
       "vite": { "entry": [".github/**/*.test.cjs"] },
       "vitest": { "entry": [".github/**/*.test.cjs"] },
     },
@@ -39,7 +41,16 @@
       // The `t3` npm package's files: copied into the package, never imported.
       // knip-schemas.test.ts writes a throwaway project to .knip-test-*, which a
       // knip run beside it in check:changed must not report.
-      "ignore": ["npm-launcher/**", ".knip-test-*/**"],
+      // coil: worklog runs by path, and the rest only ran from retired upstream workflows.
+      "ignore": [
+        "npm-launcher/**",
+        ".knip-test-*/**",
+        "coil/**",
+        "build-cli-archive.ts",
+        "notify-discord-release.ts",
+        "resolve-nightly-release.ts",
+        "smoke-cli-archive.ts",
+      ],
     },
     "apps/server": {
       // Vite+ pack entries and the launcher used by installed background services.
@@ -92,6 +103,8 @@
       // named subcomponents even before they have callers; the file audit still
       // reports an entire component module when nothing imports it.
       "ignoreIssues": { "src/components/ui/*.tsx": ["exports", "nsExports", "duplicates"] },
+      // coil: only the retired release.yml ran this.
+      "ignore": ["scripts/verify-built-boot.ts"],
     },
     "apps/marketing": {
       // `astro check` runs from the typecheck task in vite.config.ts, which knip does not read.
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index 66e79c7492ae3..5808641a5606a 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -331,6 +331,10 @@
       "types": "./src/state/threadExecution.ts",
       "default": "./src/state/threadExecution.ts"
     },
+    "./state/pending-user-input": {
+      "types": "./src/state/pendingUserInput.ts",
+      "default": "./src/state/pendingUserInput.ts"
+    },
     "./state/thread-requests": {
       "types": "./src/state/threadRequests.ts",
       "default": "./src/state/threadRequests.ts"
diff --git a/packages/client-runtime/src/device/stream.test.ts b/packages/client-runtime/src/device/stream.test.ts
index 7da96cb3d75b7..737daf5158c04 100644
--- a/packages/client-runtime/src/device/stream.test.ts
+++ b/packages/client-runtime/src/device/stream.test.ts
@@ -199,7 +199,11 @@ class MjpegImage extends EventTarget {
   }
 }
 
-function recoveryFixture(platform: "ios" | "android" = "ios", preferMjpeg = true) {
+function recoveryFixture(
+  platform: "ios" | "android" = "ios",
+  preferMjpeg = true,
+  serveSimOnly = false,
+) {
   vi.useFakeTimers();
   const sockets: Socket[] = [];
   class Socket {
@@ -211,7 +215,9 @@ function recoveryFixture(platform: "ios" | "android" = "ios", preferMjpeg = true
     onclose: ((event: { code: number; reason: string }) => void) | null = null;
     send = vi.fn();
     close = vi.fn();
-    constructor() {
+    readonly url: string;
+    constructor(url: string) {
+      this.url = url;
       sockets.push(this);
     }
   }
@@ -273,6 +279,7 @@ function recoveryFixture(platform: "ios" | "android" = "ios", preferMjpeg = true
     {
       platform,
       preferMjpeg,
+      serveSimOnly,
       deviceId: "test-device",
       access: {
         httpBase: "https://test/api/device-hub",
@@ -353,6 +360,56 @@ describe("shared device stream readiness and recovery", () => {
     }
   });
 
+  it("streams and drives a serve-sim-only Android device over serve-sim's AVCC and input socket", async () => {
+    const { client, events, fetch, sockets, videoBodies, decoders } = recoveryFixture(
+      "android",
+      false,
+      true,
+    );
+    client.start();
+    await vi.advanceTimersByTimeAsync(0);
+    // No MJPEG priming: Simlock serves only the AVCC stream and the input socket.
+    expect(fetch.mock.calls.map(([url]) => url)).toEqual([
+      "https://test/api/device-hub/vendor/serve-sim/helper/test-device/stream.avcc",
+    ]);
+    expect(sockets.map((socket) => socket.url)).toEqual([
+      "wss://test/api/device-hub/vendor/serve-sim/helper/ws?device=test-device",
+    ]);
+    // Simlock adds meta (5), keep-alive (6), and lease-end (7) frames to serve-sim's envelopes.
+    videoBodies[0]!.enqueue(
+      new Uint8Array([
+        ...envelope(5, [0x7b, 0x7d]),
+        ...envelope(1, [1, 0x64, 0, 0x1f]),
+        ...envelope(6, []),
+        ...envelope(2, [2]),
+        ...envelope(7, [0x7b, 0x7d]),
+      ]),
+    );
+    await vi.advanceTimersByTimeAsync(0);
+    expect(decoders[0]!.decode).toHaveBeenCalledOnce();
+
+    const input = sockets[0]!;
+    input.onmessage?.({ data: Uint8Array.of(0x83).buffer });
+    input.onmessage?.({
+      data: new Uint8Array([
+        0x82,
+        ...new TextEncoder().encode('{"width":1080,"height":2400,"orientation":"portrait"}'),
+      ]).buffer,
+    });
+    expect(events.onInputConnected).toHaveBeenLastCalledWith(true, undefined);
+    client.sendTouch("begin", 0.25, 0.5);
+    client.pressButton("back");
+    const sent = input.send.mock.calls.map(([payload]) => {
+      const bytes = payload as Uint8Array;
+      return [bytes[0], JSON.parse(new TextDecoder().decode(bytes.subarray(1)))];
+    });
+    expect(sent).toEqual([
+      [0x03, { type: "begin", x: 0.25, y: 0.5 }],
+      [0x04, { button: "back" }],
+    ]);
+    client.stop();
+  });
+
   it("does not repaint a delayed JPEG seed over newer decoded video", async () => {
     const { client, videoBodies, drawImage, decodedFrame } = recoveryFixture("ios", false);
     let resolveBitmap!: (bitmap: ImageBitmap) => void;
diff --git a/packages/client-runtime/src/device/stream.ts b/packages/client-runtime/src/device/stream.ts
index dc1720725f4f1..c4b8078597245 100644
--- a/packages/client-runtime/src/device/stream.ts
+++ b/packages/client-runtime/src/device/stream.ts
@@ -120,6 +120,8 @@ export interface DeviceStreamTarget {
   readonly preferMjpeg?: boolean;
   readonly panelId?: 1 | 3;
   readonly videoOnly?: boolean;
+  /** The host speaks only serve-sim's AVCC stream and input socket, on both platforms (Simlock). */
+  readonly serveSimOnly?: boolean;
 }
 
 export type DeviceHardwareButton = "home" | "back" | "recents" | "power" | "appSwitcher";
@@ -388,12 +390,16 @@ export function createDeviceStreamClient(
 ): DeviceStreamClient {
   const { access, platform, deviceId } = target;
   const sink = "present" in output ? output : createCanvasFrameSink(output);
-  const vendor = platform === "ios" ? "/vendor/serve-sim" : "/vendor/serve-emu";
+  // Android normally streams over serve-emu's socket; a serve-sim-only host serves it like iOS.
+  const serveSimOnly = target.serveSimOnly === true;
+  const avcc = platform === "ios" || serveSimOnly;
+  const vendor = avcc ? "/vendor/serve-sim" : "/vendor/serve-emu";
   const device = encodeURIComponent(deviceId);
   const httpUrl = (path: string) =>
     withDeviceHubQuery(`${access.httpBase}${vendor}${path}`, access);
   const wsUrl = (path: string) => withDeviceHubQuery(`${access.wsBase}${vendor}${path}`, access);
-  const useWebCodecs = isWebCodecsSupported() && !(platform === "ios" && target.preferMjpeg);
+  const useWebCodecs =
+    isWebCodecsSupported() && !(platform === "ios" && target.preferMjpeg && !serveSimOnly);
 
   let stopped = true;
   let socket: WebSocket | null = null;
@@ -551,7 +557,7 @@ export function createDeviceStreamClient(
 
   const paint = (source: CanvasImageSource, width: number, height: number) => {
     if (stopped) return;
-    if (platform === "android" && (screen?.width !== width || screen.height !== height)) {
+    if (!avcc && (screen?.width !== width || screen.height !== height)) {
       screen = { width, height, orientation: width > height ? "landscape_left" : "portrait" };
       events.onScreen(screen);
     }
@@ -572,7 +578,11 @@ export function createDeviceStreamClient(
   };
 
   const recoverDecoder = () => {
-    if (platform === "ios") fallBackToMjpeg();
+    if (serveSimOnly) {
+      // A new AVCC request starts a fresh capture with a keyframe; there is no MJPEG.
+      closeDecoder();
+      controller?.abort();
+    } else if (platform === "ios") fallBackToMjpeg();
     else {
       closeDecoder();
       connecting("Video decoder restarted.");
@@ -585,10 +595,7 @@ export function createDeviceStreamClient(
     const decoder = new VideoDecoder({
       output: (frame) => {
         try {
-          if (
-            videoDecoder === decoder &&
-            (platform !== "ios" || feedGeneration === videoGeneration)
-          ) {
+          if (videoDecoder === decoder && (!avcc || feedGeneration === videoGeneration)) {
             decodedVideoGeneration = feedGeneration;
             paint(frame, frame.displayWidth, frame.displayHeight);
           }
@@ -597,11 +604,7 @@ export function createDeviceStreamClient(
         }
       },
       error: () => {
-        if (
-          stopped ||
-          videoDecoder !== decoder ||
-          (platform === "ios" && feedGeneration !== videoGeneration)
-        )
+        if (stopped || videoDecoder !== decoder || (avcc && feedGeneration !== videoGeneration))
           return;
         recoverDecoder();
       },
@@ -638,7 +641,7 @@ export function createDeviceStreamClient(
       awaitingKeyframe = false;
     }
     if (videoDecoder.decodeQueueSize > SOFT_DECODE_QUEUE) {
-      if (platform !== "ios") {
+      if (!avcc) {
         recoverDecoder();
         return;
       }
@@ -769,7 +772,12 @@ export function createDeviceStreamClient(
               if (!configured) {
                 await reader.cancel().catch(() => {});
                 if (!isCurrent()) return;
-                if (target.videoOnly)
+                if (serveSimOnly)
+                  setStatus(
+                    "error",
+                    `This browser cannot decode this device's ${avcCodecString(chunk.payload)} stream.`,
+                  );
+                else if (target.videoOnly)
                   setStatus(
                     "error",
                     `This browser cannot decode the Duo panel's ${avcCodecString(chunk.payload)} stream.`,
@@ -1070,7 +1078,7 @@ export function createDeviceStreamClient(
   const connectIosInput = async () => {
     if (stopped) return;
     const session = generation;
-    await primeIosHelper(session);
+    if (!serveSimOnly) await primeIosHelper(session);
     if (stopped || generation !== session) return;
     const ws = new WebSocket(wsUrl(`/helper/ws?device=${device}`));
     ws.binaryType = "arraybuffer";
@@ -1231,7 +1239,11 @@ export function createDeviceStreamClient(
     iosInputAdmitted = false;
     iosInputUnavailable = false;
     connecting();
-    if (platform === "ios") {
+    if (serveSimOnly) {
+      if (!target.videoOnly) void connectIosInput();
+      if (useWebCodecs) void readIosVideo();
+      else fail("This browser cannot decode this device's stream (WebCodecs unavailable).");
+    } else if (platform === "ios") {
       if (!target.videoOnly) void connectIosInput();
       if (useWebCodecs) void readIosVideo();
       else fallBackToMjpeg();
@@ -1275,7 +1287,7 @@ export function createDeviceStreamClient(
   const send = (payload: Uint8Array<ArrayBuffer> | string) => {
     if (
       !stopped &&
-      (platform !== "ios" || (iosInputAdmitted && !iosInputUnavailable)) &&
+      (!avcc || (iosInputAdmitted && !iosInputUnavailable)) &&
       socket?.readyState === WebSocket.OPEN
     )
       socket.send(payload);
@@ -1326,7 +1338,7 @@ export function createDeviceStreamClient(
       startDuoVideo(panels);
     },
     sendTouch: (phase, x, y) => {
-      if (platform === "ios") {
+      if (avcc) {
         send(taggedJson(IOS_MSG_TOUCH, { type: phase, ...rawPoint(x, y) }));
         return;
       }
@@ -1334,7 +1346,7 @@ export function createDeviceStreamClient(
       send(JSON.stringify({ type: "touch", action, x, y }));
     },
     sendKey: (event, phase) => {
-      if (platform === "ios") {
+      if (avcc) {
         const usage = hidUsageForCode(event.code);
         if (usage !== null) send(taggedJson(IOS_MSG_KEY, { type: phase, usage }));
         return;
@@ -1348,7 +1360,7 @@ export function createDeviceStreamClient(
       }
     },
     sendText: (text) => {
-      if (platform !== "android") return;
+      if (avcc) return;
       let chunk = "";
       let chunkBytes = 0;
       let sentChunks = 0;
@@ -1366,15 +1378,17 @@ export function createDeviceStreamClient(
       if (chunk.length > 0) send(JSON.stringify({ type: "text", text: chunk }));
     },
     pressButton: (button) => {
-      if (platform === "ios") {
+      if (avcc) {
         const name =
           button === "home"
             ? "home"
-            : button === "appSwitcher"
+            : button === "appSwitcher" || button === "recents"
               ? "app_switcher"
               : button === "power"
                 ? "lock"
-                : null;
+                : button === "back" && platform === "android"
+                  ? "back"
+                  : null;
         if (name) send(taggedJson(IOS_MSG_BUTTON, { button: name }));
         return;
       }
diff --git a/packages/client-runtime/src/operations/commands.performance.test.ts b/packages/client-runtime/src/operations/commands.performance.test.ts
index 2378407c2df73..d4be3f1a9f456 100644
--- a/packages/client-runtime/src/operations/commands.performance.test.ts
+++ b/packages/client-runtime/src/operations/commands.performance.test.ts
@@ -223,7 +223,7 @@ describe("routine command transport budget", () => {
       if (command.type !== "message.dispatch") {
         throw new Error(`Expected message.dispatch, received ${command.type}`);
       }
-      if (!("sequence" in receipt)) {
+      if ("projection" in receipt) {
         throw new Error("Expected a dispatch receipt");
       }
       const { deliveryIntent: _deliveryIntent, ...formerCommand } = command;
diff --git a/packages/client-runtime/src/pullRequestEditing.ts b/packages/client-runtime/src/pullRequestEditing.ts
index 96b4d5c494f9b..e65c19009e653 100644
--- a/packages/client-runtime/src/pullRequestEditing.ts
+++ b/packages/client-runtime/src/pullRequestEditing.ts
@@ -25,6 +25,41 @@ export function canEditPullRequestChangeRequest(detail: EditingSubject): boolean
   );
 }
 
+export function canEditPullRequestMaintainerEdits(
+  detail: Pick<
+    PullRequestDetail,
+    "state" | "capabilities" | "viewerPermissions" | "maintainerCanModify"
+  >,
+): boolean {
+  return (
+    detail.state === "open" &&
+    detail.capabilities.edit?.maintainerEdits === true &&
+    detail.viewerPermissions.maintainerEdits === true &&
+    detail.maintainerCanModify !== undefined
+  );
+}
+
+export interface MaintainerEditsChoice {
+  readonly key: string;
+  readonly observedAt: number | undefined;
+  readonly value: boolean;
+}
+
+/**
+ * A saved choice ends at the first host reading delivered after the save. Readers refresh once it
+ * succeeds, which drops reads still in flight, so that reading started after the write.
+ */
+export function maintainerEditsChoiceInForce(
+  choice: MaintainerEditsChoice | null,
+  key: string,
+  observedAt: number | undefined,
+  saving: boolean,
+): MaintainerEditsChoice | null {
+  if (choice === null || choice.key !== key) return null;
+  if (saving) return choice.observedAt === observedAt ? choice : { ...choice, observedAt };
+  return observedAt !== undefined && choice.observedAt === observedAt ? choice : null;
+}
+
 /** Hosts do not support rewriting review summaries through comment mutations. */
 export function canEditPullRequestComment(
   detail: EditingSubject,
diff --git a/packages/client-runtime/src/state/commandPermissions.test.ts b/packages/client-runtime/src/state/commandPermissions.test.ts
index ed28cd13e3a00..adfad46a41b89 100644
--- a/packages/client-runtime/src/state/commandPermissions.test.ts
+++ b/packages/client-runtime/src/state/commandPermissions.test.ts
@@ -16,6 +16,7 @@ import {
   AuthSourceControlWriteScope,
   ThreadId,
   EnvironmentId,
+  ORCHESTRATION_V2_WS_METHODS,
   ScheduledTaskId,
   WS_METHODS,
   type AuthSessionState,
@@ -121,21 +122,45 @@ describe("command permissions", () => {
     ),
   );
 
-  it.effect("uses the target grant for both availability and execution", () =>
+  it.effect("requires the destination settings grant to check OTLP endpoints", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const registry = yield* setup;
+        const check = createCommandPermissions(runtime, WS_METHODS.serverCheckOtlpEndpoint);
         registry.set(sessions(env), AsyncResult.success(grant(true)));
-        expect(registry.get(permissions.permissionAtom(env))).toBe(true);
-        expect(permissions.permissionAtom(env)).toBe(permissions.permissionAtom(env));
-        yield* permissions.authorize(registry, env);
-        registry.set(sessions(other), AsyncResult.success(grant(false)));
-        expect(registry.get(permissions.permissionAtom(other))).toBe(false);
-        const denied = yield* permissions.authorize(registry, other).pipe(Effect.flip);
-        expect(denied._tag).toBe("EnvironmentAuthorizationError");
+        expect(registry.get(check.permissionAtom(env))).toBe(false);
+        registry.set(
+          sessions(env),
+          AsyncResult.success({
+            ...grant(false),
+            scopes: [AuthSettingsWriteScope],
+            permissions: [AuthSettingsWriteScope],
+          }),
+        );
+        expect(registry.get(check.permissionAtom(env))).toBe(true);
+        yield* check.authorize(registry, env);
       }),
     ),
   );
+
+  it.effect.each([WS_METHODS.scheduledTasksDelete, ORCHESTRATION_V2_WS_METHODS.stopWorkflow])(
+    "uses the target grant for both availability and execution of %s",
+    (method) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const registry = yield* setup;
+          const permissions = createCommandPermissions(runtime, method);
+          registry.set(sessions(env), AsyncResult.success(grant(true)));
+          expect(registry.get(permissions.permissionAtom(env))).toBe(true);
+          expect(permissions.permissionAtom(env)).toBe(permissions.permissionAtom(env));
+          yield* permissions.authorize(registry, env);
+          registry.set(sessions(other), AsyncResult.success(grant(false)));
+          expect(registry.get(permissions.permissionAtom(other))).toBe(false);
+          const denied = yield* permissions.authorize(registry, other).pipe(Effect.flip);
+          expect(denied._tag).toBe("EnvironmentAuthorizationError");
+        }),
+      ),
+  );
   it.effect("waits for an initial grant", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/packages/client-runtime/src/state/pendingUserInput.test.ts b/packages/client-runtime/src/state/pendingUserInput.test.ts
new file mode 100644
index 0000000000000..7f5a2b0b84c3d
--- /dev/null
+++ b/packages/client-runtime/src/state/pendingUserInput.test.ts
@@ -0,0 +1,180 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+  buildPendingUserInputAnswers,
+  isPendingUserInputOptionSelected,
+  resolvePendingUserInputAnswer,
+  setPendingUserInputCustomAnswer,
+  togglePendingUserInputOptionSelection,
+} from "./pendingUserInput.ts";
+
+const singleSelectQuestion = {
+  id: "scope",
+  header: "Scope",
+  question: "What should the plan target first?",
+  options: [
+    { label: "Orchestration-first", description: "Focus on orchestration first" },
+    { label: "Node.js", description: "Reuse TypeScript" },
+  ],
+  multiSelect: false,
+} as const;
+
+const nativeChoiceQuestion = {
+  id: "result",
+  header: "Result",
+  question: "Which result should be used?",
+  options: [
+    { value: " first\t", label: "Result", description: "First result" },
+    { value: "second", label: "Result", description: "Second result" },
+  ],
+  allowCustomAnswer: false,
+  multiSelect: false,
+} as const;
+
+describe("resolvePendingUserInputAnswer", () => {
+  it("preserves exact editor text, including a deliberately cleared answer", () => {
+    const question = { ...singleSelectQuestion, initialAnswer: "  Proposed message\n" };
+    expect(resolvePendingUserInputAnswer(question, { customAnswer: question.initialAnswer })).toBe(
+      question.initialAnswer,
+    );
+    expect(resolvePendingUserInputAnswer(question, { customAnswer: "  Edited message\n\n" })).toBe(
+      "  Edited message\n\n",
+    );
+    expect(resolvePendingUserInputAnswer(question, { customAnswer: "" })).toBe("");
+    expect(resolvePendingUserInputAnswer(question, { customAnswer: " \n" })).toBe(" \n");
+    expect(
+      setPendingUserInputCustomAnswer(
+        question,
+        { selectedOptionValues: ["Orchestration-first"] },
+        "",
+      ),
+    ).toEqual({ customAnswer: "" });
+  });
+
+  it("prefers a custom answer over selected options", () => {
+    expect(
+      resolvePendingUserInputAnswer(singleSelectQuestion, {
+        selectedOptionValues: ["Orchestration-first"],
+        customAnswer: "Keep the existing envelope for one release",
+      }),
+    ).toBe("Keep the existing envelope for one release");
+  });
+
+  it("does not replace a required choice with a custom answer", () => {
+    expect(
+      resolvePendingUserInputAnswer(nativeChoiceQuestion, {
+        selectedOptionValues: ["second"],
+        customAnswer: "Use another result",
+      }),
+    ).toBe("second");
+  });
+
+  it("does not submit labels or unknown values when an option has a value", () => {
+    expect(
+      resolvePendingUserInputAnswer(nativeChoiceQuestion, {
+        selectedOptionValues: ["Result", "unknown"],
+      }),
+    ).toBeNull();
+  });
+
+  it("matches a label only for an option without a value", () => {
+    expect(
+      resolvePendingUserInputAnswer(singleSelectQuestion, { selectedOptionValues: [" Node.js "] }),
+    ).toBe("Node.js");
+  });
+
+  it("accepts ready attachment-only answers while preserving selected options", () => {
+    expect(resolvePendingUserInputAnswer(singleSelectQuestion, { attachmentCount: 1 })).toBe("");
+    expect(
+      resolvePendingUserInputAnswer(singleSelectQuestion, {
+        attachmentCount: 1,
+        selectedOptionValues: ["Node.js"],
+      }),
+    ).toBe("Node.js");
+    expect(
+      resolvePendingUserInputAnswer(singleSelectQuestion, {
+        attachmentCount: 1,
+        attachmentsBlocked: true,
+      }),
+    ).toBeNull();
+    expect(
+      resolvePendingUserInputAnswer(
+        { ...singleSelectQuestion, allowCustomAnswer: false },
+        { attachmentCount: 1 },
+      ),
+    ).toBeNull();
+  });
+});
+
+describe("togglePendingUserInputOptionSelection", () => {
+  it("selects and removes options with the same label independently", () => {
+    const question = { ...nativeChoiceQuestion, multiSelect: true };
+    const firstSelected = togglePendingUserInputOptionSelection(question, undefined, " first\t");
+    const bothSelected = togglePendingUserInputOptionSelection(question, firstSelected, "second");
+
+    expect(buildPendingUserInputAnswers([question], { result: bothSelected })).toEqual({
+      result: [" first\t", "second"],
+    });
+
+    const secondSelected = togglePendingUserInputOptionSelection(
+      question,
+      bothSelected,
+      " first\t",
+    );
+    expect(buildPendingUserInputAnswers([question], { result: secondSelected })).toEqual({
+      result: ["second"],
+    });
+  });
+
+  it("submits raw option values and leaves the draft alone for an unknown option", () => {
+    const first = togglePendingUserInputOptionSelection(
+      nativeChoiceQuestion,
+      undefined,
+      " first\t",
+    );
+    expect(isPendingUserInputOptionSelected(nativeChoiceQuestion, first, " first\t")).toBe(true);
+    expect(isPendingUserInputOptionSelected(nativeChoiceQuestion, first, "second")).toBe(false);
+    expect(buildPendingUserInputAnswers([nativeChoiceQuestion], { result: first })).toEqual({
+      result: " first\t",
+    });
+    expect(togglePendingUserInputOptionSelection(nativeChoiceQuestion, first, "Result")).toBe(
+      first,
+    );
+  });
+});
+
+describe("setPendingUserInputCustomAnswer", () => {
+  it("rejects arbitrary text when the provider only accepts offered options", () => {
+    expect(setPendingUserInputCustomAnswer(nativeChoiceQuestion, undefined, "Other")).toEqual({});
+    expect(
+      buildPendingUserInputAnswers([nativeChoiceQuestion], { result: { customAnswer: "Other" } }),
+    ).toBeNull();
+    expect(
+      buildPendingUserInputAnswers([nativeChoiceQuestion], {
+        result: { selectedOptionValues: ["second"], customAnswer: "stale draft" },
+      }),
+    ).toEqual({ result: "second" });
+  });
+});
+
+const compatQuestion = {
+  id: "compat",
+  header: "Compat",
+  question: "How strict should compatibility be?",
+  options: [{ label: "Keep current envelope", description: "Preserve current wire format" }],
+  multiSelect: false,
+} as const;
+
+describe("buildPendingUserInputAnswers", () => {
+  it("returns a canonical answer map for complete prompts", () => {
+    expect(
+      buildPendingUserInputAnswers([singleSelectQuestion, compatQuestion], {
+        scope: { selectedOptionValues: ["Orchestration-first"] },
+        compat: { customAnswer: "Keep the current envelope for one release window" },
+      }),
+    ).toEqual({
+      scope: "Orchestration-first",
+      compat: "Keep the current envelope for one release window",
+    });
+  });
+});
diff --git a/packages/client-runtime/src/state/pendingUserInput.ts b/packages/client-runtime/src/state/pendingUserInput.ts
new file mode 100644
index 0000000000000..1c71cdb29b4df
--- /dev/null
+++ b/packages/client-runtime/src/state/pendingUserInput.ts
@@ -0,0 +1,176 @@
+/** The question fields answer handling reads. Web and mobile question types both fit it. */
+export interface PendingUserInputQuestion {
+  readonly id: string;
+  readonly options: ReadonlyArray<{ readonly label: string; readonly value?: string | undefined }>;
+  readonly multiSelect?: boolean | undefined;
+  readonly allowCustomAnswer?: boolean | undefined;
+  readonly initialAnswer?: string | undefined;
+}
+
+export interface PendingUserInputDraftAnswer {
+  readonly selectedOptionValues?: ReadonlyArray<string>;
+  readonly customAnswer?: string;
+  readonly attachmentCount?: number;
+  readonly attachmentsBlocked?: boolean;
+}
+
+export type PendingUserInputAnswer = string | ReadonlyArray<string>;
+
+function normalizeDraftAnswer(value: string | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+// Provider option values stay exact, including whitespace. Only options without a value match by label.
+function resolvePendingUserInputOptionValue(
+  question: PendingUserInputQuestion,
+  value: string,
+): string | null {
+  if (question.options.some((option) => option.value === value)) {
+    return value;
+  }
+
+  const label = value.trim();
+  return label.length > 0 &&
+    question.options.some((option) => option.value === undefined && option.label.trim() === label)
+    ? label
+    : null;
+}
+
+/** The draft's selections that name an offered option, deduplicated, in selection order. */
+export function normalizeSelectedOptionValues(
+  question: PendingUserInputQuestion,
+  value: ReadonlyArray<string> | undefined,
+): ReadonlyArray<string> {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return Array.from(
+    new Set(
+      value
+        .map((entry) => resolvePendingUserInputOptionValue(question, entry))
+        .filter((entry): entry is string => entry !== null),
+    ),
+  );
+}
+
+/** The answer to submit for one question, or null while it is unanswered. */
+export function resolvePendingUserInputAnswer(
+  question: PendingUserInputQuestion,
+  draft: PendingUserInputDraftAnswer | undefined,
+): PendingUserInputAnswer | null {
+  if (draft?.attachmentsBlocked) return null;
+  const customAnswer =
+    question.allowCustomAnswer === false
+      ? null
+      : question.initialAnswer !== undefined
+        ? (draft?.customAnswer ?? null)
+        : normalizeDraftAnswer(draft?.customAnswer);
+  if (customAnswer !== null && customAnswer.length > 0) {
+    return customAnswer;
+  }
+
+  const selectedOptionValues = normalizeSelectedOptionValues(question, draft?.selectedOptionValues);
+  if (question.multiSelect) {
+    return selectedOptionValues.length > 0
+      ? selectedOptionValues
+      : (customAnswer ??
+          (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null));
+  }
+  return (
+    selectedOptionValues[0] ??
+    customAnswer ??
+    (question.allowCustomAnswer !== false && (draft?.attachmentCount ?? 0) > 0 ? "" : null)
+  );
+}
+
+export function setPendingUserInputCustomAnswer(
+  question: PendingUserInputQuestion,
+  draft: PendingUserInputDraftAnswer | undefined,
+  customAnswer: string,
+): PendingUserInputDraftAnswer {
+  if (question.allowCustomAnswer === false) {
+    return draft ?? {};
+  }
+
+  const selectedOptionValues =
+    question.initialAnswer !== undefined || customAnswer.trim().length > 0
+      ? undefined
+      : normalizeSelectedOptionValues(question, draft?.selectedOptionValues);
+  return {
+    customAnswer,
+    ...(selectedOptionValues && selectedOptionValues.length > 0 ? { selectedOptionValues } : {}),
+  };
+}
+
+export function isPendingUserInputOptionSelected(
+  question: PendingUserInputQuestion,
+  draft: PendingUserInputDraftAnswer | undefined,
+  optionValue: string,
+): boolean {
+  if (question.allowCustomAnswer !== false && normalizeDraftAnswer(draft?.customAnswer)) {
+    return false;
+  }
+
+  const resolvedOptionValue = resolvePendingUserInputOptionValue(question, optionValue);
+  return (
+    resolvedOptionValue !== null &&
+    normalizeSelectedOptionValues(question, draft?.selectedOptionValues).includes(
+      resolvedOptionValue,
+    )
+  );
+}
+
+/** Toggles an offered option. An unknown option returns the same draft. */
+export function togglePendingUserInputOptionSelection(
+  question: PendingUserInputQuestion,
+  draft: PendingUserInputDraftAnswer | undefined,
+  optionValue: string,
+): PendingUserInputDraftAnswer {
+  const resolvedOptionValue = resolvePendingUserInputOptionValue(question, optionValue);
+  if (resolvedOptionValue === null) {
+    return draft ?? {};
+  }
+
+  if (question.multiSelect) {
+    const selectedOptionValues = normalizeSelectedOptionValues(
+      question,
+      draft?.selectedOptionValues,
+    );
+    const nextSelectedOptionValues = selectedOptionValues.includes(resolvedOptionValue)
+      ? selectedOptionValues.filter((value) => value !== resolvedOptionValue)
+      : [...selectedOptionValues, resolvedOptionValue];
+
+    return {
+      customAnswer: "",
+      ...(nextSelectedOptionValues.length > 0
+        ? { selectedOptionValues: nextSelectedOptionValues }
+        : {}),
+    };
+  }
+
+  return {
+    customAnswer: "",
+    selectedOptionValues: [resolvedOptionValue],
+  };
+}
+
+/** Every question's answer keyed by question id, or null while any is unanswered. */
+export function buildPendingUserInputAnswers(
+  questions: ReadonlyArray<PendingUserInputQuestion>,
+  draftAnswers: Record<string, PendingUserInputDraftAnswer>,
+): Record<string, PendingUserInputAnswer> | null {
+  const answers: Record<string, PendingUserInputAnswer> = {};
+
+  for (const question of questions) {
+    const answer = resolvePendingUserInputAnswer(question, draftAnswers[question.id]);
+    if (answer === null) {
+      return null;
+    }
+    answers[question.id] = answer;
+  }
+
+  return answers;
+}
diff --git a/packages/client-runtime/src/state/projectCommands.ts b/packages/client-runtime/src/state/projectCommands.ts
index ede83d82957a8..03db9b869cc06 100644
--- a/packages/client-runtime/src/state/projectCommands.ts
+++ b/packages/client-runtime/src/state/projectCommands.ts
@@ -201,6 +201,12 @@ export function createProjectEnvironmentAtoms<R, E>(
       scheduler: projectScheduler,
       concurrency: { mode: "serial", key: ({ environmentId }) => environmentId },
     }),
+    createFromThread: createEnvironmentRpcCommand(runtime, {
+      label: "environment-data:projects:create-from-thread",
+      tag: WS_METHODS.projectsCreateFromThread,
+      scheduler: projectScheduler,
+      concurrency: { mode: "serial", key: ({ environmentId }) => environmentId },
+    }),
     writeFile: createEnvironmentRpcCommand(runtime, {
       label: "environment-data:projects:write-file",
       tag: WS_METHODS.projectsWriteFile,
diff --git a/packages/client-runtime/src/state/server.ts b/packages/client-runtime/src/state/server.ts
index c8ce8b3878744..dadaf2dafb7a5 100644
--- a/packages/client-runtime/src/state/server.ts
+++ b/packages/client-runtime/src/state/server.ts
@@ -969,6 +969,17 @@ export function createServerEnvironmentAtoms<R, E>(
           }),
         );
 
+        // A track switch's desktop host already on its track's newest build only saved the
+        // track; nothing restarts.
+        if (
+          result.method === "desktop-app" &&
+          result.desktopUpdateToken === undefined &&
+          result.targetVersion === fromVersion
+        ) {
+          atomRegistry.set(stateAtom, IDLE_SERVER_UPDATE_STATE);
+          return result;
+        }
+
         yield* nudgeReconnectDuringUpdateRestart({
           stateChanges: environmentRegistry.stateChanges(target.environmentId),
           retryNow: environmentRegistry.retryNow(target.environmentId),
diff --git a/packages/client-runtime/src/state/subagentRuntime.test.ts b/packages/client-runtime/src/state/subagentRuntime.test.ts
index 20e334288ab00..c40c9fe42d81e 100644
--- a/packages/client-runtime/src/state/subagentRuntime.test.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.test.ts
@@ -59,6 +59,9 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
           agents: [
             member({
               state: "completed",
+              model: "claude-opus-5[1m]",
+              effort: "xhigh",
+              speed: "standard",
               startedAt: Date.UTC(2026, 7, 1, 10, 0, 0),
               durationMs: 1500,
               completedAt: Date.UTC(2026, 7, 1, 10, 0, 4, 432),
@@ -74,6 +77,9 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
     expect(settled?.status).toBe("completed");
     expect(settled?.completedAt).toBe("2026-08-01T10:00:04.432Z");
     expect(settled?.result).toBe("A1");
+    expect(settled?.model).toBe("claude-opus-5[1m]");
+    expect(settled?.effort).toBe("xhigh");
+    expect(settled?.speed).toBe("standard");
     expect(settled?.progress).toBe("Reply with exactly: A1");
     expect(settled?.usage).toEqual({ totalTokens: 71_141, toolUses: 3, durationMs: 1500 });
   });
@@ -108,6 +114,9 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
         "2026-08-01T10:00:09.000Z",
         "2026-08-01T10:00:01.500Z",
       ]);
+      expect(members?.[0]?.model).toBeNull();
+      expect(members?.[0]?.effort).toBeNull();
+      expect(members?.[0]?.speed).toBeUndefined();
     },
   );
 });
diff --git a/packages/client-runtime/src/state/subagentRuntime.ts b/packages/client-runtime/src/state/subagentRuntime.ts
index c007bc56b9743..e3807362fbdf6 100644
--- a/packages/client-runtime/src/state/subagentRuntime.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.ts
@@ -52,6 +52,7 @@ export interface RuntimeSubagent {
   readonly role: string | null;
   readonly model: string | null;
   readonly effort: string | null;
+  readonly speed?: string | undefined;
   readonly status: RuntimeSubagentStatus;
   readonly activationCount: number;
   readonly usage: SubagentUsage | null;
@@ -150,6 +151,8 @@ function workflowMembersToRuntime(
       kind: "workflow_agent" as const,
       title: agent.label,
       model: agent.model ?? null,
+      effort: agent.effort ?? null,
+      ...(agent.speed === undefined ? {} : { speed: agent.speed }),
       status,
       activationCount: agent.attempt ?? 1,
       usage: workflowUsage(agent),
diff --git a/packages/client-runtime/src/state/threadDetail.ts b/packages/client-runtime/src/state/threadDetail.ts
index 0c93800378797..e1f30998caefb 100644
--- a/packages/client-runtime/src/state/threadDetail.ts
+++ b/packages/client-runtime/src/state/threadDetail.ts
@@ -409,6 +409,12 @@ export function createEnvironmentThreadDetailAtoms<E>(
       Atom.withLabel(`environment-thread-status:${key}`),
     ),
   );
+  const sequenceAtomFamily = Atom.family((key: string) =>
+    Atom.make((get) => get(threadStateValueAtomFamily(key)).sequence).pipe(
+      Atom.setIdleTTL(0),
+      Atom.withLabel(`environment-thread-sequence:${key}`),
+    ),
+  );
   const errorAtomFamily = Atom.family((key: string) =>
     Atom.make((get) => Option.getOrNull(get(threadStateValueAtomFamily(key)).error)).pipe(
       Atom.setIdleTTL(0),
@@ -439,6 +445,7 @@ export function createEnvironmentThreadDetailAtoms<E>(
     quietVisibleTurnItemsAtom: (ref: ScopedThreadRef) =>
       quietVisibleTurnItemsAtomFamily(threadKey(ref)),
     statusAtom: (ref: ScopedThreadRef) => statusAtomFamily(threadKey(ref)),
+    sequenceAtom: (ref: ScopedThreadRef) => sequenceAtomFamily(threadKey(ref)),
     errorAtom: (ref: ScopedThreadRef) => errorAtomFamily(threadKey(ref)),
     historyAtom: (ref: ScopedThreadRef) => historyAtomFamily(threadKey(ref)),
   };
diff --git a/packages/client-runtime/src/state/threadExecution.ts b/packages/client-runtime/src/state/threadExecution.ts
index accf5c98df9a9..ba87930bebbd5 100644
--- a/packages/client-runtime/src/state/threadExecution.ts
+++ b/packages/client-runtime/src/state/threadExecution.ts
@@ -151,6 +151,7 @@ export const REASONING_EFFORT_OPTION_IDS: ReadonlyArray<string> = [
   "reasoning",
   "variant",
   "reasoning_effort",
+  "thinking_level",
 ];
 
 export function formatModelSelectionEffort(
diff --git a/packages/client-runtime/src/state/threadState.ts b/packages/client-runtime/src/state/threadState.ts
index 67b227089ab15..3b53b68b2f4fa 100644
--- a/packages/client-runtime/src/state/threadState.ts
+++ b/packages/client-runtime/src/state/threadState.ts
@@ -14,6 +14,8 @@ export interface EnvironmentThreadState {
    * disconnect path.
    */
   readonly history: ThreadHistoryMeta;
+  /** The last server sequence `data` reflects, so readers can tell a write has landed without searching paged-out history. */
+  readonly sequence: number;
 }
 
 export const EMPTY_ENVIRONMENT_THREAD_STATE: EnvironmentThreadState = {
@@ -21,4 +23,21 @@ export const EMPTY_ENVIRONMENT_THREAD_STATE: EnvironmentThreadState = {
   status: "empty",
   error: Option.none(),
   history: EMPTY_THREAD_HISTORY_META,
+  sequence: 0,
 };
+
+/**
+ * A thread holds a write once it has applied the write's commit sequence. A bounded
+ * projection can page the message out later, so finding it is only a fallback for
+ * servers that do not report the sequence.
+ */
+export function threadHasCaughtUpTo(
+  write: { readonly messageId: string; readonly sequence?: number | undefined },
+  thread: {
+    readonly sequence: number;
+    readonly messages: ReadonlyArray<{ readonly id: string }> | undefined;
+  },
+): boolean {
+  if (write.sequence !== undefined && thread.sequence >= write.sequence) return true;
+  return thread.messages?.some((entry) => entry.id === write.messageId) ?? false;
+}
diff --git a/packages/client-runtime/src/state/threadSubagents.test.ts b/packages/client-runtime/src/state/threadSubagents.test.ts
index 26b9a785c02d3..28544450bfc4e 100644
--- a/packages/client-runtime/src/state/threadSubagents.test.ts
+++ b/packages/client-runtime/src/state/threadSubagents.test.ts
@@ -56,6 +56,33 @@ const activeRun = run("run-1", "running");
 const finishedRun = run("run-1", "completed");
 
 describe("deriveThreadTurnSubagents", () => {
+  it.each(["running", "completed"] as const)(
+    "keeps finished workflows after a later %s turn",
+    (status) => {
+      const workflow = subagent({
+        id: "workflow",
+        status: "completed",
+        workflow: { phases: [], agents: [] },
+      });
+      const turn = deriveThreadTurnSubagents({
+        runs: [finishedRun, run("run-2", status)],
+        subagents: [
+          workflow,
+          subagent({ id: "old", status: "completed" }),
+          subagent({
+            id: "recent",
+            runId: RunId.make("run-2"),
+            status,
+            updatedAt: at("2026-06-20T00:00:09.000Z"),
+          }),
+        ],
+      });
+
+      expect(turn?.subagents.map((entry) => entry.id)).toEqual(["recent", "workflow"]);
+      expect(resolveSubagentPillSegment(turn)).not.toBeNull();
+    },
+  );
+
   it("scopes the roster to the active run and orders it by start time", () => {
     const turn = deriveThreadTurnSubagents({
       runs: [run("run-0", "completed"), activeRun],
@@ -264,15 +291,16 @@ describe("deriveThreadTurnSubagents", () => {
     const turn = deriveThreadTurnSubagents({
       runs: [activeRun],
       subagents: [
-        subagent({ id: "a", status: "running" }),
+        subagent({ id: "a", status: "completed" }),
         subagent({ id: "b", status: "idle" }),
         subagent({ id: "c", status: "failed" }),
       ],
     });
 
-    expect(turn?.liveCount).toBe(1);
-    expect(turn?.settledCount).toBe(1);
+    expect(turn?.liveCount).toBe(0);
+    expect(turn?.settledCount).toBe(2);
     expect(turn?.subagents).toHaveLength(3);
+    expect(resolveSubagentPillSegment(turn)?.label).toBe("2 done");
   });
 
   it("keeps settled workflows reachable without counting idle agents as done", () => {
diff --git a/packages/client-runtime/src/state/threads-sync.test.ts b/packages/client-runtime/src/state/threads-sync.test.ts
index c8c212db41ca1..eaf1751a1c2d2 100644
--- a/packages/client-runtime/src/state/threads-sync.test.ts
+++ b/packages/client-runtime/src/state/threads-sync.test.ts
@@ -678,7 +678,7 @@ describe("EnvironmentThreads", () => {
       const harness = yield* makeHarness({ cached: BASE_PROJECTION });
 
       yield* Queue.offer(harness.inputs, titleUpdated("Live title", CACHED_SNAPSHOT_SEQUENCE + 1));
-      yield* awaitThreadState(
+      const live = yield* awaitThreadState(
         harness.observed,
         (value) =>
           value.status === "live" &&
@@ -686,6 +686,8 @@ describe("EnvironmentThreads", () => {
           value.data.value.thread.title === "Live title",
       );
 
+      // Readers compare this to a command's commit sequence; it moves with the data it describes.
+      expect(live.sequence).toBe(CACHED_SNAPSHOT_SEQUENCE + 1);
       expect(yield* Ref.get(harness.lastSubscribeAfterSequence)).toBe(CACHED_SNAPSHOT_SEQUENCE);
       expect(yield* Ref.get(harness.loaderCalls)).toBe(0);
     }),
@@ -1288,6 +1290,7 @@ describe("EnvironmentThreads", () => {
               status: "cached",
               error: Option.none(),
               history: { ...EMPTY_THREAD_HISTORY_META, historyCursor: null, expanded: true },
+              sequence: CACHED_SNAPSHOT_SEQUENCE,
             },
             sequence: CACHED_SNAPSHOT_SEQUENCE,
             persisted: true,
diff --git a/packages/client-runtime/src/state/threads.ts b/packages/client-runtime/src/state/threads.ts
index 3cb4192f0ab6c..c7b22d9dcdff0 100644
--- a/packages/client-runtime/src/state/threads.ts
+++ b/packages/client-runtime/src/state/threads.ts
@@ -224,6 +224,11 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
         )
       : Option.none<OrchestrationV2ThreadDetailSnapshot>();
   const cachedThread = Option.map(cached, (snapshot) => snapshot.projection);
+  // Seed the resume cursor from the cached snapshot so a warm cache can catch up
+  // via `afterSequence` instead of re-downloading the full thread body.
+  const initialSequence =
+    retained?.sequence ??
+    Option.match(cached, { onNone: () => 0, onSome: (snapshot) => snapshot.snapshotSequence });
   const initialState: EnvironmentThreadState = retained
     ? cachedThreadState(retained.state)
     : {
@@ -234,15 +239,11 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
           onNone: () => EMPTY_THREAD_HISTORY_META,
           onSome: historyMetaFromCachedSnapshot,
         }),
+        sequence: initialSequence,
       };
   const state = yield* SubscriptionRef.make(initialState);
   const canLoadHistory = Option.isSome(httpClient) && Option.isSome(historyController);
   const acceptsBoundedSocketSnapshots = yield* Ref.make(canLoadHistory);
-  // Seed the resume cursor from the cached snapshot so a warm cache can catch up
-  // via `afterSequence` instead of re-downloading the full thread body.
-  const initialSequence =
-    retained?.sequence ??
-    Option.match(cached, { onNone: () => 0, onSome: (snapshot) => snapshot.snapshotSequence });
   const lastSequence = yield* SubscriptionRef.make(initialSequence);
   let committed: ThreadResumeSnapshot = {
     state: initialState,
@@ -400,6 +401,7 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
     },
   ) {
     const waiting = yield* Ref.get(awaitingCompletion);
+    const sequence = yield* SubscriptionRef.get(lastSequence);
     // Atomic with concurrent history meta updates: never get-then-set the whole
     // state when only the projection changes. Bounded installs pass history so
     // projection + cursor persist together in one enqueue.
@@ -420,6 +422,7 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
             : ("live" as const),
         error: previous.error,
         history,
+        sequence,
       };
     });
     // Active projections can update many times per second and retain large tool
@@ -451,6 +454,7 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
       status: "deleted",
       error: Option.none(),
       history: EMPTY_THREAD_HISTORY_META,
+      sequence: yield* SubscriptionRef.get(lastSequence),
     });
     yield* remember;
     if (resumeCache !== undefined && resumeCache.owner !== owner) return;
@@ -571,7 +575,8 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
           if (applied._tag !== "noop") result = applied;
           if (applied._tag === "delete") break;
         }
-        return [result, current];
+        // A batch that changed nothing keeps its state object, so readers do not re-render.
+        return [result, result._tag === "noop" ? current : { ...current, sequence }];
       },
     );
 
@@ -796,7 +801,7 @@ export const makeEnvironmentThreadState = Effect.fn("EnvironmentThreadState.make
             ),
           );
           if (result._tag !== "loaded") return result;
-          if (complete) yield* remember;
+          if (complete) yield* applyLock.withPermits(1)(remember);
           nextCursor = keepPaging ? page.nextCursor : null;
         }
         if (nextCursor === null) return { _tag: "loaded" } as const;
diff --git a/packages/contracts/package.json b/packages/contracts/package.json
index c87a9fed41033..2a032000896fb 100644
--- a/packages/contracts/package.json
+++ b/packages/contracts/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@t3tools/contracts",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": true,
   "files": [
     "dist"
diff --git a/packages/contracts/src/clientRpcPermissions.ts b/packages/contracts/src/clientRpcPermissions.ts
index 3cd80feea6b73..f9564b2e2441c 100644
--- a/packages/contracts/src/clientRpcPermissions.ts
+++ b/packages/contracts/src/clientRpcPermissions.ts
@@ -33,6 +33,7 @@ export const CLIENT_GUARDED_RPC_SCOPES = {
   [WS_METHODS.pullRequestsSetLabels]: AuthSourceControlWriteScope,
   // Writing a guide runs a model on this environment's providers, which reading one does not.
   [WS_METHODS.pullRequestsGenerateReviewGuide]: AuthOrchestrationOperateScope,
+  [WS_METHODS.projectsCreateFromThread]: AuthOrchestrationOperateScope,
   [WS_METHODS.sourceControlCloneRepository]: AuthSourceControlWriteScope,
   [WS_METHODS.sourceControlPublishRepository]: AuthSourceControlWriteScope,
   // Signing in replaces the server's GitHub credential, as saving a token in Settings does.
diff --git a/packages/contracts/src/device.test.ts b/packages/contracts/src/device.test.ts
index 6de9f15125d45..e49e54a09fdf5 100644
--- a/packages/contracts/src/device.test.ts
+++ b/packages/contracts/src/device.test.ts
@@ -4,6 +4,7 @@ import {
   DeviceBootError,
   DeviceServiceState,
   EasDeviceHostConfig,
+  SimlockDeviceHostConfig,
   EasDeviceHostConfigs,
   SshDeviceHostConfigs,
 } from "./device.ts";
@@ -49,6 +50,7 @@ describe("configured device hosts", () => {
 
   it("marks the EAS access token as a secret setting", () => {
     expect(secretSettingsFields(EasDeviceHostConfig)).toEqual(["accessToken"]);
+    expect(secretSettingsFields(SimlockDeviceHostConfig)).toEqual(["agentToken"]);
   });
 });
 
@@ -63,6 +65,7 @@ describe("device state for clients from before EAS hosts", () => {
     hosts: [
       { ...summary, id: "local", kind: "local" as const },
       { ...summary, id: "eas", kind: "eas" as const },
+      { ...summary, id: "pool", kind: "simlock" as const },
     ],
     hostStatus: "ready" as const,
     hostStatuses: {},
@@ -74,7 +77,7 @@ describe("device state for clients from before EAS hosts", () => {
     revision: 1,
   };
 
-  it("sends EAS hosts where an older client does not look, and reads them back", () => {
+  it("sends EAS and Simlock hosts where an older client does not look, and reads them back", () => {
     const wire = encodeState(state);
     expect(decodeOlderState(wire).hosts.map((host) => host.id)).toEqual(["local"]);
     expect(decodeState(wire).hosts).toEqual(state.hosts);
diff --git a/packages/contracts/src/device.ts b/packages/contracts/src/device.ts
index dbb90f6d41e58..24b72dbe26d7a 100644
--- a/packages/contracts/src/device.ts
+++ b/packages/contracts/src/device.ts
@@ -68,7 +68,32 @@ export const EasDeviceHostConfig = Schema.Struct({
 );
 export type EasDeviceHostConfig = typeof EasDeviceHostConfig.Type;
 
-export type DeviceHostConfig = SshDeviceHostConfig | EasDeviceHostConfig;
+/**
+ * Alpha: devices leased from a Simlock gateway (https://incubator.callstack.com/simlock).
+ * T3 never installs Simlock; the gateway and its workers are the user's own.
+ */
+export const SimlockDeviceHostConfig = Schema.Struct({
+  kind: Schema.Literal("simlock"),
+  id: ConfiguredDeviceHostId,
+  label: TrimmedNonEmptyString,
+  /** The gateway's origin, such as https://gateway.example.ts.net:4700. */
+  gatewayUrl: TrimmedNonEmptyString.check(Schema.isPattern(/^https?:\/\/[^\s/]+\/?$/)),
+  /** Leases, drives, watches, and takes input on its own leases. Kept in the secret store. */
+  agentToken: TrimmedString.pipe(
+    Schema.withDecodingDefaultKey(Effect.succeed("")),
+    Schema.annotateKey({ settingsSecret: true }),
+  ),
+  maxLeases: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20 })).pipe(
+    Schema.withDecodingDefaultKey(Effect.succeed(2)),
+  ),
+  /** A lease the Device panel keeps alive ends this long after it started. */
+  maxLeaseMinutes: Schema.Int.check(Schema.isBetween({ minimum: 5, maximum: 240 })).pipe(
+    Schema.withDecodingDefaultKey(Effect.succeed(60)),
+  ),
+});
+export type SimlockDeviceHostConfig = typeof SimlockDeviceHostConfig.Type;
+
+export type DeviceHostConfig = SshDeviceHostConfig | EasDeviceHostConfig | SimlockDeviceHostConfig;
 
 const uniqueHostIds = Schema.makeFilter(
   (hosts: ReadonlyArray<{ readonly id: string }>) =>
@@ -85,6 +110,9 @@ export const SshDeviceHostConfigs = Schema.Array(SshDeviceHostConfig).check(uniq
  */
 export const EasDeviceHostConfigs = Schema.Array(EasDeviceHostConfig).check(uniqueHostIds);
 
+/** Kept apart from the other host lists for the same reason as EAS hosts. */
+export const SimlockDeviceHostConfigs = Schema.Array(SimlockDeviceHostConfig).check(uniqueHostIds);
+
 export const DeviceEasAccountInput = Schema.Struct({
   /** A saved EAS host whose stored token is checked when no new token is given. */
   hostId: Schema.optional(DeviceHostId),
@@ -99,6 +127,33 @@ export const DeviceEasAccount = Schema.Struct({
 });
 export type DeviceEasAccount = typeof DeviceEasAccount.Type;
 
+export const DeviceSimlockIdentityInput = Schema.Struct({
+  /** Without one, the gateway this machine's agent-device points at. */
+  gatewayUrl: Schema.optional(TrimmedString),
+  /** A saved Simlock host whose stored token is checked when no new token is given. */
+  hostId: Schema.optional(DeviceHostId),
+  agentToken: Schema.optional(TrimmedString),
+});
+export type DeviceSimlockIdentityInput = typeof DeviceSimlockIdentityInput.Type;
+
+export const DeviceSimlockIdentity = Schema.Struct({
+  gatewayUrl: Schema.String,
+  /** The label the gateway gave the token. */
+  signedInAs: Schema.String,
+  /** `env`: this machine's AGENT_DEVICE_DAEMON_AUTH_TOKEN, used because it targets this gateway. */
+  tokenSource: Schema.Literals(["entered", "settings", "env"]),
+});
+export type DeviceSimlockIdentity = typeof DeviceSimlockIdentity.Type;
+
+export class DeviceSimlockIdentityError extends Schema.TaggedError<DeviceSimlockIdentityError>()(
+  "DeviceSimlockIdentityError",
+  { reason: Schema.String },
+) {
+  override get message(): string {
+    return this.reason;
+  }
+}
+
 /** Checking an Expo credential failed; no device host is involved yet. */
 export class DeviceEasAccountError extends Schema.TaggedError<DeviceEasAccountError>()(
   "DeviceEasAccountError",
@@ -161,7 +216,15 @@ const EasDeviceHostSummary = Schema.Struct({
   ...deviceHostSummaryFields,
   kind: Schema.Literal("eas"),
 });
-export const DeviceHostSummary = Schema.Union([MachineDeviceHostSummary, EasDeviceHostSummary]);
+const SimlockDeviceHostSummary = Schema.Struct({
+  ...deviceHostSummaryFields,
+  kind: Schema.Literal("simlock"),
+});
+export const DeviceHostSummary = Schema.Union([
+  MachineDeviceHostSummary,
+  EasDeviceHostSummary,
+  SimlockDeviceHostSummary,
+]);
 export type DeviceHostSummary = typeof DeviceHostSummary.Type;
 
 export const DeviceHostStatus = Schema.Literals([
@@ -198,6 +261,8 @@ const deviceServiceStateFields = {
   supportsToolInspection: Schema.optional(Schema.Boolean),
   /** Servers from before EAS hosts ignore `easDeviceHosts`, so clients offer them only when set. */
   supportsEasHosts: Schema.optional(Schema.Boolean),
+  /** Servers from before Simlock hosts ignore `simlockDeviceHosts`. */
+  supportsSimlockHosts: Schema.optional(Schema.Boolean),
   hostStatus: DeviceHostStatus,
   hostStatusDetail: Schema.optional(Schema.String),
   hostStatuses: DeviceHostStatuses,
@@ -221,6 +286,7 @@ const DeviceServiceStateWire = Schema.Struct({
   ...deviceServiceStateFields,
   hosts: Schema.Array(MachineDeviceHostSummary),
   easHosts: Schema.optional(Schema.Array(EasDeviceHostSummary)),
+  simlockHosts: Schema.optional(Schema.Array(SimlockDeviceHostSummary)),
 });
 const DeviceServiceStateDecoded = Schema.Struct({
   ...deviceServiceStateFields,
@@ -234,18 +300,22 @@ export const DeviceServiceState = DeviceServiceStateWire.pipe(
       typeof DeviceServiceStateDecoded.Type,
       typeof DeviceServiceStateWire.Type
     >({
-      decode: ({ easHosts, ...state }) => ({
+      decode: ({ easHosts, simlockHosts, ...state }) => ({
         ...state,
-        hosts: [...state.hosts, ...(easHosts ?? [])],
+        hosts: [...state.hosts, ...(easHosts ?? []), ...(simlockHosts ?? [])],
       }),
       encode: (state) => ({
         ...state,
         hosts: state.hosts.filter(
-          (host): host is typeof MachineDeviceHostSummary.Type => host.kind !== "eas",
+          (host): host is typeof MachineDeviceHostSummary.Type =>
+            host.kind === "local" || host.kind === "ssh",
         ),
         easHosts: state.hosts.filter(
           (host): host is typeof EasDeviceHostSummary.Type => host.kind === "eas",
         ),
+        simlockHosts: state.hosts.filter(
+          (host): host is typeof SimlockDeviceHostSummary.Type => host.kind === "simlock",
+        ),
       }),
     }),
   ),
diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts
index a65a91e0d3921..75a546bed875f 100644
--- a/packages/contracts/src/environment.ts
+++ b/packages/contracts/src/environment.ts
@@ -110,6 +110,7 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
   threadPinReorder: Schema.optionalKey(Schema.Boolean),
   threadActiveReorder: Schema.optionalKey(Schema.Boolean),
   threadAutoSettleOptOut: Schema.optionalKey(Schema.Boolean),
+  threadProjectFromScratch: Schema.optionalKey(Schema.Boolean),
   threadTitleRegeneration: Schema.optionalKey(Schema.Boolean),
   threadVisitedTracking: Schema.optionalKey(Schema.Boolean),
   threadPullRequestLinking: Schema.optionalKey(Schema.Boolean),
@@ -132,6 +133,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
   ignoredFileListing: Schema.optionalKey(Schema.Boolean),
   environmentIcon: Schema.optionalKey(Schema.Boolean),
   desktopAppUpdate: Schema.optionalKey(Schema.Boolean),
+  /** The desktop app switches update tracks when a server update request names one. */
+  desktopAppChannelSwitch: Schema.optionalKey(Schema.Boolean),
   /** Subscribe to command output only when advertised; older servers never send it. */
   commandOutputStreaming: Schema.optionalKey(Schema.Boolean),
   /** Hosts headless Chromium tabs streamed over /api/preview-stream for clients without a local runtime. */
@@ -159,6 +162,8 @@ export const ExecutionEnvironmentDescriptor = Schema.Struct({
   platform: ExecutionEnvironmentPlatform,
   serverVersion: TrimmedNonEmptyString,
   orchestrationProtocolVersion: Schema.optionalKey(Schema.Int),
+  /** Highest migration this server's database holds; absent on older servers. */
+  databaseMigration: Schema.optionalKey(Schema.Int),
   capabilities: ExecutionEnvironmentCapabilities,
 });
 export type ExecutionEnvironmentDescriptor = typeof ExecutionEnvironmentDescriptor.Type;
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index f760113cff3d4..2bdcf5503ec24 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -298,12 +298,21 @@ export interface DesktopUpdateReleaseNote {
   version: string;
   items: ReadonlyArray<string>;
   totalItems: number;
+  /** ISO time from the update feed for the offered version, else `YYYY-MM-DD` from a prerelease version. */
+  releasedAt?: string;
+  /** Generated summaries only: the highlights paragraph. `items` then holds the fixes. */
+  intro?: string;
+  /** Generated summaries only, for example "275 changes from 22 contributors". */
+  stats?: string;
 }
 
 export const DesktopUpdateReleaseNoteSchema = Schema.Struct({
   version: Schema.String,
   items: Schema.Array(Schema.String),
   totalItems: Schema.Number,
+  releasedAt: Schema.optionalKey(Schema.String),
+  intro: Schema.optionalKey(Schema.String),
+  stats: Schema.optionalKey(Schema.String),
 });
 
 export const DesktopUpdateStateSchema = Schema.Struct({
@@ -1106,10 +1115,15 @@ export interface DesktopBridge {
   onWindowFullscreenStateChange: (listener: (fullscreen: boolean) => void) => () => void;
   getWindowZoomFactor: () => number;
   getUpdateState: () => Promise<DesktopUpdateState>;
-  setUpdateChannel: (channel: DesktopUpdateChannel) => Promise<DesktopUpdateState>;
+  /** `minimumVersion` is a track switch's checked release; nothing older is offered after. */
+  setUpdateChannel: (
+    channel: DesktopUpdateChannel,
+    minimumVersion?: string,
+  ) => Promise<DesktopUpdateState>;
   checkForUpdate: () => Promise<DesktopUpdateCheckResult>;
   downloadUpdate: () => Promise<DesktopUpdateActionResult>;
-  installUpdate: () => Promise<DesktopUpdateActionResult>;
+  /** With a version, installs only that downloaded build. */
+  installUpdate: (expectedVersion?: string) => Promise<DesktopUpdateActionResult>;
   onUpdateState: (listener: (state: DesktopUpdateState) => void) => () => void;
   cliCommand: {
     getState: () => Promise<DesktopCliCommandState>;
diff --git a/packages/contracts/src/orchestrationV2.test.ts b/packages/contracts/src/orchestrationV2.test.ts
index 2414d3cd01984..3782307171e87 100644
--- a/packages/contracts/src/orchestrationV2.test.ts
+++ b/packages/contracts/src/orchestrationV2.test.ts
@@ -358,6 +358,9 @@ describe("orchestration V2 contracts", () => {
               index: 1,
               label: "Member",
               state: "completed" as const,
+              model: "claude-opus-5[1m]",
+              effort: "xhigh",
+              speed: "standard",
               prompt: preview,
               result: preview,
             },
@@ -379,10 +382,16 @@ describe("orchestration V2 contracts", () => {
         expect(decode(json).workflow?.agents[0]).toMatchObject({
           prompt: preview,
           result: preview,
+          model: "claude-opus-5[1m]",
+          effort: "xhigh",
+          speed: "standard",
         });
         expect(decode(incoming).workflow?.agents[0]).toMatchObject({
           prompt: preview,
           result: preview,
+          model: "claude-opus-5[1m]",
+          effort: "xhigh",
+          speed: "standard",
         });
       }
     },
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index 56d910b752deb..747d05e7ce4eb 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -787,6 +787,8 @@ export const OrchestrationV2WorkflowAgent = Schema.Struct({
   phaseIndex: Schema.optional(NonNegativeInt),
   phaseTitle: Schema.optional(TrimmedNonEmptyString),
   model: Schema.optional(TrimmedNonEmptyString),
+  effort: Schema.optional(TrimmedNonEmptyString),
+  speed: Schema.optional(TrimmedNonEmptyString),
   attempt: Schema.optional(NonNegativeInt),
   totalTokens: Schema.optional(NonNegativeInt),
   toolCalls: Schema.optional(NonNegativeInt),
@@ -3333,6 +3335,13 @@ const OrchestrationV2InternalCommand = Schema.Union([
     text: Schema.String,
     attachments: Schema.optional(Schema.Array(ChatAttachment)),
   }),
+  /** Moves a thread to a project rooted at the folder it already works in, so its cwd never changes. */
+  Schema.Struct({
+    type: Schema.Literal("thread.project.adopt-folder"),
+    commandId: CommandId,
+    threadId: ThreadId,
+    projectId: ProjectId,
+  }),
   Schema.Struct({
     type: Schema.Literal("thread.pull-request-watch.sync"),
     commandId: CommandId,
@@ -3571,6 +3580,8 @@ export const OrchestrationV2ThreadLaunchResult = Schema.Struct({
   threadId: ThreadId,
   projection: OrchestrationV2ThreadProjection,
   resumed: Schema.Boolean,
+  /** The initial message's commit sequence. Older servers omit it. */
+  sequence: Schema.optionalKey(NonNegativeInt),
 });
 export type OrchestrationV2ThreadLaunchResult = typeof OrchestrationV2ThreadLaunchResult.Type;
 
diff --git a/packages/contracts/src/project.ts b/packages/contracts/src/project.ts
index 12934a7f8ed70..79e164b71e93b 100644
--- a/packages/contracts/src/project.ts
+++ b/packages/contracts/src/project.ts
@@ -10,6 +10,7 @@ import {
   NonNegativeInt,
   PositiveInt,
   ProjectId,
+  ThreadId,
   TrimmedNonEmptyString,
   TrimmedString,
   type UnknownUnionMember,
@@ -527,6 +528,16 @@ export const ProjectCreateNewResult = Schema.Struct({
 });
 export type ProjectCreateNewResult = typeof ProjectCreateNewResult.Type;
 
+export const ProjectCreateFromThreadInput = Schema.Struct({
+  threadId: ThreadId,
+});
+export type ProjectCreateFromThreadInput = typeof ProjectCreateFromThreadInput.Type;
+
+export const ProjectCreateFromThreadResult = Schema.Struct({
+  projectId: ProjectId,
+});
+export type ProjectCreateFromThreadResult = typeof ProjectCreateFromThreadResult.Type;
+
 export class ProjectWriteFileError extends Schema.TaggedError<ProjectWriteFileError>()(
   "ProjectWriteFileError",
   {
diff --git a/packages/contracts/src/pullRequest.ts b/packages/contracts/src/pullRequest.ts
index e38d5fa6cf95a..64111ab4742b1 100644
--- a/packages/contracts/src/pullRequest.ts
+++ b/packages/contracts/src/pullRequest.ts
@@ -244,6 +244,7 @@ export type PullRequestReviewCapabilities = typeof PullRequestReviewCapabilities
 export const PullRequestEditCapabilities = Schema.Struct({
   changeRequest: Schema.Boolean,
   comment: Schema.Boolean,
+  maintainerEdits: Schema.optional(Schema.Boolean),
 });
 export type PullRequestEditCapabilities = typeof PullRequestEditCapabilities.Type;
 
@@ -295,6 +296,7 @@ export const PullRequestViewerPermissions = Schema.Struct({
   updateMethods: Schema.optional(ForwardCompatibleArray(PullRequestUpdateMethod)),
   labels: Schema.optional(Schema.Boolean),
   editChangeRequest: Schema.optional(Schema.Boolean),
+  maintainerEdits: Schema.optional(Schema.Boolean),
 });
 export type PullRequestViewerPermissions = typeof PullRequestViewerPermissions.Type;
 
@@ -589,6 +591,7 @@ export const PullRequestDetail = Schema.Struct({
   autoMergeEnabled: Schema.optional(Schema.Boolean),
   autoMergeMethod: Schema.optional(PullRequestMergeMethod),
   workflowApprovalsRequired: Schema.optional(NonNegativeInt),
+  maintainerCanModify: Schema.optional(Schema.Boolean),
 });
 export type PullRequestDetail = typeof PullRequestDetail.Type;
 
@@ -746,6 +749,7 @@ export const PullRequestUpdateInput = Schema.Struct({
   ...PullRequestRef.fields,
   title: Schema.optional(TrimmedNonEmptyString.check(Schema.isMaxLength(1024))),
   body: Schema.optional(Schema.String.check(Schema.isMaxLength(65_536))),
+  maintainerCanModify: Schema.optional(Schema.Boolean),
 });
 export type PullRequestUpdateInput = typeof PullRequestUpdateInput.Type;
 
diff --git a/packages/contracts/src/resourceTelemetry.ts b/packages/contracts/src/resourceTelemetry.ts
index bce626b0c3668..5a004f93a2a4c 100644
--- a/packages/contracts/src/resourceTelemetry.ts
+++ b/packages/contracts/src/resourceTelemetry.ts
@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 
 import { NonNegativeInt, PositiveInt, TrimmedNonEmptyString } from "./baseSchemas.ts";
 import { HostPowerSnapshot } from "./background.ts";
-import { DesktopUpdateStateSchema } from "./ipc.ts";
+import { DesktopUpdateChannelSchema, DesktopUpdateStateSchema } from "./ipc.ts";
 
 export const RESOURCE_MONITOR_PROTOCOL_VERSION = 3 as const;
 
@@ -323,6 +323,9 @@ export const DesktopTelemetryRequestDesktopUpdate = Schema.Struct({
   version: Schema.Literal(1),
   type: Schema.Literal("requestDesktopUpdate"),
   requestId: TrimmedNonEmptyString,
+  /** A track switch: move to this channel first, and install only `targetVersion`. */
+  channel: Schema.optionalKey(DesktopUpdateChannelSchema),
+  targetVersion: Schema.optionalKey(TrimmedNonEmptyString),
 });
 export type DesktopTelemetryRequestDesktopUpdate = typeof DesktopTelemetryRequestDesktopUpdate.Type;
 
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index e4823f30272bd..aae86bd9db465 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -230,6 +230,8 @@ import {
 import {
   ProjectCreateNewInput,
   ProjectCreateNewResult,
+  ProjectCreateFromThreadInput,
+  ProjectCreateFromThreadResult,
   ProjectEnsureScratchResult,
   ProjectListEntriesError,
   ProjectListEntriesInput,
@@ -293,6 +295,9 @@ import {
   DeviceEasAccount,
   DeviceEasAccountError,
   DeviceEasAccountInput,
+  DeviceSimlockIdentity,
+  DeviceSimlockIdentityError,
+  DeviceSimlockIdentityInput,
   DeviceHostSummary,
   DeviceOpenInput,
   DeviceServiceState,
@@ -402,6 +407,7 @@ export const WS_METHODS = {
   projectsMutate: "projects.mutate",
   projectsEnsureScratch: "projects.ensureScratch",
   projectsCreateNew: "projects.createNew",
+  projectsCreateFromThread: "projects.createFromThread",
 
   shellOpenInEditor: "shell.openInEditor",
 
@@ -473,6 +479,7 @@ export const WS_METHODS = {
   deviceList: "device.list",
   deviceTestHost: "device.testHost",
   deviceEasAccount: "device.easAccount",
+  deviceSimlockIdentity: "device.simlockIdentity",
   deviceOpen: "device.open",
   deviceClose: "device.close",
   deviceShutdown: "device.shutdown",
@@ -1309,6 +1316,12 @@ const WsProjectsCreateNewRpc = Rpc.make(WS_METHODS.projectsCreateNew, {
   error: Schema.Union([OrchestrationDispatchCommandError, EnvironmentAuthorizationError]),
 });
 
+const WsProjectsCreateFromThreadRpc = Rpc.make(WS_METHODS.projectsCreateFromThread, {
+  payload: ProjectCreateFromThreadInput,
+  success: ProjectCreateFromThreadResult,
+  error: Schema.Union([OrchestrationDispatchCommandError, EnvironmentAuthorizationError]),
+});
+
 const WsShellOpenInEditorRpc = Rpc.make(WS_METHODS.shellOpenInEditor, {
   payload: LaunchEditorInput,
   error: Schema.Union([ExternalLauncherError, EnvironmentAuthorizationError]),
@@ -1613,6 +1626,12 @@ const WsDeviceEasAccountRpc = Rpc.make(WS_METHODS.deviceEasAccount, {
   error: Schema.Union([DeviceEasAccountError, EnvironmentAuthorizationError]),
 });
 
+const WsDeviceSimlockIdentityRpc = Rpc.make(WS_METHODS.deviceSimlockIdentity, {
+  payload: DeviceSimlockIdentityInput,
+  success: DeviceSimlockIdentity,
+  error: Schema.Union([DeviceSimlockIdentityError, EnvironmentAuthorizationError]),
+});
+
 const WsDeviceListRpc = Rpc.make(WS_METHODS.deviceList, {
   payload: DeviceListInput,
   success: DeviceServiceState,
@@ -2033,6 +2052,7 @@ export const WsRpcGroup = RpcGroup.make(
   WsProjectsSearchEntriesRpc,
   WsProjectsEnsureScratchRpc,
   WsProjectsCreateNewRpc,
+  WsProjectsCreateFromThreadRpc,
   WsProjectsWriteFileRpc,
   WsProjectsMutateRpc,
   WsShellOpenInEditorRpc,
@@ -2088,6 +2108,7 @@ export const WsRpcGroup = RpcGroup.make(
   WsDeviceListRpc,
   WsDeviceTestHostRpc,
   WsDeviceEasAccountRpc,
+  WsDeviceSimlockIdentityRpc,
   WsDeviceOpenRpc,
   WsDeviceCloseRpc,
   WsDeviceShutdownRpc,
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index 134d8160642fc..92dc88be173a8 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -28,6 +28,7 @@ import { RuntimeMode } from "./providerPolicy.ts";
 import { ProviderDriverKind, ProviderInstanceId } from "./providerInstance.ts";
 import { ServerProviderUsageLimits, UsageLimitSourceSnapshots } from "./providerUsageLimits.ts";
 import { ServerSettings } from "./settings.ts";
+import { DesktopUpdateChannelSchema } from "./ipc.ts";
 
 const KeybindingsMalformedConfigIssue = Schema.Struct({
   kind: Schema.Literal("keybindings.malformed-config"),
@@ -879,6 +880,10 @@ export class ServerProviderUpdateError extends Schema.TaggedError<ServerProvider
 export const ServerSelfUpdateInput = Schema.Struct({
   /** Exact npm version, never a dist-tag, so server and client agree on the request. */
   targetVersion: TrimmedNonEmptyString,
+  /** Desktop-managed hosts move their app to this update track first. Sent only for a track switch. */
+  channel: Schema.optionalKey(DesktopUpdateChannelSchema),
+  /** The target release's highest migration; the host refuses to leave Nightly without it. */
+  targetDatabaseMigration: Schema.optionalKey(Schema.Int),
 });
 export type ServerSelfUpdateInput = typeof ServerSelfUpdateInput.Type;
 
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 6d62be5eea778..5f3b9f4c00d72 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -1,4 +1,4 @@
-import { EasDeviceHostConfigs, SshDeviceHostConfigs } from "./device.ts";
+import { EasDeviceHostConfigs, SimlockDeviceHostConfigs, SshDeviceHostConfigs } from "./device.ts";
 import {
   AuthOrchestrationOperateScope,
   AuthSettingsWriteScope,
@@ -477,6 +477,13 @@ export const ClientSettingsSchema = Schema.Struct({
   boringSidebarMultilineRows: Schema.Boolean.pipe(
     Schema.withDecodingDefault(Effect.succeed(false)),
   ),
+  // Retired Labs toggle. Still read as the default for the Usage item in threadDetailsItems.
+  threadDetailsUsageEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+  // Sparse show/hide overrides for thread details card items. Missing ids use the client's
+  // default, so new items appear for everyone and unknown ids survive a downgrade.
+  threadDetailsItems: Schema.Record(Schema.String, Schema.Boolean).pipe(
+    Schema.withDecodingDefault(Effect.succeed({})),
+  ),
   // Opt-in for the removed legacy sidebar. Still read so those users land in
   // the boring sidebar; the boring sidebar toggle clears it.
   legacySidebarEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
@@ -1179,6 +1186,9 @@ export const ServerSettings = Schema.Struct({
   defaultModelSelection: Schema.NullOr(ModelSelection).pipe(
     Schema.withDecodingDefault(Effect.succeed(null)),
   ),
+  fallbackModelSelection: Schema.NullOr(ModelSelection).pipe(
+    Schema.withDecodingDefault(Effect.succeed(null)),
+  ),
   defaultRuntimeMode: RuntimeMode.pipe(
     Schema.withDecodingDefault(Effect.succeed(DEFAULT_RUNTIME_MODE)),
   ),
@@ -1195,6 +1205,9 @@ export const ServerSettings = Schema.Struct({
   deviceOnboardingCompleted: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
   deviceHosts: SshDeviceHostConfigs.pipe(Schema.withDecodingDefault(Effect.succeed([]))),
   easDeviceHosts: EasDeviceHostConfigs.pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+  simlockDeviceHosts: SimlockDeviceHostConfigs.pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+  /** Alpha: Simlock device hosts. Off, the server ignores `simlockDeviceHosts`. */
+  simlockDeviceHostsEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
   sidebarAutoSettleAfterDays: Schema.NullOr(SidebarAutoSettleAfterDays).pipe(
     Schema.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_AUTO_SETTLE_AFTER_DAYS)),
   ),
@@ -1534,6 +1547,7 @@ export const ServerSettingsPatch = Schema.Struct({
   ),
   defaultModelSelection: Schema.optionalKey(Schema.NullOr(ModelSelection)),
   defaultRuntimeMode: Schema.optionalKey(RuntimeMode),
+  fallbackModelSelection: Schema.optionalKey(Schema.NullOr(ModelSelection)),
   /** Replaces each project's override set; null removes it. Omitted providerInstances retains its stored value. */
   projectSettingsOverrides: Schema.optionalKey(
     Schema.Record(
@@ -1551,6 +1565,8 @@ export const ServerSettingsPatch = Schema.Struct({
   deviceOnboardingCompleted: Schema.optionalKey(Schema.Boolean),
   deviceHosts: Schema.optionalKey(SshDeviceHostConfigs),
   easDeviceHosts: Schema.optionalKey(EasDeviceHostConfigs),
+  simlockDeviceHosts: Schema.optionalKey(SimlockDeviceHostConfigs),
+  simlockDeviceHostsEnabled: Schema.optionalKey(Schema.Boolean),
   sidebarAutoSettleAfterDays: Schema.optionalKey(Schema.NullOr(SidebarAutoSettleAfterDays)),
   compactIdleThreads: Schema.optionalKey(LegacyCompactIdleThreads),
   idleCompaction: Schema.optionalKey(IdleCompactionMode),
@@ -1711,6 +1727,8 @@ export const ClientSettingsPatch = Schema.Struct({
   showSkillsInSlashMenu: Schema.optionalKey(Schema.Boolean),
   boringSidebarEnabled: Schema.optionalKey(Schema.Boolean),
   boringSidebarMultilineRows: Schema.optionalKey(Schema.Boolean),
+  threadDetailsUsageEnabled: Schema.optionalKey(Schema.Boolean),
+  threadDetailsItems: Schema.optionalKey(Schema.Record(Schema.String, Schema.Boolean)),
   legacySidebarEnabled: Schema.optionalKey(Schema.Boolean),
   sidebarWorkingShelfEnabled: Schema.optionalKey(Schema.Boolean),
   sidebarProjectGroupingMode: Schema.optionalKey(SidebarProjectGroupingMode),
diff --git a/packages/provider-acp-registry/src/server/adapter.ts b/packages/provider-acp-registry/src/server/adapter.ts
index 26a5319c12583..71de22deb5d4d 100644
--- a/packages/provider-acp-registry/src/server/adapter.ts
+++ b/packages/provider-acp-registry/src/server/adapter.ts
@@ -210,7 +210,13 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
   const copilotRouting = isCopilot ? makeCopilotSubagentRouting() : undefined;
   const flavor: AcpAdapterV2Flavor = {
     driver: ACP_REGISTRY_PROVIDER,
-    capabilities: AcpProviderCapabilitiesV2,
+    // Cancelling a Copilot prompt also kills the background agents it started.
+    capabilities: isCopilot
+      ? {
+          ...AcpProviderCapabilitiesV2,
+          turns: { ...AcpProviderCapabilitiesV2.turns, supportsSteeringByInterruptRestart: false },
+        }
+      : AcpProviderCapabilitiesV2,
     customModels: readCustomModelEntries(options.settings.customModels).map((entry) => entry.slug),
     promptFailure: (cause) => acpRegistryPromptFailure(registryAgentId, cause),
     ...(registryAgentId === "factory-droid"
diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts
index b88e31d203948..398eac2170e70 100644
--- a/packages/provider-acp/src/server/adapter.ts
+++ b/packages/provider-acp/src/server/adapter.ts
@@ -76,6 +76,7 @@ import {
   parsePermissionRequest,
   parseSessionUpdateEvent,
   toolCallVisibleOutputChanged,
+  withTrackedPermissionToolCall,
   type AcpPlanUpdate,
   type AcpAgentTerminalState,
   type AcpSessionModeState,
@@ -287,7 +288,7 @@ export interface AcpAdapterV2Flavor {
       request: EffectAcpSchema.ReadTextFileRequest,
       cwd: string | null,
     ) => Effect.Effect<EffectAcpSchema.ReadTextFileResponse, EffectAcpErrors.AcpError>;
-    readonly writeTextFile: (
+    readonly writeTextFile?: (
       request: EffectAcpSchema.WriteTextFileRequest,
       cwd: string | null,
     ) => Effect.Effect<EffectAcpSchema.WriteTextFileResponse, EffectAcpErrors.AcpError>;
@@ -1992,7 +1993,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             clientCapabilities: {
               fs: {
                 readTextFile: flavor.clientFileSystem !== undefined,
-                writeTextFile: flavor.clientFileSystem !== undefined,
+                writeTextFile: flavor.clientFileSystem?.writeTextFile !== undefined,
               },
               terminal: clientTerminals !== undefined,
               elicitation: { form: {}, ...(flavor.onUrlElicitation ? { url: {} } : {}) },
@@ -5957,11 +5958,14 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                 Effect.flatMap(({ policy }) => clientFileSystem.readTextFile(request, policy.cwd)),
               ),
             );
-            yield* targetRuntime.handleWriteTextFile((request) =>
-              clientPolicyContext.pipe(
-                Effect.flatMap(({ policy }) => clientFileSystem.writeTextFile(request, policy.cwd)),
-              ),
-            );
+            const writeTextFile = clientFileSystem.writeTextFile;
+            if (writeTextFile !== undefined) {
+              yield* targetRuntime.handleWriteTextFile((request) =>
+                clientPolicyContext.pipe(
+                  Effect.flatMap(({ policy }) => writeTextFile(request, policy.cwd)),
+                ),
+              );
+            }
           }
           if (handlerOptions.mcp !== false) {
             yield* wireAcpRuntimeMcpHandlers(targetRuntime, runtimeMcpBridge);
@@ -5974,8 +5978,16 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               projectAcpRuntimeSessionUpdate(handlerGeneration, rawNotification),
             );
           }
-          yield* targetRuntime.handleRequestPermission((params, requestContext) =>
+          yield* targetRuntime.handleRequestPermission((nativeParams, requestContext) =>
             Effect.gen(function* () {
+              const trackedTurn = yield* Ref.get(activeTurn);
+              const params =
+                trackedTurn !== null && nativeParams.sessionId === (yield* Ref.get(activeSessionId))
+                  ? withTrackedPermissionToolCall(
+                      nativeParams,
+                      trackedTurn.tools.get(nativeParams.toolCall.toolCallId),
+                    )
+                  : nativeParams;
               const transportRequestId = requestContext.requestId;
               const permissionQuestion = flavor.extractPermissionQuestion?.(params);
               if (permissionQuestion !== undefined) {
diff --git a/packages/provider-acp/src/server/runtimeModel.test.ts b/packages/provider-acp/src/server/runtimeModel.test.ts
index 70682ec4824a5..e60671c775d51 100644
--- a/packages/provider-acp/src/server/runtimeModel.test.ts
+++ b/packages/provider-acp/src/server/runtimeModel.test.ts
@@ -17,6 +17,7 @@ import {
   sessionUpdateIsReplay,
   syntheticLoadSessionResponseFromInitialize,
   toolCallProgressLength,
+  withTrackedPermissionToolCall,
   type AcpToolCallState,
 } from "./runtimeModel.ts";
 
@@ -432,6 +433,40 @@ describe("AcpRuntimeModel", () => {
     });
   });
 
+  it("keeps an explicit permission request kind over the tracked tool call's kind", () => {
+    const request = withTrackedPermissionToolCall(
+      {
+        sessionId: "session-1",
+        options: [{ optionId: "allow-once", name: "Allow once", kind: "allow_once" }],
+        toolCall: { toolCallId: "tool-1", kind: "read" },
+      },
+      {
+        toolCallId: "tool-1",
+        kind: "execute",
+        data: { toolCallId: "tool-1", title: "git status", rawInput: { command: "git status" } },
+      },
+    );
+
+    expect(parsePermissionRequest(request)).toMatchObject({ kind: "read", detail: "git status" });
+  });
+
+  it("keeps explicitly cleared permission request fields over the tracked tool call", () => {
+    const request = withTrackedPermissionToolCall(
+      {
+        sessionId: "session-1",
+        options: [{ optionId: "allow-once", name: "Allow once", kind: "allow_once" }],
+        toolCall: { toolCallId: "tool-1", kind: null, title: null, rawInput: null },
+      },
+      {
+        toolCallId: "tool-1",
+        kind: "execute",
+        data: { toolCallId: "tool-1", title: "git status", rawInput: { command: "git status" } },
+      },
+    );
+
+    expect(parsePermissionRequest(request).kind).toBe("unknown");
+  });
+
   it("bounds an oversized cumulative tool_call_update content buffer to a tail window", () => {
     const hugeText = Array.from({ length: 2_000 }, (_, i) => `line ${i}: ${"x".repeat(50)}`).join(
       "\n",
diff --git a/packages/provider-acp/src/server/runtimeModel.ts b/packages/provider-acp/src/server/runtimeModel.ts
index 87f24c5afdbaa..43fa2bf758e2f 100644
--- a/packages/provider-acp/src/server/runtimeModel.ts
+++ b/packages/provider-acp/src/server/runtimeModel.ts
@@ -1179,6 +1179,29 @@ export function embeddedTerminalIdsFromSessionUpdate(
   return terminalIds.length === 0 ? undefined : { toolCallId: update.toolCallId, terminalIds };
 }
 
+/** ACP lets a permission request name its tool call by ID only; omitted (not null) fields come from the tracked call. */
+export function withTrackedPermissionToolCall(
+  params: EffectAcpSchema.RequestPermissionRequest,
+  tracked: AcpToolCallState | undefined,
+): EffectAcpSchema.RequestPermissionRequest {
+  if (tracked === undefined) return params;
+  const { title, kind, rawInput } = params.toolCall;
+  return {
+    ...params,
+    toolCall: {
+      ...params.toolCall,
+      ...(title === undefined && typeof tracked.data.title === "string"
+        ? { title: tracked.data.title }
+        : {}),
+      // Unrecognised kinds map to command approvals, so only a tracked execute kind may grant execution.
+      ...(kind === undefined && tracked.kind === "execute" ? { kind: "execute" as const } : {}),
+      ...(rawInput === undefined && tracked.data.rawInput !== undefined
+        ? { rawInput: tracked.data.rawInput }
+        : {}),
+    },
+  };
+}
+
 export function parsePermissionRequest(
   params: EffectAcpSchema.RequestPermissionRequest,
 ): AcpPermissionRequest {
diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts
index 668502f93e432..7794107824c9b 100644
--- a/packages/provider-core/src/server/managedProvider.test.ts
+++ b/packages/provider-core/src/server/managedProvider.test.ts
@@ -6,6 +6,7 @@ import {
   type ServerProvider,
 } from "@t3tools/contracts";
 import { createModelCapabilities } from "@t3tools/shared/model";
+import * as Cache from "effect/Cache";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
@@ -138,6 +139,116 @@ const enrichedSnapshotSecond: ServerProvider = {
 };
 
 describe("makeManagedServerProvider", () => {
+  it.effect("invalidates cached usage and queues one refresh behind an in-flight refresh", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const calls = yield* Ref.make(0);
+        const probeStarted = yield* Deferred.make<void>();
+        const releaseProbe = yield* Deferred.make<void>();
+        const cache = yield* Cache.makeWith(
+          () =>
+            Effect.gen(function* () {
+              const count = yield* Ref.updateAndGet(calls, (count) => count + 1);
+              if (count === 2) {
+                yield* Deferred.succeed(probeStarted, undefined);
+                yield* Deferred.await(releaseProbe);
+              }
+              return {
+                ...refreshedSnapshot,
+                usageLimits: {
+                  checkedAt: refreshedSnapshot.checkedAt,
+                  windows: [
+                    {
+                      id: "five_hour",
+                      kind: "session",
+                      label: "Session",
+                      usedPercent: count === 1 ? 20 : 100,
+                    },
+                  ],
+                },
+              } satisfies ServerProvider;
+            }),
+          { capacity: 1, timeToLive: () => "5 minutes" },
+        );
+        const warmed = yield* Cache.get(cache, "claude");
+        const provider = yield* makeManagedServerProvider<TestSettings>({
+          resolveMaintenance: () => Effect.die("usage refresh must not resolve maintenance"),
+          getSettings: Effect.succeed({ enabled: true }),
+          streamSettings: Stream.empty,
+          haveSettingsChanged: () => false,
+          initialSnapshot: () => Effect.succeed(warmed),
+          checkProvider: Cache.get(cache, "claude"),
+          invalidateUsageCache: Cache.invalidateAll(cache),
+          refreshOnInterval: false,
+        });
+        yield* provider.streamChanges.pipe(Stream.take(1), Stream.runDrain);
+        assert.strictEqual(yield* Ref.get(calls), 1);
+        const refresh = yield* provider.refreshUsage!.pipe(Effect.forkChild);
+        yield* Deferred.await(probeStarted);
+        const queued = yield* provider.refreshUsage!.pipe(
+          Effect.forkChild({ startImmediately: true }),
+        );
+        yield* provider.refreshUsage!;
+        assert.strictEqual(yield* Ref.get(calls), 2);
+        assert.strictEqual((yield* provider.getSnapshot).usageLimits?.windows[0]?.usedPercent, 20);
+        yield* Deferred.succeed(releaseProbe, undefined);
+        yield* Fiber.join(refresh);
+        yield* Fiber.join(queued);
+        assert.strictEqual(yield* Ref.get(calls), 3);
+        assert.strictEqual((yield* provider.getSnapshot).usageLimits?.windows[0]?.usedPercent, 100);
+      }),
+    ).pipe(Effect.provide(layerAlwaysRunTest)),
+  );
+  it.effect("keeps the waiting usage refresh's claim when the running one is interrupted", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const calls = yield* Ref.make(0);
+        const usageProbeStarted = yield* Deferred.make<void>();
+        const statusProbeStarted = yield* Deferred.make<void>();
+        const releaseStatusProbe = yield* Deferred.make<void>();
+        const provider = yield* makeManagedServerProvider<TestSettings>({
+          resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
+          getSettings: Effect.succeed({ enabled: true }),
+          streamSettings: Stream.empty,
+          haveSettingsChanged: () => false,
+          initialSnapshot: () => Effect.succeed(initialSnapshot),
+          checkProvider: Effect.gen(function* () {
+            const count = yield* Ref.updateAndGet(calls, (count) => count + 1);
+            if (count === 2) {
+              yield* Deferred.succeed(usageProbeStarted, undefined);
+              return yield* Effect.never;
+            }
+            if (count === 3) {
+              yield* Deferred.succeed(statusProbeStarted, undefined);
+              yield* Deferred.await(releaseStatusProbe);
+            }
+            return {
+              ...refreshedSnapshot,
+              usageLimits: { checkedAt: refreshedSnapshot.checkedAt, windows: [] },
+            } satisfies ServerProvider;
+          }),
+          refreshOnInterval: false,
+        });
+        yield* provider.streamChanges.pipe(Stream.take(1), Stream.runDrain);
+        const running = yield* provider.refreshUsage!.pipe(Effect.forkChild);
+        yield* Deferred.await(usageProbeStarted);
+        const status = yield* provider.refresh.pipe(Effect.forkChild({ startImmediately: true }));
+        const waiting = yield* provider.refreshUsage!.pipe(
+          Effect.forkChild({ startImmediately: true }),
+        );
+        yield* Fiber.interrupt(running);
+        yield* Deferred.await(statusProbeStarted);
+        const extra = yield* provider.refreshUsage!.pipe(
+          Effect.forkChild({ startImmediately: true }),
+        );
+        yield* Deferred.succeed(releaseStatusProbe, undefined);
+        yield* Fiber.join(status);
+        yield* Fiber.join(waiting);
+        yield* Fiber.join(extra);
+        assert.strictEqual(yield* Ref.get(calls), 4);
+      }),
+    ).pipe(Effect.provide(layerAlwaysRunTest)),
+  );
   it.effect(
     "runs the initial provider check in the background and streams the refreshed snapshot",
     () =>
diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts
index f40baee525c8d..41ff65b0f294b 100644
--- a/packages/provider-core/src/server/managedProvider.ts
+++ b/packages/provider-core/src/server/managedProvider.ts
@@ -44,6 +44,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
   readonly haveSettingsChanged: (previous: Settings, next: Settings) => boolean;
   readonly initialSnapshot: (settings: Settings) => Effect.Effect<ServerProvider>;
   readonly checkProvider: Effect.Effect<ServerProvider, ServerSettingsError>;
+  readonly invalidateUsageCache?: Effect.Effect<void>;
   readonly enrichSnapshot?: (input: {
     readonly settings: Settings;
     readonly snapshot: ServerProvider;
@@ -60,6 +61,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
 > {
   const host = yield* ProviderHost.ProviderHost;
   const refreshSemaphore = yield* Semaphore.make(1);
+  const usageRefreshQueued = yield* Ref.make<symbol | null>(null);
   const changesPubSub = yield* Effect.acquireRelease(
     PubSub.unbounded<ServerProvider>(),
     PubSub.shutdown,
@@ -216,6 +218,38 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
     return yield* applySnapshot(nextSettings, { forceRefresh: true });
   });
 
+  const refreshUsage = Effect.fn("ManagedServerProvider.refreshUsage")(function* () {
+    const { snapshot } = yield* Ref.get(snapshotStateRef);
+    if (
+      !snapshot.enabled ||
+      !snapshot.usageLimits ||
+      snapshot.usageLimits.unavailable?.reason === "unsupported"
+    )
+      return;
+    // An in-flight refresh may have read cached usage, so one refresh waits behind it.
+    const claim = Symbol();
+    const release = Ref.update(usageRefreshQueued, (queued) => (queued === claim ? null : queued));
+    yield* Effect.uninterruptibleMask((restore) =>
+      Ref.modify(usageRefreshQueued, (queued) => [queued !== null, queued ?? claim]).pipe(
+        Effect.flatMap((held) =>
+          held
+            ? Effect.void
+            : restore(
+                refreshSemaphore.withPermits(1)(
+                  release.pipe(
+                    Effect.andThen(input.invalidateUsageCache ?? Effect.void),
+                    Effect.andThen(input.getSettings),
+                    Effect.flatMap((settings) =>
+                      applySnapshotBase(settings, { forceRefresh: true }),
+                    ),
+                  ),
+                ),
+              ).pipe(Effect.onInterrupt(() => release)),
+        ),
+      ),
+    );
+  });
+
   const shouldRefreshOnInterval = Effect.gen(function* () {
     const state = yield* Ref.get(snapshotStateRef);
     // A disabled instance has nothing to probe; a periodic check would only
@@ -304,6 +338,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
       .resolveMaintenance({ fresh: true })
       .pipe(Effect.andThen(refreshSnapshot), Effect.tapError(Effect.logError), Effect.orDie),
     applyUsageLimits,
+    refreshUsage: refreshUsage(),
     get streamChanges() {
       return Stream.fromPubSub(changesPubSub);
     },
diff --git a/packages/provider-core/src/server/snapshot.ts b/packages/provider-core/src/server/snapshot.ts
index c9c877d29fe20..88f2c1f113848 100644
--- a/packages/provider-core/src/server/snapshot.ts
+++ b/packages/provider-core/src/server/snapshot.ts
@@ -1,4 +1,8 @@
-import type { ProviderUsageLimitsUpdate, ServerProvider } from "@t3tools/contracts";
+import type {
+  ProviderUsageLimitsUpdate,
+  ServerProvider,
+  ServerSettingsError,
+} from "@t3tools/contracts";
 import type * as Effect from "effect/Effect";
 import type * as Stream from "effect/Stream";
 import type { ProviderMaintenanceCapabilities } from "./maintenance.ts";
@@ -10,6 +14,7 @@ export interface ManagedServerProvider {
   }) => Effect.Effect<ProviderMaintenanceCapabilities>;
   readonly getSnapshot: Effect.Effect<ServerProvider>;
   readonly refresh: Effect.Effect<ServerProvider>;
+  readonly refreshUsage?: Effect.Effect<void, ServerSettingsError>;
   readonly streamChanges: Stream.Stream<ServerProvider>;
   /** Merge windows by ID; updates with no usable window leave the snapshot untouched. */
   readonly applyUsageLimits: (
diff --git a/packages/provider-cursor/src/server/CursorAgentSdk.ts b/packages/provider-cursor/src/server/CursorAgentSdk.ts
index 7f0decb49af3f..5986d09506d09 100644
--- a/packages/provider-cursor/src/server/CursorAgentSdk.ts
+++ b/packages/provider-cursor/src/server/CursorAgentSdk.ts
@@ -43,6 +43,21 @@ export function cursorSdkFailureMessage(error: CursorAgentSdkRunnerError): strin
     : `Cursor Agent SDK ${error.method} failed: ${reason}`;
 }
 
+// The SDK maps backend details to codes like PRO_USER_USAGE_LIMIT or RATE_LIMITED, without a status.
+const CURSOR_USAGE_LIMIT_CODE =
+  /^(?:resource_exhausted|rate_limited(?:_changeable)?|\w*_usage_limit|\w*_rate_limit(?:_exceeded)?)$/i;
+
+export function isCursorUsageLimitError(cause: unknown): boolean {
+  const error = isCursorAgentSdkRunnerError(cause) ? cause.cause : cause;
+  if (typeof error !== "object" || error === null) return false;
+  const code = Reflect.get(error, "code");
+  return (
+    Reflect.get(error, "name") === "RateLimitError" ||
+    Reflect.get(error, "status") === 429 ||
+    (typeof code === "string" && CURSOR_USAGE_LIMIT_CODE.test(code))
+  );
+}
+
 const GENERIC_SDK_ERROR_CODES = new Set(["", "error", "unknown"]);
 
 function sdkErrorReason(cause: unknown): string | undefined {
diff --git a/packages/provider-cursor/src/server/adapter.test.ts b/packages/provider-cursor/src/server/adapter.test.ts
index 5e7093b67ae21..062089fffa0c3 100644
--- a/packages/provider-cursor/src/server/adapter.test.ts
+++ b/packages/provider-cursor/src/server/adapter.test.ts
@@ -214,6 +214,15 @@ describe("CursorAdapterV2", () => {
   );
 
   it.effect.each([
+    {
+      reason: "the SDK's detailed plan usage limit code",
+      wait: Effect.succeed({
+        id: "native-cursor-run",
+        status: "error" as const,
+        error: { message: "You've hit your usage limit", code: "PRO_USER_USAGE_LIMIT" },
+      }),
+      failure: { class: "usage_limit", message: "You've hit your usage limit" },
+    },
     {
       reason: "the error Cursor's run ended with",
       wait: Effect.succeed({
@@ -232,7 +241,7 @@ describe("CursorAdapterV2", () => {
       },
     },
     {
-      reason: "the SDK error that broke the run",
+      reason: "the SDK rate limit that broke the run",
       wait: Effect.fail(
         new CursorAgentSdk.CursorAgentSdkRunnerError({
           method: "run.wait",
@@ -243,7 +252,7 @@ describe("CursorAdapterV2", () => {
         }),
       ),
       failure: {
-        class: "transport_error",
+        class: "usage_limit",
         message:
           "Cursor Agent SDK run.wait failed: Too many requests (resource_exhausted, HTTP 429)",
       },
@@ -1140,6 +1149,227 @@ describe("CursorAdapterV2", () => {
     ),
   );
 
+  it.effect("projects subagent directory trees Cursor serialized without empty lists", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspace = yield* fileSystem.makeTempDirectoryScoped({ prefix: "cursor-v2-task-ls-" });
+      const instanceId = ProviderInstanceId.make("cursor");
+      const threadId = ThreadId.make("cursor-task-ls-thread");
+      const modelSelection = { instanceId, model: "composer-2.5" };
+      const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+        runtimeMode: "full-access",
+        interactionMode: "default",
+        cwd: workspace,
+      });
+      // The SDK serializes subagent steps with protobuf toJson(), which omits empty repeated fields.
+      const conversationSteps = [
+        {
+          toolCall: {
+            toolCallId: "tool:ls",
+            lsToolCall: {
+              args: { path: workspace },
+              result: {
+                success: {
+                  directoryTreeRoot: {
+                    absPath: workspace,
+                    childrenWereProcessed: true,
+                    childrenDirs: [
+                      {
+                        absPath: path.join(workspace, "src"),
+                        childrenFiles: [{ name: "index.ts" }],
+                        childrenWereProcessed: true,
+                        numFiles: 1,
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          },
+        },
+        {
+          toolCall: {
+            toolCallId: "tool:lints",
+            readLintsToolCall: { args: {}, result: { success: {} } },
+          },
+        },
+        {
+          toolCall: {
+            toolCallId: "tool:lints-clean-file",
+            readLintsToolCall: {
+              args: {},
+              result: { success: { fileDiagnostics: [{ path: "src/clean.ts" }] } },
+            },
+          },
+        },
+        {
+          toolCall: {
+            toolCallId: "tool:mcp",
+            mcpToolCall: {
+              args: { providerIdentifier: "docs", toolName: "lookup", args: { query: "ls" } },
+              result: { success: {} },
+            },
+          },
+        },
+      ];
+      const adapter = yield* makeCursorAdapterV2({
+        instanceId,
+        environment: { HOME: workspace },
+      }).pipe(
+        Effect.provideService(CursorAgentSdk.CursorAgentSdkRunner, {
+          assertComplete: Effect.void,
+          open: () =>
+            Effect.succeed({
+              agentId: "native-cursor-task-ls",
+              listMessages: Effect.succeed([]),
+              close: Effect.void,
+              send: (input) =>
+                Effect.gen(function* () {
+                  const args = {
+                    description: "Explore",
+                    prompt: "List the workspace.",
+                    subagentType: { kind: "unspecified" as const },
+                    agentId: "cursor-task-agent",
+                    mode: "unspecified" as const,
+                  };
+                  yield* input.onDelta!({
+                    type: "tool-call-started",
+                    modelCallId: "model-call",
+                    callId: "task-call",
+                    toolCall: { type: "task", args },
+                  });
+                  yield* input.onDelta!({
+                    type: "tool-call-completed",
+                    modelCallId: "model-call",
+                    callId: "task-call",
+                    toolCall: {
+                      type: "task",
+                      args,
+                      result: {
+                        status: "success",
+                        value: {
+                          conversationSteps,
+                          isBackground: false,
+                          backgroundReason: "unspecified",
+                        },
+                      },
+                    },
+                  });
+                  return {
+                    agentId: "native-cursor-task-ls",
+                    runId: "native-cursor-run",
+                    wait: Effect.succeed({
+                      id: "native-cursor-run",
+                      requestId: "native-request",
+                      status: "finished" as const,
+                      model: { id: "composer-2.5" },
+                      durationMs: 1,
+                    }),
+                    cancel: Effect.void,
+                  };
+                }).pipe(Effect.orDie),
+            }),
+        }),
+        Effect.provide(TestProviderHost.layer({ cwd: workspace })),
+      );
+      const runtime = yield* adapter.openSession({
+        threadId,
+        providerSessionId: ProviderSessionId.make("cursor-task-ls-session"),
+        modelSelection,
+        runtimePolicy,
+      });
+      const providerThread = yield* runtime.ensureThread({
+        threadId,
+        modelSelection,
+        runtimePolicy,
+      });
+      const now = yield* DateTime.now;
+      yield* runtime.startTurn({
+        threadId,
+        providerThread,
+        modelSelection,
+        runtimePolicy,
+        runId: RunId.make("cursor-task-ls-run"),
+        runOrdinal: 1,
+        providerTurnOrdinal: 1,
+        attemptId: RunAttemptId.make("cursor-task-ls-attempt"),
+        rootNodeId: NodeId.make("cursor-task-ls-root"),
+        appThread: {
+          id: threadId,
+          projectId: ProjectId.make("cursor-task-ls-project"),
+          createdBy: "user",
+          creationSource: "web",
+          title: "Cursor subagent ls",
+          providerInstanceId: instanceId,
+          modelSelection,
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath: null,
+          activeProviderThreadId: providerThread.id,
+          lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
+          forkedFrom: null,
+          createdAt: now,
+          updatedAt: now,
+          archivedAt: null,
+          settledOverride: null,
+          settledAt: null,
+          lastVisitedAt: null,
+          deletedAt: null,
+        },
+        message: {
+          messageId: MessageId.make("cursor-task-ls-message"),
+          createdBy: "user",
+          creationSource: "web",
+          text: "List the workspace with a subagent.",
+          attachments: [],
+        },
+      });
+      const events = yield* runtime.events.pipe(
+        Stream.takeUntil((event) => event.type === "turn.terminal"),
+        Stream.runCollect,
+      );
+      const terminal = events.find((event) => event.type === "turn.terminal");
+      assert.equal(terminal?.status, "completed");
+      const childThreadId = events.findLast((event) => event.type === "subagent.updated")?.subagent
+        .childThreadId;
+      assert.isDefined(childThreadId);
+      assert.deepEqual(
+        events.flatMap((event): ReadonlyArray<unknown> => {
+          if (event.type !== "turn_item.updated" || event.turnItem.threadId !== childThreadId) {
+            return [];
+          }
+          const item = event.turnItem;
+          return item.type === "file_search"
+            ? [{ status: item.status, pattern: item.pattern, results: item.results ?? [] }]
+            : item.type === "dynamic_tool"
+              ? [{ status: item.status, toolName: item.toolName, output: item.output }]
+              : [];
+        }),
+        [
+          {
+            status: "completed",
+            pattern: workspace,
+            results: [{ fileName: path.join(workspace, "src", "index.ts") }],
+          },
+          { status: "completed", pattern: "", results: [] },
+          { status: "completed", pattern: "", results: [] },
+          {
+            status: "completed",
+            toolName: "mcp__docs__lookup",
+            output: { content: [], isError: false },
+          },
+        ],
+      );
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(
+        Layer.mergeAll(NodeServices.layer, IdAllocator.layer, McpProviderSessions.layer),
+      ),
+    ),
+  );
+
   it.effect("names a custom model Cursor's account catalog rejects", () =>
     Effect.gen(function* () {
       const fileSystem = yield* FileSystem.FileSystem;
diff --git a/packages/provider-cursor/src/server/adapter.ts b/packages/provider-cursor/src/server/adapter.ts
index 1d98c4523ffef..72aca919b25f4 100644
--- a/packages/provider-cursor/src/server/adapter.ts
+++ b/packages/provider-cursor/src/server/adapter.ts
@@ -625,6 +625,29 @@ function nestedGrepWorkspaceResults(success: Record<string, unknown>): Record<st
   );
 }
 
+function nestedArray(value: unknown): ReadonlyArray<unknown> {
+  return Array.isArray(value) ? value : [];
+}
+
+function nestedLsDirectory(rawNode: unknown): CursorLsDirectoryNode {
+  const node = unknownRecord(rawNode);
+  return {
+    absPath: typeof node?.absPath === "string" ? node.absPath : "",
+    childrenDirs: nestedArray(node?.childrenDirs).map(nestedLsDirectory),
+    childrenFiles: nestedArray(node?.childrenFiles).flatMap((rawFile) => {
+      const name = unknownRecord(rawFile)?.name;
+      return typeof name === "string" ? [{ name }] : [];
+    }),
+    childrenWereProcessed: node?.childrenWereProcessed === true,
+    fullSubtreeExtensionCounts: Object.fromEntries(
+      Object.entries(unknownRecord(node?.fullSubtreeExtensionCounts) ?? {}).filter(
+        (entry): entry is [string, number] => typeof entry[1] === "number",
+      ),
+    ),
+    numFiles: typeof node?.numFiles === "number" ? node.numFiles : 0,
+  };
+}
+
 export function nestedToolCallFromEnvelope(
   envelope: Record<string, unknown>,
 ): { readonly callId: string; readonly toolCall: ToolCall } | undefined {
@@ -730,6 +753,66 @@ export function nestedToolCallFromEnvelope(
         } as unknown as ToolCall,
       };
     }
+    case "lsToolCall":
+      return {
+        callId: nestedCallId,
+        toolCall: {
+          type: "ls",
+          args: { path: typeof args.path === "string" ? args.path : "" },
+          result: nestedToolResult(call.result, (value) => ({
+            directoryTreeRoot: nestedLsDirectory(value.directoryTreeRoot),
+          })),
+        } as unknown as ToolCall,
+      };
+    case "readLintsToolCall":
+      return {
+        callId: nestedCallId,
+        toolCall: {
+          type: "readLints",
+          args: {
+            paths: nestedArray(args.paths).filter(
+              (path): path is string => typeof path === "string",
+            ),
+          },
+          result: nestedToolResult(call.result, (value) => ({
+            fileDiagnostics: nestedArray(value.fileDiagnostics).map((rawFile) => {
+              const file = unknownRecord(rawFile);
+              return {
+                path: typeof file?.path === "string" ? file.path : "",
+                diagnostics: nestedArray(file?.diagnostics).flatMap((rawDiagnostic) => {
+                  const diagnostic = unknownRecord(rawDiagnostic);
+                  return diagnostic === undefined
+                    ? []
+                    : [
+                        {
+                          ...diagnostic,
+                          message: typeof diagnostic.message === "string" ? diagnostic.message : "",
+                        },
+                      ];
+                }),
+              };
+            }),
+            totalFiles: typeof value.totalFiles === "number" ? value.totalFiles : 0,
+            totalDiagnostics:
+              typeof value.totalDiagnostics === "number" ? value.totalDiagnostics : 0,
+          })),
+        } as unknown as ToolCall,
+      };
+    case "mcpToolCall":
+      return {
+        callId: nestedCallId,
+        toolCall: {
+          type: "mcp",
+          args,
+          result: nestedToolResult(call.result, (value) => ({
+            content: nestedArray(value.content).flatMap((rawPart) => {
+              const part = unknownRecord(rawPart);
+              return part === undefined ? [] : [part];
+            }),
+            isError: value.isError === true,
+          })),
+        } as unknown as ToolCall,
+      };
     default: {
       const type = wrapperName.slice(0, -"ToolCall".length);
       return {
@@ -2423,7 +2506,9 @@ export const makeCursorAdapterV2 = Effect.fn("makeCursorAdapterV2")(function* (
                                     cause: result.error,
                                     // makeProviderFailure never reads a cause's own text.
                                     message: result.error?.message,
-                                    class: "provider_error",
+                                    class: CursorAgentSdk.isCursorUsageLimitError(result.error)
+                                      ? "usage_limit"
+                                      : "provider_error",
                                   })
                                 : makeProviderFailure({
                                     cause: transportFailure,
@@ -2449,7 +2534,9 @@ export const makeCursorAdapterV2 = Effect.fn("makeCursorAdapterV2")(function* (
                               message: CursorAgentSdk.isCursorAgentSdkRunnerError(cause)
                                 ? CursorAgentSdk.cursorSdkFailureMessage(cause)
                                 : undefined,
-                              class: "transport_error",
+                              class: CursorAgentSdk.isCursorUsageLimitError(cause)
+                                ? "usage_limit"
+                                : "transport_error",
                             }),
                           }),
                     });
diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts
index 759545fff0d19..41da6bd0ff435 100644
--- a/packages/provider-opencode/src/server/adapter.test.ts
+++ b/packages/provider-opencode/src/server/adapter.test.ts
@@ -240,6 +240,51 @@ const makeOpenCodeRuntimeHarness = Effect.fn("makeOpenCodeRuntimeHarness")(funct
 });
 
 describe("OpenCodeAdapterV2", () => {
+  it.effect("classifies APIError 429 as a usage limit", () =>
+    Effect.gen(function* () {
+      const nativeEvents = asyncEventStream();
+      const harness = yield* makeOpenCodeRuntimeHarness("usage-limit", "root", {
+        event: { subscribe: async () => ({ stream: nativeEvents.stream }) },
+        session: {
+          create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }),
+          promptAsync: async () => ({ data: true }),
+          abort: async () => ({ data: true }),
+          children: async () => ({ data: [] }),
+        },
+      });
+      yield* harness.startTurn();
+      const received = yield* harness.runtime.events.pipe(
+        Stream.takeUntil((event) => event.type === "turn.terminal"),
+        Stream.runCollect,
+        Effect.forkScoped,
+      );
+      yield* Effect.promise(() =>
+        nativeEvents.push({
+          type: "session.error",
+          properties: {
+            sessionID: "root",
+            error: {
+              name: "APIError",
+              data: {
+                message: "Provider rejected request",
+                statusCode: 429,
+                isRetryable: true,
+              },
+            },
+          },
+        }),
+      );
+      const terminal = (yield* Fiber.join(received)).find(
+        (event) => event.type === "turn.terminal",
+      );
+      assert.equal(terminal?.status, "failed");
+      assert.equal(terminal?.failure?.class, "usage_limit");
+    }).pipe(
+      Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)),
+      Effect.scoped,
+    ),
+  );
+
   it.effect("applies a changed runtime policy to the session on resume and turn start", () =>
     Effect.gen(function* () {
       const updates: Array<{ sessionID: string; permission: unknown }> = [];
diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts
index ef85a7e70b29b..2a851188d076e 100644
--- a/packages/provider-opencode/src/server/adapter.ts
+++ b/packages/provider-opencode/src/server/adapter.ts
@@ -2643,6 +2643,8 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
                       (state): state is OpenCodeThreadState => state !== undefined,
                     );
               const message = openCodeErrorMessage(event);
+              const error = event.properties.error;
+              const usageLimit = error?.name === "APIError" && error.data.statusCode === 429;
               if (
                 !isMessageAbortedError(event) &&
                 (event.properties.sessionID === undefined ||
@@ -2659,8 +2661,8 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
                     {
                       failure: makeProviderFailure({
                         message,
-                        code: event.properties.error?.name ?? null,
-                        class: "provider_error",
+                        code: error?.name ?? null,
+                        class: usageLimit ? "usage_limit" : "provider_error",
                       }),
                       threadDisposition:
                         event.properties.sessionID === undefined ? "broken" : "reusable",
diff --git a/packages/shared/src/changedFileKind.ts b/packages/shared/src/changedFileKind.ts
index 9fd5c0c7edc79..01cbe899b26ff 100644
--- a/packages/shared/src/changedFileKind.ts
+++ b/packages/shared/src/changedFileKind.ts
@@ -67,6 +67,11 @@ const NOT_DOCS_NAME = /^(requirements.*|constraints.*|CMakeLists|robots|llms)\.t
  * output count as generated, and test support (mocks, fixtures, snapshots) is kept apart from the
  * tests themselves, and prose (Markdown, plain text) is its own kind, so a reviewer can see how much of a change is logic.
  */
+export function isTestChangedFile(path: string): boolean {
+  const kind = classifyChangedFile(path);
+  return kind === "tests" || kind === "mocks";
+}
+
 export function classifyChangedFile(path: string): ChangedFileKind {
   const segments = path.replaceAll("\\", "/").split("/");
   const name = segments.pop() ?? "";
diff --git a/packages/shared/src/cliRelease.ts b/packages/shared/src/cliRelease.ts
index 94bd3cffa168c..66777cc044478 100644
--- a/packages/shared/src/cliRelease.ts
+++ b/packages/shared/src/cliRelease.ts
@@ -1,3 +1,8 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+import { compareSemverVersions } from "./semver.ts";
+
 const CLI_RELEASE_REPOSITORY = "pingdotgg/t3code";
 export const CLI_RELEASES_PAGE_URL = `https://github.com/${CLI_RELEASE_REPOSITORY}/releases`;
 export const CLI_RELEASE_CHECKSUMS_FILE = "SHA256SUMS";
@@ -68,6 +73,32 @@ export function cliReleaseChannelOf(version: string): CliReleaseChannel {
   return channel === "nightly" || channel === "preview" ? channel : "stable";
 }
 
+/** Whether updating between these versions crosses Stable and Nightly. Preview builds cross nothing.
+ * Hosts refuse a crossing outside a track switch, which checks the database first. */
+export function crossesReleaseTrack(fromVersion: string, toVersion: string): boolean {
+  const from = cliReleaseChannelOf(fromVersion);
+  const to = cliReleaseChannelOf(toVersion);
+  return from !== to && from !== "preview" && to !== "preview";
+}
+
+/** The desktop update track a build belongs to. Preview builds have no feed and read as Stable. */
+export function desktopUpdateChannelOf(version: string): "latest" | "nightly" {
+  return cliReleaseChannelOf(version) === "nightly" ? "nightly" : "latest";
+}
+
+/** Whether a track switch may install `found` after its database check cleared `checked`: any build
+ * on the switch's track at least as new, since later releases only add migrations. */
+export function acceptsTrackSwitchRelease(
+  found: string,
+  channel: "latest" | "nightly",
+  checked: string,
+): boolean {
+  return (
+    cliReleaseChannelOf(found) === (channel === "nightly" ? "nightly" : "stable") &&
+    compareSemverVersions(found, checked) >= 0
+  );
+}
+
 /** Page until the channel matches; nightlies can push preview/stable releases past the first page. */
 export function cliReleaseIndexPageUrl(page: number): string {
   return `https://api.github.com/repos/${CLI_RELEASE_REPOSITORY}/releases?per_page=100&page=${page}`;
@@ -89,3 +120,14 @@ export function newestCliReleaseVersion(
   }
   return undefined;
 }
+
+const NpmReleaseMigrationManifest = Schema.Struct({
+  t3code: Schema.Struct({ databaseMigration: Schema.Int }),
+});
+const decodeNpmReleaseMigrationManifest = Schema.decodeUnknownOption(NpmReleaseMigrationManifest);
+
+/** Highest database migration a release's server knows, from its npm `t3` manifest. */
+export function npmReleaseDatabaseMigration(manifest: unknown): number | undefined {
+  return Option.getOrUndefined(decodeNpmReleaseMigrationManifest(manifest))?.t3code
+    .databaseMigration;
+}
diff --git a/packages/shared/src/serverSettings.test.ts b/packages/shared/src/serverSettings.test.ts
index 97846939d31cc..f9a43b6123a1e 100644
--- a/packages/shared/src/serverSettings.test.ts
+++ b/packages/shared/src/serverSettings.test.ts
@@ -24,6 +24,24 @@ import {
 const FOLDED_SERVER_SETTINGS = { ...DEFAULT_SERVER_SETTINGS, projectSettingsFolded: true };
 
 describe("fallbackTextGenerationModelSelection", () => {
+  it("replaces and clears the fallback without carrying model options", () => {
+    const fallbackModelSelection = { instanceId: ProviderInstanceId.make("codex"), model: "new" };
+    const settings = applyServerSettingsPatch(
+      {
+        ...DEFAULT_SERVER_SETTINGS,
+        fallbackModelSelection: {
+          ...fallbackModelSelection,
+          model: "old",
+          options: [{ id: "effort", value: "high" }],
+        },
+      },
+      { fallbackModelSelection },
+    );
+    expect(settings.fallbackModelSelection).toEqual(fallbackModelSelection);
+    expect(
+      applyServerSettingsPatch(settings, { fallbackModelSelection: null }).fallbackModelSelection,
+    ).toBeNull();
+  });
   it("ignores a configured non-default instance at machine scope, matching no fallback", () => {
     const configured = ProviderInstanceId.make("codex_work");
     const providerInstances = {
diff --git a/packages/shared/src/serverSettings.ts b/packages/shared/src/serverSettings.ts
index 0c151eb5025af..e7c856070658a 100644
--- a/packages/shared/src/serverSettings.ts
+++ b/packages/shared/src/serverSettings.ts
@@ -92,13 +92,15 @@ export function fallbackTextGenerationModelSelection(
   ) {
     return threadDefault;
   }
-  return {
-    instanceId,
-    model:
-      DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[driver] ??
-      DEFAULT_MODEL_BY_PROVIDER[driver] ??
-      DEFAULT_TEXT_GENERATION_MODEL,
-  };
+  return { instanceId, model: defaultTextGenerationModel(driver) };
+}
+
+export function defaultTextGenerationModel(driver: ProviderDriverKind): string {
+  return (
+    DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[driver] ??
+    DEFAULT_MODEL_BY_PROVIDER[driver] ??
+    DEFAULT_TEXT_GENERATION_MODEL
+  );
 }
 
 export function resolveSourceControlWriterModelSelection(
@@ -538,6 +540,9 @@ export function applyServerSettingsPatch(
     ...(patch.defaultModelSelection !== undefined
       ? { defaultModelSelection: patch.defaultModelSelection }
       : {}),
+    ...(patch.fallbackModelSelection !== undefined
+      ? { fallbackModelSelection: patch.fallbackModelSelection }
+      : {}),
     ...(patch.defaultProjectScripts !== undefined
       ? { defaultProjectScripts: patch.defaultProjectScripts }
       : {}),
diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts
index 503521c087d72..5da7bc2cc02db 100644
--- a/packages/shared/src/usageLimits.test.ts
+++ b/packages/shared/src/usageLimits.test.ts
@@ -1,4 +1,5 @@
 import {
+  DEFAULT_SERVER_SETTINGS,
   EnvironmentId,
   ProviderDriverKind,
   ProviderInstanceId,
@@ -17,9 +18,11 @@ import {
   collectLimitNotices,
   collectLimitPools,
   elapsedShare,
+  exhaustedUsageWindow,
   paceOf,
   paceRemainingPercent,
   usesChatGptSharing,
+  resolveNewThreadModelSelection,
 } from "./usageLimits.ts";
 
 const now = Date.parse("2026-09-03T12:00:00.000Z");
@@ -50,6 +53,106 @@ function provider(overrides: Partial<ServerProvider>): ServerProvider {
   };
 }
 
+describe("new thread model fallback", () => {
+  const selection = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-6.1-sol" };
+  const fallback = { instanceId: ProviderInstanceId.make("claude"), model: "claude-fable-5-1" };
+  const limited = provider({
+    usageLimits: {
+      checkedAt: "2026-09-03T11:00:00.000Z",
+      windows: [{ ...window, usedPercent: 100 }],
+    },
+  });
+  const available = provider({
+    instanceId: fallback.instanceId,
+    driver: ProviderDriverKind.make("claudeAgent"),
+  });
+
+  const defaults = {
+    defaultSelection: selection,
+    fallbackSelection: fallback,
+    providers: [limited, available],
+    now,
+  };
+  it.each([
+    ["exhausted default", {}, fallback],
+    ["explicit selection", { explicitSelection: selection }, selection],
+    ["missing default", { defaultSelection: null }, null],
+    ["no fallback", { fallbackSelection: null }, selection],
+    ["expired window", { now: Date.parse("2026-09-04T00:00:00Z") }, selection],
+    [
+      "environment disabled",
+      {
+        settings: {
+          ...DEFAULT_SERVER_SETTINGS,
+          providerInstances: {
+            [fallback.instanceId]: { driver: available.driver, enabled: false, config: {} },
+          },
+        },
+      },
+      selection,
+    ],
+  ] as const)("resolves %s", (_name, overrides, expected) => {
+    expect(resolveNewThreadModelSelection({ ...defaults, ...overrides }).selection).toEqual(
+      expected,
+    );
+  });
+  it.each([
+    { enabled: false },
+    { installed: false },
+    { auth: { status: "unauthenticated" as const } },
+    { availability: "unavailable" as const },
+    { usageLimits: limited.usageLimits },
+  ])("rejects an unusable fallback: %j", (overrides) => {
+    expect(
+      resolveNewThreadModelSelection({
+        ...defaults,
+        providers: [limited, { ...available, ...overrides }],
+      }).selection,
+    ).toEqual(selection);
+  });
+  it.each([undefined, "invalid"])("treats an unknown reset as exhausted: %s", (resetsAt) => {
+    expect(
+      exhaustedUsageWindow(
+        provider({
+          usageLimits: {
+            checkedAt: limited.checkedAt,
+            windows: [{ ...window, usedPercent: 100, resetsAt }],
+          },
+        }),
+        now,
+      ),
+    ).toBeDefined();
+  });
+  it.each([
+    ["cursor", ["autoPercentUsed"], "claude-opus-5-5", false],
+    ["cursor", ["autoPercentUsed"], "composer-2.5", false],
+    ["cursor", ["autoPercentUsed", "apiPercentUsed"], "composer-2.5", true],
+    ["antigravity", ["gemini-weekly"], "claude-opus-5-5", false],
+    ["antigravity", ["3p-weekly"], "claude-opus-5-5", true],
+    ["antigravity", ["gemini-weekly"], "antigravity-default", true],
+    ["opencode", ["go_weekly"], "opencode/big-pickle", false],
+    ["opencode", ["go_weekly"], "opencode-go/big-pickle", true],
+  ] as const)("matches %s pools %s to %s", (driver, ids, model, usesFallback) => {
+    const defaultSelection = { ...selection, model };
+    expect(
+      resolveNewThreadModelSelection({
+        ...defaults,
+        defaultSelection,
+        providers: [
+          provider({
+            driver: ProviderDriverKind.make(driver),
+            usageLimits: {
+              checkedAt: limited.checkedAt,
+              windows: ids.map((id) => ({ ...window, id, usedPercent: 100 })),
+            },
+          }),
+          available,
+        ],
+      }).selection,
+    ).toEqual(usesFallback ? fallback : defaultSelection);
+  });
+});
+
 describe("pace", () => {
   it("places the clock three fifths through a five-hour window with two hours left", () => {
     expect(elapsedShare(window, now)).toBeCloseTo(0.6);
diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts
index 01e2ad59a332d..3dca207a2efb7 100644
--- a/packages/shared/src/usageLimits.ts
+++ b/packages/shared/src/usageLimits.ts
@@ -1,5 +1,9 @@
 import {
   type EnvironmentId,
+  type ModelSelection,
+  type ServerSettings,
+  type ProjectId,
+  resolveProjectProviderInstanceEnabled,
   type UsageLimitsReport,
   type ProviderInstanceId,
   type ProviderConsumeResetCreditInput,
@@ -17,6 +21,85 @@ const MINUTE = 60_000;
 const HOUR = 60 * MINUTE;
 const DAY = 24 * HOUR;
 
+export function exhaustedUsageWindow(
+  provider: ServerProvider | undefined,
+  now: number,
+  model?: string,
+) {
+  const exhausted = (provider?.usageLimits?.windows ?? []).filter(
+    (window) =>
+      (window.usedPercent ?? 0) >= 100 &&
+      (!window.resetsAt ||
+        !Number.isFinite(Date.parse(window.resetsAt)) ||
+        Date.parse(window.resetsAt) > now),
+  );
+  if (model === undefined) return exhausted[0];
+  switch (provider?.driver) {
+    case "cursor": {
+      const api = exhausted.find((window) => window.id === "apiPercentUsed");
+      const auto = exhausted.find((window) => window.id === "autoPercentUsed");
+      return /^(auto|default|grok|composer)/.test(model) ? auto && api : api;
+    }
+    case "antigravity": {
+      const family = model.match(/^(gemini|claude|gpt)-/)?.[1];
+      return exhausted.find((window) => {
+        const pool = window.id.match(/^(gemini|claude|gpt|3p)-/)?.[1];
+        return (
+          pool === undefined ||
+          family === undefined ||
+          pool === family ||
+          (pool === "3p" && (family === "claude" || family === "gpt"))
+        );
+      });
+    }
+    case "opencode":
+      return exhausted.find(
+        (window) => !window.id.startsWith("go_") || model.startsWith("opencode-go/"),
+      );
+    default:
+      return exhausted[0];
+  }
+}
+
+export function resolveNewThreadModelSelection(input: {
+  readonly defaultSelection: ModelSelection | null;
+  readonly explicitSelection?: ModelSelection | null;
+  readonly fallbackSelection: ModelSelection | null;
+  readonly providers: readonly ServerProvider[];
+  readonly now: number;
+  readonly settings?: ServerSettings;
+  readonly projectId?: ProjectId | null;
+}) {
+  const selection = input.explicitSelection ?? input.defaultSelection;
+  const unchanged = { selection, fallback: null };
+  if (input.explicitSelection || !selection || !input.fallbackSelection) return unchanged;
+  const provider = input.providers.find((entry) => entry.instanceId === selection.instanceId);
+  const window = exhaustedUsageWindow(provider, input.now, selection.model);
+  const fallback = input.providers.find(
+    (entry) => entry.instanceId === input.fallbackSelection?.instanceId,
+  );
+  if (
+    !provider ||
+    !window ||
+    !fallback?.enabled ||
+    !fallback.installed ||
+    fallback.auth.status === "unauthenticated" ||
+    !isProviderAvailable(fallback) ||
+    exhaustedUsageWindow(fallback, input.now, input.fallbackSelection.model) ||
+    (input.settings &&
+      !resolveProjectProviderInstanceEnabled(
+        input.settings,
+        input.projectId ?? null,
+        fallback.instanceId,
+      ))
+  )
+    return unchanged;
+  return {
+    selection: input.fallbackSelection,
+    fallback: { provider, resetsAt: window.resetsAt ?? null },
+  };
+}
+
 export const CHATGPT_USAGE_URL = "https://chatgpt.com/#settings/Usage";
 export const CHATGPT_USAGE_LIMIT_CODE = "subscription_sharing_usage_limit_exceeded";
 /** A ChatGPT Business admin caps plan use in other apps; only the admin can raise it. */
diff --git a/packages/source-control-core/src/server/PullRequestProvider.ts b/packages/source-control-core/src/server/PullRequestProvider.ts
index b300f14afb0cb..46fc8fd48b0dc 100644
--- a/packages/source-control-core/src/server/PullRequestProvider.ts
+++ b/packages/source-control-core/src/server/PullRequestProvider.ts
@@ -182,6 +182,7 @@ export interface ProviderChangeRequestStat {
 }
 
 export interface ProviderChangeRequestDetail extends ProviderChangeRequest {
+  readonly maintainerCanModify?: boolean;
   readonly headSha?: string | null;
   readonly body: string;
   readonly changedFiles: number;
@@ -462,6 +463,7 @@ export interface PullRequestProviderApi {
   /** Requires edit capability and at least one field. */
   readonly updateChangeRequest?: (
     input: ProviderRepositoryRef & {
+      readonly maintainerCanModify?: boolean | undefined;
       readonly number: number;
       readonly title?: string | undefined;
       readonly body?: string | undefined;
diff --git a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
index 3fd74e08130ec..a4b5eb8da4c22 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts
@@ -68,6 +68,7 @@ const coreResponse = (pullRequest: Readonly<Record<string, unknown>> = {}) => ({
         mergedAt: null,
         closedAt: null,
         isCrossRepository: false,
+        maintainerCanModify: true,
         headRepositoryOwner: null,
         headRepository: null,
         headRef: null,
@@ -710,6 +711,25 @@ it.effect(
 );
 
 layer("GitHubPullRequestApi.layer", (it) => {
+  it.effect("turns maintainer edits off without rewriting the pull request's text", () =>
+    Effect.gen(function* () {
+      mockedExecute.mockImplementation((call) =>
+        Effect.succeed(
+          output(
+            encodeJson(
+              call.kind === "graphql" && matches(call, NODE_ID_QUERY) ? nodeIdAnswer("PR_7") : {},
+            ),
+          ),
+        ),
+      );
+      const api = yield* GitHubPullRequestApi.GitHubPullRequestApi;
+      yield* api.updatePullRequest({ ...pullRequestInput, maintainerCanModify: false });
+      expect(variablesOf("mutation UpdatePullRequest")).toEqual([
+        { pullRequestId: "PR_7", maintainerCanModify: false },
+      ]);
+    }),
+  );
+
   it.effect.each(["mixed", "merges", "unavailable"] as const)(
     "reads stats only for displayed non-merge commits (%s)",
     (kind) =>
diff --git a/packages/source-control-github/src/server/GitHubPullRequestApi.ts b/packages/source-control-github/src/server/GitHubPullRequestApi.ts
index 4b7014a890744..16a7a1df18cdb 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestApi.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestApi.ts
@@ -705,6 +705,7 @@ export class GitHubPullRequestApi extends Context.Service<
     }) => Effect.Effect<void, GitHubPullRequestApiError>;
 
     readonly updatePullRequest: (input: {
+      readonly maintainerCanModify?: boolean | undefined;
       readonly cwd: string;
       readonly repository: string;
       readonly host: string;
@@ -2740,6 +2741,9 @@ export const make = Effect.gen(function* () {
           client
             .UpdatePullRequest({
               pullRequestId,
+              ...(input.maintainerCanModify === undefined
+                ? {}
+                : { maintainerCanModify: input.maintainerCanModify }),
               ...(input.title === undefined ? {} : { title: input.title }),
               ...(input.body === undefined ? {} : { body: input.body }),
             })
diff --git a/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts b/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
index 81623592066e5..dc8ca69770e46 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestProvider.test.ts
@@ -16,6 +16,8 @@ import { gitHubViewerPermissions, loginAvatarUrl, make } from "./GitHubPullReque
 import type { GitHubReviewThreadComments } from "./gitHubPullRequestJson.ts";
 
 const coreFields = {
+  maintainerCanModify: true,
+  canEditMaintainerEdits: false,
   reviewRequestTeams: [],
   checksTruncated: false,
   comparison: { behindBy: 0, viewerCanUpdate: true },
@@ -205,6 +207,7 @@ describe("gitHubViewerPermissions", () => {
       });
 
       expect(detail.viewerPermissions).toEqual({
+        maintainerEdits: false,
         actions: ["ready", "draft", "close", "reopen"],
         comment: true,
         resolve: false,
diff --git a/packages/source-control-github/src/server/GitHubPullRequestProvider.ts b/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
index f90941bf882ef..4f3490eec97b0 100644
--- a/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
+++ b/packages/source-control-github/src/server/GitHubPullRequestProvider.ts
@@ -49,7 +49,7 @@ const CAPABILITIES: PullRequestCapabilities = {
     verdicts: ["comment", "approve", "request-changes"],
   },
   reviewers: { request: true, listCandidates: true },
-  edit: { changeRequest: true, comment: true },
+  edit: { changeRequest: true, comment: true, maintainerEdits: true },
   stacks: true,
   stackActions: true,
   labels: true,
@@ -453,10 +453,13 @@ export const make = Effect.gen(function* () {
             ...pullRequest.reviewRequestTeams,
           ],
           mergeCapabilities: pullRequest.viewerAccess.mergeCapabilities,
-          viewerPermissions: gitHubViewerPermissions({
-            ...pullRequest.viewerAccess,
-            canUpdateBranch: pullRequest.comparison?.viewerCanUpdate === true,
-          }),
+          viewerPermissions: {
+            ...gitHubViewerPermissions({
+              ...pullRequest.viewerAccess,
+              canUpdateBranch: pullRequest.comparison?.viewerCanUpdate === true,
+            }),
+            maintainerEdits: pullRequest.canEditMaintainerEdits,
+          },
           baseComparison:
             pullRequest.comparison === null || pullRequest.comparison.behindBy === null
               ? "unknown"
@@ -666,6 +669,9 @@ export const make = Effect.gen(function* () {
     updateChangeRequest: (input) =>
       cli
         .updatePullRequest({
+          ...(input.maintainerCanModify === undefined
+            ? {}
+            : { maintainerCanModify: input.maintainerCanModify }),
           cwd: input.cwd,
           repository: input.repository,
           host: input.host,
diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts
index 4e6321aa3c7ac..622b48db3b85d 100644
--- a/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts
+++ b/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts
@@ -362,6 +362,7 @@ describe("pull request detail decoding", () => {
             baseRefName: "main",
             headRefOid: "abc123",
             isCrossRepository: false,
+            maintainerCanModify: true,
             headRepositoryOwner: null,
             headRepository: null,
             headRef: null,
@@ -394,6 +395,30 @@ describe("pull request detail decoding", () => {
     pullRequest?: Record<string, unknown>,
   ) => expectSuccess(decodePullRequestCoreJson(coreJson(rollup, pullRequest)));
 
+  it.each([
+    [{}, true],
+    [{ viewerDidAuthor: false }, false],
+    [{ isCrossRepository: false }, false],
+    [{ state: "CLOSED" }, false],
+    [{ headRepositoryOwner: { __typename: "Organization", login: "team" } }, false],
+    [{ headRepository: null }, false],
+  ])(
+    "reads maintainer edits and lets only the author of an open personal fork change them: %j",
+    (overrides, allowed) => {
+      const detail = detailOf([], {
+        maintainerCanModify: false,
+        isCrossRepository: true,
+        viewerDidAuthor: true,
+        headRepositoryOwner: { __typename: "User", login: "octocat" },
+        headRepository: { nameWithOwner: "octocat/t3code", viewerPermission: "ADMIN" },
+        headRef: { id: "REF_7" },
+        ...overrides,
+      });
+      expect(detail.maintainerCanModify).toBe(false);
+      expect(detail.canEditMaintainerEdits).toBe(allowed);
+    },
+  );
+
   const detailJson = JSON.stringify({
     comments: [{ id: "c1", body: "second", createdAt: "2026-07-04T00:00:00Z" }],
     reviews: [
diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
index 965855a4350ac..e7c05a4aa8445 100644
--- a/packages/source-control-github/src/server/gitHubPullRequestJson.ts
+++ b/packages/source-control-github/src/server/gitHubPullRequestJson.ts
@@ -978,6 +978,8 @@ export function toPullRequestWatchFingerprint(
 }
 
 export interface GitHubPullRequestCore extends GitHubPullRequestDetail {
+  readonly maintainerCanModify: boolean;
+  readonly canEditMaintainerEdits: boolean;
   readonly reviewRequestTeams: ReadonlyArray<PullRequestActor>;
   readonly viewerAccess: GitHubViewerAccess & GitHubRepositoryAccess;
   readonly comparison: GitHubBaseComparison | null;
@@ -1023,6 +1025,14 @@ export function toPullRequestCore(result: PullRequestCore.Result): GitHubPullReq
       statusCheckRollup: toCheckContexts(nodesOf(contexts)),
     }),
     headRepositoryNameWithOwner: trimmed(pr.headRepository?.nameWithOwner),
+    maintainerCanModify: pr.maintainerCanModify,
+    canEditMaintainerEdits:
+      pr.state === "OPEN" &&
+      pr.isCrossRepository &&
+      pr.viewerDidAuthor &&
+      pr.headRepositoryOwner?.__typename === "User" &&
+      pr.headRepository !== null &&
+      pr.headRef !== null,
     viewerAccess: {
       canWrite: toCanWrite(repository.viewerPermission),
       canDeleteBranch: toCanWrite(pr.headRepository?.viewerPermission) && pr.headRef !== null,
diff --git a/packages/source-control-github/src/server/pullRequestMutations.graphql b/packages/source-control-github/src/server/pullRequestMutations.graphql
index 4ba7854507af7..3e2d5b3133ad5 100644
--- a/packages/source-control-github/src/server/pullRequestMutations.graphql
+++ b/packages/source-control-github/src/server/pullRequestMutations.graphql
@@ -41,11 +41,23 @@ mutation UnresolveReviewThread($threadId: ID!) {
   }
 }
 
-# Rewrites the pull request's own words. Both are nullable so that one document serves a change to
-# the title, to the description, or to the two together: a variable the request does not send puts
-# no entry in the input at all, which leaves that field as it was rather than clearing it.
-mutation UpdatePullRequest($pullRequestId: ID!, $title: String, $body: String) {
-  updatePullRequest(input: { pullRequestId: $pullRequestId, title: $title, body: $body }) {
+# Rewrites the pull request's own words or its maintainer-edit setting. Every field is nullable so
+# that one document serves any combination: a variable the request does not send puts no entry in
+# the input at all, which leaves that field as it was rather than clearing it.
+mutation UpdatePullRequest(
+  $pullRequestId: ID!
+  $title: String
+  $body: String
+  $maintainerCanModify: Boolean
+) {
+  updatePullRequest(
+    input: {
+      pullRequestId: $pullRequestId
+      title: $title
+      body: $body
+      maintainerCanModify: $maintainerCanModify
+    }
+  ) {
     pullRequest {
       id
     }
diff --git a/packages/source-control-github/src/server/pullRequestMutations.graphql.ts b/packages/source-control-github/src/server/pullRequestMutations.graphql.ts
index 05a67b81d4e5c..d11b2b1e69fcf 100644
--- a/packages/source-control-github/src/server/pullRequestMutations.graphql.ts
+++ b/packages/source-control-github/src/server/pullRequestMutations.graphql.ts
@@ -205,17 +205,19 @@ export const UpdatePullRequest = GraphQL.mutation("UpdatePullRequest", {
     variables: [
       { name: "pullRequestId", body: "ID!" },
       { name: "title", body: "String" },
-      { name: "body", body: "String" }
+      { name: "body", body: "String" },
+      { name: "maintainerCanModify", body: "Boolean" }
     ],
     selections: [
-      { name: "updatePullRequest", body: ["(input:{pullRequestId:$", "pullRequestId", " title:$", "title", " body:$", "body", "}){pullRequest{id}}"] }
+      { name: "updatePullRequest", body: ["(input:{pullRequestId:$", "pullRequestId", " title:$", "title", " body:$", "body", " maintainerCanModify:$", "maintainerCanModify", "}){pullRequest{id}}"] }
     ],
     fragments: []
   },
   variables: {
     pullRequestId: Shared.ID,
     title: Schema.optional(Schema.NullOr(Schema.String)),
-    body: Schema.optional(Schema.NullOr(Schema.String))
+    body: Schema.optional(Schema.NullOr(Schema.String)),
+    maintainerCanModify: Schema.optional(Schema.NullOr(Schema.Boolean))
   },
   result: Schema.Struct({
     /** Update a pull request */
diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql b/packages/source-control-github/src/server/pullRequestReads.graphql
index d5a95256fc1a3..78e5efe0e4558 100644
--- a/packages/source-control-github/src/server/pullRequestReads.graphql
+++ b/packages/source-control-github/src/server/pullRequestReads.graphql
@@ -87,6 +87,7 @@ query PullRequestCore(
       baseRefName
       headRefOid
       isCrossRepository
+      maintainerCanModify
       headRepositoryOwner {
         login
       }
diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql.ts b/packages/source-control-github/src/server/pullRequestReads.graphql.ts
index e261ec0240a73..5bc09fa4e2ce4 100644
--- a/packages/source-control-github/src/server/pullRequestReads.graphql.ts
+++ b/packages/source-control-github/src/server/pullRequestReads.graphql.ts
@@ -395,6 +395,8 @@ export const PullRequestCoreRepositoryPullRequestPullRequest = Schema.Struct({
   headRefOid: Shared.GitObjectID,
   /** The head and base repositories are different. */
   isCrossRepository: Schema.Boolean,
+  /** Indicates whether maintainers can modify the pull request. */
+  maintainerCanModify: Schema.Boolean,
   /** The owner of the repository associated with this pull request's head Ref. */
   headRepositoryOwner: Schema.NullOr(RepositoryOwner),
   /** The repository associated with this pull request's head Ref. */
@@ -457,7 +459,7 @@ export const PullRequestCore = GraphQL.query("PullRequestCore", {
       { name: "requestedReviewers", body: "Int!" }
     ],
     selections: [
-      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){mergeCommitAllowed squashMergeAllowed rebaseMergeAllowed autoMergeAllowed viewerPermission pullRequest(number:$", "number", "){number title url body state isDraft mergeable mergeStateStatus reviewDecision additions deletions changedFiles createdAt updatedAt mergedAt closedAt headRefName baseRefName headRefOid isCrossRepository headRepositoryOwner{__typename login}headRepository{nameWithOwner viewerPermission}headRef{id}author{__typename login avatarUrl...on User{id name}}autoMergeRequest{mergeMethod}viewerCanUpdate viewerDidAuthor viewerCanUpdateBranch baseRef{compare(headRef:$", "headRef", "){behindBy}}reviewRequests(first:$", "requestedReviewers", "){nodes{requestedReviewer{__typename...on User{login name}...on Bot{login}...on Team{slug combinedSlug teamName:name teamAvatarUrl:avatarUrl}}}}labels(first:100){nodes{name color}}commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage}}}}}}}}"] }
+      { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){mergeCommitAllowed squashMergeAllowed rebaseMergeAllowed autoMergeAllowed viewerPermission pullRequest(number:$", "number", "){number title url body state isDraft mergeable mergeStateStatus reviewDecision additions deletions changedFiles createdAt updatedAt mergedAt closedAt headRefName baseRefName headRefOid isCrossRepository maintainerCanModify headRepositoryOwner{__typename login}headRepository{nameWithOwner viewerPermission}headRef{id}author{__typename login avatarUrl...on User{id name}}autoMergeRequest{mergeMethod}viewerCanUpdate viewerDidAuthor viewerCanUpdateBranch baseRef{compare(headRef:$", "headRef", "){behindBy}}reviewRequests(first:$", "requestedReviewers", "){nodes{requestedReviewer{__typename...on User{login name}...on Bot{login}...on Team{slug combinedSlug teamName:name teamAvatarUrl:avatarUrl}}}}labels(first:100){nodes{name color}}commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage}}}}}}}}"] }
     ],
     fragments: [
       { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{workflow{name}}}}}"] }
diff --git a/patches/@expo__ui@58.0.20.patch b/patches/@expo__ui@58.0.20.patch
index 2546d83b80428..859ee062b9fdf 100644
--- a/patches/@expo__ui@58.0.20.patch
+++ b/patches/@expo__ui@58.0.20.patch
@@ -1,8 +1,49 @@
 diff --git a/android/src/main/java/expo/modules/ui/ExpoUIModule.kt b/android/src/main/java/expo/modules/ui/ExpoUIModule.kt
-index d58b54f..1920b1a 100644
+index d58b54fc30ba0f9e5bc35b505ae598161a59b9b1..2da4df803a918d034921d41d49d92121e6303f82 100644
 --- a/android/src/main/java/expo/modules/ui/ExpoUIModule.kt
 +++ b/android/src/main/java/expo/modules/ui/ExpoUIModule.kt
-@@ -533,6 +533,10 @@ class ExpoUIModule : Module() {
+@@ -29,6 +29,13 @@ import expo.modules.ui.button.IconButtonContent
+ import expo.modules.ui.button.FilledIconButtonContent
+ import expo.modules.ui.button.FilledTonalIconButtonContent
+ import expo.modules.ui.button.OutlinedIconButtonContent
++import expo.modules.ui.button.SplitButtonCheckedChangeEvent
++import expo.modules.ui.button.SplitButtonLayoutContent
++import expo.modules.ui.button.SplitButtonLayoutProps
++import expo.modules.ui.button.SplitButtonLeadingButtonContent
++import expo.modules.ui.button.SplitButtonLeadingButtonProps
++import expo.modules.ui.button.SplitButtonTrailingButtonContent
++import expo.modules.ui.button.SplitButtonTrailingButtonProps
+ import expo.modules.ui.graphics.ImageLoader
+ import expo.modules.ui.icon.IconView
+ import expo.modules.ui.image.ImageView
+@@ -294,6 +301,26 @@ class ExpoUIModule : Module() {
+       }
+     }
+ 
++    ExpoUIView<SplitButtonLayoutProps>("SplitButtonLayoutView") {
++      Content { props -> SplitButtonLayoutContent(props) }
++    }
++
++    ExpoUIView<SplitButtonLeadingButtonProps>("SplitButtonLeadingButtonView") {
++      val onButtonPressed by Event<Unit>()
++
++      Content { props ->
++        SplitButtonLeadingButtonContent(props) { onButtonPressed(Unit) }
++      }
++    }
++
++    ExpoUIView<SplitButtonTrailingButtonProps>("SplitButtonTrailingButtonView") {
++      val onCheckedChange by Event<SplitButtonCheckedChangeEvent>()
++
++      Content { props ->
++        SplitButtonTrailingButtonContent(props) { onCheckedChange(it) }
++      }
++    }
++
+     ExpoUIView<ButtonProps>("FilledTonalButton") {
+       val onButtonPressed by Event<ButtonPressedEvent>()
+ 
+@@ -533,6 +560,10 @@ class ExpoUIModule : Module() {
        }
      }
  
@@ -14,7 +55,7 @@ index d58b54f..1920b1a 100644
        Content { props ->
          HorizontalFloatingToolbarContent(props)
 diff --git a/android/src/main/java/expo/modules/ui/HostView.kt b/android/src/main/java/expo/modules/ui/HostView.kt
-index 4887034..6eaf039 100644
+index 4887034bf7e3e6b5d8d2c1ae25932f5a24f9435d..6eaf039a14820ddaf635a1538c2a9a644cf704fb 100644
 --- a/android/src/main/java/expo/modules/ui/HostView.kt
 +++ b/android/src/main/java/expo/modules/ui/HostView.kt
 @@ -69,6 +69,7 @@ internal enum class ExpoLayoutDirection(val value: String) : Enumerable {
@@ -89,7 +130,7 @@ index 4887034..6eaf039 100644
      // Material3's `MaterialTheme` does not provide `LocalContentColor` — only `Surface` does — so
 diff --git a/android/src/main/java/expo/modules/ui/TopAppBarView.kt b/android/src/main/java/expo/modules/ui/TopAppBarView.kt
 new file mode 100644
-index 0000000..4ed0132
+index 0000000000000000000000000000000000000000..4ed0132d57fc7aff08ecb7ee84fb8fa48942931b
 --- /dev/null
 +++ b/android/src/main/java/expo/modules/ui/TopAppBarView.kt
 @@ -0,0 +1,47 @@
@@ -140,8 +181,109 @@ index 0000000..4ed0132
 +    modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)
 +  )
 +}
+diff --git a/android/src/main/java/expo/modules/ui/button/SplitButton.kt b/android/src/main/java/expo/modules/ui/button/SplitButton.kt
+new file mode 100644
+index 0000000000000000000000000000000000000000..10df003066fb0703645c4306bd557590b2cae9aa
+--- /dev/null
++++ b/android/src/main/java/expo/modules/ui/button/SplitButton.kt
+@@ -0,0 +1,95 @@
++@file:OptIn(ExperimentalMaterial3ExpressiveApi::class)
++
++package expo.modules.ui.button
++
++import androidx.compose.material3.ButtonDefaults
++import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
++import androidx.compose.material3.SplitButtonDefaults
++import androidx.compose.material3.SplitButtonLayout
++import androidx.compose.runtime.Composable
++import expo.modules.kotlin.records.Field
++import expo.modules.kotlin.records.Record
++import expo.modules.kotlin.types.OptimizedRecord
++import expo.modules.kotlin.views.ComposeProps
++import expo.modules.kotlin.views.FunctionalComposableScope
++import expo.modules.kotlin.views.OptimizedComposeProps
++import expo.modules.ui.ModifierList
++import expo.modules.ui.ModifierRegistry
++import expo.modules.ui.UIComposableScope
++import expo.modules.ui.compose
++import expo.modules.ui.isSlotWithName
++
++@OptimizedComposeProps
++data class SplitButtonLayoutProps(
++  val modifiers: ModifierList = emptyList()
++) : ComposeProps
++
++@OptimizedComposeProps
++data class SplitButtonLeadingButtonProps(
++  val colors: ButtonColors = ButtonColors(),
++  val enabled: Boolean = true,
++  val modifiers: ModifierList = emptyList()
++) : ComposeProps
++
++@OptimizedComposeProps
++data class SplitButtonTrailingButtonProps(
++  val checked: Boolean = false,
++  val colors: ButtonColors = ButtonColors(),
++  val enabled: Boolean = true,
++  val modifiers: ModifierList = emptyList()
++) : ComposeProps
++
++@OptimizedRecord
++data class SplitButtonCheckedChangeEvent(
++  @Field val checked: Boolean = false
++) : Record
++
++@Composable
++fun FunctionalComposableScope.SplitButtonLayoutContent(props: SplitButtonLayoutProps) {
++  SplitButtonLayout(
++    leadingButton = { Children(UIComposableScope(), filter = { isSlotWithName(it, "leadingButton") }) },
++    trailingButton = { Children(UIComposableScope(), filter = { isSlotWithName(it, "trailingButton") }) },
++    modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)
++  )
++}
++
++@Composable
++fun FunctionalComposableScope.SplitButtonLeadingButtonContent(
++  props: SplitButtonLeadingButtonProps,
++  onClick: () -> Unit
++) {
++  SplitButtonDefaults.LeadingButton(
++    onClick = onClick,
++    enabled = props.enabled,
++    colors = ButtonDefaults.buttonColors(
++      containerColor = props.colors.containerColor.compose,
++      contentColor = props.colors.contentColor.compose,
++      disabledContainerColor = props.colors.disabledContainerColor.compose,
++      disabledContentColor = props.colors.disabledContentColor.compose
++    ),
++    modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)
++  ) {
++    Children(UIComposableScope(rowScope = this))
++  }
++}
++
++@Composable
++fun FunctionalComposableScope.SplitButtonTrailingButtonContent(
++  props: SplitButtonTrailingButtonProps,
++  onCheckedChange: (SplitButtonCheckedChangeEvent) -> Unit
++) {
++  SplitButtonDefaults.TrailingButton(
++    checked = props.checked,
++    onCheckedChange = { onCheckedChange(SplitButtonCheckedChangeEvent(it)) },
++    enabled = props.enabled,
++    colors = ButtonDefaults.buttonColors(
++      containerColor = props.colors.containerColor.compose,
++      contentColor = props.colors.contentColor.compose,
++      disabledContainerColor = props.colors.disabledContainerColor.compose,
++      disabledContentColor = props.colors.disabledContentColor.compose
++    ),
++    modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)
++  ) {
++    Children(UIComposableScope(rowScope = this))
++  }
++}
 diff --git a/build/jetpack-compose/Host/index.d.ts b/build/jetpack-compose/Host/index.d.ts
-index b586b65..e32f6e0 100644
+index b586b653a991ce8840b9994a6fe1e6af75480ece..e32f6e093fde22e9cfc9d7ff612cddb59e036945 100644
 --- a/build/jetpack-compose/Host/index.d.ts
 +++ b/build/jetpack-compose/Host/index.d.ts
 @@ -1,6 +1,7 @@
@@ -161,7 +303,7 @@ index b586b65..e32f6e0 100644
       * The layout direction for the content.
       * Defaults to the current locale direction from I18nManager.
 diff --git a/build/jetpack-compose/Host/index.js b/build/jetpack-compose/Host/index.js
-index 3985656..2b4a4f9 100644
+index 39856563a8cf1119f3a72e37fd35d48d245041bf..2b4a4f946f2ff04a5563c4cd8a29f28b0c5cc08b 100644
 --- a/build/jetpack-compose/Host/index.js
 +++ b/build/jetpack-compose/Host/index.js
 @@ -8,16 +8,17 @@ import { useMergeRefs } from '../../utils/useMergeRefs';
@@ -194,9 +336,141 @@ index 3985656..2b4a4f9 100644
                  onLayoutContent: onLayoutContent,
                  layoutDirection: layoutDirection ?? (I18nManager.getConstants().isRTL ? 'rightToLeft' : 'leftToRight'),
                  ref: mergedRef,
+diff --git a/build/jetpack-compose/SplitButton/index.d.ts b/build/jetpack-compose/SplitButton/index.d.ts
+new file mode 100644
+index 0000000000000000000000000000000000000000..4c228bd16b10c8d08d96c96bb143e07769d06aa6
+--- /dev/null
++++ b/build/jetpack-compose/SplitButton/index.d.ts
+@@ -0,0 +1,73 @@
++import type { ReactNode } from 'react';
++import type { ModifierConfig } from '../../types';
++import type { ButtonColors } from '../Button';
++export interface SplitButtonLayoutProps {
++    /**
++     * A `SplitButtonLayout.LeadingButton` and a `SplitButtonLayout.TrailingButton`.
++     */
++    children: ReactNode;
++    /**
++     * Modifiers for the component.
++     */
++    modifiers?: ModifierConfig[];
++}
++export interface SplitButtonLeadingButtonProps {
++    /**
++     * Callback that is called when the leading button is clicked.
++     */
++    onClick?: () => void;
++    /**
++     * Whether the button is enabled for user interaction.
++     * @default true
++     */
++    enabled?: boolean;
++    /**
++     * Colors for button elements.
++     */
++    colors?: ButtonColors;
++    /**
++     * Modifiers for the component.
++     */
++    modifiers?: ModifierConfig[];
++    /**
++     * Content to display inside the button.
++     */
++    children: ReactNode;
++}
++export interface SplitButtonTrailingButtonProps {
++    /**
++     * Whether the trailing button is checked, usually while its menu is expanded.
++     */
++    checked: boolean;
++    /**
++     * Callback that is called when the checked state changes.
++     */
++    onCheckedChange?: (checked: boolean) => void;
++    /**
++     * Whether the button is enabled for user interaction.
++     * @default true
++     */
++    enabled?: boolean;
++    /**
++     * Colors for button elements.
++     */
++    colors?: ButtonColors;
++    /**
++     * Modifiers for the component.
++     */
++    modifiers?: ModifierConfig[];
++    /**
++     * Content to display inside the button, usually a chevron icon.
++     */
++    children: ReactNode;
++}
++/**
++ * A Material 3 split button: a leading action button and a trailing toggle button,
++ * usually anchoring a `DropdownMenu` of related actions.
++ */
++declare function SplitButtonLayout(props: SplitButtonLayoutProps): import("react/jsx-runtime").JSX.Element;
++declare namespace SplitButtonLayout {
++    var LeadingButton: (props: SplitButtonLeadingButtonProps) => import("react/jsx-runtime").JSX.Element;
++    var TrailingButton: (props: SplitButtonTrailingButtonProps) => import("react/jsx-runtime").JSX.Element;
++}
++export { SplitButtonLayout };
+diff --git a/build/jetpack-compose/SplitButton/index.js b/build/jetpack-compose/SplitButton/index.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..0e723b1e28d30ba0410437eaa5a1a9a0f50e6ad4
+--- /dev/null
++++ b/build/jetpack-compose/SplitButton/index.js
+@@ -0,0 +1,47 @@
++import { jsx as _jsx } from "react/jsx-runtime";
++import { requireNativeView } from 'expo';
++import { createViewModifierEventListener } from '../modifiers/utils';
++const SplitButtonLayoutNativeView = requireNativeView('ExpoUI', 'SplitButtonLayoutView');
++const LeadingButtonNativeView = requireNativeView('ExpoUI', 'SplitButtonLeadingButtonView');
++const TrailingButtonNativeView = requireNativeView('ExpoUI', 'SplitButtonTrailingButtonView');
++const SlotNativeView = requireNativeView('ExpoUI', 'SlotView');
++function LeadingButton(props) {
++    const { onClick, modifiers, ...restProps } = props;
++    return /*#__PURE__*/ _jsx(SlotNativeView, {
++        slotName: "leadingButton",
++        children: /*#__PURE__*/ _jsx(LeadingButtonNativeView, {
++            modifiers: modifiers,
++            ...modifiers ? createViewModifierEventListener(modifiers) : undefined,
++            ...restProps,
++            enabled: props.enabled ?? true,
++            onButtonPressed: onClick ? ()=>onClick() : undefined
++        })
++    });
++}
++function TrailingButton(props) {
++    const { onCheckedChange, modifiers, ...restProps } = props;
++    return /*#__PURE__*/ _jsx(SlotNativeView, {
++        slotName: "trailingButton",
++        children: /*#__PURE__*/ _jsx(TrailingButtonNativeView, {
++            modifiers: modifiers,
++            ...modifiers ? createViewModifierEventListener(modifiers) : undefined,
++            ...restProps,
++            enabled: props.enabled ?? true,
++            onCheckedChange: onCheckedChange ? ({ nativeEvent: { checked } })=>onCheckedChange(checked) : undefined
++        })
++    });
++}
++/**
++ * A Material 3 split button: a leading action button and a trailing toggle button,
++ * usually anchoring a `DropdownMenu` of related actions.
++ */ function SplitButtonLayout(props) {
++    const { modifiers, ...restProps } = props;
++    return /*#__PURE__*/ _jsx(SplitButtonLayoutNativeView, {
++        modifiers: modifiers,
++        ...modifiers ? createViewModifierEventListener(modifiers) : undefined,
++        ...restProps
++    });
++}
++SplitButtonLayout.LeadingButton = LeadingButton;
++SplitButtonLayout.TrailingButton = TrailingButton;
++export { SplitButtonLayout };
 diff --git a/build/jetpack-compose/TopAppBar/index.d.ts b/build/jetpack-compose/TopAppBar/index.d.ts
 new file mode 100644
-index 0000000..63afa28
+index 0000000000000000000000000000000000000000..63afa28d56a9b0260de16d32e08bd7405e2c517d
 --- /dev/null
 +++ b/build/jetpack-compose/TopAppBar/index.d.ts
 @@ -0,0 +1,15 @@
@@ -217,7 +491,7 @@ index 0000000..63afa28
 +}
 diff --git a/build/jetpack-compose/TopAppBar/index.js b/build/jetpack-compose/TopAppBar/index.js
 new file mode 100644
-index 0000000..c6557fe
+index 0000000000000000000000000000000000000000..c6557fe6cb559c7d922fc02ce25fa2bf080a50d6
 --- /dev/null
 +++ b/build/jetpack-compose/TopAppBar/index.js
 @@ -0,0 +1,11 @@
@@ -233,7 +507,7 @@ index 0000000..c6557fe
 +TopAppBar.NavigationIcon = function NavigationIcon({ children }) { return jsx(Slot, { style: { position: 'absolute' }, slotName: 'navigationIcon', children }); };
 +TopAppBar.Actions = function Actions({ children }) { return jsx(Slot, { style: { position: 'absolute' }, slotName: 'actions', children }); };
 diff --git a/build/jetpack-compose/index.d.ts b/build/jetpack-compose/index.d.ts
-index fa70b35..436a8b7 100644
+index fa70b3574c4c40753b683a98c053caaf63e0385b..96fbbbeaba8396cc9c5cf255c61991bbb2afa899 100644
 --- a/build/jetpack-compose/index.d.ts
 +++ b/build/jetpack-compose/index.d.ts
 @@ -1,3 +1,4 @@
@@ -241,8 +515,16 @@ index fa70b35..436a8b7 100644
  import './MaterialSymbolsAssetsTransformer.fx';
  export * from './AlertDialog';
  export * from './Badge';
+@@ -21,6 +22,7 @@ export * from './ListItem';
+ export * from './RNHostView';
+ export * from './DatePicker';
+ export * from './SegmentedButton';
++export * from './SplitButton';
+ export * from './Progress';
+ export * from './Slider';
+ export * from './Spacer';
 diff --git a/build/jetpack-compose/index.js b/build/jetpack-compose/index.js
-index 2457ed1..fdc8eb1 100644
+index 2457ed1be68b4295442f24a6175fa347cbf80cdb..f394321920fbf1ebb6c7c68bb46690538a05aa0d 100644
 --- a/build/jetpack-compose/index.js
 +++ b/build/jetpack-compose/index.js
 @@ -1,3 +1,4 @@
@@ -250,8 +532,16 @@ index 2457ed1..fdc8eb1 100644
  import './MaterialSymbolsAssetsTransformer.fx';
  export * from './AlertDialog';
  export * from './Badge';
+@@ -21,6 +22,7 @@ export * from './ListItem';
+ export * from './RNHostView';
+ export * from './DatePicker';
+ export * from './SegmentedButton';
++export * from './SplitButton';
+ export * from './Progress';
+ export * from './Slider';
+ export * from './Spacer';
 diff --git a/src/jetpack-compose/Host/index.tsx b/src/jetpack-compose/Host/index.tsx
-index e994f6e..d0ed70a 100644
+index e994f6e1fbad28414207482deeceb542a7b95746..d0ed70a3b9ab0ce5e5c1fd9106c0759f181b6e96 100644
 --- a/src/jetpack-compose/Host/index.tsx
 +++ b/src/jetpack-compose/Host/index.tsx
 @@ -12,7 +12,7 @@ import {
@@ -300,9 +590,157 @@ index e994f6e..d0ed70a 100644
            onLayoutContent={onLayoutContent}
            layoutDirection={
              layoutDirection ?? (I18nManager.getConstants().isRTL ? 'rightToLeft' : 'leftToRight')
+diff --git a/src/jetpack-compose/SplitButton/index.tsx b/src/jetpack-compose/SplitButton/index.tsx
+new file mode 100644
+index 0000000000000000000000000000000000000000..05cba2bfa15b553f74ccacac0b889fae73b13007
+--- /dev/null
++++ b/src/jetpack-compose/SplitButton/index.tsx
+@@ -0,0 +1,142 @@
++import { requireNativeView } from 'expo';
++import type { ReactNode } from 'react';
++
++import type { ModifierConfig, ViewEvent } from '../../types';
++import type { ButtonColors } from '../Button';
++import { createViewModifierEventListener } from '../modifiers/utils';
++
++export interface SplitButtonLayoutProps {
++  /**
++   * A `SplitButtonLayout.LeadingButton` and a `SplitButtonLayout.TrailingButton`.
++   */
++  children: ReactNode;
++  /**
++   * Modifiers for the component.
++   */
++  modifiers?: ModifierConfig[];
++}
++
++export interface SplitButtonLeadingButtonProps {
++  /**
++   * Callback that is called when the leading button is clicked.
++   */
++  onClick?: () => void;
++  /**
++   * Whether the button is enabled for user interaction.
++   * @default true
++   */
++  enabled?: boolean;
++  /**
++   * Colors for button elements.
++   */
++  colors?: ButtonColors;
++  /**
++   * Modifiers for the component.
++   */
++  modifiers?: ModifierConfig[];
++  /**
++   * Content to display inside the button.
++   */
++  children: ReactNode;
++}
++
++export interface SplitButtonTrailingButtonProps {
++  /**
++   * Whether the trailing button is checked, usually while its menu is expanded.
++   */
++  checked: boolean;
++  /**
++   * Callback that is called when the checked state changes.
++   */
++  onCheckedChange?: (checked: boolean) => void;
++  /**
++   * Whether the button is enabled for user interaction.
++   * @default true
++   */
++  enabled?: boolean;
++  /**
++   * Colors for button elements.
++   */
++  colors?: ButtonColors;
++  /**
++   * Modifiers for the component.
++   */
++  modifiers?: ModifierConfig[];
++  /**
++   * Content to display inside the button, usually a chevron icon.
++   */
++  children: ReactNode;
++}
++
++type NativeLeadingButtonProps = Omit<SplitButtonLeadingButtonProps, 'onClick'> &
++  ViewEvent<'onButtonPressed', void>;
++
++type NativeTrailingButtonProps = Omit<SplitButtonTrailingButtonProps, 'onCheckedChange'> &
++  ViewEvent<'onCheckedChange', { checked: boolean }>;
++
++const SplitButtonLayoutNativeView: React.ComponentType<SplitButtonLayoutProps> = requireNativeView(
++  'ExpoUI',
++  'SplitButtonLayoutView'
++);
++const LeadingButtonNativeView: React.ComponentType<NativeLeadingButtonProps> = requireNativeView(
++  'ExpoUI',
++  'SplitButtonLeadingButtonView'
++);
++const TrailingButtonNativeView: React.ComponentType<NativeTrailingButtonProps> = requireNativeView(
++  'ExpoUI',
++  'SplitButtonTrailingButtonView'
++);
++const SlotNativeView: React.ComponentType<{ slotName: string; children: ReactNode }> =
++  requireNativeView('ExpoUI', 'SlotView');
++
++function LeadingButton(props: SplitButtonLeadingButtonProps) {
++  const { onClick, modifiers, ...restProps } = props;
++  return (
++    <SlotNativeView slotName="leadingButton">
++      <LeadingButtonNativeView
++        modifiers={modifiers}
++        {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
++        {...restProps}
++        enabled={props.enabled ?? true}
++        onButtonPressed={onClick ? () => onClick() : undefined}
++      />
++    </SlotNativeView>
++  );
++}
++
++function TrailingButton(props: SplitButtonTrailingButtonProps) {
++  const { onCheckedChange, modifiers, ...restProps } = props;
++  return (
++    <SlotNativeView slotName="trailingButton">
++      <TrailingButtonNativeView
++        modifiers={modifiers}
++        {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
++        {...restProps}
++        enabled={props.enabled ?? true}
++        onCheckedChange={
++          onCheckedChange ? ({ nativeEvent: { checked } }) => onCheckedChange(checked) : undefined
++        }
++      />
++    </SlotNativeView>
++  );
++}
++
++/**
++ * A Material 3 split button: a leading action button and a trailing toggle button,
++ * usually anchoring a `DropdownMenu` of related actions.
++ */
++function SplitButtonLayout(props: SplitButtonLayoutProps) {
++  const { modifiers, ...restProps } = props;
++  return (
++    <SplitButtonLayoutNativeView
++      modifiers={modifiers}
++      {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
++      {...restProps}
++    />
++  );
++}
++
++SplitButtonLayout.LeadingButton = LeadingButton;
++SplitButtonLayout.TrailingButton = TrailingButton;
++
++export { SplitButtonLayout };
 diff --git a/src/jetpack-compose/TopAppBar/index.tsx b/src/jetpack-compose/TopAppBar/index.tsx
 new file mode 100644
-index 0000000..ca69824
+index 0000000000000000000000000000000000000000..ca6982443d5711c48e90e79a57b794055efbfcb5
 --- /dev/null
 +++ b/src/jetpack-compose/TopAppBar/index.tsx
 @@ -0,0 +1,28 @@
@@ -335,7 +773,7 @@ index 0000000..ca69824
 +TopAppBar.NavigationIcon = function NavigationIcon({ children }: { children: ReactNode }) { return <Slot style={{ position: "absolute" }} slotName="navigationIcon">{children}</Slot>; };
 +TopAppBar.Actions = function Actions({ children }: { children: ReactNode }) { return <Slot style={{ position: "absolute" }} slotName="actions">{children}</Slot>; };
 diff --git a/src/jetpack-compose/index.ts b/src/jetpack-compose/index.ts
-index 77fe3d7..3fa0fb9 100644
+index 77fe3d7412fb0ef423e3d7a870676ebb54f07350..08ab59f63c7b40f4727500a37d95bed4f262de82 100644
 --- a/src/jetpack-compose/index.ts
 +++ b/src/jetpack-compose/index.ts
 @@ -1,3 +1,4 @@
@@ -343,3 +781,11 @@ index 77fe3d7..3fa0fb9 100644
  import './MaterialSymbolsAssetsTransformer.fx';
  
  export * from './AlertDialog';
+@@ -22,6 +23,7 @@ export * from './ListItem';
+ export * from './RNHostView';
+ export * from './DatePicker';
+ export * from './SegmentedButton';
++export * from './SplitButton';
+ export * from './Progress';
+ export * from './Slider';
+ export * from './Spacer';
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e5f5495d42cf6..8c903ef002a9c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -372,7 +372,7 @@ patchedDependencies:
   '@effect/vitest@4.0.5': 2731c9c3761c595f25ddc625a7d61ca376b389d5b3049ecb837c8940f21cfa02
   '@expo/fingerprint@0.21.5': 8fba80d6bbce46c72de427fe8c7907462d262a0bfe50c6b2b7ee9c4e0c61e5e1
   '@expo/metro-config@58.0.14': 90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760
-  '@expo/ui@58.0.20': 5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e
+  '@expo/ui@58.0.20': 64559cb60723e19a8a72256d4c78d1315d937a7af3b32d19860ea596f88736ce
   '@ff-labs/fff-node@0.11.0': cc71fcec015f4d39bc96ae2e2bf6b0ca678124c722c66a7841efce9d34b5983c
   '@legendapp/list@3.3.5': 6cbdacd8c380d9a5afb9f73d4198dc2cc44be6ef28a955b1183c781469307896
   '@muse-code/sdk@1.4.6': 7b495b607fc5d76b444c7c4d58821e839726a30e6f3c53564f0d59f2d5b42101
@@ -440,7 +440,7 @@ importers:
     dependencies:
       '@clerk/electron':
         specifier: 0.1.3
-        version: 0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.9.3(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
+        version: 0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.10.0(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
       '@clerk/electron-passkeys':
         specifier: 0.0.3
         version: 0.0.3
@@ -475,8 +475,8 @@ importers:
         specifier: 4.0.5
         version: 4.0.5
       electron:
-        specifier: 44.9.3
-        version: 44.9.3(supports-color@8.1.1)
+        specifier: 44.10.0
+        version: 44.10.0(supports-color@8.1.1)
       electron-store:
         specifier: ^8.2.0
         version: 8.2.0
@@ -523,6 +523,9 @@ importers:
 
   apps/marketing:
     dependencies:
+      '@fontsource-variable/inter':
+        specifier: ^5.3.0
+        version: 5.3.0
       '@t3tools/shared':
         specifier: workspace:*
         version: link:../../packages/shared
@@ -562,7 +565,7 @@ importers:
         version: 58.0.14(@expo/log-box@58.0.12)(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
       '@expo/ui':
         specifier: 58.0.20
-        version: 58.0.20(patch_hash=5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
+        version: 58.0.20(patch_hash=64559cb60723e19a8a72256d4c78d1315d937a7af3b32d19860ea596f88736ce)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
       '@legendapp/list':
         specifier: 3.3.5
         version: 3.3.5(patch_hash=6cbdacd8c380d9a5afb9f73d4198dc2cc44be6ef28a955b1183c781469307896)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
@@ -921,6 +924,9 @@ importers:
       character-entities:
         specifier: 2.0.2
         version: 2.0.2
+      diff:
+        specifier: 8.0.3
+        version: 8.0.3
       effect:
         specifier: 4.0.5
         version: 4.0.5
@@ -1032,7 +1038,7 @@ importers:
         version: 6.40.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
       '@clerk/electron':
         specifier: 0.1.3
-        version: 0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.9.3(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
+        version: 0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.10.0(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
       '@clerk/react':
         specifier: 6.18.0
         version: 6.18.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
@@ -8464,8 +8470,8 @@ packages:
     resolution: {integrity: sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg==}
     engines: {node: '>=8.0.0'}
 
-  electron@44.9.3:
-    resolution: {integrity: sha512-Cv9/yMnZxNWsMlIe8T4v//NKHdUvbeyoTJoXE3BIcRxus2meeFaO9h/P3zB5d4cBXum51IgAYrT2QjpIDWKpJA==}
+  electron@44.10.0:
+    resolution: {integrity: sha512-ss4pCfrQKV4TWkuVYtWB4HmeysPZgB96cSYNKYZv1UVCRP4vQMGNW5oopFbvx6Bbfce1XtP5pm5RDuKehp0svQ==}
     engines: {node: '>= 22.12.0'}
     hasBin: true
 
@@ -13241,12 +13247,12 @@ snapshots:
       '@clerk/electron-passkeys-win32-arm64-msvc': 0.0.3
       '@clerk/electron-passkeys-win32-x64-msvc': 0.0.3
 
-  '@clerk/electron@0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.9.3(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)':
+  '@clerk/electron@0.1.3(@clerk/electron-passkeys@0.0.3)(electron-store@8.2.0)(electron@44.10.0(supports-color@8.1.1))(react-dom@19.3.0(react@19.3.0))(react@19.3.0)':
     dependencies:
       '@clerk/clerk-js': 6.40.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
       '@clerk/react': 6.18.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
       '@clerk/shared': 4.41.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
-      electron: 44.9.3(supports-color@8.1.1)
+      electron: 44.10.0(supports-color@8.1.1)
       react: 19.3.0
       tslib: 2.8.1
     optionalDependencies:
@@ -14373,7 +14379,7 @@ snapshots:
 
   '@expo/sudo-prompt@9.3.2': {}
 
-  ? '@expo/ui@58.0.20(patch_hash=5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)'
+  ? '@expo/ui@58.0.20(patch_hash=64559cb60723e19a8a72256d4c78d1315d937a7af3b32d19860ea596f88736ce)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)'
   : dependencies:
       expo: 58.0.14(277a83826bb26ba15256633fefeb0bc2)
       react: 19.3.0
@@ -18087,7 +18093,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  electron@44.9.3(supports-color@8.1.1):
+  electron@44.10.0(supports-color@8.1.1):
     dependencies:
       '@electron-internal/extract-zip': 1.0.5
       '@electron/get': 5.1.0(supports-color@8.1.1)
@@ -18624,7 +18630,7 @@ snapshots:
   ? expo-widgets@58.0.20(patch_hash=8bf49067f93742855e15f29559ac75c8b50230b47069060993c9ea01dac11171)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
   : dependencies:
       '@expo/plist': 0.10.1
-      '@expo/ui': 58.0.20(patch_hash=5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
+      '@expo/ui': 58.0.20(patch_hash=64559cb60723e19a8a72256d4c78d1315d937a7af3b32d19860ea596f88736ce)(@babel/core@7.29.7(supports-color@8.1.1))(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)(supports-color@8.1.1))(react-native@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(react@19.3.0)
       expo: 58.0.14(277a83826bb26ba15256633fefeb0bc2)
       react: 19.3.0
       react-native: 0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(@react-native/metro-config@0.88.0(@babel/core@7.29.7(supports-color@8.1.1))(bufferutil@4.1.0)(supports-color@8.1.1)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(supports-color@8.1.1)(utf-8-validate@6.0.6)
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 98f415c0d982c..228a8edcebc7f 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -170,7 +170,7 @@ minimumReleaseAgeExclude:
   - expo-sharing@58.0.19
   - expo-sqlite@58.0.13
   - expo-symbols@58.0.4
-  - electron@44.9.3
+  - electron@44.10.0
   - "@anthropic-ai/claude-agent-sdk@0.3.276"
   - "@shadcn/lint@0.1.5"
   - cn@0.3.2
diff --git a/scripts/build-cli-archive.ts b/scripts/build-cli-archive.ts
index ee7c45ada5dd6..3c74b6714ddeb 100644
--- a/scripts/build-cli-archive.ts
+++ b/scripts/build-cli-archive.ts
@@ -251,6 +251,69 @@ const stageWebClient = Effect.fn("stageWebClient")(function* (source: string, ta
   }
 });
 
+/** Node links libatomic.so.1, which Ubuntu server and container images lack, so t3 carries its own. */
+const bundleLinuxLibatomic = Effect.fn("bundleLinuxLibatomic")(function* (input: {
+  readonly repoRoot: string;
+  readonly contentDir: string;
+  readonly executablePath: string;
+}) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const ldd = yield* spawner.string(ChildProcess.make("ldd", [input.executablePath]));
+  const source = /libatomic\.so\.1 => (\/\S+)/.exec(ldd)?.[1];
+  if (source === undefined) {
+    return yield* new CliArchiveInputMissingError({
+      inputPath: "libatomic.so.1",
+      hint: `ldd did not resolve it for ${input.executablePath}. Install libatomic1 on the build host.`,
+    });
+  }
+  yield* fs.makeDirectory(path.join(input.contentDir, "lib"));
+  yield* fs.copyFile(source, path.join(input.contentDir, "lib/libatomic.so.1"));
+
+  // libatomic is GPL-3.0-or-later WITH GCC-exception-3.1, so its terms and source travel with it.
+  const owner = yield* spawner.string(
+    ChildProcess.make("dpkg-query", ["-S", yield* fs.realPath(source)]),
+  );
+  // Keep the arch qualifier so a second installed arch cannot add its own line.
+  const [, qualifiedPkg, pkg] = /^(([^:\s]+)(?::[^:\s]+)?): /.exec(owner) ?? [];
+  const versions = qualifiedPkg
+    ? yield* spawner.string(
+        ChildProcess.make("dpkg-query", [
+          "-W",
+          "-f=${Version} ${source:Package} ${source:Version}",
+          qualifiedPkg,
+        ]),
+      )
+    : "";
+  const [version, sourcePackage, sourceVersion] = versions.trim().split(" ");
+  if (!pkg || !version || !sourcePackage || !sourceVersion) {
+    return yield* new CliArchiveInputMissingError({
+      inputPath: `dpkg package for ${source}`,
+      hint: "The archive copies libatomic's license and source reference from its Ubuntu package.",
+    });
+  }
+  const header = [
+    `libatomic.so.1 is copied from the Ubuntu package ${pkg} ${version}.`,
+    `Source: https://launchpad.net/ubuntu/+source/${sourcePackage}/${sourceVersion}`,
+  ].join("\n");
+  // Vendored because CI runner images strip /usr/share/doc.
+  const license = yield* fs.readFileString(
+    path.join(input.repoRoot, "scripts/licenses/libatomic.LICENSE"),
+  );
+  yield* fs.writeFileString(
+    path.join(input.contentDir, "lib/libatomic.so.1.LICENSE"),
+    `${header}\n\n${license}`,
+  );
+
+  // RUNPATH resolves through symlinks and is not inherited by child processes, unlike LD_LIBRARY_PATH.
+  yield* runCommand(
+    ChildProcess.make("patchelf", ["--set-rpath", "$ORIGIN/lib", input.executablePath]),
+    "patchelf --set-rpath",
+  );
+  yield* Effect.log(`[cli-archive] Bundled ${source} as lib/libatomic.so.1.`);
+});
+
 const MacSigningConfig = Config.all({
   identity: Config.String("T3CODE_CLI_MAC_SIGN_IDENTITY").pipe(Config.option),
   appleApiKey: Config.String("APPLE_API_KEY").pipe(Config.option),
@@ -444,11 +507,6 @@ const buildCliArchive = Effect.fn("buildCliArchive")(function* (input: {
     builtExecutable,
     `Run \`node apps/server/scripts/cli.ts build-exe${targetKey === hostKey ? "" : ` --target ${targetKey}`}\` first.`,
   );
-  // TEMPORARY one-time Node fix. Remove when fixed: https://github.com/nodejs/node/issues/67048
-  if (input.platform === "linux" && input.arch === "arm64") {
-    const bytes = yield* fs.readFile(builtExecutable);
-    yield* Effect.try(() => assertLinuxArm64PageCompatibility(bytes));
-  }
   yield* requireInput(path.join(webClient, "index.html"), "Run `vp run --filter t3 build` first.");
   yield* requireInput(
     resourceMonitorDir,
@@ -473,6 +531,14 @@ const buildCliArchive = Effect.fn("buildCliArchive")(function* (input: {
   });
 
   const executablePath = path.join(contentDir, executableName);
+  if (input.platform === "linux") {
+    yield* bundleLinuxLibatomic({ repoRoot, contentDir, executablePath });
+  }
+  // TEMPORARY one-time Node fix. Remove when fixed: https://github.com/nodejs/node/issues/67048
+  if (input.platform === "linux" && input.arch === "arm64") {
+    const bytes = yield* fs.readFile(executablePath);
+    yield* Effect.try(() => assertLinuxArm64PageCompatibility(bytes));
+  }
   if (input.platform === "mac") {
     yield* signMacArchiveContents({ repoRoot, contentDir, executablePath });
   } else if (input.platform === "win") {
diff --git a/scripts/build-npm-launcher.test.ts b/scripts/build-npm-launcher.test.ts
index 8dd98225cd073..749e27bd5454a 100644
--- a/scripts/build-npm-launcher.test.ts
+++ b/scripts/build-npm-launcher.test.ts
@@ -13,6 +13,8 @@ import * as NodeCrypto from "node:crypto";
 import * as NodeEvents from "node:events";
 import * as NodeHttp from "node:http";
 
+import { npmReleaseDatabaseMigration } from "@t3tools/shared/cliRelease";
+
 import { buildNpmLauncher } from "./build-npm-launcher.ts";
 
 const VERSION = "1.2.3";
@@ -118,6 +120,7 @@ it.layer(NodeServices.layer)("build-npm-launcher", (it) => {
         assert.deepStrictEqual(manifest.bin, { t3: "./bin/t3.mjs" });
         assert.isUndefined(manifest.dependencies);
         assert.isUndefined(manifest.optionalDependencies);
+        assert.isAbove(npmReleaseDatabaseMigration(manifest) ?? 0, 0);
 
         const installed = path.join(root, "installed");
         yield* fs.makeDirectory(installed);
diff --git a/scripts/build-npm-launcher.ts b/scripts/build-npm-launcher.ts
index df1cc488814aa..bae124fb008a5 100644
--- a/scripts/build-npm-launcher.ts
+++ b/scripts/build-npm-launcher.ts
@@ -30,8 +30,8 @@ export class NpmLauncherCommandFailedError extends Schema.TaggedError<NpmLaunche
   }
 }
 
-/** engines requires import.meta.dirname and fetch. */
-export function npmLauncherPackageManifest(version: string) {
+/** engines requires import.meta.dirname and fetch. `t3code` is read back by npmReleaseDatabaseMigration. */
+export function npmLauncherPackageManifest(version: string, databaseMigration: number) {
   return {
     name: NPM_LAUNCHER_PACKAGE_NAME,
     version,
@@ -42,9 +42,24 @@ export function npmLauncherPackageManifest(version: string) {
     bin: { t3: "./bin/t3.mjs" },
     files: ["bin", "dist"],
     engines: { node: ">=20.11" },
+    t3code: { databaseMigration },
   };
 }
 
+/** Highest server migration id, from the `NNN_Name.ts` files the server registers. */
+const latestServerMigrationId = Effect.fn("latestServerMigrationId")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const dir = yield* path.fromFileUrl(
+    new URL("../apps/server/src/persistence/Migrations/", import.meta.url),
+  );
+  const ids = (yield* fs.readDirectory(dir)).flatMap((name) => {
+    const id = /^(\d+)_\w+\.ts$/.exec(name)?.[1];
+    return id === undefined ? [] : [Number(id)];
+  });
+  return Math.max(0, ...ids);
+});
+
 export const buildNpmLauncher = Effect.fn("buildNpmLauncher")(function* (input: {
   readonly version: string;
   readonly outputDir: string;
@@ -64,7 +79,9 @@ export const buildNpmLauncher = Effect.fn("buildNpmLauncher")(function* (input:
   yield* fs.makeDirectory(path.join(stageDir, "dist"));
   yield* fs.writeFileString(
     path.join(stageDir, "package.json"),
-    `${yield* encodePackageJson(npmLauncherPackageManifest(input.version))}\n`,
+    `${yield* encodePackageJson(
+      npmLauncherPackageManifest(input.version, yield* latestServerMigrationId()),
+    )}\n`,
   );
   yield* fs.copyFile(path.join(sourceDir, "t3.mjs"), path.join(stageDir, "bin/t3.mjs"));
   yield* fs.chmod(path.join(stageDir, "bin/t3.mjs"), 0o755);
diff --git a/scripts/check-changed.ts b/scripts/check-changed.ts
index 25630728e3d66..b854cf0a4e539 100644
--- a/scripts/check-changed.ts
+++ b/scripts/check-changed.ts
@@ -1,7 +1,9 @@
 // @effect-diagnostics nodeBuiltinImport:off globalConsole:off
 // Runs CI's fast checks for this branch's changes: format and lint of the
 // changed files, knip, generated GraphQL operations, typecheck of the affected
-// packages and their dependents, and the test files beside the changed files.
+// packages and their dependents, the test files beside the changed files, and
+// the cross-file checks those miss (agent context budget, React Compiler
+// coverage of the changed client files).
 // A dependency change also gets the unused-patch install check below. CI still
 // runs the full test suites and the jobs listed in the summary.
 //
@@ -138,6 +140,52 @@ for (const file of code) {
     if (entry.startsWith(prefix) && TEST.test(entry)) tests.add(NodePath.join(dir, entry));
   }
 }
+// It reads files other than the ones beside it, so no changed file selects it.
+if (affected.includes("t3")) tests.add("apps/server/src/provider/AgentContextBudget.test.ts");
+
+// React Compiler coverage compiles every client source file, so run only the
+// changed files' cases, in one extra step: a -t filter in the main test step
+// would drop every other test. An app is skipped when the main step already
+// runs its coverage file unfiltered. File filters mirror each coverage test.
+const escapeRegExp = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const compilerApps = [
+  {
+    test: "apps/web/src/reactCompilerCoverage.test.ts",
+    root: "apps/web/src/",
+    // Test names keep the repo-relative path.
+    name: (file: string) => file,
+    compiled: (file: string) =>
+      /\.tsx?$/.test(file) && !/\.(test|browser)\.tsx?$/.test(file) && !file.endsWith(".gen.ts"),
+    // Web has only per-file cases.
+    always: [],
+  },
+  {
+    test: "apps/mobile/src/reactCompilerCoverage.test.ts",
+    root: "apps/mobile/src/",
+    name: (file: string) => file.slice("apps/mobile/".length),
+    compiled: (file: string) => /\.tsx?$/.test(file) && !/\.(test\.tsx?|d\.ts)$/.test(file),
+    // The Metro, cache, and stale-allowlist cases check more than one file, deletions included.
+    always: ["^(?!.*compiles )"],
+  },
+].flatMap(({ test, root: appRoot, name, compiled, always }) => {
+  const changed = files.filter((file) => file.startsWith(appRoot) && compiled(file));
+  if (changed.length === 0 || tests.has(test)) return [];
+  const names = changed
+    .filter((file) => present.includes(file))
+    .map((file) => `compiles ${escapeRegExp(name(file))}$`);
+  const pattern = [...names, ...always];
+  return pattern.length > 0 ? [{ test, names, pattern }] : [];
+});
+const compilerCoverage = compilerApps.length > 0 && {
+  name: `react compiler (${compilerApps.reduce((count, app) => count + app.names.length, 0)} files)`,
+  args: [
+    "test",
+    "run",
+    ...compilerApps.map((app) => app.test),
+    "-t",
+    compilerApps.flatMap((app) => app.pattern).join("|"),
+  ],
+};
 
 // knip:check cannot be scoped to a package. Any code change can leave a file,
 // export, or dependency unused (removing the last import of a helper does), so
@@ -255,33 +303,42 @@ const steps = [
     name: `test (${tests.size} files)`,
     args: ["test", "run", "--passWithNoTests", ...tests],
   },
+  compilerCoverage,
 ].filter((step) => step !== false);
 
 // Output is piped, so keep the colors a terminal would get.
 const env = process.stdout.isTTY ? { ...process.env, FORCE_COLOR: "1" } : process.env;
+const runStep = (step: (typeof steps)[number]) =>
+  new Promise<{ name: string; ok: boolean; seconds: string }>((resolve) => {
+    const started = performance.now();
+    const finish = (ok: boolean, output?: Buffer) => {
+      const seconds = ((performance.now() - started) / 1000).toFixed(1);
+      console.log(`\n> vp ${step.name}  ${ok ? "pass" : "FAIL"}  ${seconds}s`);
+      if (output) process.stdout.write(output);
+      resolve({ name: step.name, ok, seconds });
+    };
+    // In-process steps print their own output. The patch check is first and
+    // takes about a second, so the commands start right after it.
+    if ("run" in step) return finish(step.run());
+    const output: Array<Buffer> = [];
+    const child = NodeChildProcess.spawn("vp", step.args, { cwd: root, env });
+    child.stdout.on("data", (chunk: Buffer) => output.push(chunk));
+    child.stderr.on("data", (chunk: Buffer) => output.push(chunk));
+    // A failed spawn emits "error", then "close" with a nonzero code.
+    child.on("error", (error) => output.push(Buffer.from(`${error.message}\n`)));
+    child.on("close", (status) => finish(status === 0, Buffer.concat(output)));
+  });
+
+// Vitest runs started together race to rebuild node_modules/.vitest-cache after
+// an install (ENOTEMPTY), so they run one after another.
+let previousVitest: Promise<unknown> = Promise.resolve();
 const results = await Promise.all(
-  steps.map(
-    (step) =>
-      new Promise<{ name: string; ok: boolean; seconds: string }>((resolve) => {
-        const started = performance.now();
-        const finish = (ok: boolean, output?: Buffer) => {
-          const seconds = ((performance.now() - started) / 1000).toFixed(1);
-          console.log(`\n> vp ${step.name}  ${ok ? "pass" : "FAIL"}  ${seconds}s`);
-          if (output) process.stdout.write(output);
-          resolve({ name: step.name, ok, seconds });
-        };
-        // In-process steps print their own output. The patch check is first and
-        // takes about a second, so the commands start right after it.
-        if ("run" in step) return finish(step.run());
-        const output: Array<Buffer> = [];
-        const child = NodeChildProcess.spawn("vp", step.args, { cwd: root, env });
-        child.stdout.on("data", (chunk: Buffer) => output.push(chunk));
-        child.stderr.on("data", (chunk: Buffer) => output.push(chunk));
-        // A failed spawn emits "error", then "close" with a nonzero code.
-        child.on("error", (error) => output.push(Buffer.from(`${error.message}\n`)));
-        child.on("close", (status) => finish(status === 0, Buffer.concat(output)));
-      }),
-  ),
+  steps.map((step) => {
+    if (!("args" in step) || step.args[0] !== "test") return runStep(step);
+    const result = previousVitest.then(() => runStep(step));
+    previousVitest = result;
+    return result;
+  }),
 );
 
 const summary = ["check:changed summary"];
diff --git a/scripts/coil/sync-upstream.sh b/scripts/coil/sync-upstream.sh
index 7fa223f8cc433..52e1f38faba80 100755
--- a/scripts/coil/sync-upstream.sh
+++ b/scripts/coil/sync-upstream.sh
@@ -197,7 +197,8 @@ if ! git merge --no-ff --no-commit "$UPSTREAM_REMOTE/$UPSTREAM_BRANCH"; then
 fi
 
 retire_upstream_workflows
-if ! git commit -m "$MERGE_MSG"; then
+# Upstream's pre-commit hook gates authoring, not merges; the verify step below is the gate.
+if ! git commit --no-verify -m "$MERGE_MSG"; then
   FAILING_STEP="commit"
   write_status daily error "merge resolved but the merge commit could not be created"
   exit 1
diff --git a/scripts/coil/sync-upstream.test.ts b/scripts/coil/sync-upstream.test.ts
index 1661915ac477d..1d4ce93f69990 100644
--- a/scripts/coil/sync-upstream.test.ts
+++ b/scripts/coil/sync-upstream.test.ts
@@ -71,6 +71,8 @@ it("keeps a retired workflow deleted when upstream modifies it", () => {
     NodeFS.writeFileSync(fixture.workflow, "name: upstream-ci-v2\n");
     NodeFS.writeFileSync(NodePath.join(fixture.upstream, "upstream.txt"), "new\n");
     commit(fixture.upstream, "modify retired workflow");
+    const hook = NodePath.join(fixture.fork, ".git", "hooks", "pre-commit");
+    NodeFS.writeFileSync(hook, "#!/bin/sh\nexit 1\n", { mode: 0o755 });
 
     const result = runSync(fixture.fork);
 
diff --git a/scripts/generate-release-notes.test.ts b/scripts/generate-release-notes.test.ts
new file mode 100644
index 0000000000000..0c55b082dcfb9
--- /dev/null
+++ b/scripts/generate-release-notes.test.ts
@@ -0,0 +1,65 @@
+import { assert, it } from "@effect/vitest";
+
+import * as Option from "effect/Option";
+
+import {
+  countContributors,
+  isReleaseNoteCommit,
+  summaryText,
+  type PullRequest,
+} from "./generate-release-notes.ts";
+
+const pullRequest = (author: PullRequest["author"]): PullRequest => ({
+  body: "",
+  additions: 1,
+  deletions: 1,
+  changedFiles: 1,
+  author,
+});
+
+it("counts each person once and leaves out bots", () => {
+  const commits = [
+    { subject: "fix(web): one (#1)", authorName: "Ada Lovelace" },
+    { subject: "fix(web): two (#2)", authorName: "Ada Lovelace" },
+    { subject: "chore: bump (#3)", authorName: "dependabot[bot]" },
+    { subject: "fix: direct push by a PR author", authorName: "Ada Lovelace" },
+    { subject: "fix: direct push by someone else", authorName: "Grace Hopper" },
+    { subject: "chore: direct push by a bot", authorName: "t3-code[bot]" },
+    { subject: "fix(web): four (#4)", authorName: "Linus T" },
+    { subject: "fix: direct push by a PR author with no profile name", authorName: "Linus T" },
+    { subject: "fix(web): five, whose PR did not resolve (#5)", authorName: "Ken T" },
+  ];
+  const pullRequests = new Map([
+    [1, pullRequest({ __typename: "User", login: "ada", name: "Ada Lovelace" })],
+    [2, pullRequest({ __typename: "User", login: "ada", name: "Ada Lovelace" })],
+    [3, pullRequest({ __typename: "Bot", login: "dependabot" })],
+    [4, pullRequest({ __typename: "User", login: "linus", name: null })],
+  ]);
+
+  assert.equal(countContributors(commits, pullRequests), 4);
+});
+
+it("leaves mobile-only scopes out and keeps shared ones", () => {
+  const subjects = {
+    "fix(mobile): a": false,
+    "feat(android): b": false,
+    "fix(ios)!: c": false,
+    "fix(web,mobile): d": true,
+    "feat(mobile,web): f": true,
+    "fix(server): e": true,
+  };
+  for (const [subject, kept] of Object.entries(subjects)) {
+    assert.equal(isReleaseNoteCommit({ subject, authorName: "" }), kept, subject);
+  }
+});
+
+it("uses model text only from a completed response", () => {
+  const output = [
+    { type: "message", content: [{ type: "output_text", text: " ## Highlights\nX " }] },
+  ];
+  assert.deepStrictEqual(
+    summaryText({ status: "completed", output }),
+    Option.some("## Highlights\nX"),
+  );
+  assert.deepStrictEqual(summaryText({ status: "incomplete", output }), Option.none());
+});
diff --git a/scripts/generate-release-notes.ts b/scripts/generate-release-notes.ts
new file mode 100644
index 0000000000000..909247dae1262
--- /dev/null
+++ b/scripts/generate-release-notes.ts
@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { Command, Flag } from "effect/cli";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+
+// Release notes cover web, desktop, and server. Mobile ships its own store notes.
+const MOBILE_SCOPES = new Set(["mobile", "android", "ios"]);
+const COMMIT_SCOPES = /^[a-z]+\(([^)]*)\)!?:/i;
+const PULL_REQUEST_NUMBER = /\(#(\d+)\)$/;
+const PULL_REQUEST_BODY_LIMIT = 300;
+const SUMMARY_MODEL = "gpt-6.1-terra";
+
+const SUMMARY_INSTRUCTIONS = `You write release notes for T3 Code, a GUI for coding agents (web and desktop apps backed by a server; providers like Codex, Claude, Cursor, OpenCode).
+
+These notes cover the web app, desktop app, and server only. The mobile app has its own release notes, so leave out anything only about mobile, iOS, or Android.
+
+You get the commit subjects merged since the last release, oldest first. Most end with a PR number like (#1234). Each commit shows lines added and removed and files changed, then a trimmed PR description on the next line starting with ">". Use the descriptions to understand what changed for users and why it matters. Line counts hint at size, but a small change can still matter most.
+
+Output Markdown in exactly this shape and nothing else:
+
+## Highlights
+Up to 4 short sentences. Name only the new features a user would care about most. If no new feature matters to users, write one sentence about the most important fix. Each feature gets a few words that make the benefit clear, not a description of how it works or where the button is.
+
+## Fixes
+- Up to 10 bullets, one fix each, under 10 words, ending with the PR number like (#123). Fewer is fine. Never pad.
+- Each bullet names what was broken and says it works now. A user who hit the bug should recognize it.
+- Only list fixes from fix commits. New abilities go in Highlights or nowhere. Say "again" only if the commit says it.
+
+How to write:
+- Pick only significant, user-facing changes. Leave out visual polish (focus rings, spacing, colors), layout tweaks, refactors, tests, CI, build, docs, deps, internal tooling, and performance or efficiency work a user would not feel.
+- Include Labs and beta features, with "(beta)" after the feature. Leave out work marked internal testing or dev-only.
+- Describe each feature as it is at the end of the range. If a beta feature became standard later in the range, it is not beta.
+- Say what the user gets, as short as possible. Cut details, conditions, and mechanics.
+- No defaults or rollout state ("on by default", "now available", "behind a flag").
+- For lists of file types or formats, use common extensions: "previews for .docx, .ttf, .sqlite, .zip and more".
+- No internal names, env vars, file paths, or code terms.
+- No em dashes. No hype words. Do not invent anything that is not in the input.
+
+Examples of the tone:
+- Bad: "Cmd+K now finds the right thread first, and it searches message text too." Good: "Much better Cmd+K search."
+- Bad: "You can share a thread with a guest who watches it live and sends messages that you approve." Good: "Share threads with guests, safely."
+- Bad: "Triage issues from the command palette." Good: "Fix and debug T3 Code itself with a new 'triage' command."
+- Bad: "Settings and Usage open as large modals over your thread." Good: leave it out.
+- Bad: "Cmd/Ctrl+W closes tabs safely (#25860)" Good: "Cmd/Ctrl+W no longer closes the whole window (#25860)"`;
+
+class EmptyReleaseRangeError extends Schema.TaggedError<EmptyReleaseRangeError>()(
+  "EmptyReleaseRangeError",
+  { range: Schema.String },
+) {}
+
+interface ReleaseCommit {
+  readonly subject: string;
+  readonly authorName: string;
+}
+
+const PullRequest = Schema.Struct({
+  body: Schema.String,
+  additions: Schema.Number,
+  deletions: Schema.Number,
+  changedFiles: Schema.Number,
+  author: Schema.NullOr(
+    Schema.Struct({
+      __typename: Schema.String,
+      login: Schema.String,
+      name: Schema.optional(Schema.NullOr(Schema.String)),
+    }),
+  ),
+});
+export type PullRequest = typeof PullRequest.Type;
+
+const PullRequestQueryResponse = Schema.Struct({
+  data: Schema.Struct({
+    repository: Schema.Record(Schema.String, Schema.NullOr(PullRequest)),
+  }),
+});
+
+const GeneratedNotes = Schema.Struct({ body: Schema.String });
+
+const SummaryResponse = Schema.Struct({
+  status: Schema.String,
+  output: Schema.Array(
+    Schema.Struct({
+      type: Schema.String,
+      content: Schema.optional(
+        Schema.Array(Schema.Struct({ type: Schema.String, text: Schema.optional(Schema.String) })),
+      ),
+    }),
+  ),
+  usage: Schema.optional(
+    Schema.Struct({ input_tokens: Schema.Number, output_tokens: Schema.Number }),
+  ),
+});
+
+const pullRequestNumber = (subject: string) => {
+  const match = PULL_REQUEST_NUMBER.exec(subject);
+  return match ? Number(match[1]) : undefined;
+};
+
+/** Drops a commit only when every scope is mobile, so `fix(web,mobile)` stays. */
+export function isReleaseNoteCommit(commit: ReleaseCommit): boolean {
+  const scopes = COMMIT_SCOPES.exec(commit.subject)?.[1]?.split(",");
+  return !scopes?.every((scope) => MOBILE_SCOPES.has(scope.trim().toLowerCase()));
+}
+
+/** Keeps the prose of a PR body: no images, tables, headings, HTML, or verification sections. */
+function trimPullRequestBody(body: string, limit = PULL_REQUEST_BODY_LIMIT): string {
+  const [prose = ""] = body.split(/\n#+\s*(?:Verification|Council|Test|Testing|Screenshots)\b/i);
+  const text = prose
+    .split("\n")
+    .filter((line) => line.trim() !== "" && !/^\s*[!|#<]/.test(line))
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return text.length > limit ? `${text.slice(0, limit)}...` : text;
+}
+
+function buildSummaryInput(
+  commits: ReadonlyArray<ReleaseCommit>,
+  pullRequests: ReadonlyMap<number, PullRequest>,
+): string {
+  return commits
+    .flatMap(({ subject }) => {
+      const number = pullRequestNumber(subject);
+      const pullRequest = number === undefined ? undefined : pullRequests.get(number);
+      if (!pullRequest) return [subject];
+      const line = `${subject} [+${pullRequest.additions} -${pullRequest.deletions}, ${pullRequest.changedFiles} files]`;
+      const body = trimPullRequestBody(pullRequest.body);
+      return body ? [line, `  > ${body}`] : [line];
+    })
+    .join("\n");
+}
+
+/** PR authors without bots, plus authors of direct pushes who have no PR in the range. */
+export function countContributors(
+  commits: ReadonlyArray<ReleaseCommit>,
+  pullRequests: ReadonlyMap<number, PullRequest>,
+): number {
+  const people = new Set<string>();
+  // A PR's squash commit carries its author's git name, which may differ from the profile name.
+  const prAuthorNames = new Set<string>();
+  const directAuthors: string[] = [];
+  for (const commit of commits) {
+    const number = pullRequestNumber(commit.subject);
+    const author = number === undefined ? undefined : pullRequests.get(number)?.author;
+    if (!author) {
+      directAuthors.push(commit.authorName);
+      continue;
+    }
+    if (author.__typename === "Bot" || author.login.endsWith("[bot]")) continue;
+    people.add(author.login);
+    prAuthorNames.add(commit.authorName);
+    if (author.name) prAuthorNames.add(author.name);
+  }
+  for (const name of directAuthors) {
+    if (!name.endsWith("[bot]") && !prAuthorNames.has(name)) people.add(name);
+  }
+  return people.size;
+}
+
+/** No date here: the app shows how long ago a release shipped, and GitHub shows the date. */
+function buildReleaseHeader(version: string, changes: number, contributors: number): string {
+  const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`;
+  return `**v${version.replace(/^v/, "")}** · ${plural(changes, "change")} from ${plural(contributors, "contributor")}`;
+}
+
+/** The summary leads; GitHub's full list folds under it. Clients cut the body at `<details>`. */
+function assembleReleaseNotes(header: string, summary: string, fullChangelog: string): string {
+  return `${header}\n\n${summary.trim()}\n\n<details>\n<summary>Full changelog</summary>\n\n${fullChangelog.trim()}\n\n</details>\n`;
+}
+
+const run = Effect.fn("generateReleaseNotes.run")(function* (
+  command: string,
+  args: ReadonlyArray<string>,
+) {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  return yield* spawner.string(ChildProcess.make(command, args));
+});
+
+const decodeJson = <S extends Schema.Top>(schema: S) =>
+  Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
+
+const readCommits = Effect.fn("generateReleaseNotes.readCommits")(function* (
+  previousTag: string,
+  ref: string,
+) {
+  const log = yield* run("git", [
+    "log",
+    "--reverse",
+    "--format=%s%x1f%an",
+    `${previousTag}..${ref}`,
+  ]);
+  return log
+    .split("\n")
+    .filter((line) => line !== "")
+    .map((line): ReleaseCommit => {
+      const [subject = "", authorName = ""] = line.split("\x1f");
+      return { subject, authorName };
+    });
+});
+
+const readPullRequests = Effect.fn("generateReleaseNotes.readPullRequests")(function* (
+  repository: string,
+  numbers: ReadonlyArray<number>,
+) {
+  const [owner, name] = repository.split("/");
+  const pullRequests = new Map<number, PullRequest>();
+  for (let start = 0; start < numbers.length; start += 100) {
+    const fields = numbers
+      .slice(start, start + 100)
+      .map(
+        (number) =>
+          `pr${number}: pullRequest(number: ${number}) { body additions deletions changedFiles author { __typename login ... on User { name } } }`,
+      )
+      .join("\n");
+    const query = `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${fields} } }`;
+    const response = yield* decodeJson(PullRequestQueryResponse)(
+      yield* run("gh", [
+        "api",
+        "graphql",
+        "-f",
+        `query=${query}`,
+        "-f",
+        `owner=${owner}`,
+        "-f",
+        `name=${name}`,
+      ]),
+    );
+    for (const [alias, pullRequest] of Object.entries(response.data.repository)) {
+      if (pullRequest) pullRequests.set(Number(alias.slice(2)), pullRequest);
+    }
+  }
+  return pullRequests;
+});
+
+const readFullChangelog = Effect.fn("generateReleaseNotes.readFullChangelog")(function* (options: {
+  readonly repository: string;
+  readonly tag: string;
+  readonly ref: string;
+  readonly previousTag: string;
+}) {
+  const response = yield* run("gh", [
+    "api",
+    `repos/${options.repository}/releases/generate-notes`,
+    "-f",
+    `tag_name=${options.tag}`,
+    "-f",
+    `target_commitish=${options.ref}`,
+    "-f",
+    `previous_tag_name=${options.previousTag}`,
+  ]);
+  return (yield* decodeJson(GeneratedNotes)(response)).body;
+});
+
+export function summaryText(response: typeof SummaryResponse.Type): Option.Option<string> {
+  // An incomplete response can carry partial text; publishing it would cut the notes short.
+  if (response.status !== "completed") return Option.none();
+  const text = response.output
+    .flatMap((item) => item.content ?? [])
+    .flatMap((part) => (part.type === "output_text" && part.text ? [part.text] : []))
+    .join("")
+    .trim();
+  return text === "" ? Option.none() : Option.some(text);
+}
+
+const summarize = Effect.fn("generateReleaseNotes.summarize")(function* (input: string) {
+  const apiKey = yield* Config.Redacted("OPENAI_API_KEY");
+  const httpClient = yield* HttpClient.HttpClient;
+  const response = yield* HttpClientRequest.post("https://api.openai.com/v1/responses").pipe(
+    HttpClientRequest.bearerToken(apiKey),
+    HttpClientRequest.bodyJson({
+      model: SUMMARY_MODEL,
+      reasoning: { effort: "low" },
+      instructions: SUMMARY_INSTRUCTIONS,
+      input: `Commits:\n${input}`,
+    }),
+    Effect.flatMap(httpClient.execute),
+    Effect.flatMap(HttpClientResponse.filterStatusOk),
+    Effect.flatMap((response) => response.json),
+    Effect.flatMap(Schema.decodeUnknownEffect(SummaryResponse)),
+    Effect.timeout("3 minutes"),
+  );
+  yield* Effect.logInfo("release summary generated").pipe(
+    Effect.annotateLogs({
+      model: SUMMARY_MODEL,
+      inputTokens: response.usage?.input_tokens,
+      outputTokens: response.usage?.output_tokens,
+    }),
+  );
+  return summaryText(response);
+});
+
+const command = Command.make(
+  "generate-release-notes",
+  {
+    repository: Flag.String("repository").pipe(Flag.withDescription("GitHub owner/name.")),
+    tag: Flag.String("tag").pipe(Flag.withDescription("Tag being released.")),
+    ref: Flag.String("ref").pipe(Flag.withDescription("Commit being released.")),
+    previousTag: Flag.String("previous-tag").pipe(Flag.withDescription("Previous release tag.")),
+    version: Flag.String("version").pipe(Flag.withDescription("Version shown in the header.")),
+    output: Flag.String("output").pipe(Flag.withDescription("File to write the notes to.")),
+  },
+  ({ repository, tag, ref, previousTag, version, output }) =>
+    Effect.gen(function* () {
+      // The header counts every commit in the range; the summary skips mobile-only work.
+      const allCommits = yield* readCommits(previousTag, ref);
+      // The spawner ignores exit codes, so a failed git log shows up as an empty range.
+      if (allCommits.length === 0) {
+        return yield* new EmptyReleaseRangeError({ range: `${previousTag}..${ref}` });
+      }
+      const commits = allCommits.filter(isReleaseNoteCommit);
+      const numbers = [
+        ...new Set(allCommits.flatMap(({ subject }) => pullRequestNumber(subject) ?? [])),
+      ];
+      const [pullRequests, fullChangelog] = yield* Effect.all(
+        [
+          readPullRequests(repository, numbers),
+          readFullChangelog({ repository, tag, ref, previousTag }),
+        ],
+        { concurrency: "unbounded" },
+      );
+      const header = buildReleaseHeader(
+        version,
+        allCommits.length,
+        countContributors(allCommits, pullRequests),
+      );
+      // With no summary, write nothing: the release falls back to GitHub's generated notes.
+      const summary =
+        commits.length === 0
+          ? Option.none<string>()
+          : yield* summarize(buildSummaryInput(commits, pullRequests));
+      if (Option.isNone(summary)) {
+        return yield* Effect.logWarning("no release summary, leaving GitHub's notes in place");
+      }
+      const fs = yield* FileSystem.FileSystem;
+      // Publish uses the file when it exists, so a partial write must never land at `output`.
+      yield* fs.writeFileString(
+        `${output}.tmp`,
+        assembleReleaseNotes(header, summary.value, fullChangelog),
+      );
+      yield* fs.rename(`${output}.tmp`, output);
+      yield* Effect.logInfo("release notes written").pipe(
+        Effect.annotateLogs({ output, commits: commits.length }),
+      );
+    }),
+).pipe(
+  Command.withDescription("Write release notes with a model summary over GitHub's full list."),
+);
+
+if (import.meta.main) {
+  Command.run(command, { version: "0.0.0" }).pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        Logger.layer([Logger.consolePretty()]),
+        NodeServices.layer,
+        FetchHttpClient.layer,
+      ),
+    ),
+    NodeRuntime.runMain,
+  );
+}
diff --git a/scripts/licenses/libatomic.LICENSE b/scripts/licenses/libatomic.LICENSE
new file mode 100644
index 0000000000000..bea77366d7f51
--- /dev/null
+++ b/scripts/licenses/libatomic.LICENSE
@@ -0,0 +1,753 @@
+libatomic is part of GCC. Copyright (C) Free Software Foundation, Inc.
+It is licensed under GPL-3.0-or-later WITH GCC-exception-3.1. Both texts follow.
+
+
+GCC RUNTIME LIBRARY EXCEPTION
+
+Version 3.1, 31 March 2009
+
+Copyright (C) 2009 Free Software Foundation, Inc. <http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This GCC Runtime Library Exception ("Exception") is an additional
+permission under section 7 of the GNU General Public License, version
+3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
+bears a notice placed by the copyright holder of the file stating that
+the file is governed by GPLv3 along with this Exception.
+
+When you use GCC to compile a program, GCC may combine portions of
+certain GCC header files and runtime libraries with the compiled
+program. The purpose of this Exception is to allow compilation of
+non-GPL (including proprietary) programs to use, in this way, the
+header files and runtime libraries covered by this Exception.
+
+0. Definitions.
+
+A file is an "Independent Module" if it either requires the Runtime
+Library for execution after a Compilation Process, or makes use of an
+interface provided by the Runtime Library, but is not otherwise based
+on the Runtime Library.
+
+"GCC" means a version of the GNU Compiler Collection, with or without
+modifications, governed by version 3 (or a specified later version) of
+the GNU General Public License (GPL) with the option of using any
+subsequent versions published by the FSF.
+
+"GPL-compatible Software" is software whose conditions of propagation,
+modification and use would permit combination with GCC in accord with
+the license of GCC.
+
+"Target Code" refers to output from any compiler for a real or virtual
+target processor architecture, in executable form or suitable for
+input to an assembler, loader, linker and/or execution
+phase. Notwithstanding that, Target Code does not include data in any
+format that is used as a compiler intermediate representation, or used
+for producing a compiler intermediate representation.
+
+The "Compilation Process" transforms code entirely represented in
+non-intermediate languages designed for human-written code, and/or in
+Java Virtual Machine byte code, into Target Code. Thus, for example,
+use of source code generators and preprocessors need not be considered
+part of the Compilation Process, since the Compilation Process can be
+understood as starting with the output of the generators or
+preprocessors.
+
+A Compilation Process is "Eligible" if it is done using GCC, alone or
+with other GPL-compatible software, or if it is done without using any
+work based on GCC. For example, using non-GPL-compatible Software to
+optimize any GCC intermediate representations would not qualify as an
+Eligible Compilation Process.
+
+1. Grant of Additional Permission.
+
+You have permission to propagate a work of Target Code formed by
+combining the Runtime Library with Independent Modules, even if such
+propagation would otherwise violate the terms of GPLv3, provided that
+all Target Code was generated by Eligible Compilation Processes. You
+may then convey such a combination under terms of your choice,
+consistent with the licensing of the Independent Modules.
+
+2. No Weakening of GCC Copyleft.
+
+The availability of this Exception does not imply any general
+presumption that third-party software is unaffected by the copyleft
+requirements of the license of GCC.
+
+
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/scripts/notify-discord-release.ts b/scripts/notify-discord-release.ts
index 0eb3bf348530a..29d94561c8fbc 100644
--- a/scripts/notify-discord-release.ts
+++ b/scripts/notify-discord-release.ts
@@ -135,6 +135,12 @@ const suppressMentions = (text: string) =>
 
 const escapeLinkLabel = (text: string) => text.replace(/[\\[\]]/g, "\\$&");
 
+/** GitHub links `(#123)` on the release page; Discord needs the link written out. */
+function linkPullRequestNumbers(notes: string, releaseUrl: URL) {
+  const repositoryUrl = releaseUrl.href.split("/releases/")[0];
+  return notes.replace(/#(\d+)\b/g, `[#$1](${repositoryUrl}/pull/$1)`);
+}
+
 function formatReleaseNotes(notes: string) {
   return notes
     .replace(
@@ -193,9 +199,15 @@ export const buildDiscordReleaseAnnouncement = (
     options.target === "prerelease"
       ? "A new T3 Code prerelease is available for nightly testers."
       : `[View full release notes on GitHub](${options.releaseUrl.href})`;
+  // Generated summaries fold the full list under <details>, which Discord cannot render.
+  const [summary = "", folded] = (options.releaseNotes ?? "").split(/^<details>/m);
   const notes =
     options.target === "prerelease"
-      ? suppressMentions(formatReleaseNotes(options.releaseNotes?.trim() ?? ""))
+      ? suppressMentions(
+          folded === undefined
+            ? formatReleaseNotes(summary.trim())
+            : `${linkPullRequestNumbers(summary.trim(), options.releaseUrl)}\n\n[Full changelog](${options.releaseUrl.href})`,
+        )
       : "";
   const description = notes ? `${intro}\n\n${notes}` : intro;
   // Separate embeds avoid URL deduplication; reserve title and footer space within Discord's 6000-character limit.
diff --git a/scripts/smoke-cli-archive.ts b/scripts/smoke-cli-archive.ts
index c5344bdeb43fe..1318aa3c0c6dd 100644
--- a/scripts/smoke-cli-archive.ts
+++ b/scripts/smoke-cli-archive.ts
@@ -97,7 +97,12 @@ const smokeCliArchive = Effect.fn("smokeCliArchive")(function* (input: {
   }
   const contentDir = path.join(scratch, root);
   const executable = path.join(contentDir, platform === "win32" ? "t3.exe" : "t3");
-  for (const required of [executable, path.join(contentDir, "client/index.html")]) {
+  const bundledLibatomic = path.join(contentDir, "lib/libatomic.so.1");
+  for (const required of [
+    executable,
+    path.join(contentDir, "client/index.html"),
+    ...(platform === "linux" ? [bundledLibatomic, `${bundledLibatomic}.LICENSE`] : []),
+  ]) {
     if (!(yield* fs.exists(required))) {
       return yield* new CliArchiveSmokeError({
         step: "checking the archive layout",
@@ -106,6 +111,22 @@ const smokeCliArchive = Effect.fn("smokeCliArchive")(function* (input: {
     }
   }
 
+  // The runner has libatomic installed; fresh Ubuntu servers do not.
+  if (platform === "linux") {
+    const ldd = yield* spawner.string(ChildProcess.make("ldd", [executable]));
+    // Older glibc prints the path as given, newer prints it resolved; compare both resolved.
+    const loaded = /libatomic\.so\.1 => (\/.*) \(0x[0-9a-f]+\)/.exec(ldd)?.[1];
+    if (
+      loaded === undefined ||
+      (yield* fs.realPath(loaded)) !== (yield* fs.realPath(bundledLibatomic))
+    ) {
+      return yield* new CliArchiveSmokeError({
+        step: "checking that t3 loads the bundled libatomic",
+        detail: ldd,
+      });
+    }
+  }
+
   const version = yield* runExecutable(executable, ["--version"], contentDir);
   if (version.exitCode !== 0 || !version.stdout.includes(input.expectVersion)) {
     return yield* new CliArchiveSmokeError({
diff --git a/vite.config.ts b/vite.config.ts
index 909becac31779..468837c255686 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -149,7 +149,11 @@ export default defineConfig({
       : {}),
   },
   staged: {
-    "*": "vp fmt --no-error-on-unmatched-pattern",
+    // In order, so lint reads the formatted file. CI lint failures cost a full round trip.
+    "*": ["vp fmt --no-error-on-unmatched-pattern", "vp lint --no-error-on-unmatched-pattern"],
+    // knip checks the whole repo, so it takes no file list. Any code or manifest change can leave
+    // a file, export, or dependency unused.
+    "{*.{js,jsx,ts,tsx,mjs,cjs,mts,cts},package.json,knip.jsonc}": () => "vp run knip:check",
   },
   fmt: {
     ignorePatterns: [