diff --git a/.github/workflows/cursor-hygiene-webhook.yml b/.github/workflows/cursor-hygiene-webhook.yml
index 8f8dde38a5fe6..19c82229e98fc 100644
--- a/.github/workflows/cursor-hygiene-webhook.yml
+++ b/.github/workflows/cursor-hygiene-webhook.yml
@@ -3,7 +3,9 @@ name: Forward to Cursor hygiene
 on:
   push:
     branches: [main]
-  pull_request:
+  # Use trusted workflow code and repository secrets for fork PRs.
+  # Keep this job payload-only: never check out or run PR code.
+  pull_request_target:
     types: [opened, reopened, ready_for_review]
   issues:
     types: [opened, closed, reopened]
@@ -34,7 +36,7 @@ jobs:
               --output /dev/null --write-out '%{http_code}' \
               -H "Authorization: $AUTH" \
               -H "Content-Type: application/json" \
-              -H "X-GitHub-Event: ${{ github.event_name }}" \
+              -H "X-GitHub-Event: ${{ github.event_name == 'pull_request_target' && 'pull_request' || github.event_name }}" \
               -H "X-GitHub-Delivery: ${{ github.run_id }}-${{ github.run_attempt }}" \
               --data-binary @"${{ github.event_path }}") || curl_status=$?
             if [ "$curl_status" -eq 0 ]; then
diff --git a/apps/desktop/src/app/DesktopClerk.test.ts b/apps/desktop/src/app/DesktopClerk.test.ts
index 58fff8297898b..e415a15489dcb 100644
--- a/apps/desktop/src/app/DesktopClerk.test.ts
+++ b/apps/desktop/src/app/DesktopClerk.test.ts
@@ -1,6 +1,7 @@
 // @effect-diagnostics nodeBuiltinImport:off globalFetchInEffect:off - Hosted handoff test uses a real localhost listener without an OpenAI account.
 import * as NodeHttp from "node:http";
-import * as NodePath from "@effect/platform-node/NodePath";
+import * as NodePath from "node:path";
+import * as PlatformNodePath from "@effect/platform-node/NodePath";
 import { codexAuthHandoffUrl, readCodexAuthDelivery } from "@t3tools/shared/codexAuthHandoff";
 import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
@@ -59,11 +60,15 @@ const layerDesktopClerk = (
     copyText: () => Effect.void,
   },
   listeners = new Map<string, (...args: unknown[]) => void>(),
+  isPackaged = false,
 ) => {
   const environment = DesktopEnvironment.DesktopEnvironment.of({
     stateDir: "/tmp/t3-state",
     isDevelopment,
     appDataDirectory: "/tmp/app-data",
+    isPackaged,
+    dirname: platform === "win32" ? String.raw`C:\T3 Code\dist-electron` : "/tmp/dist-electron",
+    path: platform === "win32" ? NodePath.win32 : NodePath.posix,
     platform,
   } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]);
 
@@ -95,7 +100,7 @@ const layerDesktopClerk = (
   return DesktopClerk.layer.pipe(
     Layer.provide(
       Layer.mergeAll(
-        NodePath.layerPosix,
+        PlatformNodePath.layerPosix,
         Layer.succeed(DesktopEnvironment.DesktopEnvironment, environment),
         Layer.succeed(ElectronApp.ElectronApp, electronApp),
         Layer.succeed(ElectronShell.ElectronShell, shell),
@@ -112,6 +117,67 @@ describe("DesktopClerk", () => {
     storageMock.mockReset();
   });
 
+  it.effect.each([
+    { platform: "win32", isPackaged: false, isDevelopment: false, registers: true },
+    { platform: "win32", isPackaged: false, isDevelopment: true, registers: false },
+    { platform: "win32", isPackaged: true, isDevelopment: false, registers: false },
+    { platform: "darwin", isPackaged: false, isDevelopment: false, registers: false },
+    { platform: "linux", isPackaged: false, isDevelopment: false, registers: false },
+  ] as const)(
+    "registers an entry point only for unpackaged non-development Windows ($platform, packaged=$isPackaged, development=$isDevelopment)",
+    ({ platform, isPackaged, isDevelopment, registers }) => {
+      const events: string[] = [];
+      storageMock.mockReturnValue(storageAdapter);
+      createClerkBridgeMock.mockImplementation(() => {
+        events.push("bridge");
+        return { cleanup: vi.fn() };
+      });
+      const setAsDefaultProtocolClient = vi.fn(() =>
+        Effect.sync(() => {
+          events.push("register");
+          return true;
+        }),
+      );
+      const electronApp = {
+        on: () => Effect.void,
+        setAsDefaultProtocolClient,
+      } as unknown as ElectronApp.ElectronApp["Service"];
+
+      return Effect.gen(function* () {
+        const clerk = yield* DesktopClerk.DesktopClerk;
+        yield* clerk.configure;
+
+        assert.deepEqual(
+          setAsDefaultProtocolClient.mock.calls,
+          registers
+            ? [["t3code", process.execPath, [String.raw`C:\T3 Code\dist-electron\main.cjs`]]]
+            : [],
+        );
+        assert.deepEqual(events, registers ? ["bridge", "register"] : ["bridge"]);
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(
+          layerDesktopClerk(
+            isDevelopment,
+            [],
+            platform,
+            undefined,
+            undefined,
+            undefined,
+            isPackaged,
+          ),
+        ),
+        Effect.provideService(ElectronApp.ElectronApp, electronApp),
+        Effect.provideService(
+          ElectronWindow.ElectronWindow,
+          {} as ElectronWindow.ElectronWindow["Service"],
+        ),
+        Effect.provideService(DesktopWebLinks.DesktopWebLinks, ignoreWebLinks),
+        Effect.provideService(HostProcess.Arguments, ["electron"]),
+      );
+    },
+  );
+
   it.effect("acquires and releases the SDK bridge with the layer", () => {
     const cleanup = vi.fn();
     const events: string[] = [];
diff --git a/apps/desktop/src/app/DesktopClerk.ts b/apps/desktop/src/app/DesktopClerk.ts
index 505b48194cf7c..f4de0b4ebaf59 100644
--- a/apps/desktop/src/app/DesktopClerk.ts
+++ b/apps/desktop/src/app/DesktopClerk.ts
@@ -151,6 +151,20 @@ export const make = Effect.gen(function* () {
       const context = yield* Effect.context<ElectronWindow.ElectronWindow>();
       const runPromise = Effect.runPromiseWith(context);
 
+      // Clerk's bare scheme registration omits the app entry on unpackaged Windows.
+      // Development callbacks also need dev server environment this command cannot restore.
+      if (
+        !environment.isPackaged &&
+        !environment.isDevelopment &&
+        environment.platform === "win32"
+      ) {
+        yield* electronApp.setAsDefaultProtocolClient(
+          ElectronProtocol.getDesktopScheme(environment.isDevelopment),
+          process.execPath,
+          [environment.path.join(environment.dirname, "main.cjs")],
+        );
+      }
+
       const startProviderAuthHandoff = (value: string | undefined) => {
         if (!value) return false;
         const request = readCodexAuthHandoff(value, environment.isDevelopment);
diff --git a/apps/desktop/src/ipc/methods/wsl.test.ts b/apps/desktop/src/ipc/methods/wsl.test.ts
index 644597eaf451d..34c3c9080eac0 100644
--- a/apps/desktop/src/ipc/methods/wsl.test.ts
+++ b/apps/desktop/src/ipc/methods/wsl.test.ts
@@ -120,6 +120,43 @@ describe("WSL IPC", () => {
     ),
   );
 
+  it.effect("does not enumerate distros until the WSL backend is enabled", () => {
+    const distros = [
+      { name: "Ubuntu", isDefault: true, version: 2 as const },
+      { name: "Debian", isDefault: false, version: 2 as const },
+    ];
+    const layer = Layer.mergeAll(
+      DesktopAppSettings.layerTest({
+        ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
+        wslDistro: "Debian",
+      }),
+      DesktopWslEnvironment.layerTest({ isAvailable: true, distros }),
+      layerWslBackend(),
+      layerLifecycle([]),
+      layerUnusedLifecycleRuntime,
+    );
+
+    return Effect.gen(function* () {
+      const wsl = yield* DesktopWslEnvironment.DesktopWslEnvironment;
+      const state = yield* getWslState.handler(undefined).pipe(
+        Effect.provideService(DesktopWslEnvironment.DesktopWslEnvironment, {
+          ...wsl,
+          listDistros: Effect.die("must not enumerate distros"),
+        }),
+        Effect.flatMap(decodeWslState),
+      );
+      assert.equal(state.enabled, false);
+      assert.equal(state.available, true);
+      assert.equal(state.distro, "Debian");
+      assert.deepEqual(state.distros, []);
+
+      const enabledState = yield* invokeSetWslBackendEnabled(true);
+      assert.equal(enabledState.enabled, true);
+      assert.equal(enabledState.distro, "Debian");
+      assert.deepEqual(enabledState.distros, distros);
+    }).pipe(Effect.provide(layer));
+  });
+
   it.effect("stages dual-backend preferences before enabling without relaunching", () => {
     const relaunchReasons: Array<string> = [];
     const layer = Layer.mergeAll(
diff --git a/apps/desktop/src/ipc/methods/wsl.ts b/apps/desktop/src/ipc/methods/wsl.ts
index 3c10f04512b4c..6a36e87bbfcbf 100644
--- a/apps/desktop/src/ipc/methods/wsl.ts
+++ b/apps/desktop/src/ipc/methods/wsl.ts
@@ -22,9 +22,9 @@ const readWslState: Effect.Effect<
   const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
   const settings = yield* appSettings.get;
   const available = settings.localEnvironmentEnabled && (yield* wslEnvironment.isAvailable);
-  // Only enumerate distros when WSL is actually available — listDistros on a
-  // non-WSL host would spawn wsl.exe and hit the timeout for nothing.
-  const distros = available ? yield* wslEnvironment.listDistros : [];
+  // Windows ships a wsl.exe stub that can prompt to install WSL when invoked.
+  // Keep disabled state reads from launching it to enumerate distros.
+  const distros = available && settings.wslBackendEnabled ? yield* wslEnvironment.listDistros : [];
   const preflightError = yield* wslBackend.lastPreflightError;
   return {
     enabled: settings.wslBackendEnabled,
diff --git a/apps/desktop/src/preview/BrowserImport/ChromiumCookies.test.ts b/apps/desktop/src/preview/BrowserImport/ChromiumCookies.test.ts
index eace39003e39d..7cf73ef633b05 100644
--- a/apps/desktop/src/preview/BrowserImport/ChromiumCookies.test.ts
+++ b/apps/desktop/src/preview/BrowserImport/ChromiumCookies.test.ts
@@ -151,56 +151,57 @@ describe("readChromiumCookieDatabase", () => {
       }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
   );
 
-  it.effect("reads plaintext, encrypted, and genuinely empty cookie values", () =>
-    Effect.gen(function* () {
-      const fileSystem = yield* FileSystem.FileSystem;
-      const directory = yield* fileSystem.makeTempDirectoryScoped({
-        prefix: "t3code-chromium-cookies-",
-      });
-      const filename = `${directory}/Cookies`;
-      const key = Buffer.from("0123456789abcdef");
+  it.effect.each([14, 24])(
+    "imports mixed TEXT and BLOB cookie values, including empty values, in schema %i",
+    (schemaVersion) =>
+      Effect.gen(function* () {
+        const fileSystem = yield* FileSystem.FileSystem;
+        const directory = yield* fileSystem.makeTempDirectoryScoped({
+          prefix: "t3code-chromium-cookies-",
+        });
+        const filename = `${directory}/Cookies`;
+        const key = Buffer.from("0123456789abcdef");
+        const host = "secure.example";
+        const value = "stored encrypted";
+        const payload =
+          schemaVersion >= 24
+            ? Buffer.concat([
+                NodeCrypto.createHash("sha256").update(host).digest(),
+                Buffer.from(value),
+              ])
+            : Buffer.from(value);
+        const encrypted = encryptV10(payload, key);
 
-      yield* Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient;
-        yield* sql`create table meta (key text primary key, value text not null)`;
-        yield* sql`insert into meta values ('version', 23)`;
-        yield* sql`
-          create table cookies (
-            host_key text not null,
-            name text not null,
-            value text not null,
-            encrypted_value blob not null,
-            path text not null,
-            expires_utc integer not null,
-            is_secure integer not null,
-            is_httponly integer not null,
-            samesite integer not null,
-            top_frame_site_key text not null default ''
-          )
-        `;
-        yield* sql`
-          insert into cookies (host_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, samesite) values
-            ('plain.example', 'plain', 'stored plaintext', ${new Uint8Array()}, '/', 0, 0, 0, -1)
-        `;
-        yield* sql`
-          insert into cookies (host_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, samesite) values
-            ('secure.example', 'encrypted', '', ${encryptV10("stored encrypted", key)}, '/', 0, 1, 1, 2)
-        `;
-        yield* sql`
-          insert into cookies (host_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, samesite) values
-            ('empty.example', 'empty', '', ${new Uint8Array()}, '/', 0, 0, 0, 0)
-        `;
-      }).pipe(Effect.provide(NodeSqliteClient.layer({ filename })));
+        yield* Effect.gen(function* () {
+          const sql = yield* SqlClient.SqlClient;
+          yield* sql`create table meta (key text primary key, value text not null)`;
+          yield* sql`insert into meta values ('version', ${schemaVersion})`;
+          yield* sql`create table cookies (
+            host_key text not null, name text not null, value text not null,
+            encrypted_value blob not null, path text not null, expires_utc integer not null,
+            is_secure integer not null, is_httponly integer not null, samesite integer not null
+          )`;
+          if (schemaVersion >= 15) {
+            yield* sql`alter table cookies add column top_frame_site_key text not null default ''`;
+          }
+          yield* sql`insert into cookies
+            (host_key, name, value, encrypted_value, path, expires_utc, is_secure, is_httponly, samesite) values
+            ('plain.example', 'plain', 'stored plaintext', '', '/', 0, 0, 0, -1),
+            (${host}, 'text-encrypted', '', cast(${encrypted} as text), '/', 0, 1, 1, 2),
+            (${host}, 'blob-encrypted', '', ${encrypted}, '/', 0, 1, 1, 2),
+            ('empty.example', 'empty', '', ${new Uint8Array()}, '/', 0, 0, 0, 0)`;
+        }).pipe(Effect.provide(NodeSqliteClient.layer({ filename })));
 
-      const result = yield* readChromiumCookieDatabase(filename, { cbcV10: key }, "darwin");
+        const result = yield* readChromiumCookieDatabase(filename, { cbcV10: key }, "darwin");
 
-      expect(result.undecryptable).toBe(0);
-      expect(result.cookies.map(({ name, value }) => ({ name, value }))).toEqual([
-        { name: "plain", value: "stored plaintext" },
-        { name: "encrypted", value: "stored encrypted" },
-        { name: "empty", value: "" },
-      ]);
-    }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
+        expect(result.undecryptable).toBe(0);
+        expect(result.cookies.map(({ name, value }) => ({ name, value }))).toEqual([
+          { name: "plain", value: "stored plaintext" },
+          { name: "text-encrypted", value },
+          { name: "blob-encrypted", value },
+          { name: "empty", value: "" },
+        ]);
+      }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
   );
 
   it.effect("enforces domain binding only for schema 24 and newer", () =>
diff --git a/apps/desktop/src/preview/BrowserImport/ChromiumCookies.ts b/apps/desktop/src/preview/BrowserImport/ChromiumCookies.ts
index d5f7592b26068..a3720f962b650 100644
--- a/apps/desktop/src/preview/BrowserImport/ChromiumCookies.ts
+++ b/apps/desktop/src/preview/BrowserImport/ChromiumCookies.ts
@@ -200,12 +200,14 @@ export const readChromiumCookieDatabase = Effect.fn("ChromiumCookies.readChromiu
         Effect.flatMap(decodeSchemaVersion),
         Effect.map(([row]) => row.value),
       );
+      // SQLite's BLOB affinity still permits TEXT. Cast before Node decodes
+      // those bytes as UTF-8, which can corrupt an encrypted payload.
       const raw =
         schemaVersion >= 15
-          ? yield* sql`select host_key, name, value, encrypted_value, path,
+          ? yield* sql`select host_key, name, value, cast(encrypted_value as blob) as encrypted_value, path,
                 expires_utc / 1000000 as expires_seconds, is_secure, is_httponly,
                 samesite, top_frame_site_key from cookies`
-          : yield* sql`select host_key, name, value, encrypted_value, path,
+          : yield* sql`select host_key, name, value, cast(encrypted_value as blob) as encrypted_value, path,
                 expires_utc / 1000000 as expires_seconds, is_secure, is_httponly,
                 samesite, '' as top_frame_site_key from cookies`;
       return { rows: yield* decodeCookieRows(raw), schemaVersion };
diff --git a/apps/desktop/src/settings/DesktopAppSettings.test.ts b/apps/desktop/src/settings/DesktopAppSettings.test.ts
index a98aa96079e67..7313b9b859e39 100644
--- a/apps/desktop/src/settings/DesktopAppSettings.test.ts
+++ b/apps/desktop/src/settings/DesktopAppSettings.test.ts
@@ -283,7 +283,7 @@ describe("DesktopSettings", () => {
       Effect.gen(function* () {
         const settings = yield* DesktopAppSettings.DesktopAppSettings;
         yield* writeSettingsPatch({
-          mainWindowBounds: { x: 10.5, y: 20, width: 839, height: 620 },
+          mainWindowBounds: { x: 10, y: 20, width: 599, height: 620 },
           mainWindowMaximized: true,
           serverExposureMode: "network-accessible",
         });
@@ -342,17 +342,24 @@ describe("DesktopSettings", () => {
         const fileSystem = yield* FileSystem.FileSystem;
         const settings = yield* DesktopAppSettings.DesktopAppSettings;
 
-        yield* settings.setMainWindowBounds({ x: -1200, y: 40, width: 1440, height: 960 }, true);
+        yield* settings.setMainWindowBounds({ x: -1200, y: 40, width: 600, height: 620 }, true);
         yield* settings.setServerExposureMode("network-accessible");
 
         const persisted = yield* decodeDesktopSettingsPatch(
           yield* fileSystem.readFileString(environment.desktopSettingsPath),
         );
         assert.deepEqual(persisted, {
-          mainWindowBounds: { x: -1200, y: 40, width: 1440, height: 960 },
+          mainWindowBounds: { x: -1200, y: 40, width: 600, height: 620 },
           mainWindowMaximized: true,
           serverExposureMode: "network-accessible",
         } satisfies typeof DesktopSettingsPatch.Type);
+
+        const restored = yield* Effect.gen(function* () {
+          const freshSettings = yield* DesktopAppSettings.DesktopAppSettings;
+          return yield* freshSettings.load;
+        }).pipe(Effect.provide(DesktopAppSettings.layer));
+        assert.deepEqual(restored.mainWindowBounds, persisted.mainWindowBounds);
+        assert.isTrue(restored.mainWindowMaximized);
       }),
     ),
   );
diff --git a/apps/desktop/src/settings/DesktopAppSettings.ts b/apps/desktop/src/settings/DesktopAppSettings.ts
index 1c131681295fa..a26892d6984a1 100644
--- a/apps/desktop/src/settings/DesktopAppSettings.ts
+++ b/apps/desktop/src/settings/DesktopAppSettings.ts
@@ -48,8 +48,8 @@ export interface DesktopSettingsChange {
 }
 
 const DEFAULT_TAILSCALE_SERVE_PORT = 443;
-const MIN_MAIN_WINDOW_SIZE = {
-  width: 840,
+export const MIN_MAIN_WINDOW_SIZE = {
+  width: 600,
   height: 620,
 } as const;
 export const DesktopWindowBoundsSchema = Schema.Struct({
diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts
index 27f4298a49f82..9e50257c9a0c5 100644
--- a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts
+++ b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts
@@ -1,6 +1,9 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Clock from "effect/Clock";
 import { assert, describe, it } from "@effect/vitest";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as PlatformError from "effect/PlatformError";
@@ -9,6 +12,7 @@ import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as ChildProcess from "effect/process/ChildProcess";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
+import * as TestClock from "effect/testing/TestClock";
 import * as NodeOS from "node:os";
 import { vi } from "vite-plus/test";
 
@@ -74,7 +78,10 @@ function runShellEnvironment(input: {
   readonly userShell?: string;
   readonly handler: (
     command: ChildProcess.Command,
-  ) => string | { output: string; exitCode: number };
+  ) =>
+    | string
+    | { output: string; exitCode: number }
+    | Effect.Effect<ChildProcessSpawner.ChildProcessHandle, PlatformError.PlatformError>;
   readonly failure?: PlatformError.PlatformError;
 }) {
   const layerEnvironment = Layer.succeed(
@@ -88,6 +95,7 @@ function runShellEnvironment(input: {
     ChildProcessSpawner.make((command) => {
       if (input.failure !== undefined) return Effect.fail(input.failure);
       const result = input.handler(command);
+      if (Effect.isEffect(result)) return result;
       return Effect.succeed(
         typeof result === "string"
           ? makeProcess(result)
@@ -489,6 +497,85 @@ describe("DesktopShellEnvironment", () => {
     }),
   );
 
+  it.effect("waits at most 5 seconds in total when the PowerShell profile hangs", () =>
+    Effect.gen(function* () {
+      const env: NodeJS.ProcessEnv = { PATH: "C:\\Windows\\System32" };
+      const profileShells: string[] = [];
+      const started = yield* Deferred.make<void>();
+      const completed = yield* Deferred.make<void>();
+      const baseClock = yield* Clock.Clock;
+      let wallTime = 0;
+      const clockWithBackwardWallJump: Clock.Clock = {
+        ...baseClock,
+        currentTimeMillisUnsafe: () => wallTime,
+        currentTimeMillis: Effect.sync(() => wallTime),
+      };
+
+      const install = yield* Effect.forkChild(
+        runShellEnvironment({
+          env,
+          platform: "win32",
+          handler: (command) => {
+            if (command._tag !== "StandardCommand") return "";
+            if (command.args.includes("-NoProfile")) {
+              return envOutput({ PATH: "C:\\NoProfile\\Bin;C:\\Windows\\System32" });
+            }
+            profileShells.push(command.command);
+            return Deferred.succeed(started, undefined).pipe(
+              Effect.as(
+                ChildProcessSpawner.makeHandle({
+                  ...makeProcess(""),
+                  stdout: Stream.never,
+                  all: Stream.never,
+                  exitCode: Effect.never,
+                  isRunning: Effect.succeed(true),
+                }),
+              ),
+            );
+          },
+        }).pipe(
+          Effect.tap(() => Deferred.succeed(completed, undefined)),
+          Effect.provide(Logger.layer([])),
+          Effect.provideService(Clock.Clock, clockWithBackwardWallJump),
+        ),
+      );
+      yield* Deferred.await(started);
+      wallTime = -60_000;
+      yield* TestClock.adjust("5 seconds");
+      assert.isTrue(yield* Deferred.isDone(completed), "finishes within the shared budget");
+      assert.isFalse(yield* Fiber.join(install));
+      assert.deepEqual(profileShells, ["pwsh.exe"]);
+      assert.equal(env.PATH, "C:\\NoProfile\\Bin;C:\\Windows\\System32");
+    }),
+  );
+
+  it.effect("falls back to Windows PowerShell when pwsh.exe is not installed", () =>
+    Effect.gen(function* () {
+      const env: NodeJS.ProcessEnv = { PATH: "C:\\Windows\\System32" };
+      const missing = PlatformError.systemError({
+        _tag: "NotFound",
+        module: "ChildProcess",
+        method: "spawn",
+        pathOrDescriptor: "pwsh.exe",
+      });
+
+      const prepared = yield* runShellEnvironment({
+        env,
+        platform: "win32",
+        handler: (command) => {
+          if (command._tag !== "StandardCommand") return "";
+          if (command.command === "pwsh.exe") return Effect.fail(missing);
+          return command.args.includes("-NoProfile")
+            ? envOutput({ PATH: "C:\\Windows\\System32" })
+            : envOutput({ PATH: "C:\\Profile\\Node;C:\\Windows\\System32" });
+        },
+      }).pipe(Effect.provide(Logger.layer([])));
+
+      assert.isTrue(prepared);
+      assert.equal(env.PATH, "C:\\Profile\\Node;C:\\Windows\\System32");
+    }),
+  );
+
   it.effect.each([false, true])(
     "leaves Windows preparation incomplete when loadProfile=%s fails",
     (loadProfile) =>
diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts
index ad21a8d617635..b033f1cead20f 100644
--- a/apps/desktop/src/shell/DesktopShellEnvironment.ts
+++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts
@@ -1,4 +1,5 @@
 import { listLoginShellCandidates, setWindowsPath } from "@t3tools/shared/shell";
+import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -377,12 +378,16 @@ const readWindowsEnvironment = Effect.fn("desktop.shellEnvironment.readWindowsEn
       captureWindowsEnvironmentCommand(names),
     ];
 
+    const deadline =
+      (yield* Clock.monotonicTimeNanos) + Duration.toNanosUnsafe(LOGIN_SHELL_TIMEOUT);
     for (const command of WINDOWS_SHELL_CANDIDATES) {
+      const remainingNanos = deadline - (yield* Clock.monotonicTimeNanos);
+      if (remainingNanos <= 0n) break;
       const output = yield* runCommandOutput({
         probe: options.loadProfile ? "powershell-profile" : "powershell-no-profile",
         command,
         args,
-        timeout: LOGIN_SHELL_TIMEOUT,
+        timeout: Duration.nanos(remainingNanos),
       });
       const environment = extractEnvironment(output, names);
       if (Object.keys(environment).length > 0) {
diff --git a/apps/desktop/src/window/DesktopWindow.test.ts b/apps/desktop/src/window/DesktopWindow.test.ts
index 56206a2279631..827a48997fb86 100644
--- a/apps/desktop/src/window/DesktopWindow.test.ts
+++ b/apps/desktop/src/window/DesktopWindow.test.ts
@@ -660,6 +660,8 @@ describe("DesktopWindow", () => {
         assert.equal(yield* Ref.get(createCount), 1);
         assert.equal(createdWindowOptions[0]?.width, 1100);
         assert.equal(createdWindowOptions[0]?.height, 780);
+        assert.equal(createdWindowOptions[0]?.minWidth, 600);
+        assert.equal(createdWindowOptions[0]?.minHeight, 620);
         assert.isUndefined(createdWindowOptions[0]?.x);
         assert.isUndefined(createdWindowOptions[0]?.y);
         assert.isTrue(createdWindowOptions[0]?.disableAutoHideCursor);
@@ -918,7 +920,7 @@ describe("DesktopWindow", () => {
         createdWindowOptions,
         desktopSettings: {
           ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
-          mainWindowBounds: { x: 120, y: 80, width: 1320, height: 880 },
+          mainWindowBounds: { x: 120, y: 80, width: 768, height: 780 },
         },
       });
 
@@ -926,8 +928,8 @@ describe("DesktopWindow", () => {
         const desktopWindow = yield* DesktopWindow.DesktopWindow;
         yield* desktopWindow.handleBackendReady(new URL("http://127.0.0.1:3773"));
 
-        assert.equal(createdWindowOptions[0]?.width, 1320);
-        assert.equal(createdWindowOptions[0]?.height, 880);
+        assert.equal(createdWindowOptions[0]?.width, 768);
+        assert.equal(createdWindowOptions[0]?.height, 780);
         assert.equal(createdWindowOptions[0]?.x, 120);
         assert.equal(createdWindowOptions[0]?.y, 80);
       }).pipe(Effect.provide(layer));
@@ -1152,14 +1154,14 @@ describe("DesktopWindow", () => {
         move();
         yield* TestClock.adjust(250);
 
-        fakeWindow.getBounds.mockReturnValue({ x: 160, y: 100, width: 1360, height: 900 });
+        fakeWindow.getBounds.mockReturnValue({ x: 160, y: 100, width: 664, height: 780 });
         resize();
         yield* TestClock.adjust(499);
         assert.deepEqual(mainWindowBoundsUpdates, []);
 
         yield* TestClock.adjust(1);
         yield* Effect.promise(() => Promise.resolve());
-        assert.deepEqual(mainWindowBoundsUpdates, [{ x: 160, y: 100, width: 1360, height: 900 }]);
+        assert.deepEqual(mainWindowBoundsUpdates, [{ x: 160, y: 100, width: 664, height: 780 }]);
       }).pipe(Effect.provide(layer));
     }),
   );
@@ -1241,7 +1243,7 @@ describe("DesktopWindow", () => {
   it.effect("does not persist bounds that fail the domain schema", () =>
     Effect.gen(function* () {
       const fakeWindow = makeFakeBrowserWindow();
-      fakeWindow.getBounds.mockReturnValue({ x: 100.4, y: 80.2, width: 839.4, height: 619.4 });
+      fakeWindow.getBounds.mockReturnValue({ x: 100, y: 80, width: 599, height: 620 });
       const createCount = yield* Ref.make(0);
       const mainWindow = yield* Ref.make<Option.Option<Electron.BrowserWindow>>(Option.none());
       const mainWindowBoundsUpdates: DesktopAppSettings.DesktopWindowBounds[] = [];
diff --git a/apps/desktop/src/window/DesktopWindow.ts b/apps/desktop/src/window/DesktopWindow.ts
index 5d14fdfdc53f2..f99eeffd62c2f 100644
--- a/apps/desktop/src/window/DesktopWindow.ts
+++ b/apps/desktop/src/window/DesktopWindow.ts
@@ -383,8 +383,8 @@ export const make = Effect.gen(function* () {
     if (yield* Ref.get(desktopState.quitting)) return Option.none();
     const window = yield* electronWindow.create({
       ...initialBounds,
-      minWidth: 840,
-      minHeight: 620,
+      minWidth: DesktopAppSettings.MIN_MAIN_WINDOW_SIZE.width,
+      minHeight: DesktopAppSettings.MIN_MAIN_WINDOW_SIZE.height,
       show: false,
       autoHideMenuBar: true,
       ...(environment.platform === "darwin" ? { disableAutoHideCursor: true } : {}),
diff --git a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
index ca2426f8c023f..1d57632eee5fc 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
@@ -754,16 +754,22 @@ internal class SelectionAwareEditText(context: Context) : EditText(context) {
     return shouldIntercept
   }
 
-  // coerceToText opens content: URIs synchronously. Leave URI-backed
-  // clipboard items to Android's normal paste path so the UI thread never
-  // reads an arbitrary provider just to measure a text paste.
-  private fun ClipData.plainText(): String? =
-    takeIf { itemCount > 0 }
-      ?.getItemAt(0)
-      ?.takeIf { it.uri == null }
-      ?.coerceToText(context)
-      ?.toString()
-      ?.takeIf(String::isNotEmpty)
+  // Match native paste's newlines, including empty items.
+  // URI-backed clips stay native: coerceToText can read a provider synchronously.
+  private fun ClipData.plainText(): String? {
+    var joined: StringBuilder? = null
+    for (index in 0 until itemCount) {
+      val item = getItemAt(index)
+      if (item.uri != null) return null
+      val itemText = item.coerceToText(context) ?: continue
+      if (joined == null) {
+        joined = StringBuilder(itemText)
+      } else {
+        joined.append('\n').append(itemText)
+      }
+    }
+    return joined?.toString()?.takeIf(String::isNotEmpty)
+  }
 
   override fun onKeyShortcut(keyCode: Int, event: KeyEvent): Boolean {
     if (keyCode == KeyEvent.KEYCODE_V && event.isCtrlPressed && event.isShiftPressed) {
diff --git a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
index 9838c6314680b..ca15fb2b1ba19 100644
--- a/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
+++ b/apps/mobile/modules/t3-composer-editor/android/src/test/java/expo/modules/t3composereditor/ComposerPasteTest.kt
@@ -1,8 +1,10 @@
 package expo.modules.t3composereditor
 
 import android.content.ClipData
+import android.content.ClipDescription
 import android.content.ClipboardManager
 import android.content.Context
+import android.net.Uri
 import android.view.KeyEvent
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -91,6 +93,53 @@ class ComposerPasteTest {
     assertEquals("old", editor.text.toString())
   }
 
+  @Test
+  fun regularPasteMeasuresAndInterceptsEveryTextItemJoinedWithNewlines() {
+    // Only the complete UTF-8 payload, including both newlines, reaches 32 KiB.
+    val first = "é".repeat(8191)
+    val last = "x".repeat(16 * 1024)
+    val clip = ClipData.newPlainText("test", first).apply {
+      addItem(ClipData.Item(""))
+      addItem(ClipData.Item(last))
+    }
+    clipboard.setPrimaryClip(clip)
+    editor.setText("before old after")
+    editor.setSelection(10, 7)
+    val intercepted = mutableListOf<Triple<String, Int, Int>>()
+    editor.pasteTextListener = { text, start, end -> intercepted.add(Triple(text, start, end)) }
+
+    assertTrue(editor.onTextContextMenuItem(android.R.id.paste))
+    assertEquals(listOf(Triple("$first\n\n$last", 7, 10)), intercepted)
+    assertEquals("before old after", editor.text.toString())
+    assertEquals(10, editor.selectionStart)
+    assertEquals(7, editor.selectionEnd)
+  }
+
+  @Test
+  fun regularPasteKeepsClipsWithAnyUriItemNative() {
+    editor.textPasteThresholdBytes = 1
+    editor.pasteTextListener = { _, _, _ -> error("URI-backed clips must stay native") }
+    for (uriIndex in 0..2) {
+      val items = (0..2).map { index ->
+        if (index == uriIndex) {
+          ClipData.Item("ITEM_$index", null, Uri.parse("content://test/item/$index"))
+        } else {
+          ClipData.Item("ITEM_$index")
+        }
+      }
+      val clip = ClipData("test", arrayOf(ClipDescription.MIMETYPE_TEXT_PLAIN), items[0]).apply {
+        addItem(items[1])
+        addItem(items[2])
+      }
+      clipboard.setPrimaryClip(clip)
+      editor.setText("before old after")
+      editor.setSelection(10, 7)
+
+      assertTrue(editor.onTextContextMenuItem(android.R.id.paste))
+      assertEquals("before ITEM_0\nITEM_1\nITEM_2 after", editor.text.toString())
+    }
+  }
+
   @Test
   fun shortcutPastesStructuredClipboardAsText() {
     clipboard.setPrimaryClip(
diff --git a/apps/mobile/src/components/ComposerEditor.tsx b/apps/mobile/src/components/ComposerEditor.tsx
index a49fa6ef391b7..3d06dfd9f344a 100644
--- a/apps/mobile/src/components/ComposerEditor.tsx
+++ b/apps/mobile/src/components/ComposerEditor.tsx
@@ -34,6 +34,7 @@ import {
 
 export type ComposerEditorProps = NativeComposerEditorProps & {
   readonly draftKey?: string | null;
+  readonly hidden?: boolean;
   readonly environmentId?: EnvironmentId;
   readonly onOpenMention?: (path: string) => void;
   readonly onOpenAttachment?: (attachment: ComposerDocumentAttachment) => void;
@@ -43,6 +44,7 @@ export type ComposerEditorProps = NativeComposerEditorProps & {
 
 export function ComposerEditor({
   draftKey,
+  hidden,
   environmentId,
   onOpenMention,
   onOpenAttachment,
@@ -155,7 +157,9 @@ export function ComposerEditor({
   );
   return (
     <>
+      {/* Reset revision history with the recreated iOS view without aborting context imports. */}
       <NativeComposerEditor
+        key={hidden ? "hidden" : "visible"}
         {...props}
         enterBehavior={props.enterBehavior ?? preferredEnterBehavior}
         onChangeText={changeText}
diff --git a/apps/mobile/src/features/browser/BrowserPreviewRouteScreen.tsx b/apps/mobile/src/features/browser/BrowserPreviewRouteScreen.tsx
index cb7a7615fd3fa..a458046ee2be1 100644
--- a/apps/mobile/src/features/browser/BrowserPreviewRouteScreen.tsx
+++ b/apps/mobile/src/features/browser/BrowserPreviewRouteScreen.tsx
@@ -271,7 +271,7 @@ function BrowserAddressBar({
       <BrowserTabMenu
         environmentId={environmentId}
         tab={tab}
-        disabled={!streaming}
+        streaming={streaming}
         onPaste={ready ? onPaste : undefined}
       />
     </View>
diff --git a/apps/mobile/src/features/browser/BrowserTabMenu.tsx b/apps/mobile/src/features/browser/BrowserTabMenu.tsx
index 0ade61a7a1b0e..916fde2470ec3 100644
--- a/apps/mobile/src/features/browser/BrowserTabMenu.tsx
+++ b/apps/mobile/src/features/browser/BrowserTabMenu.tsx
@@ -1,4 +1,5 @@
 import * as Dialog from "../../components/ui/Dialog";
+import { useAtomValue } from "@effect/atom-react";
 import type { MenuAction } from "@react-native-menu/menu";
 import {
   DEFAULT_PREVIEW_ZOOM_FACTOR,
@@ -40,16 +41,18 @@ const VIEWPORTS = [
 export function BrowserTabMenu({
   environmentId,
   tab,
-  disabled,
+  streaming,
   onPaste,
 }: {
   readonly environmentId: EnvironmentId;
   readonly tab: PreviewSessionSnapshot;
-  readonly disabled: boolean;
+  readonly streaming: boolean;
   readonly onPaste?: () => void;
 }) {
   const adjust = useAtomCommand(previewEnvironment.adjust, "browser tab change");
   const resize = useAtomCommand(previewEnvironment.resize, "browser viewport change");
+  const close = useAtomCommand(previewEnvironment.close, "browser tab close");
+  const canClose = useAtomValue(previewEnvironment.close.permissionAtom(environmentId));
   const target = { threadId: tab.threadId as PreviewAdjustInput["threadId"], tabId: tab.tabId };
   const colorScheme = tab.colorScheme ?? "system";
   const zoomFactor = tab.zoomFactor ?? DEFAULT_PREVIEW_ZOOM_FACTOR;
@@ -65,6 +68,12 @@ export function BrowserTabMenu({
         ? `preset:${tab.viewport.presetId}`
         : "custom";
 
+  const closeAction: MenuAction = {
+    id: "close",
+    title: "Close tab",
+    image: "xmark",
+    attributes: { destructive: true, disabled: !canClose },
+  };
   const actions: MenuAction[] = [
     ...(onPaste ? [{ id: "paste", title: "Paste", image: "doc.on.clipboard" }] : []),
     { id: "hard-reload", title: "Hard reload", image: "arrow.clockwise.circle" },
@@ -107,6 +116,7 @@ export function BrowserTabMenu({
         { id: "clear:cache", title: "Clear cache", attributes: { destructive: true } },
       ],
     },
+    closeAction,
   ];
 
   const run = async (change: Omit<PreviewAdjustInput, "threadId" | "tabId">) => {
@@ -115,6 +125,12 @@ export function BrowserTabMenu({
   };
 
   const onAction = (id: string) => {
+    if (id === "close") {
+      void close({ environmentId, input: target }).then((result) => {
+        if (result._tag === "Failure") Dialog.alert("Could not close this browser tab");
+      });
+      return;
+    }
     if (id === "paste") return onPaste?.();
     if (id === "hard-reload") return void run({ hardReload: true });
     if (id === "zoom:in") return void run({ zoomFactor: zoomTo(1) });
@@ -138,19 +154,18 @@ export function BrowserTabMenu({
     }
   };
 
-  const pill = (
-    <ControlPill icon="ellipsis" accessibilityLabel="Browser tab options" disabled={disabled} />
-  );
-  if (disabled) return pill;
   return (
     <Menu
+      // Remount when streaming changes, so an open menu never keeps offering
+      // the other state's actions.
+      key={streaming ? "streaming" : "idle"}
       accessible
       accessibilityLabel="Browser tab options"
       accessibilityRole="button"
-      actions={actions}
+      actions={streaming ? actions : [closeAction]}
       onPressAction={({ nativeEvent }) => onAction(nativeEvent.event)}
     >
-      {pill}
+      <ControlPill icon="ellipsis" accessibilityLabel="Browser tab options" />
     </Menu>
   );
 }
diff --git a/apps/mobile/src/features/home/HomeHeader.tsx b/apps/mobile/src/features/home/HomeHeader.tsx
index 28fab112c8630..b6203916dea1c 100644
--- a/apps/mobile/src/features/home/HomeHeader.tsx
+++ b/apps/mobile/src/features/home/HomeHeader.tsx
@@ -13,7 +13,10 @@ import { createNativeMailSearchToolbarItem } from "../layout/native-mail-search-
 import { useNativeMailSearchToolbar } from "../../native/use-native-mail-search-toolbar";
 import { useDeviceType } from "../../native/native-layout-metrics";
 import { buildHomeListFilterMenu } from "./home-list-filter-menu";
-import { createSidebarHeaderItems } from "../threads/sidebar-native-header-items";
+import {
+  createSidebarFilterHeaderItem,
+  createSidebarHeaderItems,
+} from "../threads/sidebar-native-header-items";
 import type { HomeHeaderProps } from "./HomeHeader.types";
 import { useAdaptiveWorkspaceLayout } from "../layout/AdaptiveWorkspaceLayout";
 
@@ -58,7 +61,19 @@ export function HomeHeader(props: HomeHeaderProps) {
   const filterMenu = buildHomeListFilterMenu(props);
 
   if (props.usesWorkspaceToolbar) {
-    return null;
+    return deviceType === "duo-unfolded" ? (
+      <NativeStackScreenOptions
+        optionsVersion={filterMenu.items}
+        options={{
+          nativeSidebarFilter: createSidebarFilterHeaderItem({
+            filterIcon: hasCustomListOptions
+              ? "line.3.horizontal.decrease.circle.fill"
+              : "line.3.horizontal.decrease.circle",
+            filterMenu,
+          }),
+        }}
+      />
+    ) : null;
   }
 
   return (
diff --git a/apps/mobile/src/features/layout/createWorkspaceStackNavigator.ios.tsx b/apps/mobile/src/features/layout/createWorkspaceStackNavigator.ios.tsx
index d6819517deb6b..2b23ad865f042 100644
--- a/apps/mobile/src/features/layout/createWorkspaceStackNavigator.ios.tsx
+++ b/apps/mobile/src/features/layout/createWorkspaceStackNavigator.ios.tsx
@@ -14,6 +14,7 @@ import {
 } from "@react-navigation/native";
 import {
   NativeStackView,
+  type NativeStackHeaderItemMenu,
   type NativeStackNavigationEventMap,
   type NativeStackNavigationOptions,
   type NativeStackNavigatorProps,
@@ -62,6 +63,7 @@ function ColumnScreen(props: {
   readonly primary?: boolean;
   readonly selectedThreadKey?: string | null;
   readonly selectedPullRequestKey?: string | null;
+  readonly sidebarFilter?: NativeStackHeaderItemMenu;
   readonly onDismiss: (routeKey: string) => void;
   readonly navigation: ViewProps["navigation"];
 }) {
@@ -102,6 +104,7 @@ function ColumnScreen(props: {
             options={descriptor.options}
             canGoBack={!props.primary}
             primary={props.primary}
+            sidebarFilter={props.sidebarFilter}
           />
           <ColumnContent
             primary={props.primary}
@@ -175,6 +178,7 @@ function WorkspaceColumns(
 
   const primary = props.descriptors[props.primary.key];
   if (!primary) return null;
+  const sidebarFilter = (primary.options as AppNativeStackNavigationOptions).nativeSidebarFilter;
   return (
     <Split.Host
       ref={hostRef}
@@ -231,6 +235,7 @@ function WorkspaceColumns(
                 ],
               }}
               canGoBack={false}
+              sidebarFilter={sidebarFilter}
             />
             <ColumnContent>
               <WorkspaceEmptyDetail
@@ -248,6 +253,7 @@ function WorkspaceColumns(
                 descriptor={descriptor}
                 onDismiss={handleNativeDismiss}
                 navigation={props.navigation}
+                sidebarFilter={sidebarFilter}
               />
             ) : null;
           })}
diff --git a/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx b/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
index dcece75411ead..dcc1f66cd2b02 100644
--- a/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
+++ b/apps/mobile/src/features/pull-requests/PullRequestRouteScreen.tsx
@@ -44,13 +44,13 @@ import {
   useRoute,
   type StaticScreenProps,
 } from "@react-navigation/native";
-import { useAtomRefresh } from "@effect/atom-react";
+import { RegistryContext, useAtomRefresh } from "@effect/atom-react";
 import { pullRequestReviewKey } from "./pullRequestReviewDrafts";
 import { type PullRequestDetail, type PullRequestListEntry } from "@t3tools/contracts";
 import { PullRequestOverviewLoading } from "./PullRequestOverviewLoading";
 import { copyPullRequestLink, sharePullRequestLink } from "./pullRequestLink";
 import { pullRequestStatus } from "./pullRequestStatus";
-import { useEffect, useRef, useState } from "react";
+import { use, useEffect, useRef, useState } from "react";
 import {
   Linking,
   Platform,
@@ -354,13 +354,22 @@ export function PullRequestRouteScreen({ route }: StaticScreenProps<PullRequestP
   const stack = usePullRequestStack(params, pr);
   const refreshActivity = useAtomRefresh(composerPullRequests.activity(requestTarget(params)));
   const refreshGuide = useAtomRefresh(composerPullRequests.reviewGuide(requestTarget(params)));
-  const refresh = () => {
-    pullRefresh.onRefresh();
-    if (guidesEnabled) refreshGuide();
-    stack.refresh();
-    refreshActivity();
-    filesContent.refresh();
-  };
+  const registry = use(RegistryContext);
+  const refresh = () =>
+    pullRefresh.onRefresh(async (signal) => {
+      const target = requestTarget(params);
+      await composerPullRequests.invalidate
+        .run(registry, {
+          environmentId: target.environmentId,
+          input: { reference: target.input },
+        })
+        .catch(() => undefined);
+      if (signal.aborted) return;
+      if (guidesEnabled) refreshGuide();
+      stack.refresh();
+      refreshActivity();
+      filesContent.refresh();
+    });
   const jumpToFiles = () => {
     scrollViews.current.overview?.scrollToOffset({
       offset: bodyY.current + filesY.current - insets.top,
diff --git a/apps/mobile/src/features/review/nativeReviewDiffAdapter.test.ts b/apps/mobile/src/features/review/nativeReviewDiffAdapter.test.ts
index 6f55fef7c2a7c..e89338c55e735 100644
--- a/apps/mobile/src/features/review/nativeReviewDiffAdapter.test.ts
+++ b/apps/mobile/src/features/review/nativeReviewDiffAdapter.test.ts
@@ -252,6 +252,91 @@ describe("getCachedNativeReviewDiffData", () => {
   });
 });
 
+describe("buildNativeReviewDiffData row bound", () => {
+  function singleFilePatch(path: string, lineCount: number) {
+    return [
+      `diff --git a/${path} b/${path}`,
+      `--- a/${path}`,
+      `+++ b/${path}`,
+      `@@ -0,0 +1,${lineCount} @@`,
+      ...Array.from({ length: lineCount }, (_, index) => `+const value${index} = ${index};`),
+    ].join("\n");
+  }
+
+  it("caps each huge file excerpt while preserving full counts and ordinary files", () => {
+    const data = buildNativeReviewDiffData(
+      buildReviewParsedDiff(
+        [singleFilePatch("huge.ts", 200_000), singleFilePatch("ordinary.ts", 1_000)].join("\n"),
+        "native-review-row-bound",
+      ),
+    );
+    const hugeHeader = data.rows.find((row) => row.kind === "file" && row.filePath === "huge.ts");
+    const ordinaryHeader = data.rows.find(
+      (row) => row.kind === "file" && row.filePath === "ordinary.ts",
+    );
+    expect(hugeHeader).toMatchObject({ additions: 200_000, deletions: 0 });
+    expect(ordinaryHeader).toMatchObject({ additions: 1_000, deletions: 0 });
+    expect(data).toMatchObject({ additions: 201_000, deletions: 0 });
+    const hugeRows = data.rows.filter((row) => row.fileId === hugeHeader?.fileId);
+    expect(hugeRows.filter((row) => row.kind === "line" || row.kind === "hunk")).toHaveLength(
+      2_000,
+    );
+    expect(hugeRows.at(-2)).toMatchObject({ kind: "line", newLineNumber: 1_999 });
+    expect(hugeRows.at(-1)).toMatchObject({
+      kind: "notice",
+      text: "This diff is too large to show in full.",
+    });
+    const ordinaryRows = data.rows.filter((row) => row.fileId === ordinaryHeader?.fileId);
+    expect(ordinaryRows.filter((row) => row.kind === "line")).toHaveLength(1_000);
+    expect(ordinaryRows.at(-1)).toMatchObject({
+      kind: "line",
+      newLineNumber: 1_000,
+      content: "const value999 = 999;",
+    });
+    expect(ordinaryRows.some((row) => row.kind === "notice")).toBe(false);
+  });
+
+  it("omits comments beyond the excerpt and retains overlapping ranges at its boundary", () => {
+    const diff = buildReviewParsedDiff(singleFilePatch("example.ts", 3_000), "excerpt-comments");
+    const visible = { ...makeComment("Visible"), id: "visible", startIndex: 10, endIndex: 10 };
+    const overlapping = {
+      ...makeComment("Overlapping"),
+      id: "overlapping",
+      startIndex: 1_998,
+      endIndex: 2_001,
+      rangeLabel: "+1999 to +2002",
+    };
+    const omitted = {
+      ...makeComment("Outside excerpt"),
+      id: "omitted",
+      startIndex: 1_999,
+      endIndex: 1_999,
+      rangeLabel: "+2000",
+    };
+    const data = getCachedNativeReviewDiffData({
+      parsedDiff: diff,
+      comments: [visible, overlapping, omitted],
+    });
+
+    const visibleIndex = data.rows.findIndex((row) => row.id === visible.id);
+    expect(data.rows[visibleIndex - 1]).toMatchObject({ kind: "line", newLineNumber: 11 });
+    const overlappingIndex = data.rows.findIndex((row) => row.id === overlapping.id);
+    expect(data.rows[overlappingIndex - 1]).toMatchObject({ kind: "line", newLineNumber: 1_999 });
+    expect(data.rows[overlappingIndex]).toMatchObject({
+      commentRangeLabel: overlapping.rangeLabel,
+      commentText: overlapping.text,
+    });
+    expect(data.rows.filter((row) => row.kind === "comment").map((row) => row.id)).toEqual([
+      visible.id,
+      overlapping.id,
+    ]);
+    expect(data.rows[overlappingIndex + 1]).toMatchObject({ kind: "notice" });
+    expect(getCachedNativeReviewDiffData({ parsedDiff: diff }).rows).toEqual(
+      data.rows.filter((row) => row.kind !== "comment"),
+    );
+  });
+});
+
 describe("createNativeReviewDiffTheme", () => {
   it("serializes every native color as cross-platform opaque hex", () => {
     for (const themeId of MOBILE_THEME_IDS) {
diff --git a/apps/mobile/src/features/review/nativeReviewDiffAdapter.ts b/apps/mobile/src/features/review/nativeReviewDiffAdapter.ts
index f09206703298c..7e10d2024cedc 100644
--- a/apps/mobile/src/features/review/nativeReviewDiffAdapter.ts
+++ b/apps/mobile/src/features/review/nativeReviewDiffAdapter.ts
@@ -19,6 +19,9 @@ import type { ReviewInlineComment } from "./reviewCommentSelection";
 
 const NATIVE_REVIEW_MAX_WORD_DIFF_RANGE_COUNT = 4;
 const NATIVE_REVIEW_MAX_WORD_DIFF_COVERAGE = 0.45;
+// Bound the rows serialized to the native heap before mapping and word matching.
+const NATIVE_REVIEW_MAX_FILE_ROWS = 2_000;
+const TRUNCATED_FILE_NOTICE = "This diff is too large to show in full.";
 const NATIVE_HEX_COLOR = /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?$/i;
 const NATIVE_RGBA_COLOR =
   /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/;
@@ -131,6 +134,7 @@ interface PreparedNativeReviewFileRows {
   readonly fileId: string;
   readonly filePath: string;
   readonly lineCount: number;
+  readonly truncated: boolean;
   readonly rows: ReadonlyArray<NativeReviewDiffRow>;
   readonly commentTargetsByRowId: ReadonlyMap<string, NativeReviewDiffCommentTarget>;
   readonly rowIdByCommentLineId: ReadonlyMap<string, string>;
@@ -435,9 +439,13 @@ function prepareFileRows(file: ReviewRenderableFile): PreparedNativeReviewFileRo
     },
   ];
 
-  const lineRows = file.rows.filter((row): row is ReviewRenderableLineRow => row.kind === "line");
+  const sourceRows =
+    file.rows.length > NATIVE_REVIEW_MAX_FILE_ROWS
+      ? file.rows.slice(0, NATIVE_REVIEW_MAX_FILE_ROWS)
+      : file.rows;
+  const lineRows = sourceRows.filter((row): row is ReviewRenderableLineRow => row.kind === "line");
   let lineIndex = 0;
-  file.rows.forEach((row, rowIndex) => {
+  sourceRows.forEach((row, rowIndex) => {
     if (row.kind === "hunk") {
       rows.push({
         kind: "hunk",
@@ -459,11 +467,15 @@ function prepareFileRows(file: ReviewRenderableFile): PreparedNativeReviewFileRo
     lineIndex += 1;
   });
 
+  if (sourceRows !== file.rows) {
+    rows.push(createNoticeRow(file.id, "truncated", TRUNCATED_FILE_NOTICE));
+  }
   rows.push(...noticeRowsForFile(file));
   const prepared: PreparedNativeReviewFileRows = {
     fileId: file.id,
     filePath: file.path,
     lineCount: lineRows.length,
+    truncated: sourceRows !== file.rows,
     // Comments must not split the source deletion/addition runs used for word matching.
     rows: addNativeWordDiffRanges(rows),
     commentTargetsByRowId,
@@ -489,6 +501,7 @@ function insertFileComments(
 
   const commentsByEndIndex = new Map<number, ReviewInlineComment[]>();
   for (const comment of comments) {
+    if (file.truncated && comment.startIndex >= file.lineCount) continue;
     const endIndex = Math.min(comment.endIndex, file.lineCount - 1);
     if (endIndex < 0) continue;
     const existing = commentsByEndIndex.get(endIndex);
diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
index ff02b9db8a59d..d1c18a4ebbcde 100644
--- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
@@ -1473,11 +1473,11 @@ export function NewTaskDraftScreen(props: {
       <View className="flex-row flex-wrap items-center justify-center gap-x-1">
         <ComposerInlineControl
           accessibilityHint="Opens the project picker"
-          accessibilityLabel="Choose a project"
+          accessibilityLabel="No project"
           chevronDirection="right"
           disabled={isComposerInteractionLocked}
           icon="folder"
-          label="Choose a project"
+          label="No project"
           onPress={chooseProject}
         />
         {environmentControl}
diff --git a/apps/mobile/src/features/threads/PendingUserInputCard.tsx b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
index 6be28f295d638..b7fb9a107df7d 100644
--- a/apps/mobile/src/features/threads/PendingUserInputCard.tsx
+++ b/apps/mobile/src/features/threads/PendingUserInputCard.tsx
@@ -2,7 +2,7 @@ import { Button } from "../../components/ui/Button";
 import { QuestionAttachments } from "./QuestionAttachments";
 import type { RuntimeRequestId } from "@t3tools/contracts";
 import type { ThreadUserInputQuestion } from "@t3tools/client-runtime/state/thread-requests";
-import { useCallback, useRef } from "react";
+import { useCallback, useRef, useState } from "react";
 import { Platform, Pressable, ScrollView, View, type LayoutChangeEvent } from "react-native";
 import Animated, {
   Easing,
@@ -79,6 +79,22 @@ function QuestionText(props: { readonly markdown: string }) {
 }
 
 export function PendingUserInputCard(props: PendingUserInputCardProps) {
+  const [focusedOption, setFocusedOption] = useState<{
+    requestId: RuntimeRequestId;
+    questionId: string;
+    optionIndex: number;
+  } | null>(null);
+  const focusedQuestion = props.pendingUserInput.questions.find(
+    (question) => question.id === focusedOption?.questionId,
+  );
+  if (
+    focusedOption &&
+    (focusedOption.requestId !== props.pendingUserInput.requestId ||
+      !focusedQuestion ||
+      (props.drafts[focusedQuestion.id]?.customAnswer?.trim().length ?? 0) > 0)
+  ) {
+    setFocusedOption(null);
+  }
   const questionCount = props.pendingUserInput.questions.length;
   const canRespond = props.pendingUserInput.responseCapability !== "not_resumable";
   const isResponding = props.respondingUserInputId === props.pendingUserInput.requestId;
@@ -238,6 +254,19 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
         ) : null}
         {props.pendingUserInput.questions.map((question) => {
           const draft = props.drafts[question.id];
+          const customAnswerActive = (draft?.customAnswer?.trim().length ?? 0) > 0;
+          const selectedOptionValue = draft?.selectedOptionValues?.at(-1);
+          const savedOptionMatches = question.options.filter(
+            (option) => (option.value ?? option.label.trim()) === selectedOptionValue,
+          );
+          const previewOption = customAnswerActive
+            ? undefined
+            : focusedOption?.requestId === props.pendingUserInput.requestId &&
+                focusedOption.questionId === question.id
+              ? question.options[focusedOption.optionIndex]
+              : savedOptionMatches.length === 1
+                ? savedOptionMatches[0]
+                : undefined;
           return (
             <View key={question.id} className="gap-2 pt-1">
               <Text className="font-t3-bold text-xs uppercase tracking-[1px] text-foreground-muted">
@@ -245,14 +274,16 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
               </Text>
               <QuestionText markdown={question.question} />
               <View className="gap-2">
-                {question.options.map((option) => {
+                {question.options.map((option, optionIndex) => {
                   const optionValue = option.value ?? option.label.trim();
                   const selected = isPendingUserInputOptionSelected(question, draft, optionValue);
                   const description =
                     option.description !== option.label ? option.description : undefined;
                   return (
                     <Pressable
-                      key={optionValue}
+                      // Options keep their positions within a question and may share answer values.
+                      // oxlint-disable-next-line react/no-array-index-key
+                      key={`${question.id}:${optionIndex}`}
                       accessibilityRole={question.multiSelect ? "checkbox" : "radio"}
                       accessibilityState={{ checked: selected, disabled: responseDisabled }}
                       disabled={responseDisabled}
@@ -260,13 +291,18 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
                         "min-h-12 w-full rounded-2xl border px-3.5 py-3",
                         selected ? "border-primary bg-primary/10" : "border-border bg-input",
                       )}
-                      onPress={() =>
+                      onPress={() => {
+                        setFocusedOption({
+                          requestId: props.pendingUserInput.requestId,
+                          questionId: question.id,
+                          optionIndex,
+                        });
                         props.onSelectOption(
                           props.pendingUserInput.requestId,
                           question,
                           optionValue,
-                        )
-                      }
+                        );
+                      }}
                     >
                       <View className="min-w-0 flex-1 gap-0.5">
                         <Text
@@ -287,6 +323,14 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
                   );
                 })}
               </View>
+              {previewOption?.preview?.trim() ? (
+                <View className="gap-1.5 rounded-2xl border border-border bg-input p-3.5">
+                  <Text className="font-t3-bold text-xs text-foreground-muted">
+                    Preview · {previewOption.label}
+                  </Text>
+                  <QuestionText markdown={previewOption.preview} />
+                </View>
+              ) : null}
               {question.allowCustomAnswer !== false ? (
                 <QuestionAttachments
                   requestId={props.pendingUserInput.requestId}
@@ -294,9 +338,14 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
                   questions={props.pendingUserInput.questions}
                   disabled={responseDisabled}
                   value={draft?.customAnswer ?? ""}
-                  onChangeText={(value) =>
-                    props.onChangeCustomAnswer(props.pendingUserInput.requestId, question.id, value)
-                  }
+                  onChangeText={(value) => {
+                    setFocusedOption(null);
+                    props.onChangeCustomAnswer(
+                      props.pendingUserInput.requestId,
+                      question.id,
+                      value,
+                    );
+                  }}
                   onInputFocusChange={props.onInputFocusChange}
                 />
               ) : null}
diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx
index 705772f054fab..1619612a5aef3 100644
--- a/apps/mobile/src/features/threads/ThreadComposer.tsx
+++ b/apps/mobile/src/features/threads/ThreadComposer.tsx
@@ -170,6 +170,7 @@ export interface ThreadComposerProps {
   } | null;
   readonly followUpBehavior: FollowUpBehavior;
   readonly canSteerActiveTurn: boolean;
+  readonly hidden: boolean;
   readonly editorRef?: RefObject<ComposerEditorHandle | null>;
   readonly onChangeDraftMessage: (value: string) => void;
   readonly onPickDraftMedia: () => Promise<void>;
@@ -819,6 +820,7 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
               layout={COMPOSER_LAYOUT_TRANSITION}
             >
               <ComposerEditor
+                hidden={props.hidden}
                 draftKey={composerDraftKey}
                 environmentId={props.environmentId}
                 onOpenMention={(path) => {
@@ -835,7 +837,8 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
                 ref={inputRef}
                 multiline
                 value={draftMessage}
-                readOnly={voiceInput.freezesEditor}
+                // The save uses a draft snapshot; further typing would be discarded on success.
+                readOnly={voiceInput.freezesEditor || queuedEdit?.saving === true}
                 skills={composerMenu.skills}
                 selection={composerMenu.selection}
                 onChangeText={props.onChangeDraftMessage}
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index ac22a8b7d9e10..272864c5e718b 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -493,16 +493,13 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
   const [anchorMessageId, setAnchorMessageId] = useState<MessageId | null>(null);
   const [submittedMessageId, setSubmittedMessageId] = useState<MessageId | null>(null);
   const [endFollowEnabled, setEndFollowEnabled] = useState(true);
-  // Android keys the safe-area padding on keyboard visibility (#5988): the back gesture closes
-  // the keyboard while the editor stays focused, and a focus-keyed inset would leave the toolbar
-  // under the gesture bar. iOS must NOT use visibility — it only flips on keyboardDidHide, after
-  // the hide animation, so the composer would ride down flush to the screen edge and then snap up
-  // into the inset.
-  const composerBottomInset = (
-    Platform.OS === "android" ? isKeyboardVisible : composerExpanded || composerFocused
-  )
-    ? 0
-    : Math.max(insets.bottom, 12);
+  // Android Back hides the keyboard without blurring. Keep its safe-area padding
+  // fixed through the animation and cancel it with matching composer/list offsets.
+  const composerBottomInset =
+    Platform.OS === "ios" && (composerExpanded || composerFocused)
+      ? 0
+      : Math.max(insets.bottom, 12);
+  const composerKeyboardOffset = Platform.OS === "android" ? composerBottomInset : 0;
   const contentPresentationKind = props.contentPresentation.kind;
   const realThreadSyncLabel = (() => {
     switch (props.threadSyncStatus) {
@@ -1145,6 +1142,7 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
               anchorMessageId={anchorMessageId}
               submittedMessageId={submittedMessageId}
               contentInsetEndAdjustment={combinedContentInsetEndAdjustment}
+              keyboardOffset={composerKeyboardOffset}
               contentTopInset={0}
               contentBottomInset={
                 estimatedOverlayHeight +
@@ -1180,12 +1178,11 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
 
       {showContent ? (
         <KeyboardStickyView
-          // iOS emits a native animated height target on both will-show and
-          // will-hide, so stay subscribed for the full transition.
-          enabled={Platform.OS === "ios" || (isKeyboardVisible && !keyboardStateSuspect)}
+          // Waiting for a visibility render misses the first keyboard frames.
+          enabled={Platform.OS === "ios" || !keyboardStateSuspect}
           pointerEvents="box-none"
           style={{ position: "absolute", bottom: 0, left: 0, right: 0, top: 0 }}
-          offset={{ closed: 0, opened: 0 }}
+          offset={{ closed: 0, opened: composerKeyboardOffset }}
         >
           <ComposerPopoverHost hidden={composerSlotHidden} popoverHeight={composerPopoverHeight}>
             {/* The fixed sticky host gives this bottom-anchored child a stable
@@ -1357,10 +1354,6 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
                   ) : null}
                 </View>
 
-                {/*
-                 * Hidden (not unmounted) while a user-input request owns the composer slot, so
-                 * composer drafts and editor state survive.
-                 */}
                 <View style={composerSlotHidden ? { display: "none" } : undefined}>
                   {isProviderSubagent ? (
                     <View
@@ -1426,6 +1419,7 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
                         draftKey={props.composerDraftKey ?? undefined}
                         followUpBehavior={props.followUpBehavior}
                         canSteerActiveTurn={props.canSteerActiveTurn}
+                        hidden={composerSlotHidden}
                         queuedEdit={
                           props.queuedRunEdit === null
                             ? null
diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx
index 293f6aceac63e..46d9fccac17f9 100644
--- a/apps/mobile/src/features/threads/ThreadFeed.tsx
+++ b/apps/mobile/src/features/threads/ThreadFeed.tsx
@@ -304,6 +304,7 @@ export interface ThreadFeedProps {
   readonly anchorMessageId: MessageId | null;
   readonly submittedMessageId: MessageId | null;
   readonly contentInsetEndAdjustment: SharedValue<number>;
+  readonly keyboardOffset: number;
   readonly contentTopInset?: number;
   readonly contentBottomInset?: number;
   readonly historyControls?: ThreadFeedHistoryControls;
@@ -1996,6 +1997,8 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
     themeAppearance,
     userBubbleColor,
     viewportWidth,
+    contentWidth,
+    skills: props.skills,
     workflowOpening,
   };
   const reportHeaderMaterialVisibility = (visible: boolean) => {
@@ -2468,6 +2471,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
             // content rest below the transparent header rather than at frame top.
             contentInsetStartAdjustment={usesNativeAutomaticInsets ? anchorTopInset : 0}
             contentInsetEndAdjustment={props.contentInsetEndAdjustment}
+            keyboardOffset={props.keyboardOffset}
             // UIKit's automatic behavior adds the safe-area bottom on top of the
             // raw contentInset the keyboard integration writes. The detail screen
             // under-reports the composer inset by this amount (see
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 1da765bc775fc..27754c86dadc4 100644
--- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx
+++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
@@ -453,13 +453,17 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
     canReadFiles && selectedProject !== null && selectedProject.workspaceRoot !== ""
       ? projectEnvironment.readFile({
           environmentId: selectedProject.environmentId,
-          input: { cwd: selectedProject.workspaceRoot, relativePath: T3_PROJECT_FILE_NAME },
+          input: {
+            cwd: selectedProject.workspaceRoot,
+            relativePath: T3_PROJECT_FILE_NAME,
+            allowMissing: true,
+          },
         })
       : null,
   );
   const t3ProjectFileData = t3ProjectFileQuery.data as ProjectReadFileResult | null;
   const t3ProjectFile =
-    t3ProjectFileData === null || t3ProjectFileData.truncated
+    t3ProjectFileData === null || t3ProjectFileData.exists === false || t3ProjectFileData.truncated
       ? null
       : parseT3ProjectFile(t3ProjectFileData.contents);
   const projectSettings = resolveProjectSettings(
diff --git a/apps/mobile/src/features/threads/sidebar-native-header-items.ts b/apps/mobile/src/features/threads/sidebar-native-header-items.ts
index cfbaf755e89a4..c2f309a011edb 100644
--- a/apps/mobile/src/features/threads/sidebar-native-header-items.ts
+++ b/apps/mobile/src/features/threads/sidebar-native-header-items.ts
@@ -31,23 +31,30 @@ function toNativeHeaderMenuItems(items: HomeListFilterMenu["items"]): NativeHead
   );
 }
 
+export function createSidebarFilterHeaderItem(input: {
+  readonly filterIcon: string;
+  readonly filterMenu: HomeListFilterMenu;
+}): NativeStackHeaderItemMenu {
+  return withNativeGlassHeaderItem({
+    type: "menu",
+    axisBehavior: "horizontalOnly",
+    label: "",
+    accessibilityLabel: "Filter threads",
+    icon: sfSymbolIcon(input.filterIcon),
+    menu: {
+      title: input.filterMenu.title,
+      items: toNativeHeaderMenuItems(input.filterMenu.items),
+    },
+  });
+}
+
 export function createSidebarHeaderItems(input: {
   readonly filterIcon: string;
   readonly filterMenu: HomeListFilterMenu;
   readonly onOpenSettings: () => void;
 }): NativeStackHeaderItem[] {
   return [
-    withNativeGlassHeaderItem({
-      type: "menu",
-      axisBehavior: "horizontalOnly",
-      label: "",
-      accessibilityLabel: "Filter threads",
-      icon: sfSymbolIcon(input.filterIcon),
-      menu: {
-        title: input.filterMenu.title,
-        items: toNativeHeaderMenuItems(input.filterMenu.items),
-      },
-    }),
+    createSidebarFilterHeaderItem(input),
     withNativeGlassHeaderItem({
       type: "button",
       axisBehavior: "horizontalOnly",
diff --git a/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx b/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
index 6e7977e928a8a..3e7d852be7554 100644
--- a/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
+++ b/apps/mobile/src/features/voice-input/ComposerDictationControl.tsx
@@ -13,6 +13,7 @@ import Animated, {
   LinearTransition,
   ReduceMotion,
   useAnimatedStyle,
+  useReducedMotion,
   useSharedValue,
   withTiming,
   type EntryExitAnimationFunction,
@@ -135,14 +136,19 @@ export function ComposerDictationToolbar(props: {
   readonly showsDictation: boolean;
   readonly visible?: boolean;
 }) {
+  // Android can drop the reduced-motion flip's final frame, leaving the toolbar invisible.
+  const reducedMotion = useReducedMotion();
+  const entering = props.showsDictation ? DICTATION_TOOLBAR_ENTERING : DRAFT_TOOLBAR_ENTERING;
+  const exiting = props.showsDictation ? DICTATION_TOOLBAR_EXITING : DRAFT_TOOLBAR_EXITING;
+
   return (
     <View className="relative h-[44px] overflow-hidden">
       {props.visible !== false ? (
         <Animated.View
           key={props.showsDictation ? "dictation" : "draft"}
           className="absolute inset-0"
-          entering={props.showsDictation ? DICTATION_TOOLBAR_ENTERING : DRAFT_TOOLBAR_ENTERING}
-          exiting={props.showsDictation ? DICTATION_TOOLBAR_EXITING : DRAFT_TOOLBAR_EXITING}
+          entering={reducedMotion ? undefined : entering}
+          exiting={reducedMotion ? undefined : exiting}
           style={{ backfaceVisibility: "hidden" }}
         >
           {props.children}
diff --git a/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx b/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
index 3f6dc6415e206..98040a69c0f43 100644
--- a/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
+++ b/apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx
@@ -112,6 +112,7 @@ function WorkspaceRootContent() {
               headerShown: true,
               unstable_headerLeftItems: () => [],
               headerTitle: renderHeaderTitle,
+              ...(state.selectedTab === "threads" ? {} : { nativeSidebarFilter: undefined }),
             }}
           />
         ) : (
diff --git a/apps/mobile/src/native/StackHeader.tsx b/apps/mobile/src/native/StackHeader.tsx
index 3b1fb0be06fa7..8240fbc74df44 100644
--- a/apps/mobile/src/native/StackHeader.tsx
+++ b/apps/mobile/src/native/StackHeader.tsx
@@ -1,5 +1,6 @@
 import { useNavigation, type ParamListBase } from "@react-navigation/native";
 import type {
+  NativeStackHeaderItemMenu,
   NativeStackNavigationOptions,
   NativeStackNavigationProp,
 } from "@react-navigation/native-stack";
@@ -19,6 +20,7 @@ export type AppNativeStackNavigationOptions = Omit<
   "headerTintColor" | "unstable_headerLeftItems" | "unstable_headerRightItems"
 > & {
   readonly nativeContentInsetHorizontally?: boolean;
+  readonly nativeSidebarFilter?: NativeStackHeaderItemMenu;
   readonly headerTintColor?: string | ColorValue;
   readonly unstable_headerCenterItems?: unknown;
   readonly unstable_headerLeftItems?: unknown;
diff --git a/apps/mobile/src/native/V5StackHeader.ios.tsx b/apps/mobile/src/native/V5StackHeader.ios.tsx
index 495492b9b55dc..85419d80353e5 100644
--- a/apps/mobile/src/native/V5StackHeader.ios.tsx
+++ b/apps/mobile/src/native/V5StackHeader.ios.tsx
@@ -140,21 +140,30 @@ export function V5StackHeader(props: {
   readonly options: Options;
   readonly canGoBack: boolean;
   readonly primary?: boolean;
+  readonly sidebarFilter?: NativeStackHeaderItemMenu;
 }) {
   const { options } = props;
   const theme = useMobileNavigationTheme();
   const nativeMetrics = useNativeLayoutMetrics();
   const deviceType = useDeviceType();
   const searchRef = useRef<SearchBarCommands>(null);
+  const usesDuoToolbarRail =
+    deviceType === "duo-unfolded" && (nativeMetrics?.verticalBarEdge ?? "none") !== "none";
   const itemProps = { tintColor: options.headerTintColor, canGoBack: props.canGoBack };
   const leading = convertItems(options.unstable_headerLeftItems?.(itemProps) ?? [], "leading");
-  const trailing = convertItems(
-    [
-      ...(options.unstable_headerCenterItems?.() ?? []),
-      ...(options.unstable_headerRightItems?.(itemProps) ?? []),
-    ],
-    "trailing",
-  );
+  const trailingItems = [
+    ...(options.unstable_headerCenterItems?.() ?? []),
+    ...(options.unstable_headerRightItems?.(itemProps) ?? []),
+  ];
+  // Keep the sidebar's filter actions when UIKit moves the menu to the detail rail.
+  if (usesDuoToolbarRail && !props.primary && props.sidebarFilter) {
+    trailingItems.push({
+      ...props.sidebarFilter,
+      identifier: "home-filter",
+      axisBehavior: "verticalPreferred",
+    });
+  }
+  const trailing = convertItems(trailingItems, "trailing");
   const toolbar = options.unstable_headerToolbarItems?.() ?? [];
   const mailSearch = toolbar.find(
     (item): item is HeaderBarButtonMailSearchToolbarItem => item.type === "mailSearchToolbar",
diff --git a/apps/mobile/src/state/use-pull-to-refresh.ts b/apps/mobile/src/state/use-pull-to-refresh.ts
index cf29eefa9307f..98686da323462 100644
--- a/apps/mobile/src/state/use-pull-to-refresh.ts
+++ b/apps/mobile/src/state/use-pull-to-refresh.ts
@@ -17,24 +17,36 @@ export function usePullToRefresh<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A
     [atom],
   );
 
-  const onRefresh = useCallback(() => {
-    if (!atom || (request.current?.atom === atom && !request.current.controller.signal.aborted))
-      return;
-    request.current?.controller.abort();
-    const controller = new AbortController();
-    request.current = { atom, controller };
-    setRefreshingAtom(atom);
-    void executeAtomQuery(registry, atom, {
-      refresh: true,
-      signal: controller.signal,
-      reportFailure: false,
-      reportDefect: false,
-    }).finally(() => {
-      if (controller.signal.aborted || request.current?.controller !== controller) return;
-      request.current = null;
-      setRefreshingAtom(null);
-    });
-  }, [atom, registry]);
+  const onRefresh = useCallback(
+    (beforeRefresh?: (signal: AbortSignal) => Promise<unknown>) => {
+      if (!atom || (request.current?.atom === atom && !request.current.controller.signal.aborted))
+        return;
+      request.current?.controller.abort();
+      const controller = new AbortController();
+      request.current = { atom, controller };
+      setRefreshingAtom(atom);
+      void Promise.resolve()
+        .then(() => {
+          if (!controller.signal.aborted) return beforeRefresh?.(controller.signal);
+        })
+        .catch(() => undefined)
+        .then(() => {
+          if (controller.signal.aborted) return;
+          return executeAtomQuery(registry, atom, {
+            refresh: true,
+            signal: controller.signal,
+            reportFailure: false,
+            reportDefect: false,
+          });
+        })
+        .finally(() => {
+          if (controller.signal.aborted || request.current?.controller !== controller) return;
+          request.current = null;
+          setRefreshingAtom(null);
+        });
+    },
+    [atom, registry],
+  );
 
   return { refreshing: atom !== null && refreshingAtom === atom, onRefresh };
 }
diff --git a/apps/mobile/src/widgets/AgentActivity.tsx b/apps/mobile/src/widgets/AgentActivity.tsx
index 02c2a13930695..4c28fb0d8f745 100644
--- a/apps/mobile/src/widgets/AgentActivity.tsx
+++ b/apps/mobile/src/widgets/AgentActivity.tsx
@@ -158,6 +158,7 @@ export function AgentActivity(
     deepLinkRow && deepLinkRow.deepLink.startsWith("/") && !deepLinkRow.deepLink.startsWith("//")
       ? `t3code://${deepLinkRow.deepLink.slice(1)}`
       : null;
+  const linkModifiers = deepLink ? [widgetURL(deepLink)] : [];
 
   type SFName = NonNullable<ComponentProps<typeof Image>["systemName"]>;
   const phaseSymbol = (phase: AgentActivityPhase): SFName => {
@@ -182,8 +183,15 @@ export function AgentActivity(
 
   // SF Symbols, like the logo, ignore frame/foregroundStyle applied directly to
   // the image; size + tint them through a container the resizable symbol fills.
-  const renderGlyph = (systemName: SFName, size: number, color: Foreground) => (
-    <HStack modifiers={[frame({ width: size, height: size }), foregroundStyle(color)]}>
+  const renderGlyph = (
+    systemName: SFName,
+    size: number,
+    color: Foreground,
+    modifiers: typeof linkModifiers = [],
+  ) => (
+    <HStack
+      modifiers={[frame({ width: size, height: size }), foregroundStyle(color), ...modifiers]}
+    >
       <Image systemName={systemName} modifiers={[resizable()]} />
     </HStack>
   );
@@ -223,8 +231,10 @@ export function AgentActivity(
   // dropped), so we size it via a container frame the resizable image fills and
   // tint it through the container's foreground style, which the template image
   // inherits.
-  const renderLogo = (height: number, color: Foreground) => (
-    <HStack modifiers={[frame({ width: height * 1.5, height }), foregroundStyle(color)]}>
+  const renderLogo = (height: number, color: Foreground, modifiers: typeof linkModifiers = []) => (
+    <HStack
+      modifiers={[frame({ width: height * 1.5, height }), foregroundStyle(color), ...modifiers]}
+    >
       <Image assetName="T3Mark" modifiers={[resizable()]} />
     </HStack>
   );
@@ -315,9 +325,15 @@ export function AgentActivity(
         ) : null}
       </VStack>
     ),
-    compactLeading: renderLogo(14, tint),
+    compactLeading: renderLogo(14, tint, linkModifiers),
     compactTrailing: (
-      <Text modifiers={[font({ weight: "semibold", size: 11 }), foregroundStyle(tint)]}>
+      <Text
+        modifiers={[
+          font({ weight: "semibold", size: 11 }),
+          foregroundStyle(tint),
+          ...linkModifiers,
+        ]}
+      >
         {attentionRow
           ? attentionRow.phase === "waiting_for_approval"
             ? "Approval"
@@ -327,8 +343,8 @@ export function AgentActivity(
     ),
     minimal:
       (attentionRow || failedRow || allDone) && heroRow
-        ? renderGlyph(phaseSymbol(heroRow.phase), 13, phaseTint(heroRow.phase))
-        : renderLogo(11, tint),
+        ? renderGlyph(phaseSymbol(heroRow.phase), 13, phaseTint(heroRow.phase), linkModifiers)
+        : renderLogo(11, tint, linkModifiers),
     expandedLeading: (
       <HStack spacing={5} alignment="center" modifiers={[padding({ leading: 4, vertical: 4 })]}>
         {renderLogo(15, tint)}
diff --git a/apps/server/src/cli/update.test.ts b/apps/server/src/cli/update.test.ts
index 67ae3bfa53219..48c7c3a4f44cb 100644
--- a/apps/server/src/cli/update.test.ts
+++ b/apps/server/src/cli/update.test.ts
@@ -10,15 +10,68 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import { Command } from "effect/cli";
+import { HttpClient, HttpClientResponse } from "effect/http";
 import { afterEach, vi } from "vite-plus/test";
 
 import packageJson from "../../package.json" with { type: "json" };
 import * as BootService from "../cloud/bootService.ts";
 import { pinnedRuntimePaths } from "../cloud/pinnedRuntime.ts";
-import { repointLauncher, resolveLauncherPath, updateCommand } from "./update.ts";
+import {
+  repointLauncher,
+  resolveLauncherPath,
+  resolveNewestVersion,
+  updateCommand,
+} from "./update.ts";
 
 afterEach(() => vi.restoreAllMocks());
 
+it.effect.each([
+  { environment: { GH_TOKEN: " gh-token ", GITHUB_TOKEN: "github-token" }, token: "gh-token" },
+  { environment: { GH_TOKEN: "  ", GITHUB_TOKEN: " github-token " }, token: "github-token" },
+  { environment: { GITHUB_TOKEN: "github-token" }, token: "github-token" },
+  { environment: { GH_TOKEN: "  ", GITHUB_TOKEN: "  " }, token: undefined },
+  { environment: {}, token: undefined },
+])("selects release authentication from $environment", ({ environment, token }) =>
+  Effect.gen(function* () {
+    const authorizations: Array<string | undefined> = [];
+    const httpClient = HttpClient.make((request) => {
+      authorizations.push(request.headers.authorization);
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(request, Response.json([{ tag_name: "v1.2.3" }])),
+      );
+    });
+    const version = yield* resolveNewestVersion("stable").pipe(
+      Effect.provideService(HostProcess.Environment, environment),
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+    );
+    assert.equal(version, "1.2.3");
+    assert.deepStrictEqual(authorizations, [token === undefined ? undefined : `Bearer ${token}`]);
+  }),
+);
+
+it.effect("authenticates each release page until the requested channel is found", () =>
+  Effect.gen(function* () {
+    const pages: string[] = [];
+    const httpClient = HttpClient.make((request) => {
+      const url = new URL(request.url);
+      assert.equal(url.origin, "https://api.github.com");
+      assert.equal(url.pathname, "/repos/pingdotgg/t3code/releases");
+      assert.equal(request.headers.accept, "application/vnd.github+json");
+      assert.equal(request.headers.authorization, "Bearer gh-token");
+      const page = url.searchParams.get("page") ?? "";
+      pages.push(page);
+      const tag_name = page === "1" ? "v1.2.4-preview.20260101.1" : "v1.2.3";
+      return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json([{ tag_name }])));
+    });
+    const version = yield* resolveNewestVersion("stable").pipe(
+      Effect.provideService(HostProcess.Environment, { GH_TOKEN: "gh-token" }),
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+    );
+    assert.equal(version, "1.2.3");
+    assert.deepStrictEqual(pages, ["1", "2"]);
+  }),
+);
+
 it.layer(NodeServices.layer)("t3 update launcher", (it) => {
   it.effect("repoints a symlink that lives in a runtime versions tree", () =>
     Effect.gen(function* () {
diff --git a/apps/server/src/cli/update.ts b/apps/server/src/cli/update.ts
index 3d18f8015a298..9a35a47424e4d 100644
--- a/apps/server/src/cli/update.ts
+++ b/apps/server/src/cli/update.ts
@@ -52,27 +52,29 @@ const decodeReleaseIndex = Schema.decodeUnknownEffect(Schema.fromJsonString(Rele
 const RELEASE_INDEX_TIMEOUT = Duration.seconds(30);
 const RELEASE_INDEX_MAX_PAGES = 10;
 
-const resolveNewestVersion = Effect.fn("cli.update.resolve_newest")(function* (
+export const resolveNewestVersion = Effect.fn("cli.update.resolve_newest")(function* (
   channel: CliReleaseChannel,
 ) {
   const httpClient = yield* HttpClient.HttpClient;
+  const environment = yield* HostProcess.Environment;
+  const githubToken = environment.GH_TOKEN?.trim() || environment.GITHUB_TOKEN?.trim() || undefined;
   for (let page = 1; page <= RELEASE_INDEX_MAX_PAGES; page += 1) {
-    const body = yield* httpClient
-      .execute(
-        HttpClientRequest.get(cliReleaseIndexPageUrl(page)).pipe(
-          HttpClientRequest.setHeader("Accept", "application/vnd.github+json"),
-        ),
-      )
-      .pipe(
-        Effect.flatMap(HttpClientResponse.filterStatusOk),
-        Effect.flatMap((response) => response.text),
-        Effect.mapError(() => new CliUpdateError({ reason: "Could not list t3 releases." })),
-        Effect.timeoutOrElse({
-          duration: RELEASE_INDEX_TIMEOUT,
-          orElse: () =>
-            Effect.fail(new CliUpdateError({ reason: "Timed out listing t3 releases." })),
-        }),
-      );
+    const request = HttpClientRequest.get(cliReleaseIndexPageUrl(page)).pipe(
+      HttpClientRequest.setHeader("Accept", "application/vnd.github+json"),
+    );
+    const authenticatedRequest =
+      githubToken === undefined
+        ? request
+        : HttpClientRequest.setHeader(request, "Authorization", `Bearer ${githubToken}`);
+    const body = yield* httpClient.execute(authenticatedRequest).pipe(
+      Effect.flatMap(HttpClientResponse.filterStatusOk),
+      Effect.flatMap((response) => response.text),
+      Effect.mapError(() => new CliUpdateError({ reason: "Could not list t3 releases." })),
+      Effect.timeoutOrElse({
+        duration: RELEASE_INDEX_TIMEOUT,
+        orElse: () => Effect.fail(new CliUpdateError({ reason: "Timed out listing t3 releases." })),
+      }),
+    );
     const releases = yield* decodeReleaseIndex(body).pipe(
       Effect.mapError(
         () => new CliUpdateError({ reason: "The t3 release index had an unexpected shape." }),
diff --git a/apps/server/src/cloud/CloudLink.ts b/apps/server/src/cloud/CloudLink.ts
index 3270f93baca9a..04c4cb5997c7e 100644
--- a/apps/server/src/cloud/CloudLink.ts
+++ b/apps/server/src/cloud/CloudLink.ts
@@ -2,6 +2,7 @@
 import * as NodeCrypto from "node:crypto";
 import {
   AuthStandardClientScopes,
+  EnvironmentAuthenticatedPrincipal,
   type EnvironmentCloudLinkStateResult,
   type EnvironmentCloudPreferencesRequest,
   type EnvironmentCloudRelayConfigResult,
@@ -417,14 +418,18 @@ export class CloudLink extends Context.Service<
   {
     /**
      * Signs the proof the relay asks for to link this environment. The request
-     * must reach this server directly on the loopback origin it names.
+     * must reach this server directly. Desktop bootstrap sessions may use the
+     * WSL IP; all other sessions must use the loopback origin they name.
      */
     readonly linkProof: (
       request: RelayLinkProofRequest,
       httpRequest: HttpServerRequest.HttpServerRequest,
     ) => Effect.Effect<
       RelayEnvironmentLinkProof,
-      CloudLinkOriginInvalidError | CloudLinkInternalError | EnvironmentAuth.ServerAuthInternalError
+      | CloudLinkOriginInvalidError
+      | CloudLinkInternalError
+      | EnvironmentAuth.ServerAuthInternalError,
+      EnvironmentAuthenticatedPrincipal
     >;
     readonly applyRelayConfig: (
       payload: RelayEnvironmentConfigRequest,
@@ -580,6 +585,7 @@ const make = Effect.gen(function* () {
   const makeCloudLinkProof = Effect.fn("environment.cloud.makeLinkProof")(function* (
     request: RelayLinkProofRequest,
     requestUrl: string,
+    allowNonLoopbackRequestHost = false,
   ) {
     const keyPair = yield* getOrCreateEnvironmentKeyPairFromSecretStore(secrets);
     if (
@@ -587,6 +593,7 @@ const make = Effect.gen(function* () {
       !isAllowedEndpointOrigin({
         origin: request.origin,
         requestUrl,
+        allowNonLoopbackRequestHost,
       })
     ) {
       return yield* new CloudLinkOriginInvalidError({ origin: "endpoint" });
@@ -630,8 +637,13 @@ const make = Effect.gen(function* () {
       if (requestUrl === null || hasForwardedAuthorityHeaders(httpRequest)) {
         return yield* new CloudLinkOriginInvalidError({ origin: "endpoint" });
       }
-      const proof = yield* makeCloudLinkProof(request, requestUrl);
-      return proof satisfies RelayEnvironmentLinkProof;
+      const principal = yield* EnvironmentAuthenticatedPrincipal;
+      // WSL desktop requests use the distro IP; only the server-issued bootstrap subject qualifies.
+      return yield* makeCloudLinkProof(
+        request,
+        requestUrl,
+        principal.subject === "desktop-bootstrap",
+      );
     },
     Effect.catchIf(ServerSecretStore.isSecretStoreError, internalError("generate-link-proof")),
     Effect.catchTags({ PlatformError: internalError("generate-link-proof") }),
diff --git a/apps/server/src/cloud/http.test.ts b/apps/server/src/cloud/http.test.ts
index 7b6a575c7db47..3e3aae1423c5f 100644
--- a/apps/server/src/cloud/http.test.ts
+++ b/apps/server/src/cloud/http.test.ts
@@ -1,18 +1,275 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { EnvironmentHttpApi } from "@t3tools/contracts";
 import { describe, expect, it } from "@effect/vitest";
+import {
+  AuthAccessTokenType,
+  AuthEnvironmentBootstrapTokenType,
+  AuthTokenExchangeGrantType,
+  EnvironmentHttpApi,
+  EnvironmentId,
+} from "@t3tools/contracts";
+import {
+  RelayEnvironmentLinkProofPayload,
+  type RelayLinkProofRequest,
+} from "@t3tools/contracts/relay";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { HttpClient, HttpServer } from "effect/http";
 import * as Etag from "effect/http/Etag";
 import * as HttpPlatform from "effect/http/HttpPlatform";
 import * as HttpRouter from "effect/http/HttpRouter";
 import * as HttpApi from "effect/http-api/HttpApi";
 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
+import * as NetAddress from "effect/net/NetAddress";
+import { decodeJwt, importSPKI, jwtVerify } from "jose";
+import { RELAY_LINK_PROOF_TYP } from "@t3tools/shared/relayJwt";
 
 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
 import * as AuthHttp from "../auth/http.ts";
+import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import * as ServerConfig from "../config.ts";
+import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
+import * as SqlitePersistence from "../persistence/Sqlite.ts";
+import * as AgentAwarenessRelay from "../relay/AgentAwarenessRelay.ts";
+import * as CliTokenManager from "./CliTokenManager.ts";
 import * as CloudLink from "./CloudLink.ts";
 import * as ConnectHttp from "./http.ts";
+import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts";
+
+const DESKTOP_BOOTSTRAP_TOKEN = "test-desktop-bootstrap-token";
+const NON_LOOPBACK_ORIGIN = "http://172.24.162.233:3773";
+const LOOPBACK_ORIGIN = "http://127.0.0.1:3773";
+const proofRequest: RelayLinkProofRequest = {
+  challenge: "test-challenge",
+  relayIssuer: "https://relay.example.test",
+  endpoint: {
+    providerKind: "cloudflare_tunnel",
+    httpBaseUrl: "https://environment.example.test",
+    wsBaseUrl: "wss://environment.example.test",
+  },
+  origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
+};
+const decodeLinkProofPayload = Schema.decodeUnknownSync(RelayEnvironmentLinkProofPayload);
+
+class LinkProofTestApi extends HttpApi.make("environment").add(
+  EnvironmentHttpApi.groups.auth,
+  EnvironmentHttpApi.groups.connect,
+) {}
+
+const layerConfig = Layer.effect(
+  ServerConfig.ServerConfig,
+  Effect.gen(function* () {
+    const config = yield* ServerConfig.ServerConfig;
+    return {
+      ...config,
+      mode: "desktop" as const,
+      host: "0.0.0.0",
+      port: 3773,
+      desktopBootstrapToken: DESKTOP_BOOTSTRAP_TOKEN,
+    };
+  }),
+).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-link-proof-test-" })));
+
+// Real credential issuance, verification, origin checks and signing; no relay or tunnel is started.
+const layerLinkProofRoutes = HttpApiBuilder.layer(LinkProofTestApi).pipe(
+  Layer.provide([AuthHttp.layer, ConnectHttp.layer]),
+  Layer.provide(AuthHttp.layerAuthenticatedAuth),
+  Layer.provide(CloudLink.layer),
+  Layer.provide(EnvironmentAuth.layer),
+  Layer.provide([
+    SqlitePersistence.layerMemory,
+    ServerEnvironment.layerIdentity,
+    Layer.mock(ServerEnvironment.ServerEnvironment)({
+      getDescriptor: Effect.succeed({
+        environmentId: EnvironmentId.make("wsl-environment"),
+        label: "WSL",
+        platform: { os: "linux", arch: "x64" },
+        serverVersion: "0.0.0-test",
+        capabilities: { repositoryIdentity: false },
+      }),
+    }),
+    Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({}),
+    Layer.mock(CliTokenManager.CloudCliTokenManager)({}),
+    Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({}),
+    Layer.mock(HttpServer.HttpServer)({
+      address: NetAddress.inetAddressFromIpStringUnsafe("0.0.0.0", 3773),
+    }),
+    Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make(() => Effect.die("Unexpected relay call")),
+    ),
+  ]),
+  Layer.provideMerge(ServerSecretStore.layer),
+  Layer.provide(layerConfig),
+  Layer.provideMerge(HttpPlatform.layer.pipe(Layer.provideMerge(Etag.layerWeak))),
+  Layer.provideMerge(NodeServices.layer),
+);
+
+const withLinkProofClient = async (
+  body: (client: {
+    post: (
+      path: string,
+      payload: unknown,
+      headers?: Record<string, string>,
+      origin?: string,
+    ) => Promise<Response>;
+    exchange: (credential: string, scope?: string) => Promise<string>;
+  }) => Promise<void>,
+) => {
+  const { handler, dispose } = HttpRouter.toWebHandler(layerLinkProofRoutes, {
+    disableLogger: true,
+  });
+  const post = (
+    path: string,
+    payload: unknown,
+    headers?: Record<string, string>,
+    origin = NON_LOOPBACK_ORIGIN,
+  ) =>
+    handler(
+      new Request(`${origin}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...headers },
+        body: JSON.stringify(payload),
+      }),
+    );
+  const exchange = async (credential: string, scope?: string) => {
+    const response = await handler(
+      new Request(`${NON_LOOPBACK_ORIGIN}/oauth/token`, {
+        method: "POST",
+        body: new URLSearchParams({
+          grant_type: AuthTokenExchangeGrantType,
+          subject_token: credential,
+          subject_token_type: AuthEnvironmentBootstrapTokenType,
+          requested_token_type: AuthAccessTokenType,
+          ...(scope ? { scope } : {}),
+        }),
+      }),
+    );
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as { access_token: string };
+    return payload.access_token;
+  };
+  try {
+    await body({ post, exchange });
+  } finally {
+    await dispose();
+  }
+};
+
+describe("link proof over a non-loopback desktop transport", () => {
+  it("signs a loopback tunnel origin after desktop bootstrap token exchange over a non-loopback host", () =>
+    withLinkProofClient(async ({ post, exchange }) => {
+      const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
+      const response = await post("/api/connect/link-proof", proofRequest, {
+        authorization: `Bearer ${token}`,
+      });
+      expect(response.status).toBe(200);
+      const proof = (await response.json()) as string;
+      const payload = decodeLinkProofPayload(decodeJwt(proof));
+      const verified = await jwtVerify(
+        proof,
+        await importSPKI(payload.environmentPublicKey, "EdDSA"),
+        {
+          algorithms: ["EdDSA"],
+          typ: RELAY_LINK_PROOF_TYP,
+          issuer: "t3-env:wsl-environment",
+          audience: proofRequest.relayIssuer,
+        },
+      );
+      expect(verified.payload).toMatchObject({
+        origin: proofRequest.origin,
+        endpoint: proofRequest.endpoint,
+        challenge: proofRequest.challenge,
+      });
+      expect(response.headers.get("cache-control")).toBe("no-store");
+    }));
+
+  it("does not pass desktop trust to a paired client or accept client-supplied provenance", () =>
+    withLinkProofClient(async ({ post, exchange }) => {
+      const desktop = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
+      const paired = await post(
+        "/api/auth/pairing-token",
+        {
+          scopes: ["relay:write"],
+          label: "desktop-bootstrap",
+          subject: "desktop-bootstrap",
+        },
+        { authorization: `Bearer ${desktop}` },
+      );
+      expect(paired.status).toBe(200);
+      const { credential } = (await paired.json()) as { credential: string };
+      const token = await exchange(credential);
+      const headers = { authorization: `Bearer ${token}`, "x-desktop-bootstrap": "true" };
+      const payload = {
+        ...proofRequest,
+        allowNonLoopbackRequestHost: true,
+        subject: "desktop-bootstrap",
+      };
+      const rejected = await post("/api/connect/link-proof", payload, headers);
+      expect(rejected.status).toBe(400);
+      expect(await rejected.json()).toMatchObject({ message: "Invalid managed endpoint origin." });
+      const loopback = await post(
+        "/api/connect/link-proof",
+        proofRequest,
+        headers,
+        LOOPBACK_ORIGIN,
+      );
+      expect(loopback.status).toBe(200);
+    }));
+
+  it.each([
+    {
+      name: "non-loopback tunnel origin",
+      origin: { localHttpHost: "172.24.162.233", localHttpPort: 3773 },
+      headers: {},
+    },
+    {
+      name: "mismatched port",
+      origin: { localHttpHost: "127.0.0.1", localHttpPort: 3774 },
+      headers: {},
+    },
+    {
+      name: "forwarded host",
+      origin: proofRequest.origin,
+      headers: { "x-forwarded-host": "127.0.0.1:3773" },
+    },
+    {
+      name: "forwarded protocol",
+      origin: proofRequest.origin,
+      headers: { "x-forwarded-proto": "http" },
+    },
+  ])("rejects $name even for desktop bootstrap", ({ origin, headers }) =>
+    withLinkProofClient(async ({ post, exchange }) => {
+      const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN);
+      const response = await post(
+        "/api/connect/link-proof",
+        { ...proofRequest, origin },
+        { ...headers, authorization: `Bearer ${token}` },
+      );
+      expect(response.status).toBe(400);
+      expect(await response.json()).toMatchObject({ message: "Invalid managed endpoint origin." });
+    }),
+  );
+
+  it("requires relay-write scope even for desktop bootstrap", () =>
+    withLinkProofClient(async ({ post, exchange }) => {
+      const token = await exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:read");
+      const response = await post("/api/connect/link-proof", proofRequest, {
+        authorization: `Bearer ${token}`,
+      });
+      expect(response.status).toBe(403);
+      expect(await response.json()).toMatchObject({
+        code: "insufficient_scope",
+        requiredScope: "relay:write",
+      });
+    }));
+
+  it("rejects unauthenticated requests", () =>
+    withLinkProofClient(async ({ post }) => {
+      const response = await post("/api/connect/link-proof", proofRequest);
+      expect(response.status).toBe(401);
+    }));
+});
 
 class ConnectTestApi extends HttpApi.make("environment").add(EnvironmentHttpApi.groups.connect) {}
 
diff --git a/apps/server/src/cloud/linkChecks.ts b/apps/server/src/cloud/linkChecks.ts
index 9882dcaf8f589..af26c659b4d98 100644
--- a/apps/server/src/cloud/linkChecks.ts
+++ b/apps/server/src/cloud/linkChecks.ts
@@ -82,13 +82,14 @@ export function parseManagedEndpointLocalOrigin(localOrigin: string) {
 export function isAllowedEndpointOrigin(input: {
   readonly origin: RelayManagedEndpointOrigin;
   readonly requestUrl: string;
+  readonly allowNonLoopbackRequestHost?: boolean;
 }): boolean {
   if (!isLoopbackHostname(input.origin.localHttpHost)) {
     return false;
   }
 
   const url = new URL(input.requestUrl);
-  if (!isLoopbackHostname(url.hostname)) {
+  if (!input.allowNonLoopbackRequestHost && !isLoopbackHostname(url.hostname)) {
     return false;
   }
 
diff --git a/apps/server/src/cloud/managedTunnelStartup.test.ts b/apps/server/src/cloud/managedTunnelStartup.test.ts
index e87f3e8e363e7..03d379a513f0b 100644
--- a/apps/server/src/cloud/managedTunnelStartup.test.ts
+++ b/apps/server/src/cloud/managedTunnelStartup.test.ts
@@ -1,13 +1,21 @@
 import { describe, expect, it } from "@effect/vitest";
+import * as Clock from "effect/Clock";
 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 TestClock from "effect/testing/TestClock";
 
 import {
+  MANAGED_TUNNEL_RECOVERY_COOLDOWN,
+  makeManagedTunnelRecovery,
   managedTunnelStartupAction,
+  nextManagedTunnelRecoveryCooldown,
+  relayRetrySchedule,
+  retryDesiredLinkReconcile,
   retryManagedTunnelRegistration,
 } from "./managedTunnelStartup.ts";
+import { RelayRequestError } from "./relayResponse.ts";
 
 describe("managedTunnelStartupAction", () => {
   const config = {
@@ -129,3 +137,201 @@ describe("retryManagedTunnelRegistration", () => {
     }),
   );
 });
+
+describe("nextManagedTunnelRecoveryCooldown", () => {
+  const minutes = (value: number) => Duration.minutes(value);
+
+  it("backs off while recoveries keep failing to fix the tunnel, up to 30 minutes", () => {
+    let cooldown = MANAGED_TUNNEL_RECOVERY_COOLDOWN;
+    const seen: Array<number> = [];
+    for (let attempt = 0; attempt < 6; attempt++) {
+      cooldown = nextManagedTunnelRecoveryCooldown({
+        current: cooldown,
+        sinceLastRecovery: minutes(3),
+      });
+      seen.push(Duration.toMinutes(cooldown));
+    }
+    expect(seen).toEqual([4, 8, 16, 30, 30, 30]);
+  });
+
+  it("starts over once the previous recovery held", () => {
+    expect(
+      Duration.toMinutes(
+        nextManagedTunnelRecoveryCooldown({ current: minutes(16), sinceLastRecovery: minutes(26) }),
+      ),
+    ).toBe(2);
+    expect(
+      Duration.toMinutes(
+        nextManagedTunnelRecoveryCooldown({ current: minutes(16), sinceLastRecovery: minutes(20) }),
+      ),
+    ).toBe(30);
+  });
+});
+
+describe("relayRetrySchedule", () => {
+  it.effect("waits at least as long as the relay's Retry-After", () =>
+    Effect.gen(function* () {
+      let attempts = 0;
+      const request = Effect.suspend(() => {
+        attempts += 1;
+        return attempts === 1
+          ? Effect.fail(
+              new RelayRequestError({
+                rejection: "unavailable",
+                description: "paused",
+                retryAfterMillis: 120_000,
+              }),
+            )
+          : Effect.succeed("done");
+      });
+      const fiber = yield* Effect.forkChild(
+        Effect.retry(request, { schedule: relayRetrySchedule }),
+        {
+          startImmediately: true,
+        },
+      );
+      yield* TestClock.adjust("90 seconds");
+      expect(attempts).toBe(1);
+      yield* TestClock.adjust("31 seconds");
+      expect(yield* Fiber.join(fiber)).toBe("done");
+      expect(attempts).toBe(2);
+    }),
+  );
+});
+
+describe("makeManagedTunnelRecovery", () => {
+  const config = {
+    providerKind: "cloudflare_tunnel" as const,
+    connectorToken: "connector-token",
+    tunnelId: "tunnel-1",
+  };
+
+  it.effect("retries an unavailable relay every cooldown, and cools down from when it ends", () =>
+    Effect.gen(function* () {
+      const attemptMinutes: Array<number> = [];
+      const recover = makeManagedTunnelRecovery({
+        recover: () =>
+          Effect.gen(function* () {
+            attemptMinutes.push((yield* Clock.currentTimeMillis) / 60_000);
+            return attemptMinutes.length < 4
+              ? yield* Effect.fail("relay unavailable" as const)
+              : true;
+          }),
+        isRetryable: () => true,
+      });
+      const run = yield* recover;
+      const fiber = yield* Effect.forkChild(run(config), { startImmediately: true });
+      yield* TestClock.adjust("6 minutes");
+      expect(yield* Fiber.join(fiber)).toBe(true);
+      expect(attemptMinutes.map(Math.round)).toEqual([0, 2, 4, 6]);
+
+      yield* TestClock.adjust("1 minute");
+      const next = yield* Effect.forkChild(run(config), { startImmediately: true });
+      yield* TestClock.adjust("10 minutes");
+      yield* Fiber.join(next);
+      expect(attemptMinutes.map(Math.round)).toEqual([0, 2, 4, 6, 10]);
+    }),
+  );
+});
+
+describe("retryManagedTunnelRegistration fallback", () => {
+  it.effect("falls back by the end of the window and keeps honoring Retry-After", () =>
+    Effect.gen(function* () {
+      let fallbackAtMillis: number | undefined;
+      const attemptMillis: Array<number> = [];
+      const registration = Clock.currentTimeMillis.pipe(
+        Effect.tap((now) => Effect.sync(() => attemptMillis.push(now))),
+        Effect.andThen(
+          Effect.fail(
+            new RelayRequestError({
+              rejection: "unavailable",
+              description: "paused",
+              retryAfterMillis: 900_000,
+            }),
+          ),
+        ),
+      );
+      yield* Effect.forkChild(
+        retryManagedTunnelRegistration(
+          registration,
+          () => true,
+          Clock.currentTimeMillis.pipe(
+            Effect.tap((now) =>
+              Effect.sync(() => {
+                fallbackAtMillis ??= now;
+              }),
+            ),
+            Effect.asVoid,
+          ),
+        ),
+        { startImmediately: true },
+      );
+      yield* TestClock.adjust("1 hour");
+      expect(fallbackAtMillis).toBeDefined();
+      expect(fallbackAtMillis).toBeLessThanOrEqual(10 * 60_000);
+      expect(attemptMillis.length).toBeGreaterThan(2);
+      for (let index = 1; index < attemptMillis.length; index++) {
+        expect(attemptMillis[index]! - attemptMillis[index - 1]!).toBeGreaterThanOrEqual(900_000);
+      }
+    }),
+  );
+});
+
+describe("retryDesiredLinkReconcile", () => {
+  const relayUnavailable = new RelayRequestError({
+    rejection: "unavailable",
+    description: "relay unavailable",
+  });
+
+  it.effect("gives up on a local failure once the retry window ends", () =>
+    Effect.gen(function* () {
+      let attempts = 0;
+      let windowLogs = 0;
+      const fiber = yield* Effect.forkChild(
+        Effect.flip(
+          retryDesiredLinkReconcile(
+            Effect.suspend(() => {
+              attempts += 1;
+              return Effect.fail("cloudflared cannot run" as const);
+            }),
+            () => true,
+            () =>
+              Effect.sync(() => {
+                windowLogs += 1;
+              }),
+          ),
+        ),
+        { startImmediately: true },
+      );
+      yield* TestClock.adjust("2 hours");
+      expect(yield* Fiber.join(fiber)).toBe("cloudflared cannot run");
+      expect(attempts).toBeLessThan(20);
+      expect(windowLogs).toBe(0);
+    }),
+  );
+
+  it.effect("keeps relinking while the relay is down and succeeds when it returns", () =>
+    Effect.gen(function* () {
+      let windowLogs = 0;
+      const reconcile = Effect.gen(function* () {
+        return (yield* Clock.currentTimeMillis) < 30 * 60_000
+          ? yield* Effect.fail(relayUnavailable)
+          : "managed";
+      });
+      const fiber = yield* Effect.forkChild(
+        retryDesiredLinkReconcile(
+          reconcile,
+          () => true,
+          () =>
+            Effect.sync(() => {
+              windowLogs += 1;
+            }),
+        ),
+        { startImmediately: true },
+      );
+      yield* TestClock.adjust("45 minutes");
+      expect(yield* Fiber.join(fiber)).toBe("managed");
+      expect(windowLogs).toBe(1);
+    }),
+  );
+});
diff --git a/apps/server/src/cloud/managedTunnelStartup.ts b/apps/server/src/cloud/managedTunnelStartup.ts
index bf442e848ad74..7101a19b19f75 100644
--- a/apps/server/src/cloud/managedTunnelStartup.ts
+++ b/apps/server/src/cloud/managedTunnelStartup.ts
@@ -1,7 +1,11 @@
 import type { RelayManagedEndpointRuntimeConfig } from "@t3tools/contracts/relay";
+import * as Clock from "effect/Clock";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
+import * as Semaphore from "effect/Semaphore";
+
+import { isRelayUnavailable, relayRetryAfterMillis } from "./relayResponse.ts";
 
 // "revoked" leads to no action: relinking a deregistered environment is the
 // user's call, so startup neither retries nor relinks it.
@@ -38,40 +42,177 @@ export function managedTunnelStartupAction(input: {
 
 const MANAGED_TUNNEL_REGISTRATION_RETRY_WINDOW = Duration.minutes(10);
 
+// Every host retries against the same relay, so while it is failing the
+// retries themselves are load. Backing off to minutes, and never sooner than
+// the relay's Retry-After, lets it recover instead of absorbing the storm.
+// Not HttpClient.retryTransient: it resends the identical request, and these
+// carry proofs that expire after 60 s or single-use link challenges, so each
+// retry has to re-run the whole operation.
+const RELAY_RETRY_MAX_DELAY = Duration.minutes(5);
+
+export const relayRetrySchedule = Schedule.exponential("1 second").pipe(
+  Schedule.jittered,
+  Schedule.modifyDelay(({ duration }) =>
+    Effect.succeed(Duration.min(duration, RELAY_RETRY_MAX_DELAY)),
+  ),
+  Schedule.modifyDelay(({ duration, input }) => {
+    const retryAfterMillis = relayRetryAfterMillis(input);
+    return Effect.succeed(
+      retryAfterMillis === undefined
+        ? duration
+        : Duration.max(duration, Duration.millis(retryAfterMillis)),
+    );
+  }),
+);
+
+const windowMillis = Duration.toMillis(MANAGED_TUNNEL_REGISTRATION_RETRY_WINDOW);
+
+/**
+ * Retries on the relay schedule. The window closes at the first sleep that
+ * would end past it: then `onWindowExhausted` runs, and retrying continues
+ * only while `whilePastWindow` holds. One schedule covers both sides, so the
+ * relay's Retry-After still holds across the handoff.
+ */
+const retryAcrossWindow = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  options: {
+    readonly while: (error: E) => boolean;
+    readonly whilePastWindow: (error: E) => boolean;
+    readonly onWindowExhausted: (error: E) => Effect.Effect<void, never, R>;
+  },
+) =>
+  Effect.suspend(() => {
+    let pastWindow = false;
+    return effect.pipe(
+      Effect.retry({
+        while: (error) => (pastWindow ? options.whilePastWindow(error) : options.while(error)),
+        schedule: relayRetrySchedule.pipe(
+          Schedule.setInputType<E>(),
+          Schedule.modifyDelay(({ duration, elapsed, input }) => {
+            if (pastWindow || elapsed + Duration.toMillis(duration) < windowMillis) {
+              return Effect.succeed(duration);
+            }
+            pastWindow = true;
+            return options.whilePastWindow(input)
+              ? options.onWindowExhausted(input).pipe(Effect.as(duration))
+              : Effect.fail(input);
+          }),
+        ),
+      }),
+    );
+  });
+
 export const retryManagedTunnelRegistration = <A, E, R>(
   registration: Effect.Effect<A, E, R>,
   isRetryable: (error: E) => boolean,
   onRetryWindowExhausted?: Effect.Effect<void, never, R>,
-) => {
-  const schedule = Schedule.exponential("1 second").pipe(
-    Schedule.modifyDelay(({ duration }) =>
-      Effect.succeed(Duration.min(duration, Duration.seconds(30))),
-    ),
-    Schedule.jittered,
-  );
-  const withinWindow = registration.pipe(
-    Effect.retry({
-      while: isRetryable,
-      schedule: schedule.pipe(
-        Schedule.upTo({ duration: MANAGED_TUNNEL_REGISTRATION_RETRY_WINDOW }),
-      ),
-    }),
-  );
-  if (onRetryWindowExhausted === undefined) return withinWindow;
-  return withinWindow.pipe(
-    Effect.catchIf(isRetryable, () =>
-      onRetryWindowExhausted.pipe(
-        Effect.andThen(registration.pipe(Effect.retry({ while: isRetryable, schedule }))),
-      ),
-    ),
-  );
-};
+) =>
+  retryAcrossWindow(registration, {
+    while: isRetryable,
+    whilePastWindow: onRetryWindowExhausted === undefined ? () => false : isRetryable,
+    onWindowExhausted: () => onRetryWindowExhausted ?? Effect.void,
+  });
+
+/**
+ * Relinks a desired link at startup. Past the retry window it keeps going only
+ * while the relay itself is unavailable: a headless host has nobody to restart
+ * it once the relay recovers, but a local failure (cloudflared that cannot run)
+ * would otherwise relink, and provision a tunnel, forever.
+ */
+export const retryDesiredLinkReconcile = <A, E, R>(
+  reconcile: Effect.Effect<A, E, R>,
+  isRetryable: (error: E) => boolean,
+  onRetryWindowExhausted: (error: E) => Effect.Effect<void, never, R>,
+) =>
+  retryAcrossWindow(reconcile, {
+    while: isRetryable,
+    whilePastWindow: isRelayUnavailable,
+    onWindowExhausted: onRetryWindowExhausted,
+  });
 
 // Every managed host shares one relay, so a host stuck in a bad loop must not
 // turn into a fleet-wide request storm.
 export const MANAGED_TUNNEL_RECOVERY_COOLDOWN = Duration.minutes(2);
 
+// Retries inside one recovery, while the relay keeps failing, stay at least a
+// cooldown apart. They do not grow the cooldown: only a new request does.
+const managedTunnelRecoveryRetrySchedule = relayRetrySchedule.pipe(
+  Schedule.modifyDelay(({ duration }) =>
+    Effect.succeed(Duration.max(duration, MANAGED_TUNNEL_RECOVERY_COOLDOWN)),
+  ),
+);
+const MANAGED_TUNNEL_RECOVERY_MAX_COOLDOWN = Duration.minutes(30);
+// A recovery that fixed the tunnel stops the runtime asking for another, so a
+// request this long after the cooldown means the previous one worked.
+const MANAGED_TUNNEL_RECOVERY_SETTLED_AFTER = Duration.minutes(10);
+
+/**
+ * Recovery can only replace the relay-side tunnel. When the connector keeps
+ * failing for local reasons (no network, a firewall), the runtime keeps asking
+ * and recovery cannot help, so each request that follows right after a
+ * recovery doubles the wait, up to 30 minutes.
+ */
+export function nextManagedTunnelRecoveryCooldown(input: {
+  readonly current: Duration.Duration;
+  readonly sinceLastRecovery: Duration.Duration;
+}): Duration.Duration {
+  const settled = Duration.sum(input.current, MANAGED_TUNNEL_RECOVERY_SETTLED_AFTER);
+  if (Duration.isGreaterThanOrEqualTo(input.sinceLastRecovery, settled)) {
+    return MANAGED_TUNNEL_RECOVERY_COOLDOWN;
+  }
+  return Duration.min(Duration.times(input.current, 2), MANAGED_TUNNEL_RECOVERY_MAX_COOLDOWN);
+}
+
 // Existing hosts register on their first boot after an upgrade, and desktop
 // auto-update delivers that boot to many hosts at once. Spread the first
 // registration so the relay and Cloudflare see a ramp instead of a spike.
 export const MANAGED_TUNNEL_FIRST_REGISTRATION_JITTER = Duration.seconds(30);
+
+/**
+ * Runs one recovery per request, one at a time: waits out the current
+ * cooldown, then calls the relay, retrying it while it stays unavailable.
+ */
+export const makeManagedTunnelRecovery = Effect.fn("ManagedTunnelRecovery.make")(function* <
+  A,
+  E,
+  R,
+>(options: {
+  readonly recover: (config: RelayManagedEndpointRuntimeConfig) => Effect.Effect<A, E, R>;
+  readonly isRetryable: (error: E) => boolean;
+}) {
+  const lock = yield* Semaphore.make(1);
+  let lastRecoveryAtMillis = Number.NEGATIVE_INFINITY;
+  let cooldown = MANAGED_TUNNEL_RECOVERY_COOLDOWN;
+  const waitForCooldown = Effect.gen(function* () {
+    const elapsed = (yield* Clock.currentTimeMillis) - lastRecoveryAtMillis;
+    cooldown = nextManagedTunnelRecoveryCooldown({
+      current: cooldown,
+      sinceLastRecovery: Duration.millis(elapsed),
+    });
+    const wait = Duration.toMillis(cooldown) - elapsed;
+    if (wait > 0) yield* Effect.sleep(Duration.millis(wait));
+  });
+  // Measured from the end: a recovery that retried through a long relay
+  // outage must not look settled the moment it finishes.
+  const recordRecovery = Clock.currentTimeMillis.pipe(
+    Effect.tap((now) =>
+      Effect.sync(() => {
+        lastRecoveryAtMillis = now;
+      }),
+    ),
+  );
+  return (config: RelayManagedEndpointRuntimeConfig) =>
+    lock.withPermits(1)(
+      waitForCooldown.pipe(
+        Effect.andThen(
+          options.recover(config).pipe(
+            Effect.retry({
+              while: options.isRetryable,
+              schedule: managedTunnelRecoveryRetrySchedule,
+            }),
+            Effect.ensuring(recordRecovery),
+          ),
+        ),
+      ),
+    );
+});
diff --git a/apps/server/src/cloud/relayResponse.test.ts b/apps/server/src/cloud/relayResponse.test.ts
index 59f341aa3c475..88170942ee17c 100644
--- a/apps/server/src/cloud/relayResponse.test.ts
+++ b/apps/server/src/cloud/relayResponse.test.ts
@@ -6,6 +6,7 @@ import * as HttpClientError from "effect/http/HttpClientError";
 import {
   filterRelayResponse,
   relayRequestError,
+  relayRetryAfterMillis,
   shouldRetryRelayRequest,
 } from "./relayResponse.ts";
 
@@ -121,6 +122,27 @@ it.effect("reports an unrecognized access denial without printing its response b
   }),
 );
 
+it.effect("keeps the relay's Retry-After on a retryable failure", () =>
+  Effect.gen(function* () {
+    const seconds = yield* filterRelayResponse(
+      response(503, "paused", { "retry-after": "30" }),
+    ).pipe(Effect.flip);
+    expect(seconds).toMatchObject({ rejection: "unavailable", retryAfterMillis: 30_000 });
+    expect(relayRetryAfterMillis({ cause: { cause: seconds } })).toBe(30_000);
+
+    // The test clock starts at the epoch, so the date is 90 seconds after it.
+    const date = yield* filterRelayResponse(
+      response(429, "slow down", { "retry-after": "Thu, 01 Jan 1970 00:01:30 GMT" }),
+    ).pipe(Effect.flip);
+    expect(date.retryAfterMillis).toBe(90_000);
+
+    const malformed = yield* filterRelayResponse(
+      response(503, "paused", { "retry-after": "soon" }),
+    ).pipe(Effect.flip);
+    expect(malformed.retryAfterMillis).toBeUndefined();
+  }),
+);
+
 it.effect.each([408, 429, 500, 502, 503, 504])(
   "keeps transient HTTP %s failures retryable",
   (status) =>
diff --git a/apps/server/src/cloud/relayResponse.ts b/apps/server/src/cloud/relayResponse.ts
index f86cc57194011..33cefa8870773 100644
--- a/apps/server/src/cloud/relayResponse.ts
+++ b/apps/server/src/cloud/relayResponse.ts
@@ -1,4 +1,5 @@
 import { RelayProtectedError } from "@t3tools/contracts/relay";
+import * as Clock from "effect/Clock";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
@@ -15,6 +16,8 @@ export class RelayRequestError extends Schema.TaggedError<RelayRequestError>()(
   {
     rejection: Schema.Literals(["unauthorized", "forbidden", "rejected", "unavailable"]),
     description: Schema.String,
+    /** How long the relay asked callers to wait (`Retry-After`) before retrying. */
+    retryAfterMillis: Schema.optionalKey(Schema.Number),
   },
 ) {
   override get message(): string {
@@ -36,6 +39,30 @@ export function relayRequestError(cause: unknown): RelayRequestError {
 export const shouldRetryRelayRequest = (error: unknown): boolean =>
   !isRelayRequestError(error) || error.rejection === "unavailable";
 
+/** The relay answered and asked to be retried later; nothing local is wrong. */
+export const isRelayUnavailable = (error: unknown): boolean =>
+  isRelayRequestError(error) && error.rejection === "unavailable";
+
+// Retry-After is either delay-seconds or an HTTP date (RFC 9110 §10.2.3).
+const MAX_RELAY_RETRY_AFTER_MILLIS = 15 * 60 * 1000;
+function parseRetryAfterMillis(value: string | undefined, nowMillis: number): number | undefined {
+  if (value === undefined) return undefined;
+  const trimmed = value.trim();
+  const millis = /^\d+$/.test(trimmed) ? Number(trimmed) * 1000 : Date.parse(trimmed) - nowMillis;
+  if (!Number.isFinite(millis) || millis <= 0) return undefined;
+  return Math.min(millis, MAX_RELAY_RETRY_AFTER_MILLIS);
+}
+
+/** The relay's requested wait, found anywhere in a failure's cause chain. */
+export function relayRetryAfterMillis(error: unknown): number | undefined {
+  for (let current = error, depth = 0; depth < 8; depth++) {
+    if (isRelayRequestError(current)) return current.retryAfterMillis;
+    if (typeof current !== "object" || current === null || !("cause" in current)) return undefined;
+    current = current.cause;
+  }
+  return undefined;
+}
+
 function recoveryHint(error: RelayProtectedError): string {
   switch (error._tag) {
     case "RelayEnvironmentLinkLimitExceededError":
@@ -88,5 +115,13 @@ export const filterRelayResponse = Effect.fn("cloud.filter_relay_response")(func
   ) {
     return yield* new RelayRequestError({ rejection: "rejected", description });
   }
-  return yield* new RelayRequestError({ rejection: "unavailable", description });
+  const retryAfterMillis = parseRetryAfterMillis(
+    response.headers["retry-after"],
+    yield* Clock.currentTimeMillis,
+  );
+  return yield* new RelayRequestError({
+    rejection: "unavailable",
+    description,
+    ...(retryAfterMillis === undefined ? {} : { retryAfterMillis }),
+  });
 });
diff --git a/apps/server/src/device/SshDeviceHost.test.ts b/apps/server/src/device/SshDeviceHost.test.ts
index 57e7226e4300f..24c128c65438d 100644
--- a/apps/server/src/device/SshDeviceHost.test.ts
+++ b/apps/server/src/device/SshDeviceHost.test.ts
@@ -33,6 +33,7 @@ it.effect("preserves installed status after probes and cleans failed agent activ
         (forwarding ? tunnelArgs : commandArgs).push([...command.args]);
         if (forwarding) tunnelStdins.push(command.options.stdin);
         let output = "";
+        let exitCode = 0;
         if (forwarding) {
           if (failForward) {
             failForward = false;
@@ -77,13 +78,19 @@ it.effect("preserves installed status after probes and cleans failed agent activ
               ? { daemonPort: 1235, token: "fixture", entryPath: "/agent.mjs" }
               : {}),
           });
+          if (mode === "") {
+            output = `${"verbose-prefix ".repeat(400)}PANIC: emulator SDK is broken\n`;
+            exitCode = 1;
+          }
         }
         return ChildProcessSpawner.makeHandle({
           pid: ChildProcessSpawner.ProcessId(123),
           stdout: Stream.make(new TextEncoder().encode(output)),
           stderr: Stream.empty,
           all: Stream.empty,
-          exitCode: forwarding ? Effect.never : Effect.succeed(ChildProcessSpawner.ExitCode(0)),
+          exitCode: forwarding
+            ? Effect.never
+            : Effect.succeed(ChildProcessSpawner.ExitCode(exitCode)),
           isRunning: Effect.succeed(forwarding),
           kill: () => Effect.void,
           stdin: Sink.drain,
@@ -124,6 +131,15 @@ it.effect("preserves installed status after probes and cleans failed agent activ
     expect(owners[0]).toMatch(/^[a-f0-9]{24}$/);
     expect(forwards).toBe(1);
     expect(modes.filter((mode) => mode === "start")).toHaveLength(2);
+    const ready = yield* host.current;
+    expect(ready).not.toBeNull();
+    if (ready) {
+      const failed = yield* ready.run("emulator", ["-list-avds"]);
+      expect(failed.code).toBe(1);
+      expect(failed.stdout).toMatch(/^\[truncated\]/);
+      expect(failed.stderr).toBe(failed.stdout.trim());
+      expect(failed.stderr).toMatch(/PANIC: emulator SDK is broken$/);
+    }
     yield* host.platformAvailability("ios");
     expect((yield* host.summary).hubInstalled).toBe(true);
     const failed = yield* host.ensureAgentReady(() => Effect.void).pipe(Effect.result);
diff --git a/apps/server/src/device/SshDeviceHost.ts b/apps/server/src/device/SshDeviceHost.ts
index 2fc8c57e05d72..1587fab9804cb 100644
--- a/apps/server/src/device/SshDeviceHost.ts
+++ b/apps/server/src/device/SshDeviceHost.ts
@@ -176,6 +176,7 @@ export const make = Effect.fn("SshDeviceHost.make")(function* (
         remoteCommandArgs: commandArgs(
           `cd "$HOME/.t3/device/hosts/${owner}" && exec ${[command, ...args].map(quoteRemoteArg).join(" ")}`,
         ),
+        keepErrorOutputTail: true,
         ...(options?.stdin === undefined ? {} : { stdin: options.stdin }),
         ...(options?.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
       }),
diff --git a/apps/server/src/mcp/McpSessionRegistry.test.ts b/apps/server/src/mcp/McpSessionRegistry.test.ts
index a3f74c3e28c24..94f6aa6777994 100644
--- a/apps/server/src/mcp/McpSessionRegistry.test.ts
+++ b/apps/server/src/mcp/McpSessionRegistry.test.ts
@@ -178,3 +178,65 @@ it.effect("does not keep credentials of other threads alive", () =>
     expect(yield* registry.resolve(token)).toBeUndefined();
   }),
 );
+
+it.effect("only a trusted touch restores an expired token with its original scope", () =>
+  Effect.gen(function* () {
+    let timestamp = 1_000;
+    const registry = yield* makeRegistry(() => timestamp);
+    const threadId = ThreadId.make("thread-idle");
+    const issued = yield* registry.issue({
+      threadId,
+      providerInstanceId: ProviderInstanceId.make("claude"),
+      capabilities: new Set(["preview"]),
+    });
+    const token = issued.config.authorizationHeader.replace(/^Bearer\s+/, "");
+    const scope = yield* registry.resolve(token);
+    expect(scope).toBeDefined();
+
+    timestamp += 101;
+    expect(yield* registry.resolve(token)).toBeUndefined();
+    const otherThreadId = ThreadId.make("thread-active");
+    const other = yield* registry.issue({
+      threadId: otherThreadId,
+      providerInstanceId: ProviderInstanceId.make("codex"),
+      capabilities: new Set(["device"]),
+    });
+    yield* registry.touch(otherThreadId);
+    expect(
+      (yield* registry.resolve(other.config.authorizationHeader.replace(/^Bearer\s+/, "")))?.thread
+        .threadId,
+    ).toBe(otherThreadId);
+    expect(yield* registry.resolve("unknown-token")).toBeUndefined();
+    expect(yield* registry.resolve(token)).toBeUndefined();
+
+    yield* registry.touch(threadId);
+    expect(yield* registry.resolve(token)).toEqual(scope);
+    timestamp += 101;
+    expect(yield* registry.resolve(token)).toBeUndefined();
+  }),
+);
+
+it.effect.each(["provider-session", "thread", "all"] as const)(
+  "never restores an expired token after %s revocation",
+  (revocation) =>
+    Effect.gen(function* () {
+      let timestamp = 1_000;
+      const registry = yield* makeRegistry(() => timestamp);
+      const threadId = ThreadId.make("thread-revoked");
+      const issued = yield* registry.issue({
+        threadId,
+        providerInstanceId: ProviderInstanceId.make("codex"),
+        capabilities: new Set(["preview"]),
+      });
+      const token = issued.config.authorizationHeader.replace(/^Bearer\s+/, "");
+
+      timestamp += 101;
+      yield* {
+        "provider-session": registry.revokeProviderSession(issued.config.providerSessionId),
+        thread: registry.revokeThread(threadId),
+        all: registry.revokeAll,
+      }[revocation];
+      yield* registry.touch(threadId);
+      expect(yield* registry.resolve(token)).toBeUndefined();
+    }),
+);
diff --git a/apps/server/src/mcp/McpSessionRegistry.ts b/apps/server/src/mcp/McpSessionRegistry.ts
index b16529924a430..ae05529cd250d 100644
--- a/apps/server/src/mcp/McpSessionRegistry.ts
+++ b/apps/server/src/mcp/McpSessionRegistry.ts
@@ -60,9 +60,9 @@ export interface McpSessionRegistryOptions {
 }
 
 /**
- * The bound matters because `/mcp` is mounted outside the environment auth
- * stack and is reachable on whatever host the server binds to, so this token is
- * the only thing guarding the `t3-code` toolkits on a remote-reachable server.
+ * `/mcp` is outside environment auth, so idle tokens stop authenticating.
+ * Keep expired records until explicit revocation: a trusted provider turn can
+ * refresh the token its subprocess still holds; MCP requests cannot.
  */
 const DEFAULT_LIVENESS_WINDOW_MS = 24 * 60 * 60 * 1_000;
 
@@ -95,15 +95,6 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       .digest("SHA-256", new TextEncoder().encode(token))
       .pipe(Effect.map(bytesToHex), Effect.orDie);
 
-  const pruneDead = (records: ReadonlyMap<string, CredentialRecord>, timestamp: number) => {
-    const next = new Map(
-      Array.from(records).filter(
-        ([, record]) => timestamp - record.lastAliveAt <= livenessWindowMs,
-      ),
-    );
-    return next.size === records.size ? records : next;
-  };
-
   const issue: McpSessionRegistryShape["issue"] = Effect.fn("McpSessionRegistry.issue")(
     function* (request) {
       const issuedAt = yield* currentTimeMillis;
@@ -129,7 +120,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
         issuedAt,
       };
       yield* SynchronizedRef.update(state, ({ records }) => {
-        const next = new Map(pruneDead(records, issuedAt));
+        const next = new Map(records);
         next.set(tokenHash, { tokenHash, scope, lastAliveAt: issuedAt });
         return { records: next };
       });
@@ -154,10 +145,11 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       const tokenHash = yield* hashToken(rawToken);
       const timestamp = yield* currentTimeMillis;
       return yield* SynchronizedRef.modify(state, ({ records }) => {
-        const current = pruneDead(records, timestamp);
-        const record = current.get(tokenHash);
-        if (!record) return [undefined, { records: current }] as const;
-        const next = new Map(current);
+        const record = records.get(tokenHash);
+        if (!record || timestamp - record.lastAliveAt > livenessWindowMs) {
+          return [undefined, { records }] as const;
+        }
+        const next = new Map(records);
         next.set(tokenHash, { ...record, lastAliveAt: timestamp });
         return [record.scope, { records: next }] as const;
       });
@@ -168,9 +160,8 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
     function* (threadId) {
       const timestamp = yield* currentTimeMillis;
       yield* SynchronizedRef.update(state, ({ records }) => {
-        const current = pruneDead(records, timestamp);
-        const next = new Map(current);
-        for (const [tokenHash, record] of current) {
+        const next = new Map(records);
+        for (const [tokenHash, record] of records) {
           if (record.scope.thread.threadId === threadId) {
             next.set(tokenHash, { ...record, lastAliveAt: timestamp });
           }
diff --git a/apps/server/src/observability/EventLoopMonitor.test.ts b/apps/server/src/observability/EventLoopMonitor.test.ts
index 963279d138247..0941c8428b1ba 100644
--- a/apps/server/src/observability/EventLoopMonitor.test.ts
+++ b/apps/server/src/observability/EventLoopMonitor.test.ts
@@ -4,6 +4,7 @@ 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 Metric from "effect/Metric";
 import * as Tracer from "effect/Tracer";
 import * as TestClock from "effect/testing/TestClock";
 
@@ -24,6 +25,8 @@ const stalled: EventLoopMonitor.EventLoopReadings = {
     involuntaryContextSwitches: 57,
   },
   rssBytes: 1536 * 1024 * 1024,
+  heapUsedBytes: 512 * 1024 * 1024,
+  elapsedMs: 30_000,
 };
 const quiet: EventLoopMonitor.EventLoopReadings = { ...stalled, delayMaxNs: ms(2_950) };
 
@@ -78,6 +81,29 @@ describe("EventLoopMonitor", () => {
     }),
   );
 
+  it.effect("exports the server's memory, CPU and event loop from each sample", () =>
+    Effect.gen(function* () {
+      yield* monitor([quiet, stalled]);
+      yield* TestClock.adjust("60 seconds");
+
+      const gauges = Object.fromEntries(
+        (yield* Metric.snapshot).flatMap((snapshot) =>
+          snapshot.id.startsWith("t3_server_") && snapshot.type === "Gauge"
+            ? [[snapshot.id, snapshot.state.value]]
+            : [],
+        ),
+      );
+      assert.deepStrictEqual(gauges, {
+        t3_server_resident_bytes: 1536 * 1024 * 1024,
+        t3_server_heap_used_bytes: 512 * 1024 * 1024,
+        t3_server_event_loop_utilization: 0.176,
+        t3_server_event_loop_delay_max: 4_950,
+        // 406 ms of CPU over 30 s of wall time.
+        t3_server_cpu_utilization: 406 / 30_000,
+      });
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("keeps each stall as one line in a capped stall log", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
diff --git a/apps/server/src/observability/EventLoopMonitor.ts b/apps/server/src/observability/EventLoopMonitor.ts
index d713e71940dec..a2944b87b749f 100644
--- a/apps/server/src/observability/EventLoopMonitor.ts
+++ b/apps/server/src/observability/EventLoopMonitor.ts
@@ -5,11 +5,13 @@ import { RotatingFileSink } from "@t3tools/shared/logging";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Metric from "effect/Metric";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 
 import * as ServerConfig from "../config.ts";
+import * as Metrics from "./Metrics.ts";
 
 // Node's delay histogram wakes a native timer every RESOLUTION_MS and records the
 // gap between wakeups, so an idle loop reads about RESOLUTION_MS and a stall of S
@@ -34,6 +36,9 @@ export interface EventLoopReadings {
     | "involuntaryContextSwitches"
   >;
   readonly rssBytes: number;
+  readonly heapUsedBytes: number;
+  /** Wall time the readings cover. */
+  readonly elapsedMs: number;
 }
 
 // Node skips the first gap after a reset, so a stall right at a sample boundary can be missed.
@@ -48,11 +53,14 @@ const makeNodeSampler = Effect.gen(function* () {
   );
   let elu = NodePerfHooks.performance.eventLoopUtilization();
   let usage = process.resourceUsage();
+  let sampledAt = NodePerfHooks.performance.now();
 
   // @effect-diagnostics-next-line returnEffectInGen:off - the read effect is the result.
   return Effect.sync(() => {
     const nextElu = NodePerfHooks.performance.eventLoopUtilization();
     const nextUsage = process.resourceUsage();
+    const nextSampledAt = NodePerfHooks.performance.now();
+    const memory = process.memoryUsage();
     const loop = NodePerfHooks.performance.eventLoopUtilization(nextElu, elu);
     const readings: EventLoopReadings = {
       delayMaxNs: histogram.max,
@@ -66,11 +74,14 @@ const makeNodeSampler = Effect.gen(function* () {
         involuntaryContextSwitches:
           nextUsage.involuntaryContextSwitches - usage.involuntaryContextSwitches,
       },
-      rssBytes: process.memoryUsage.rss(),
+      rssBytes: memory.rss,
+      heapUsedBytes: memory.heapUsed,
+      elapsedMs: nextSampledAt - sampledAt,
     };
     histogram.reset();
     elu = nextElu;
     usage = nextUsage;
+    sampledAt = nextSampledAt;
     return readings;
   });
 });
@@ -83,6 +94,21 @@ export const stallMs = ({ delayMaxNs, activeMs }: EventLoopReadings) => {
   return delayMs;
 };
 
+// Untraced: it runs inside every 30-second tick, which already has the monitor's own span.
+const recordGauges = Effect.fnUntraced(function* (readings: EventLoopReadings) {
+  const cpuMs = (readings.usage.userCPUTime + readings.usage.systemCPUTime) / 1000;
+  yield* Metric.update(Metrics.serverResidentBytes, readings.rssBytes);
+  yield* Metric.update(Metrics.serverHeapUsedBytes, readings.heapUsedBytes);
+  yield* Metric.update(Metrics.serverEventLoopUtilization, readings.utilization);
+  yield* Metric.update(
+    Metrics.serverEventLoopDelayMax,
+    Math.max(0, Math.round(readings.delayMaxNs / 1e6) - RESOLUTION_MS),
+  );
+  if (readings.elapsedMs > 0) {
+    yield* Metric.update(Metrics.serverCpuUtilization, cpuMs / readings.elapsedMs);
+  }
+});
+
 const encodeStallLine = Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 
 export interface StallLogOptions {
@@ -114,6 +140,7 @@ export const layerWith = (
       );
       const tick = Effect.gen(function* () {
         const readings = yield* sample;
+        yield* recordGauges(readings);
         const delayMaxMs = stallMs(readings);
         if (delayMaxMs === undefined) return;
         const { utilization, usage, rssBytes } = readings;
diff --git a/apps/server/src/observability/Metrics.ts b/apps/server/src/observability/Metrics.ts
index 849b611043730..3fbd12fc86e9f 100644
--- a/apps/server/src/observability/Metrics.ts
+++ b/apps/server/src/observability/Metrics.ts
@@ -69,6 +69,30 @@ export const providerRuntimeEventsTotal = Metric.counter("t3_provider_runtime_ev
   description: "Total canonical provider runtime events processed.",
 });
 
+// OTLP carries the unit, and Prometheus names the series by it: a unitless gauge gains `_ratio`.
+export const serverResidentBytes = Metric.gauge("t3_server_resident_bytes", {
+  description: "Resident memory of the server process.",
+  attributes: { unit: "By" },
+});
+
+export const serverHeapUsedBytes = Metric.gauge("t3_server_heap_used_bytes", {
+  description: "JavaScript heap in use by the server process.",
+  attributes: { unit: "By" },
+});
+
+export const serverCpuUtilization = Metric.gauge("t3_server_cpu_utilization", {
+  description: "CPU time the server used per second over the last sample; 1 is one full core.",
+});
+
+export const serverEventLoopUtilization = Metric.gauge("t3_server_event_loop_utilization", {
+  description: "Share of the last sample the server's event loop spent busy.",
+});
+
+export const serverEventLoopDelayMax = Metric.gauge("t3_server_event_loop_delay_max", {
+  description: "Longest event loop delay over the last sample.",
+  attributes: { unit: "ms" },
+});
+
 export const gitCommandsTotal = Metric.counter("t3_git_commands_total", {
   description: "Total git commands executed by the server runtime.",
 });
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
index 92bb99e4de16e..cbc0ee419ea0d 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
@@ -22,10 +22,12 @@ import {
   ProviderThreadId,
   ThreadId,
   type OrchestrationV2ProviderThread,
+  type OrchestrationV2TurnItem,
   type ProviderOptionDescriptor,
 } from "@t3tools/contracts";
 import { GrokSettings } from "@t3tools/provider-grok/settings";
 import * as HostProcess from "@t3tools/shared/HostProcess";
+import { deriveBlockedOnThreadWait } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import { resolveSelfInvocation } from "@t3tools/shared/nodeRuntime";
 import * as DateTime from "effect/DateTime";
 import * as Deferred from "effect/Deferred";
@@ -913,6 +915,139 @@ describe("AcpAdapterV2", () => {
     }).pipe(Effect.provide(layerTest), Effect.scoped),
   );
 
+  it.effect.each(["agent_message_chunk", "agent_thought_chunk"] as const)(
+    "keeps named ACP %s open while deriving thread wait execution state",
+    (sessionUpdate) =>
+      Effect.gen(function* () {
+        type RuntimeService = AcpSessionRuntime.AcpSessionRuntime["Service"];
+        let handler: Parameters<RuntimeService["handleSessionUpdate"]>[0] | undefined;
+        const instanceId = ProviderInstanceId.make("acp-named-stream-wait");
+        const path = yield* Path.Path;
+        const adapter = yield* makeAcpAdapterV2({
+          instanceId,
+          selfInvocation: yield* resolveSelfInvocation(),
+          flavor: {
+            driver: ACP_TEST_DRIVER,
+            capabilities: AcpProviderCapabilitiesV2,
+            makeRuntime: makeMockRuntime({
+              childProcessSpawner: yield* ChildProcessSpawner.ChildProcessSpawner,
+              mockAgentPath: yield* path.fromFileUrl(
+                new URL("../../../scripts/acp-mock-agent.ts", import.meta.url),
+              ),
+              wrapRuntime: (runtime) => ({
+                ...runtime,
+                handleSessionUpdate: (next) =>
+                  Effect.sync(() => {
+                    handler = next;
+                  }).pipe(Effect.andThen(runtime.handleSessionUpdate(next))),
+                prompt: () =>
+                  Effect.gen(function* () {
+                    assert.isDefined(handler);
+                    const updates = [
+                      {
+                        sessionUpdate,
+                        messageId: "named-stream",
+                        content: { type: "text", text: "Waiting for the child result" },
+                      },
+                      {
+                        sessionUpdate: "tool_call",
+                        toolCallId: "wait",
+                        title: "Wait for the child",
+                        status: "in_progress",
+                        rawInput: {
+                          server: "t3-code",
+                          tool: "t3_thread_wait",
+                          arguments: { threadId: "child" },
+                        },
+                        _meta: { is_mcp_tool_call: true },
+                      },
+                      {
+                        sessionUpdate: "tool_call",
+                        toolCallId: "command",
+                        kind: "execute",
+                        title: "Run command",
+                        status: "in_progress",
+                        rawInput: { command: "pwd" },
+                      },
+                      {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: "command",
+                        status: "completed",
+                      },
+                      {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: "wait",
+                        status: "completed",
+                      },
+                    ] satisfies Array<EffectAcpSchema.SessionUpdate>;
+                    for (const update of updates)
+                      yield* handler!({ sessionId: "mock-session-1", update });
+                    return { stopReason: "end_turn" as const };
+                  }),
+              }),
+            }),
+          },
+        });
+        const threadId = ThreadId.make("thread-acp-named-stream-wait");
+        const modelSelection = { instanceId, model: "default" };
+        const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          cwd: process.cwd(),
+        });
+        const runtime = yield* adapter.openSession({
+          threadId,
+          providerSessionId: ProviderSessionId.make("session-acp-named-stream-wait"),
+          modelSelection,
+          runtimePolicy,
+        });
+        const providerThread = yield* runtime.ensureThread({
+          threadId,
+          modelSelection,
+          runtimePolicy,
+        });
+        const input = makeTurnInput({
+          threadId,
+          providerThread,
+          instanceId,
+          runtimePolicy,
+          now: yield* DateTime.now,
+        });
+        yield* runtime.startTurn(input);
+        const events = yield* runtime.events.pipe(
+          Stream.takeUntil((event) => event.type === "turn.terminal"),
+          Stream.runCollect,
+        );
+        const retained = new Map<string, OrchestrationV2TurnItem>();
+        const states: Array<boolean> = [];
+        for (const event of events) {
+          if (event.type !== "turn_item.updated") continue;
+          const item = event.turnItem;
+          retained.set(item.id, item);
+          if (item.type !== "dynamic_tool" && item.type !== "command_execution") continue;
+          const streams = [...retained.values()].filter(
+            (entry) => entry.type === "assistant_message" || entry.type === "reasoning",
+          );
+          assert.deepEqual(
+            streams.map((entry) => [entry.type, entry.status]),
+            [
+              [
+                sessionUpdate === "agent_message_chunk" ? "assistant_message" : "reasoning",
+                "running",
+              ],
+            ],
+          );
+          states.push(
+            deriveBlockedOnThreadWait({
+              activeRun: { id: input.runId, status: "running" },
+              turnItems: [...retained.values()],
+            }),
+          );
+        }
+        assert.deepEqual(states, [true, false, true, false]);
+      }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
   it.effect("starts a new replay message after ACP v2 plan boundaries", () =>
     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 fb931519d9e36..06e165ada7796 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpRegistryAdapterV2.test.ts
@@ -1,13 +1,22 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, describe, it } from "@effect/vitest";
 import {
+  MessageId,
+  NodeId,
+  ProjectId,
+  RunAttemptId,
+  RunId,
   type ModelSelection,
   ProviderInstanceId,
   ProviderSessionId,
   ThreadId,
 } from "@t3tools/contracts";
+import { pendingBackgroundTurnItems } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import { resolveSelfInvocation } from "@t3tools/shared/nodeRuntime";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as DateTime from "effect/DateTime";
+import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
@@ -24,6 +33,11 @@ import * as EffectAcpErrors from "effect-acp/errors";
 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
+import {
+  makeProviderReplayGate,
+  type ProviderReplayGate,
+} from "@t3tools/provider-testing/replayGate";
+import type { ProviderContinuationRequest } from "@t3tools/provider-core/server/ProviderContinuationRequests";
 import * as ServerSettings from "../../serverSettings.ts";
 import type {
   AcpRegistryAvailableCommands,
@@ -106,6 +120,305 @@ const layerTest = Layer.mergeAll(
   ServerSettings.layerTest(),
 );
 
+const CLAUDE_ROOT_SESSION = "claude-session";
+
+/** Replay frames of Claude Agent (claude-agent-acp 0.90.0) on ACP v2. */
+const claudeFrames = {
+  open: [
+    { type: "expect_outbound", frame: { kind: "request", method: "initialize", params: "<any>" } },
+    {
+      type: "emit_inbound",
+      frame: {
+        kind: "response",
+        method: "initialize",
+        result: {
+          protocolVersion: 2,
+          info: { name: "@agentclientprotocol/claude-agent-acp", version: "0.90.0" },
+          capabilities: { session: {} },
+          authMethods: [],
+        },
+      },
+    },
+    { type: "expect_outbound", frame: { kind: "request", method: "session/new", params: "<any>" } },
+    {
+      type: "emit_inbound",
+      frame: {
+        kind: "response",
+        method: "session/new",
+        result: { sessionId: CLAUDE_ROOT_SESSION },
+      },
+    },
+  ],
+  update: (sessionId: string, sessionUpdate: Record<string, unknown>) => ({
+    type: "emit_inbound",
+    frame: {
+      kind: "notification",
+      method: "session/update",
+      params: { sessionId, update: sessionUpdate },
+    },
+  }),
+  childState: (parent: string, child: string, state: string) =>
+    claudeFrames.update(parent, {
+      sessionUpdate: "subagent_update",
+      sessionId: child,
+      state: { state },
+    }),
+  /** A prompt Claude takes in and works on. */
+  prompt: (ordinal: number) => [
+    {
+      type: "expect_outbound",
+      frame: { kind: "request", method: "session/prompt", params: "<any>" },
+    },
+    claudeFrames.update(CLAUDE_ROOT_SESSION, {
+      sessionUpdate: "user_message",
+      messageId: `user-${ordinal}`,
+      content: [{ type: "text", text: "test prompt" }],
+    }),
+    {
+      type: "emit_inbound",
+      frame: {
+        kind: "response",
+        method: "session/prompt",
+        result: { messageId: `user-${ordinal}` },
+      },
+    },
+    claudeFrames.update(CLAUDE_ROOT_SESSION, { sessionUpdate: "state_update", state: "running" }),
+  ],
+  idle: (stopReason: string) =>
+    claudeFrames.update(CLAUDE_ROOT_SESSION, {
+      sessionUpdate: "state_update",
+      state: "idle",
+      stopReason,
+    }),
+  closeRequest: {
+    type: "expect_outbound",
+    frame: {
+      kind: "request",
+      method: "session/close",
+      params: { sessionId: CLAUDE_ROOT_SESSION },
+    },
+  },
+  closed: {
+    type: "emit_inbound",
+    frame: { kind: "response", method: "session/close", result: {} },
+  },
+};
+
+const openClaudeReplaySession = Effect.fn("openClaudeReplaySession")(function* (
+  entries: ReadonlyArray<unknown>,
+  replayGate?: ProviderReplayGate,
+  continuationEnabled = true,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const replayDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-claude-lifecycle-" });
+  const transcript = yield* decodeAcpReplayTranscript(
+    {
+      provider: ACP_REGISTRY_PROVIDER,
+      protocol: "acp.ndjson-jsonrpc",
+      version: "1",
+      scenario: "claude-lifecycle",
+      entries: entries as never,
+    },
+    ACP_REGISTRY_PROVIDER,
+  );
+  const offers: Array<ProviderContinuationRequest> = [];
+  const offered = yield* Queue.unbounded<void>();
+  const continuationRequests = {
+    offer: (request: ProviderContinuationRequest) =>
+      Effect.sync(() => {
+        offers.push(request);
+      }).pipe(Effect.andThen(Queue.offer(offered, undefined)), Effect.asVoid),
+  };
+  const instanceId = ProviderInstanceId.make("claude-lifecycle");
+  let onTermination: NonNullable<
+    AcpSessionRuntime.AcpSessionRuntimeOptions["onTermination"]
+  > = () => Effect.die("Runtime has not started");
+  const replayRuntime = makeAcpReplayRuntime({
+    transcript,
+    statusPath: path.join(replayDir, "status.json"),
+    scriptPath: yield* path.fromFileUrl(
+      new URL("../../../scripts/acp-replay-agent.ts", import.meta.url),
+    ),
+    childProcessSpawner,
+    fileSystem,
+    ...(replayGate === undefined ? {} : { replayGate }),
+  });
+  const adapterOptions = {
+    selfInvocation: yield* resolveSelfInvocation(),
+    instanceId,
+    settings: yield* decodeAcpRegistryAdapterSettings({ agentId: "claude-acp" }),
+    environment: {},
+    ...(continuationEnabled ? { continuationRequests } : {}),
+    makeRuntime: (runtimeInput: Parameters<typeof replayRuntime>[0]) => {
+      onTermination = runtimeInput.onTermination;
+      return replayRuntime(runtimeInput);
+    },
+  };
+  const adapter = yield* makeAcpRegistryAdapterV2(adapterOptions).pipe(
+    Effect.provide(layerInjectedRuntimeCatalog),
+  );
+  const threadId = ThreadId.make("thread-claude-lifecycle");
+  const modelSelection = { instanceId, model: "default" } as const;
+  const runtimeMode = "approval-required";
+  const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+    runtimeMode,
+    interactionMode: "default",
+    cwd: replayDir,
+  });
+  const runtime = yield* adapter.openSession({
+    threadId,
+    providerSessionId: ProviderSessionId.make("session-claude-lifecycle"),
+    modelSelection,
+    runtimePolicy,
+  });
+  yield* Effect.addFinalizer(() => Effect.sync(() => replayGate?.releaseAll()));
+  if (continuationEnabled) {
+    assert.isDefined(
+      runtime.hasPendingBackgroundWork,
+      "Claude ACP v2 must report background work after foreground idle",
+    );
+  }
+  const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
+  yield* runtime.events.pipe(
+    Stream.runForEach((event) => Queue.offer(events, event)),
+    Effect.forkScoped,
+  );
+  const providerThread = yield* runtime.ensureThread({ threadId, modelSelection, runtimePolicy });
+  const now = yield* DateTime.now;
+  const turnInput = (
+    ordinal: number,
+    options: { readonly continuation?: boolean } = {},
+  ): ProviderAdapter.ProviderAdapterV2TurnInput => ({
+    appThread: {
+      createdBy: "user",
+      creationSource: "web",
+      id: threadId,
+      projectId: ProjectId.make(`project-claude-lifecycle`),
+      title: "Claude Agent",
+      providerInstanceId: instanceId,
+      modelSelection,
+      runtimeMode,
+      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,
+    },
+    threadId,
+    runId: RunId.make(`run-claude-lifecycle-${ordinal}`),
+    runOrdinal: ordinal,
+    providerTurnOrdinal: ordinal,
+    attemptId: RunAttemptId.make(`attempt-claude-lifecycle-${ordinal}`),
+    rootNodeId: NodeId.make(`node-claude-lifecycle-${ordinal}`),
+    providerThread,
+    message: {
+      ...(options.continuation === true
+        ? { createdBy: "agent" as const, creationSource: "provider" as const }
+        : { createdBy: "user" as const, creationSource: "web" as const }),
+      messageId: MessageId.make(`message-claude-lifecycle-${ordinal}`),
+      text: "test prompt",
+      attachments: [],
+    },
+    modelSelection,
+    runtimePolicy,
+  });
+  const until = (predicate: (event: ProviderAdapter.ProviderAdapterV2Event) => boolean) =>
+    Effect.gen(function* () {
+      const seen: Array<ProviderAdapter.ProviderAdapterV2Event> = [];
+      while (true) {
+        const event = yield* Queue.take(events);
+        seen.push(event);
+        if (predicate(event)) return seen;
+      }
+    });
+  const throughMarker = (title: string) =>
+    until(
+      (event) =>
+        event.type === "provider_thread.updated" &&
+        event.providerThread.nativeMetadata?.title === title,
+    );
+  const terminal = until((event) => event.type === "turn.terminal").pipe(
+    Effect.map((seen) => {
+      const event = seen.at(-1)!;
+      if (event.type !== "turn.terminal") throw new Error("Missing terminal");
+      return event;
+    }),
+  );
+  return {
+    runtime,
+    providerThread,
+    turnInput,
+    until,
+    throughMarker,
+    terminal,
+    offers,
+    offered,
+    terminate: () =>
+      onTermination(
+        new EffectAcpErrors.AcpTransportError({
+          detail: "Injected fixture process exit",
+          cause: "test",
+        }),
+      ),
+  };
+});
+
+const claudeMarker = (title: string) =>
+  claudeFrames.update(CLAUDE_ROOT_SESSION, {
+    sessionUpdate: "session_info_update",
+    title,
+  });
+const claudeChild = [
+  claudeFrames.update(CLAUDE_ROOT_SESSION, {
+    sessionUpdate: "tool_call_update",
+    toolCallId: "agent-1",
+    name: "Agent",
+    title: "Review",
+    kind: "think",
+    status: "in_progress",
+    rawInput: { prompt: "Review the code", description: "Review", run_in_background: true },
+  }),
+  claudeFrames.childState(CLAUDE_ROOT_SESSION, "child-1", "running"),
+  claudeFrames.update("child-1", {
+    sessionUpdate: "session_message",
+    messageId: "agent-1",
+    senderSessionId: CLAUDE_ROOT_SESSION,
+    recipientSessionId: "child-1",
+    content: [{ type: "text", text: "Review the code" }],
+  }),
+  claudeFrames.update(CLAUDE_ROOT_SESSION, {
+    sessionUpdate: "tool_call_update",
+    toolCallId: "agent-1",
+    status: "completed",
+    _meta: { claudeCode: { toolResponse: { isAsync: true } } },
+  }),
+];
+
+const claudeUnrelatedChildren = [
+  claudeFrames.childState("unknown-parent", "unrelated-child", "running"),
+  claudeFrames.update("unrelated-child", {
+    sessionUpdate: "session_message",
+    messageId: "agent-1",
+    senderSessionId: "unknown-parent",
+    content: [{ type: "text", text: "Unrelated delegation" }],
+  }),
+  claudeFrames.update("unlinked-child", {
+    sessionUpdate: "agent_message_chunk",
+    messageId: "unlinked-reply",
+    content: { type: "text", text: "Unlinked output" },
+  }),
+];
+
 describe("AcpRegistryAdapterV2", () => {
   it("preserves and sanitizes structured ACP errors without exposing arbitrary defects", () => {
     const limit = new EffectAcpErrors.AcpRequestError({
@@ -685,6 +998,935 @@ describe("AcpRegistryAdapterV2", () => {
     }).pipe(Effect.provide(layerTest), Effect.scoped),
   );
 
+  it.effect("launches Claude Agent on ACP v2 unless its instance environment decides", () =>
+    Effect.gen(function* () {
+      const launchSwitch = Effect.fn("launchSwitch")(function* (
+        config: Record<string, unknown>,
+        environment: NodeJS.ProcessEnv = {},
+      ) {
+        let launched: NodeJS.ProcessEnv | undefined;
+        const instanceId = ProviderInstanceId.make("acp-registry-launch-environment");
+        const adapter = yield* makeAcpRegistryAdapterV2({
+          selfInvocation: yield* resolveSelfInvocation(),
+          instanceId,
+          settings: yield* decodeAcpRegistryAdapterSettings(config),
+          environment,
+        }).pipe(
+          Effect.provide(
+            Layer.mock(AcpRegistrySupport.AcpRegistryCatalog)({
+              resolve: (_settings, _cwd, launchEnvironment) => {
+                launched = launchEnvironment;
+                return Effect.fail(
+                  new AcpRegistrySupport.AcpRegistryError({
+                    reason: "runner_unavailable",
+                    detail: "Recorded the launch environment.",
+                  }),
+                );
+              },
+            }),
+          ),
+        );
+        yield* adapter
+          .openSession({
+            threadId: ThreadId.make("thread-acp-registry-launch-environment"),
+            providerSessionId: ProviderSessionId.make("provider-session-launch-environment"),
+            modelSelection: { instanceId, model: "default" },
+            runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+              runtimeMode: "full-access",
+              interactionMode: "default",
+              cwd: process.cwd(),
+            }),
+          })
+          .pipe(Effect.flip);
+        return launched?.CLAUDE_AGENT_ACP_EXPERIMENTAL_V2;
+      });
+
+      assert.equal(yield* launchSwitch({ agentId: "claude-acp" }), "1");
+      assert.equal(
+        yield* launchSwitch(
+          { source: "local", commandPath: "/opt/bin/claude-agent-acp" },
+          { PATH: "/opt/bin" },
+        ),
+        "1",
+      );
+      assert.equal(
+        yield* launchSwitch({ agentId: "claude-acp" }, { CLAUDE_AGENT_ACP_EXPERIMENTAL_V2: "0" }),
+        "0",
+      );
+      assert.isUndefined(yield* launchSwitch({ agentId: "gemini" }));
+      const fallback = yield* openClaudeReplaySession(
+        [
+          ...claudeFrames.open,
+          claudeFrames.prompt(1)[0],
+          claudeChild[0],
+          claudeFrames.update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "agent-1",
+            status: "completed",
+          }),
+          ...claudeFrames.prompt(1).slice(1),
+          claudeFrames.idle("end_turn"),
+          claudeFrames.closeRequest,
+          claudeFrames.closed,
+        ],
+        undefined,
+        false,
+      );
+      assert.isUndefined(
+        fallback.runtime.hasPendingBackgroundWork,
+        "an adapter without a continuation dispatcher must use ordinary prompt completion",
+      );
+      yield* fallback.runtime.startTurn(fallback.turnInput(1));
+      const completed = yield* fallback.until((event) => event.type === "turn.terminal");
+      assert.isTrue(
+        completed.some(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.type === "dynamic_tool" &&
+            event.turnItem.nativeItemRef?.nativeId === "agent-1",
+        ),
+      );
+      const terminal = completed.at(-1)!;
+      if (terminal.type !== "turn.terminal") throw new Error("Missing fallback terminal");
+      assert.equal(terminal.status, "completed");
+    }).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"]);
+      const { update, idle, prompt } = claudeFrames;
+      const session = yield* openClaudeReplaySession(
+        [
+          ...claudeFrames.open,
+          prompt(1)[0],
+          idle("end_turn"),
+          claudeMarker("before acceptance"),
+          { ...prompt(1)[1], label: "accepted" },
+          ...prompt(1).slice(2),
+          update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "agent-1",
+            name: "Agent",
+            title: "Review",
+            kind: "think",
+            status: "pending",
+            rawInput: { description: "Review" },
+          }),
+          update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "malformed-agent",
+            name: "Agent",
+            title: "Incomplete agent",
+            kind: "think",
+            status: "pending",
+            rawInput: { description: "Never receives a prompt" },
+          }),
+          update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "failed-task",
+            name: "Task",
+            title: "Malformed task",
+            kind: "think",
+            status: "failed",
+            rawInput: { description: "Missing prompt" },
+          }),
+          ...claudeChild.slice(0, 2),
+          update("child-1", {
+            sessionUpdate: "agent_message_chunk",
+            messageId: "early-reply",
+            content: { type: "text", text: "First review result." },
+          }),
+          claudeFrames.childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+          ...claudeChild.slice(2),
+          update("child-1", { sessionUpdate: "state_update", state: "running" }),
+          ...claudeUnrelatedChildren,
+          update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "agent_message_chunk",
+            messageId: "reply",
+            content: { type: "text", text: "The review is running." },
+          }),
+          idle("end_turn"),
+          {
+            ...update("child-1", {
+              sessionUpdate: "agent_message_chunk",
+              messageId: "child-reply",
+              content: { type: "text", text: "Found the regression." },
+            }),
+            label: "child-output",
+          },
+          update("child-1", {
+            sessionUpdate: "usage_update",
+            used: 2_500,
+            size: 10_000,
+            cost: { amount: 0.42, currency: "USD" },
+          }),
+          update("child-1", {
+            sessionUpdate: "session_info_update",
+            title: "Child review",
+            updatedAt: "2026-10-19T00:00:00Z",
+          }),
+          update("child-1", {
+            sessionUpdate: "state_update",
+            state: "idle",
+            stopReason: "end_turn",
+            usage: { totalTokens: 3_000, inputTokens: 2_500, outputTokens: 500, thoughtTokens: 0 },
+          }),
+          claudeMarker("child output"),
+          {
+            ...update(CLAUDE_ROOT_SESSION, {
+              sessionUpdate: "user_message",
+              messageId: "wake-user",
+              content: [{ type: "text", text: "Continue the review." }],
+            }),
+            label: "wake",
+          },
+          idle("end_turn"),
+          claudeMarker("continuation idle"),
+          claudeFrames.closeRequest,
+          claudeFrames.closed,
+        ],
+        gate,
+      );
+      yield* session.runtime.startTurn(session.turnInput(1));
+      const beforeAcceptance = yield* session.throughMarker("before acceptance");
+      assert.isFalse(beforeAcceptance.some((event) => event.type === "turn.terminal"));
+      gate.release("accepted");
+      const foreground = yield* session.until((event) => event.type === "turn.terminal");
+      const foregroundTerminal = foreground.at(-1)!;
+      if (foregroundTerminal.type !== "turn.terminal")
+        throw new Error("Missing foreground terminal");
+      assert.equal(foregroundTerminal.status, "completed");
+      const earlyResult = foreground.findLast(
+        (event) => event.type === "subagent.updated" && event.subagent.status === "completed",
+      );
+      assert.isDefined(earlyResult, "a child can finish before its spawn acknowledgement");
+      if (earlyResult?.type !== "subagent.updated") throw new Error("Missing early result");
+      assert.equal(earlyResult.subagent.result, "First review result.");
+      const earlyItem = foreground.findLast(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "subagent" &&
+          event.turnItem.status === "completed",
+      );
+      if (earlyItem?.type !== "turn_item.updated" || earlyItem.turnItem.type !== "subagent")
+        throw new Error("Missing early parent item");
+      assert.equal(earlyItem.turnItem.result, "First review result.");
+      assert.isTrue(yield* session.runtime.hasPendingBackgroundWork!);
+      gate.release("child-output");
+      const childOutput = yield* session.throughMarker("child output");
+      const message = childOutput.find(
+        (event) =>
+          event.type === "message.updated" && event.message.text === "Found the regression.",
+      );
+      assert.isDefined(message, "child output survives foreground completion");
+      if (message?.type !== "message.updated") throw new Error("Missing child output");
+      assert.notEqual(message.message.threadId, session.turnInput(1).threadId);
+      const childThreads = childOutput.flatMap((event) =>
+        event.type === "provider_thread.updated" &&
+        event.providerThread.appThreadId === message.message.threadId
+          ? [event.providerThread]
+          : [],
+      );
+      assert.deepEqual(
+        childThreads.map((thread) => thread.contextUsage),
+        [
+          { usedTokens: 2_500, maxTokens: 10_000, cost: { amount: 0.42, currency: "USD" } },
+          { usedTokens: 2_500, maxTokens: 10_000, cost: { amount: 0.42, currency: "USD" } },
+          { usedTokens: 3_000 },
+        ],
+      );
+      assert.deepEqual(childThreads.at(-1)?.nativeMetadata, {
+        title: "Child review",
+        updatedAt: "2026-10-19T00:00:00Z",
+      });
+      assert.isFalse(childOutput.some((event) => event.type === "turn.terminal"));
+      assert.isTrue(
+        childOutput.some(
+          (event) => event.type === "subagent.updated" && event.subagent.status === "completed",
+        ),
+      );
+      const latestChild = childOutput.findLast((event) => event.type === "subagent.updated");
+      if (latestChild?.type !== "subagent.updated") throw new Error("Missing current child result");
+      assert.equal(latestChild.subagent.result, "Found the regression.");
+      const rootItems = new Map(
+        [...foreground, ...childOutput].flatMap((event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.threadId === session.turnInput(1).threadId
+            ? [[event.turnItem.id, event.turnItem] as const]
+            : [],
+        ),
+      );
+      const generic = [...rootItems.values()].filter((item) => item.type === "dynamic_tool");
+      assert.isFalse(
+        generic.some((item) => item.nativeItemRef?.nativeId === "agent-1"),
+        "native subagents never project a duplicate generic tool",
+      );
+      const malformed = generic.find((item) => item.nativeItemRef?.nativeId === "malformed-agent");
+      assert.isDefined(malformed, "unclassified tools still project on foreground completion");
+      assert.equal(malformed?.status, "completed");
+      const failed = generic.find((item) => item.nativeItemRef?.nativeId === "failed-task");
+      assert.isDefined(failed, "unclassified terminal tools retain ordinary failures");
+      assert.equal(failed?.status, "failed");
+      assert.isFalse(
+        [...rootItems.values()].some((item) => item.type === "user_message"),
+        "the submitted root prompt is already owned by the app",
+      );
+      assert.deepEqual(pendingBackgroundTurnItems({ turnItems: [...rootItems.values()] }), []);
+      assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+      gate.release("wake");
+      yield* Queue.take(session.offered);
+      yield* session.throughMarker("continuation idle");
+      const offer = session.offers[0]!;
+      yield* offer.dispatchIfCurrent!(Effect.void);
+      yield* session.runtime.startTurn(session.turnInput(2, { continuation: true }));
+      const continuation = yield* session.until((event) => event.type === "turn.terminal");
+      const terminal = continuation.at(-1)!;
+      if (terminal.type !== "turn.terminal") throw new Error("Missing continuation terminal");
+      assert.equal(
+        terminal.status,
+        "completed",
+        "buffered acceptance preserves the latest live idle",
+      );
+      assert.isFalse(
+        continuation.some(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "user_message",
+        ),
+        "autonomous root echoes only signal acceptance",
+      );
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
+  it.effect.each([
+    { kind: "approval", stopReason: "end_turn", status: "completed" },
+    { kind: "question", stopReason: "error", status: "failed" },
+  ] as const)("continues Claude's background $kind and preserves $status idle", (testCase) =>
+    Effect.gen(function* () {
+      const gate = makeProviderReplayGate(["wake", "stop-request", "refused-response"]);
+      const method =
+        testCase.kind === "approval" ? "session/request_permission" : "elicitation/create";
+      const params =
+        testCase.kind === "approval"
+          ? {
+              sessionId: "child-1",
+              title: "Run tests?",
+              subject: {
+                type: "tool_call",
+                toolCall: {
+                  toolCallId: "test-command",
+                  name: "Bash",
+                  title: "Run tests",
+                  kind: "execute",
+                  status: "pending",
+                  rawInput: { command: "vp test run" },
+                },
+              },
+              options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }],
+            }
+          : {
+              sessionId: "child-1",
+              mode: "form",
+              message: "Which file?",
+              requestedSchema: {
+                type: "object",
+                properties: { file: { type: "string", title: "File", enum: ["a.ts", "b.ts"] } },
+                required: ["file"],
+              },
+            };
+      const session = yield* openClaudeReplaySession(
+        [
+          ...claudeFrames.open,
+          ...claudeFrames.prompt(1),
+          ...claudeChild,
+          claudeFrames.idle("end_turn"),
+          {
+            ...claudeFrames.update(CLAUDE_ROOT_SESSION, {
+              sessionUpdate: "state_update",
+              state: "running",
+            }),
+            label: "wake",
+          },
+          claudeFrames.update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "user_message",
+            messageId: "wake-user",
+            content: [{ type: "text", text: "Continue the review." }],
+          }),
+          claudeFrames.closeRequest,
+          { type: "emit_inbound", frame: { kind: "request", method, params } },
+          {
+            type: "emit_inbound",
+            label: "refused-response",
+            frame: {
+              kind: "response",
+              method: "session/close",
+              error: { code: -32603, message: "Close refused" },
+            },
+          },
+          {
+            type: "expect_outbound",
+            frame: {
+              kind: "response",
+              method,
+              result:
+                testCase.kind === "approval"
+                  ? { outcome: { outcome: "selected", optionId: "allow" } }
+                  : { action: "accept", content: { file: "a.ts" } },
+            },
+          },
+          claudeFrames.childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+          ...claudeUnrelatedChildren,
+          claudeFrames.update(CLAUDE_ROOT_SESSION, {
+            sessionUpdate: "state_update",
+            state: "idle",
+            stopReason: testCase.stopReason,
+            ...(testCase.status === "failed"
+              ? { error: { code: -32603, message: "API Error: 529 overloaded" } }
+              : {}),
+          }),
+          {
+            type: "emit_inbound",
+            label: "stop-request",
+            frame: { kind: "request", method, params },
+          },
+          claudeFrames.closeRequest,
+          claudeFrames.closed,
+          {
+            type: "expect_outbound",
+            frame: {
+              kind: "response",
+              method,
+              result:
+                testCase.kind === "approval"
+                  ? { outcome: { outcome: "cancelled" } }
+                  : { action: "cancel" },
+            },
+          },
+          claudeMarker("detached request cancelled"),
+        ],
+        gate,
+      );
+      yield* session.runtime.startTurn(session.turnInput(1));
+      assert.equal((yield* session.terminal).status, "completed");
+      assert.isTrue(yield* session.runtime.hasPendingBackgroundWork!);
+      gate.release("wake");
+      yield* Queue.take(session.offered);
+      const offer = session.offers[0]!;
+      assert.isDefined(offer.dispatchIfCurrent);
+      yield* offer.dispatchIfCurrent!(Effect.void);
+      yield* session.runtime.startTurn(session.turnInput(2, { continuation: true }));
+      const started = yield* session.until(
+        (event) =>
+          event.type === "provider_turn.updated" && event.providerTurn.status === "running",
+      );
+      const running = started.at(-1)!;
+      if (running.type !== "provider_turn.updated") throw new Error("Missing active continuation");
+      const closing = yield* session.runtime
+        .interruptTurn({
+          providerThread: session.providerThread,
+          providerTurnId: running.providerTurn.id,
+          requestRuntimeRestart: true,
+        })
+        .pipe(Effect.exit, Effect.forkScoped);
+      yield* Effect.addFinalizer(() => Effect.sync(() => gate.releaseAll()));
+      const seen = yield* session.until(
+        (event) =>
+          event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
+      );
+      assert.isFalse(
+        seen.some(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "user_message",
+        ),
+      );
+      const request = seen.at(-1)!;
+      if (request.type !== "runtime_request.updated") throw new Error("Missing request");
+      assert.isTrue(
+        seen.some(
+          (event) =>
+            event.type === "node.updated" &&
+            event.node.id === request.runtimeRequest.nodeId &&
+            event.node.runId === session.turnInput(2).runId,
+        ),
+      );
+      yield* Effect.promise(() => gate.waitForReached("refused-response"));
+      gate.release("refused-response");
+      assert.isTrue(Exit.isFailure(yield* Fiber.join(closing)));
+      assert.isTrue(yield* session.runtime.hasPendingBackgroundWork!);
+      yield* session.runtime.respondToRuntimeRequest({
+        requestId: request.runtimeRequest.id,
+        ...(testCase.kind === "approval"
+          ? { decision: "accept" as const }
+          : { answers: { file: "a.ts" } }),
+      });
+      const terminal = yield* session.terminal;
+      assert.equal(terminal.status, testCase.status);
+      if (terminal.status === "failed") {
+        assert.include(terminal.failure?.message ?? "", "529 overloaded");
+        assert.isUndefined(terminal.childTurnsContinue);
+        assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+      }
+      gate.release("stop-request");
+      yield* Queue.take(session.offered);
+      yield* session.runtime.interruptTurn({
+        providerThread: session.providerThread,
+        providerTurnId: terminal.providerTurnId,
+        requestRuntimeRestart: true,
+      });
+      const cancelled = yield* session.throughMarker("detached request cancelled");
+      assert.isFalse(
+        cancelled.some(
+          (event) =>
+            event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending",
+        ),
+        "detached requests are cancelled before turn admission",
+      );
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
+  it.effect.each(["error", "end_turn"])(
+    "hands live Claude child tools to the next run after %s and keeps nested output in the child",
+    (stopReason) =>
+      Effect.gen(function* () {
+        const { update, childState, idle, prompt } = claudeFrames;
+        const gate = makeProviderReplayGate(["nested-output", "nested-idle"]);
+        const session = yield* openClaudeReplaySession(
+          [
+            ...claudeFrames.open,
+            ...prompt(1),
+            update(CLAUDE_ROOT_SESSION, {
+              sessionUpdate: "tool_call_update",
+              toolCallId: "agent-1",
+              name: "Agent",
+              title: "Review",
+              kind: "think",
+              status: "in_progress",
+              rawInput: { prompt: "Review the code", description: "Review" },
+            }),
+            ...claudeChild.slice(1, -1),
+            update("child-1", {
+              sessionUpdate: "tool_call_update",
+              toolCallId: "child-tool",
+              name: "Bash",
+              title: "Read package",
+              kind: "execute",
+              status: "in_progress",
+              rawInput: { command: "cat package.json" },
+            }),
+            update("child-1", {
+              sessionUpdate: "agent_message_chunk",
+              messageId: "progress",
+              content: { type: "text", text: "Review in progress." },
+            }),
+            idle(stopReason),
+            ...prompt(2),
+            childState(CLAUDE_ROOT_SESSION, "child-1", "running"),
+            update("child-1", {
+              sessionUpdate: "session_message",
+              messageId: "resume-child",
+              senderSessionId: CLAUDE_ROOT_SESSION,
+              recipientSessionId: "child-1",
+              content: [{ type: "text", text: "Continue the review." }],
+            }),
+            claudeMarker("resumed"),
+            childState("child-1", "grandchild", "running"),
+            childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+            update(CLAUDE_ROOT_SESSION, {
+              sessionUpdate: "tool_call_update",
+              toolCallId: "agent-1",
+              name: "Agent",
+              status: "completed",
+              rawInput: { prompt: "Review the code", description: "Review" },
+            }),
+            idle("end_turn"),
+            {
+              ...update("grandchild", {
+                sessionUpdate: "terminal_update",
+                terminalId: "nested-terminal",
+                command: "/usr/bin/node /srv/t3/bin.ts acp-mcp-call orchestrator_capabilities {}",
+              }),
+              label: "nested-output",
+            },
+            update("grandchild", {
+              sessionUpdate: "terminal_output_chunk",
+              terminalId: "nested-terminal",
+              data: Buffer.from("{}\n").toString("base64"),
+            }),
+            update("grandchild", {
+              sessionUpdate: "terminal_update",
+              terminalId: "nested-terminal",
+              exitStatus: { exitCode: 0 },
+            }),
+            update("grandchild", {
+              sessionUpdate: "tool_call_update",
+              toolCallId: "terminal-tool",
+              name: "Bash",
+              title: "Run nested command",
+              kind: "execute",
+              status: "in_progress",
+              content: [{ type: "terminal", terminalId: "nested-terminal" }],
+            }),
+            update("grandchild", {
+              sessionUpdate: "tool_call_update",
+              toolCallId: "nested-tool",
+              name: "Bash",
+              title: "Read nested package",
+              kind: "execute",
+              status: "in_progress",
+              rawInput: { command: "cat nested/package.json" },
+            }),
+            update("grandchild", {
+              sessionUpdate: "agent_message_chunk",
+              messageId: "nested-reply",
+              content: { type: "text", text: "Nested output" },
+            }),
+            update(CLAUDE_ROOT_SESSION, {
+              sessionUpdate: "user_message",
+              messageId: "nested-wake",
+              content: [{ type: "text", text: "Continue the review." }],
+            }),
+            idle("end_turn"),
+            claudeMarker("nested"),
+            {
+              ...childState("child-1", "grandchild", "idle"),
+              label: "nested-idle",
+            },
+            claudeMarker("nested idle"),
+            ...prompt(4),
+            update("child-1", {
+              sessionUpdate: "session_message",
+              messageId: "second-review",
+              senderSessionId: CLAUDE_ROOT_SESSION,
+              recipientSessionId: "child-1",
+              content: [{ type: "text", text: "Review the fix." }],
+            }),
+            childState(CLAUDE_ROOT_SESSION, "child-1", "running"),
+            update("child-1", {
+              sessionUpdate: "agent_message_chunk",
+              messageId: "nested-reply",
+              content: { type: "text", text: "The fix is correct." },
+            }),
+            childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+            idle("end_turn"),
+            claudeFrames.closeRequest,
+            claudeFrames.closed,
+          ],
+          gate,
+        );
+        yield* session.runtime.startTurn(session.turnInput(1));
+        const settled = yield* session.terminal;
+        assert.equal(settled.status, stopReason === "error" ? "failed" : "completed");
+        if (settled.status === "failed") assert.isTrue(settled.childTurnsContinue);
+        yield* session.runtime.startTurn(session.turnInput(2));
+        const resumed = yield* session.throughMarker("resumed");
+        const row = resumed.find((event) => event.type === "subagent.updated");
+        assert.isDefined(row);
+        if (row?.type !== "subagent.updated") throw new Error("Missing resumed child");
+        assert.equal(row.subagent.runId, session.turnInput(2).runId);
+        assert.equal(
+          row.subagent.result,
+          "Review in progress.",
+          "live handoff retains current execution progress",
+        );
+        assert.lengthOf(
+          resumed.filter(
+            (event) =>
+              event.type === "message.updated" &&
+              event.message.threadId === row.subagent.childThreadId &&
+              event.message.role === "user" &&
+              event.message.text === "Continue the review.",
+          ),
+          1,
+          "child resume prompts remain visible once",
+        );
+        const openTools = resumed.filter(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.type === "dynamic_tool" &&
+            event.turnItem.status === "running",
+        );
+        assert.lengthOf(openTools, 1, "handoff announces each open child tool once");
+        const foreground = yield* session.until((event) => event.type === "turn.terminal");
+        assert.isTrue(
+          foreground.some(
+            (event) => event.type === "subagent.updated" && event.subagent.status === "completed",
+          ),
+          "the foreground Agent tool terminalizes its visible owner",
+        );
+        assert.isTrue(yield* session.runtime.hasPendingBackgroundWork!);
+        gate.release("nested-output");
+        const childOutput = yield* session.throughMarker("nested");
+        yield* Queue.take(session.offered);
+        assert.lengthOf(session.offers, 1);
+        yield* session.offers[0]!.dispatchIfCurrent!(Effect.void);
+        yield* session.runtime.startTurn(session.turnInput(3, { continuation: true }));
+        const continued = yield* session.until((event) => event.type === "turn.terminal");
+        const terminal = continued.at(-1)!;
+        if (terminal.type !== "turn.terminal") throw new Error("Missing continuation terminal");
+        assert.equal(terminal.status, "completed");
+        const nested = [...childOutput, ...continued];
+        const messages = nested.filter(
+          (event) => event.type === "message.updated" && event.message.text === "Nested output",
+        );
+        assert.lengthOf(messages, 1);
+        if (messages[0]?.type === "message.updated") {
+          assert.equal(messages[0].message.threadId, row.subagent.childThreadId);
+        }
+        const nestedTool = nested.find(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.type === "dynamic_tool" &&
+            event.turnItem.nativeItemRef?.nativeId ===
+              "agent-1:session:grandchild:tool:nested-tool",
+        );
+        assert.isDefined(nestedTool);
+        if (nestedTool?.type === "turn_item.updated") {
+          assert.equal(nestedTool.turnItem.threadId, row.subagent.childThreadId);
+          if (nestedTool.turnItem.type === "dynamic_tool")
+            assert.deepEqual(nestedTool.turnItem.input, { command: "cat nested/package.json" });
+        }
+        assert.isTrue(
+          nested.some(
+            (event) =>
+              event.type === "turn_item.updated" &&
+              event.turnItem.type === "dynamic_tool" &&
+              event.turnItem.nativeItemRef?.nativeId ===
+                "agent-1:session:grandchild:tool:terminal-tool" &&
+              event.turnItem.threadId === row.subagent.childThreadId &&
+              event.turnItem.toolName === "t3-code.orchestrator_capabilities",
+          ),
+          "embedded agent-terminal commands preserve nested MCP identity",
+        );
+        assert.isTrue(yield* session.runtime.hasPendingBackgroundWork!);
+        gate.release("nested-idle");
+        const finished = yield* session.throughMarker("nested idle");
+        assert.isTrue(
+          finished.some(
+            (event) => event.type === "subagent.updated" && event.subagent.status === "completed",
+          ),
+        );
+        assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+        assert.lengthOf(session.offers, 1, "nested frames make progress in one continuation");
+        const firstResult = finished.findLast((event) => event.type === "subagent.updated");
+        if (firstResult?.type !== "subagent.updated")
+          throw new Error("Missing first review result");
+        assert.equal(
+          firstResult.subagent.result,
+          "Review in progress.",
+          "reopening the visible owner for a running descendant keeps its execution result",
+        );
+        yield* session.runtime.startTurn(session.turnInput(4));
+        const reviewed = yield* session.until((event) => event.type === "turn.terminal");
+        const currentResult = reviewed.findLast((event) => event.type === "subagent.updated");
+        if (currentResult?.type !== "subagent.updated")
+          throw new Error("Missing second review result");
+        assert.equal(currentResult.subagent.id, row.subagent.id);
+        assert.equal(currentResult.subagent.childThreadId, row.subagent.childThreadId);
+        assert.equal(currentResult.subagent.result, "The fix is correct.");
+        const currentItem = reviewed.findLast(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "subagent",
+        );
+        if (currentItem?.type !== "turn_item.updated" || currentItem.turnItem.type !== "subagent")
+          throw new Error("Missing current parent item");
+        assert.equal(currentItem.turnItem.result, "The fix is correct.");
+        assert.lengthOf(
+          reviewed.filter(
+            (event) =>
+              event.type === "message.updated" && event.message.text === "The fix is correct.",
+          ),
+          1,
+          "a new execution does not append the previous execution's text",
+        );
+        assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+      }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
+  it.effect("fails active Claude work and releases its children when the process exits", () =>
+    Effect.gen(function* () {
+      const session = yield* openClaudeReplaySession([
+        ...claudeFrames.open,
+        ...claudeFrames.prompt(1),
+        ...claudeChild,
+        claudeMarker("child ready"),
+      ]);
+      yield* session.runtime.startTurn(session.turnInput(1));
+      yield* session.throughMarker("child ready");
+      yield* session.terminate();
+      const terminal = yield* session.terminal;
+      assert.equal(terminal.status, "failed");
+      assert.equal(terminal.failure?.class, "transport_error");
+      assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+      const settled = yield* openClaudeReplaySession([
+        ...claudeFrames.open,
+        ...claudeFrames.prompt(1),
+        ...claudeChild,
+        claudeFrames.childState("child-1", "grandchild", "running"),
+        claudeFrames.update("grandchild", {
+          sessionUpdate: "tool_call_update",
+          toolCallId: "nested-tool",
+          name: "Bash",
+          kind: "execute",
+          status: "in_progress",
+          rawInput: { command: "cat package.json" },
+        }),
+        claudeFrames.childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+        claudeFrames.idle("end_turn"),
+      ]);
+      yield* settled.runtime.startTurn(settled.turnInput(1));
+      const foreground = yield* settled.until((event) => event.type === "turn.terminal");
+      const completed = foreground.at(-1)!;
+      if (completed.type !== "turn.terminal") throw new Error("Missing settled root terminal");
+      assert.equal(completed.status, "completed");
+      assert.isTrue(yield* settled.runtime.hasPendingBackgroundWork!);
+      yield* settled.terminate();
+      assert.isFalse(
+        yield* settled.runtime.hasPendingBackgroundWork!,
+        "exit releases visible owners held open by nested work",
+      );
+      const exited = yield* settled.until(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "subagent" &&
+          event.turnItem.status === "failed",
+      );
+      assert.isTrue(
+        exited.some(
+          (event) => event.type === "subagent.updated" && event.subagent.status === "failed",
+        ),
+      );
+      const items = new Map(
+        [...foreground, ...exited].flatMap((event) =>
+          event.type === "turn_item.updated" ? [[event.turnItem.id, event.turnItem] as const] : [],
+        ),
+      );
+      assert.deepEqual(pendingBackgroundTurnItems({ turnItems: [...items.values()] }), []);
+      assert.isTrue(
+        exited.some(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.type === "dynamic_tool" &&
+            event.turnItem.status === "interrupted",
+        ),
+      );
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
+  it.effect("keeps Claude activity after a refused Stop and closes it on retry", () =>
+    Effect.gen(function* () {
+      const gate = makeProviderReplayGate(["close-response", "queued-close-response"]);
+      const session = yield* openClaudeReplaySession(
+        [
+          ...claudeFrames.open,
+          ...claudeFrames.prompt(1),
+          ...claudeChild,
+          claudeMarker("before Stop"),
+          claudeFrames.closeRequest,
+          claudeFrames.update("child-1", {
+            sessionUpdate: "agent_message_chunk",
+            messageId: "closing-reply",
+            content: { type: "text", text: "Finished during close." },
+          }),
+          claudeFrames.childState(CLAUDE_ROOT_SESSION, "child-1", "idle"),
+          claudeFrames.idle("end_turn"),
+          claudeMarker("idle during close"),
+          {
+            type: "emit_inbound",
+            label: "close-response",
+            frame: {
+              kind: "response",
+              method: "session/close",
+              error: { code: -32603, message: "Close refused" },
+            },
+          },
+          ...claudeFrames.prompt(2),
+          claudeMarker("before retry"),
+          claudeFrames.closeRequest,
+          claudeFrames.idle("cancelled"),
+          claudeFrames.closed,
+        ],
+        gate,
+      );
+      yield* session.runtime.startTurn(session.turnInput(1));
+      const started = yield* session.throughMarker("before Stop");
+      const running = started.findLast((event) => event.type === "provider_turn.updated");
+      if (running?.type !== "provider_turn.updated") throw new Error("Missing active turn");
+      const stop = {
+        providerThread: session.providerThread,
+        providerTurnId: running.providerTurn.id,
+        requestRuntimeRestart: true,
+      };
+      const closing = yield* session.runtime
+        .interruptTurn(stop)
+        .pipe(Effect.exit, Effect.forkScoped);
+      yield* Effect.addFinalizer(() => Effect.sync(() => gate.releaseAll()));
+      const idle = yield* session.throughMarker("idle during close");
+      gate.release("close-response");
+      const refused = yield* Fiber.join(closing);
+      assert.isTrue(Exit.isFailure(refused), "a refused close must not report a successful Stop");
+      const terminal = idle.findLast((event) => event.type === "turn.terminal");
+      assert.equal(
+        terminal?.type === "turn.terminal" ? terminal.status : null,
+        "completed",
+        "idle during a refused close must settle the foreground turn",
+      );
+      const result = idle.findLast((event) => event.type === "subagent.updated");
+      if (result?.type !== "subagent.updated") throw new Error("Missing child close-time result");
+      assert.equal(result.subagent.status, "completed");
+      assert.equal(result.subagent.result, "Finished during close.");
+      assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+      yield* session.runtime.startTurn(session.turnInput(2));
+      const retry = yield* session.throughMarker("before retry");
+      const retryRunning = retry.findLast((event) => event.type === "provider_turn.updated");
+      if (retryRunning?.type !== "provider_turn.updated")
+        throw new Error("Missing active retry turn");
+      yield* session.runtime.interruptTurn({
+        ...stop,
+        providerTurnId: retryRunning.providerTurn.id,
+      });
+      assert.equal((yield* session.terminal).status, "interrupted");
+      assert.isFalse(yield* session.runtime.hasPendingBackgroundWork!);
+
+      const queued = yield* openClaudeReplaySession(
+        [
+          ...claudeFrames.open,
+          {
+            type: "expect_outbound",
+            frame: { kind: "request", method: "session/prompt", params: "<any>" },
+          },
+          claudeMarker("before queued Stop"),
+          claudeFrames.closeRequest,
+          {
+            type: "emit_inbound",
+            frame: {
+              kind: "response",
+              method: "session/prompt",
+              error: { code: -32800, message: "Request cancelled" },
+            },
+          },
+          { ...claudeFrames.closed, label: "queued-close-response" },
+        ],
+        gate,
+      );
+      yield* queued.runtime.startTurn(queued.turnInput(3));
+      const pending = yield* queued.throughMarker("before queued Stop");
+      const queuedRunning = pending.findLast((event) => event.type === "provider_turn.updated");
+      if (queuedRunning?.type !== "provider_turn.updated")
+        throw new Error("Missing queued provider turn");
+      const queuedClosing = yield* queued.runtime
+        .interruptTurn({
+          providerThread: queued.providerThread,
+          providerTurnId: queuedRunning.providerTurn.id,
+          requestRuntimeRestart: true,
+        })
+        .pipe(Effect.forkScoped);
+      const queuedTerminal = yield* queued.terminal;
+      gate.release("queued-close-response");
+      yield* Fiber.join(queuedClosing);
+      assert.equal(queuedTerminal.providerTurnId, queuedRunning.providerTurn.id);
+      assert.equal(queuedTerminal.status, "interrupted");
+      assert.isNull(queuedTerminal.failure);
+      assert.isFalse(yield* queued.runtime.hasPendingBackgroundWork!);
+    }).pipe(Effect.provide(layerTest), Effect.scoped),
+  );
+
   it.effect("opens a real ACP child process resolved from registry configuration", () =>
     Effect.gen(function* () {
       const path = yield* Path.Path;
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index c54b6e9006ba6..d3a63ae6ac27d 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -331,13 +331,17 @@ describe("ClaudeAdapterV2 runtime query policy", () => {
   });
 
   it("projects AskUserQuestion input with question text as the answer key", () => {
+    const preview = "\n  **Proposed change**\n\n```ts\n\tconst enabled = true;\n```\n  ";
     assert.deepEqual(
       ClaudeAdapterV2.claudeUserInputQuestions({
         questions: [
           {
             header: "Approach",
             question: "Which approach?",
-            options: [{ label: "Simple", description: "Use fewer moving parts" }],
+            options: [
+              { label: "Simple", description: "Use fewer moving parts", preview },
+              { label: "Safe", description: "Keep the current setup" },
+            ],
             multiSelect: true,
           },
         ],
@@ -347,7 +351,10 @@ describe("ClaudeAdapterV2 runtime query policy", () => {
           id: "Which approach?",
           header: "Approach",
           question: "Which approach?",
-          options: [{ label: "Simple", description: "Use fewer moving parts" }],
+          options: [
+            { label: "Simple", description: "Use fewer moving parts", preview },
+            { label: "Safe", description: "Keep the current setup" },
+          ],
           multiSelect: true,
         },
       ],
@@ -500,6 +507,30 @@ describe("ClaudeAdapterV2 runtime query policy", () => {
     });
   });
 
+  it("keeps approval checks when Full access must fall back to an allowed Claude mode", () => {
+    const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
+      runtimeMode: "full-access",
+      interactionMode: "default",
+      cwd: "/workspace",
+      approvalPolicy: "never",
+    });
+
+    assert.deepEqual(
+      ClaudeAdapterV2.claudeRuntimeQueryPolicyForRuntimePolicy(runtimePolicy, {
+        bypassDisabled: true,
+        autoDisabled: false,
+      }),
+      { permissionMode: "auto", installPermissionCallback: true },
+    );
+    assert.deepEqual(
+      ClaudeAdapterV2.claudeRuntimeQueryPolicyForRuntimePolicy(runtimePolicy, {
+        bypassDisabled: true,
+        autoDisabled: true,
+      }),
+      { permissionMode: "default", installPermissionCallback: true },
+    );
+  });
+
   it("maps Auto runtime mode to Claude's AI-reviewed permission mode", () => {
     const queryPolicy = ClaudeAdapterV2.claudeRuntimeQueryPolicyForRuntimePolicy(
       ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
@@ -3640,6 +3671,97 @@ describe("ClaudeAdapterV2 background wake turns", () => {
     ),
   );
 
+  it.effect.each([
+    {
+      name: "an unflagged result with surrounding whitespace",
+      isError: false,
+      result: "  API Error: 400 Request rejected by a safeguard.\n",
+      expected: "API Error: 400 Request rejected by a safeguard.",
+    },
+    {
+      name: "a secret crossing the truncation boundary",
+      isError: true,
+      result: `API Error: 400 ${"x".repeat(440)} {"token":"${"synthetic-secret".repeat(100)}"} ${"y".repeat(100)}`,
+      expected: `API Error: 400 ${"x".repeat(440)} {"token":"[REDACTED]"} `.padEnd(500, "y"),
+    },
+    {
+      name: "ordinary assistant text",
+      isError: true,
+      result: "I found three files.",
+      expected: "Claude gave up after repeated API errors.",
+    },
+    {
+      name: "a listed non-diagnostic error",
+      isError: true,
+      result: "API Error: 400 Request rejected.",
+      errors: ["[ede_diagnostic] internal detail", "Tool execution failed: EACCES"],
+      expected: "Tool execution failed: EACCES",
+    },
+    {
+      name: "an HTTP 529 overload",
+      isError: true,
+      result: "API Error: 529 Specific overload detail.",
+      apiErrorStatus: 529,
+      expected: "Claude API is overloaded (529). Try again shortly.",
+    },
+    {
+      name: "an HTTP 429 rate limit",
+      isError: true,
+      result: "API Error: 429 Specific rate limit detail.",
+      apiErrorStatus: 429,
+      expected: "Claude API rate limit reached. Try again later.",
+    },
+    {
+      name: "a different terminal reason",
+      isError: true,
+      result: "API Error: 400 Request rejected.",
+      terminalReason: "prompt_too_long" as const,
+      expected:
+        "Claude stopped: the prompt exceeds the model's context window. Run /compact or start a new thread.",
+    },
+  ])("reports terminal API error text for $name", (input) =>
+    Effect.gen(function* () {
+      const harness = yield* makeWakeHarness;
+      const now = yield* DateTime.now;
+      yield* harness.runtime.startTurn(
+        makeClaudeTestTurnInput({
+          threadId: harness.threadId,
+          providerThread: harness.providerThread,
+          now,
+          attemptId: RunAttemptId.make("attempt-claude-specific-api-error"),
+          text: "Continue.",
+          attachments: [],
+        }),
+      );
+      const apiErrorStatus = input.apiErrorStatus ?? 400;
+      yield* Queue.offer(
+        harness.sdkMessages,
+        makeResultFrame({
+          uuid: "00000000-0000-4000-8000-000000000699",
+          result: input.result,
+          terminalReason: input.terminalReason ?? "api_error",
+          apiErrorStatus,
+          isError: input.isError,
+          ...(input.errors === undefined ? {} : { errors: input.errors }),
+        }),
+      );
+
+      const terminal = yield* Queue.take(harness.terminalReceipts);
+      assert.equal(terminal.status, "failed");
+      if (terminal.status !== "failed") return;
+      assert.equal(terminal.failure.message, input.expected);
+      assert.equal(terminal.failure.code, `api_error_${apiErrorStatus}`);
+      assert.equal(
+        terminal.failure.class,
+        apiErrorStatus === 429 ? "usage_limit" : "provider_error",
+      );
+    }).pipe(
+      Effect.provide(
+        Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer),
+      ),
+    ),
+  );
+
   it.effect("names an expired Claude login instead of the terminal API error", () =>
     Effect.gen(function* () {
       const configDir = "/synthetic/Claude config";
@@ -3671,7 +3793,7 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         }),
         makeResultFrame({
           uuid: "00000000-0000-4000-8000-000000000607",
-          result: "API Error",
+          result: "API Error: 401 Credentials expired.",
           terminalReason: "api_error",
         }),
       ]);
@@ -3930,7 +4052,7 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         harness.sdkMessages,
         makeResultFrame({
           uuid: "00000000-0000-4000-8000-000000000610",
-          result: "API Error",
+          result: recovered ? "API Error" : "API Error: 400 Specific provider detail.",
           terminalReason: "api_error",
         }),
       );
@@ -13190,6 +13312,8 @@ describe("ClaudeAdapterV2 background wake turns", () => {
     readonly state: "queued" | "start" | "done";
     readonly secondState?: "queued" | "start" | "done";
     readonly startedAt?: number;
+    readonly lastProgressAt?: number;
+    readonly durationMs?: number;
     readonly label?: string;
     readonly prompt?: string;
     readonly model?: string;
@@ -13215,6 +13339,8 @@ describe("ClaudeAdapterV2 background wake turns", () => {
           model: input.model ?? "claude-opus-5[1m]",
           promptPreview: input.prompt ?? "Reply with exactly: A1",
           ...(input.startedAt === undefined ? {} : { startedAt: input.startedAt }),
+          ...(input.lastProgressAt === undefined ? {} : { lastProgressAt: input.lastProgressAt }),
+          ...(input.durationMs === undefined ? {} : { durationMs: input.durationMs }),
           ...(input.attempt === undefined ? {} : { attempt: input.attempt }),
           ...(input.state === "done" && input.omitResult !== true
             ? { resultPreview: "A1 excerpt" }
@@ -15385,6 +15511,10 @@ describe("ClaudeAdapterV2 background wake turns", () => {
         );
         assert.equal(workflowMemberEvents(harness.events, 1).at(-1)?.subagent.status, "completed");
         assert.equal(workflowMemberEvents(harness.events, 2).at(-1)?.subagent.status, "completed");
+        assert.deepEqual(
+          workflowMemberEvents(harness.events, 1).at(-1)?.subagent.completedAt,
+          yield* DateTime.now,
+        );
         assert.deepEqual(
           threadMessages(harness.events, firstThreadId).map((event) => event.message.text),
           ["Reply with exactly: A1", "A1 from the transcript"],
@@ -15445,6 +15575,9 @@ describe("ClaudeAdapterV2 background wake turns", () => {
             uuid: "00000000-0000-4000-8000-000000001018",
             state: "done",
             attempt: 2,
+            startedAt: 1000,
+            durationMs: 500,
+            lastProgressAt: 4432,
           }),
         );
         yield* awaitUntil(
@@ -15452,22 +15585,24 @@ describe("ClaudeAdapterV2 background wake turns", () => {
           "two-turn workflow member answer",
         );
         assert.deepEqual(currentAssistantAnswers().slice(-2), ["First answer", "Second answer"]);
+        const completedMember = workflowMemberEvents(harness.events, 1).at(-1)?.subagent;
+        assert.equal(
+          completedMember?.completedAt && DateTime.toEpochMillis(completedMember.completedAt),
+          4432,
+        );
         assert.notDeepEqual(
           workflowMemberEvents(harness.events, 1).at(-1)?.subagent.startedAt,
           previousStartedAt,
         );
-        yield* Queue.offer(
-          harness.sdkMessages,
+        yield* harness.offerAndWait(
           workflowSnapshot({
             uuid: "00000000-0000-4000-8000-000000001019",
             state: "start",
             attempt: 3,
           }),
         );
-        yield* awaitUntil(
-          () => workflowMemberEvents(harness.events, 1).at(-1)?.subagent.status === "running",
-          "retried workflow member running",
-        );
+        assert.equal(workflowMemberEvents(harness.events, 1).at(-1)?.subagent.status, "running");
+        assert.isNull(workflowMemberEvents(harness.events, 1).at(-1)?.subagent.completedAt);
         yield* Queue.offer(
           harness.sdkMessages,
           workflowSnapshot({
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index a3403eb49aedc..bdaa000bf401d 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -1937,10 +1937,27 @@ export interface ClaudeRuntimeQueryPolicy {
   readonly installPermissionCallback: boolean;
 }
 
+interface ClaudeBypassAvailability {
+  readonly bypassDisabled: boolean;
+  readonly autoDisabled: boolean;
+}
+
+const CLAUDE_BYPASS_FULLY_AVAILABLE: ClaudeBypassAvailability = {
+  bypassDisabled: false,
+  autoDisabled: false,
+};
+
 export function claudeRuntimeQueryPolicyForRuntimePolicy(
   runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy,
+  availability: ClaudeBypassAvailability = CLAUDE_BYPASS_FULLY_AVAILABLE,
 ): ClaudeRuntimeQueryPolicy {
-  const permissionMode = permissionModeForClaudeRuntimePolicy(runtimePolicy);
+  const requestedMode = permissionModeForClaudeRuntimePolicy(runtimePolicy);
+  const downgraded = requestedMode === "bypassPermissions" && availability.bypassDisabled;
+  const permissionMode = downgraded
+    ? availability.autoDisabled
+      ? "default"
+      : "auto"
+    : requestedMode;
   const readOnlyTools =
     sandboxPolicyKindForClaudeRuntimePolicy(runtimePolicy) === "readOnly"
       ? CLAUDE_READ_ONLY_ALLOWED_TOOLS
@@ -1952,10 +1969,11 @@ export function claudeRuntimeQueryPolicyForRuntimePolicy(
   // acceptEdits approves edits before the callback runs; everything else it
   // leaves to the callback, which must ask rather than allow.
   const installPermissionCallback =
-    runtimePolicy.approvalPolicy === undefined
+    downgraded ||
+    (runtimePolicy.approvalPolicy === undefined
       ? runtimePolicy.runtimeMode === "approval-required" ||
         runtimePolicy.runtimeMode === "auto-accept-edits"
-      : runtimePolicy.approvalPolicy !== "never";
+      : runtimePolicy.approvalPolicy !== "never");
 
   if (permissionMode === "plan") {
     return {
@@ -2950,11 +2968,17 @@ function providerFailureFromResult(
       ? "usage_limit"
       : "provider_error";
   const listedError = resultUserFacingError(message);
+  const apiErrorMessage =
+    message.subtype === "success" &&
+    message.terminal_reason === "api_error" &&
+    message.result.trim().startsWith("API Error:")
+      ? makeProviderFailure({ message: message.result }).message.slice(0, 500)
+      : undefined;
   const structuredError = isOverloadedResult(message)
     ? "Claude API is overloaded (529). Try again shortly."
     : message.subtype === "success" && message.api_error_status === 429
       ? "Claude API rate limit reached. Try again later."
-      : terminalResultError(message.terminal_reason, failureHint);
+      : terminalResultError(message.terminal_reason, failureHint ?? apiErrorMessage);
   if (message.subtype !== "success") {
     return makeProviderFailure({
       message: listedError ?? structuredError ?? message.errors.join("\n"),
@@ -3400,7 +3424,15 @@ export function claudeUserInputQuestions(
           if (label.length === 0) return [];
           const description =
             typeof optionRecord.description === "string" ? optionRecord.description.trim() : "";
-          return [{ label, description: description || label }];
+          return [
+            {
+              label,
+              description: description || label,
+              ...(typeof optionRecord.preview === "string"
+                ? { preview: optionRecord.preview }
+                : {}),
+            },
+          ];
         })
       : [];
     return [
@@ -4826,12 +4858,15 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                   : ((restarted ? null : previous?.startedAt) ??
                     (status === "running" ? now : null));
             const completedAt = settled
-              ? ((restarted ? null : previous?.completedAt) ?? now)
+              ? member.completedAt !== undefined
+                ? DateTime.makeUnsafe(member.completedAt)
+                : ((restarted ? null : previous?.completedAt) ?? now)
               : null;
             const changed =
               restarted ||
               previous?.status !== status ||
               !Equal.equals(previous?.startedAt, startedAt) ||
+              !Equal.equals(previous?.completedAt, completedAt) ||
               previous?.result !== member.result ||
               previous?.label !== member.label ||
               previous?.prompt !== prompt ||
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
index 2c6c62446bc1a..a7212a95a572c 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
@@ -3333,6 +3333,50 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
     }).pipe(Effect.scoped),
   );
 
+  it.effect("keeps thread-scoped T3 waits as dynamic tools through their lifecycle", () =>
+    Effect.gen(function* () {
+      const tool = { sessionID: SESSION, assistantMessageID: "msg_assistant", id: "call-wait" };
+      const name = "t3-code-web_delegate_task";
+      const input = { task: "Review", mode: "wait" };
+      const { runtime, thread } = yield* resumed([
+        out("session.prompt", { sessionID: SESSION, text: "<any>" }),
+        promptAccepted,
+        event("session.tool.input.started", { ...tool, name }),
+        event("session.tool.called", { ...tool, name, input, executed: true }),
+        event("session.tool.success", {
+          ...tool,
+          content: [{ type: "text", text: "Reviewed" }],
+          metadata: {},
+          executed: true,
+        }),
+        event("session.execution.succeeded", { sessionID: SESSION }),
+      ]);
+      const events = yield* runtime.events.pipe(
+        Stream.takeUntil((event) => event.type === "turn.terminal"),
+        Stream.runCollect,
+        Effect.forkScoped,
+      );
+      yield* runtime.startTurn(turnInput(thread));
+      const items = (yield* Fiber.join(events)).flatMap((event) =>
+        event.type === "turn_item.updated" &&
+        event.turnItem.nativeItemRef?.nativeId?.endsWith(tool.id)
+          ? [event.turnItem]
+          : [],
+      );
+      assert.deepEqual(
+        items.map((item) => item.type),
+        ["dynamic_tool", "dynamic_tool", "dynamic_tool"],
+      );
+      assert.deepEqual(
+        items.map((item) => item.status),
+        ["running", "running", "completed"],
+      );
+      const last = items.at(-1);
+      assert.equal(last?.type === "dynamic_tool" ? last.toolName : null, name);
+      assert.deepEqual(last?.type === "dynamic_tool" ? last.input : null, input);
+    }).pipe(Effect.scoped),
+  );
+
   it.effect(
     "registers T3's MCP server for the thread alone and removes it when the thread unloads",
     () =>
diff --git a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
index 2ece93ea3fb9c..c5d5b980092b8 100644
--- a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.test.ts
@@ -76,11 +76,13 @@ describe("mergeClaudeWorkflowProgress", () => {
           toolCalls: 3,
           durationMs: 1277,
           startedAt: 1_700_000_000_000,
+          lastProgressAt: 1_700_000_004_432,
           queuedAt: 1_699_999_999_000,
           promptPreview: "Reply with exactly: A1",
           resultPreview: "A1",
         }),
-        agent({ index: 2, label: "alpha:two", state: "queued" }),
+        agent({ index: 2, label: "alpha:two", state: "queued", lastProgressAt: 1000 }),
+        agent({ index: 3, state: "progress", lastProgressAt: 2000 }),
       ]),
     });
     expect(workflow?.phases).toEqual([{ index: 1, title: "Alpha" }]);
@@ -98,10 +100,13 @@ describe("mergeClaudeWorkflowProgress", () => {
       durationMs: 1277,
       queuedAt: 1_699_999_999_000,
       startedAt: 1_700_000_000_000,
+      completedAt: 1_700_000_004_432,
       prompt: "Reply with exactly: A1",
       result: "A1",
     });
     expect(workflow?.agents[1]?.state).toBe("queued");
+    expect(workflow?.agents[1]).not.toHaveProperty("completedAt");
+    expect(workflow?.agents[2]).not.toHaveProperty("completedAt");
   });
 
   it.each(["something-new", "toString", "constructor", "__proto__"])(
@@ -186,10 +191,13 @@ describe("mergeClaudeWorkflowProgress", () => {
           durationMs: 50,
           queuedAt: 1000,
           startedAt: 1010,
+          lastProgressAt: 2010,
         }),
         agent({ index: 2, state: "done" }),
       ]),
     });
+    expect(first?.agents[0]?.completedAt).toBe(2010);
+    expect(first?.agents[1]).not.toHaveProperty("completedAt");
     const second = mergeClaudeWorkflowProgress({
       previous: first,
       message: snapshotFrame([
@@ -293,12 +301,18 @@ describe("mergeClaudeWorkflowProgress", () => {
     const workflow = mergeClaudeWorkflowProgress({
       previous: undefined,
       message: snapshotFrame([
-        agent({ startedAt: 8_640_000_000_000_001, queuedAt: Number.MAX_SAFE_INTEGER }),
+        agent({
+          state: "done",
+          lastProgressAt: 8_640_000_000_000_001,
+          startedAt: 8_640_000_000_000_001,
+          queuedAt: Number.MAX_SAFE_INTEGER,
+        }),
         agent({ index: 2, startedAt: 8_640_000_000_000_000, queuedAt: 0 }),
       ]),
     });
     expect(workflow?.agents[0]).not.toHaveProperty("startedAt");
     expect(workflow?.agents[0]).not.toHaveProperty("queuedAt");
+    expect(workflow?.agents[0]).not.toHaveProperty("completedAt");
     expect(workflow?.agents[1]?.startedAt).toBe(8_640_000_000_000_000);
     expect(workflow?.agents[1]?.queuedAt).toBe(0);
   });
diff --git a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.ts b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.ts
index 393d9ea23c2ae..2bb43e53ca6bc 100644
--- a/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.ts
+++ b/apps/server/src/orchestration-v2/Adapters/claudeWorkflowProgress.ts
@@ -70,6 +70,13 @@ function parseAgent(entry: unknown): OrchestrationV2WorkflowAgent | null {
     ...optional("durationMs", count(field(entry, "durationMs"))),
     ...optional("queuedAt", timestamp(field(entry, "queuedAt"))),
     ...optional("startedAt", timestamp(field(entry, "startedAt"))),
+    // Execution duration excludes startup waits; terminal progress carries the end instant.
+    ...optional(
+      "completedAt",
+      state === "completed" || state === "failed"
+        ? timestamp(field(entry, "lastProgressAt"))
+        : undefined,
+    ),
     ...optional("prompt", preview(field(entry, "promptPreview"))),
     ...optional("result", preview(field(entry, "resultPreview"))),
   };
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
index 35581cde5409a..32c83629c6652 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
@@ -9,6 +9,7 @@ import {
   MessageId,
   type ModelSelection,
   type OrchestrationV2ProviderThread,
+  type OrchestrationV2TurnItem,
   type OrchestrationV2ThreadShellSnapshot,
   NodeId,
   PlanId,
@@ -185,6 +186,194 @@ const addRolledBackRecoveryCandidate = Effect.fn("addRolledBackRecoveryCandidate
   return threadId;
 });
 
+it.effect.each([
+  ["memory", ProjectionStore.layerMemory],
+  ["SQL", layerTest],
+] as const)("%s shells flag only an active turn blocked solely on T3 thread waits", ([, layer]) =>
+  Effect.gen(function* () {
+    const store = yield* ProjectionStore.ProjectionStoreV2;
+    const threadId = yield* addRolledBackRecoveryCandidate("thread-wait");
+    const initial = yield* store.getThreadProjection(threadId);
+    const at = initial.updatedAt;
+    const previousCommand = initial.turnItems.find((item) => item.type === "command_execution")!;
+    const itemBase = {
+      ...previousCommand,
+      providerThreadId: previousCommand.providerThreadId ?? null,
+      providerTurnId: previousCommand.providerTurnId ?? null,
+      nativeItemRef: previousCommand.nativeItemRef ?? null,
+      parentItemId: previousCommand.parentItemId ?? null,
+    };
+    yield* store.apply({
+      id: EventId.make("event:thread-wait:previous-completed"),
+      type: "run.updated",
+      threadId,
+      occurredAt: at,
+      payload: { ...initial.runs[0]!, status: "completed", completedAt: at },
+    });
+    const run = {
+      ...initial.runs[0]!,
+      id: RunId.make("run:thread-wait:active"),
+      ordinal: 2,
+      status: "running" as const,
+      completedAt: null,
+    };
+    yield* store.apply({
+      id: EventId.make("event:thread-wait:active"),
+      type: "run.created",
+      threadId,
+      occurredAt: at,
+      payload: run,
+    });
+    let sequence = 0;
+    const updateItem = (payload: OrchestrationV2TurnItem) =>
+      store.apply({
+        id: EventId.make(`event:thread-wait:item:${sequence++}`),
+        type: "turn-item.updated",
+        threadId,
+        runId: payload.runId ?? undefined,
+        driver,
+        occurredAt: at,
+        payload,
+      });
+    const assertBlocked = Effect.fnUntraced(function* (expected: boolean) {
+      const listed = (yield* store.getShellSnapshot()).threads.find((row) => row.id === threadId);
+      for (const shell of [yield* store.getThreadShell(threadId), listed]) {
+        assert.equal(shell?.activeRunId, run.id);
+        assert.equal(shell?.status, "running");
+        assert.equal(shell?.blockedOnThreadWait ?? false, expected);
+      }
+    });
+    const wait = {
+      ...itemBase,
+      id: TurnItemId.make("item:thread-wait:active"),
+      runId: run.id,
+      type: "dynamic_tool" as const,
+      toolName: "mcp__t3_code__t3_thread_wait",
+      input: { threadId: "child-thread" },
+      status: "running" as const,
+    };
+
+    yield* updateItem({
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:stale"),
+      runId: initial.runs[0]!.id,
+    });
+    yield* assertBlocked(false);
+    const foreign = {
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:foreign"),
+      toolName: "weather.t3_thread_wait",
+    };
+    yield* updateItem(foreign);
+    yield* assertBlocked(false);
+    yield* updateItem({ ...foreign, status: "completed", completedAt: at });
+    yield* updateItem({ ...wait, status: "pending", startedAt: null });
+    yield* assertBlocked(false);
+    yield* updateItem(wait);
+    yield* assertBlocked(true);
+
+    yield* updateItem({
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:plan"),
+      type: "todo_list",
+      planId: PlanId.make("plan:thread-wait"),
+      steps: [{ id: "review", text: "Review the child result", status: "running" }],
+    });
+    yield* assertBlocked(true);
+    yield* updateItem({
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:proposed-plan"),
+      type: "proposed_plan",
+      planId: PlanId.make("plan:thread-wait:proposed"),
+      markdown: "Review the child result",
+      streaming: true,
+    });
+    yield* updateItem({
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:named-message"),
+      nativeItemRef: { driver, nativeId: "named-message", strength: "weak" },
+      type: "assistant_message",
+      messageId: MessageId.make("message:thread-wait:named"),
+      text: "Waiting for the child result",
+      streaming: true,
+    });
+    yield* updateItem({
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:named-thought"),
+      nativeItemRef: { driver, nativeId: "named-thought", strength: "weak" },
+      type: "reasoning",
+      text: "I need the child result",
+      streaming: true,
+    });
+    yield* assertBlocked(true);
+
+    const command = {
+      ...itemBase,
+      id: TurnItemId.make("item:thread-wait:concurrent"),
+      runId: run.id,
+    };
+    yield* updateItem(command);
+    yield* assertBlocked(false);
+    yield* updateItem({ ...wait, status: "waiting" });
+    yield* assertBlocked(false);
+    yield* updateItem({ ...command, status: "completed", completedAt: at });
+    yield* assertBlocked(true);
+    const fileChange = {
+      ...command,
+      id: TurnItemId.make("item:thread-wait:concurrent-edit"),
+      type: "file_change" as const,
+      fileName: "example.ts",
+    };
+    yield* updateItem(fileChange);
+    yield* assertBlocked(false);
+    yield* updateItem({ ...fileChange, status: "completed", completedAt: at });
+    yield* assertBlocked(true);
+    const compaction = {
+      ...command,
+      id: TurnItemId.make("item:thread-wait:compaction"),
+      type: "compaction" as const,
+      driver,
+    };
+    yield* updateItem(compaction);
+    yield* assertBlocked(false);
+    yield* updateItem({ ...compaction, status: "completed", completedAt: at });
+    yield* assertBlocked(true);
+    yield* updateItem({ ...wait, status: "completed", completedAt: at });
+    yield* assertBlocked(false);
+
+    const delegation = {
+      ...wait,
+      id: TurnItemId.make("item:thread-wait:delegation"),
+      toolName: "t3-code-thread_opencode2-adapter_delegate_task",
+      input: { task: "Review", mode: "async" },
+    };
+    yield* updateItem(delegation);
+    yield* assertBlocked(false);
+    yield* updateItem({ ...delegation, status: "completed", completedAt: at });
+    const blockingDelegation = {
+      ...delegation,
+      id: TurnItemId.make("item:thread-wait:blocking-delegation"),
+      input: { task: "Review", mode: "wait" },
+    };
+    yield* updateItem({
+      ...command,
+      id: TurnItemId.make("item:thread-wait:child"),
+      type: "subagent",
+      subagentId: NodeId.make("node:thread-wait:child"),
+      origin: "app_owned",
+      driver,
+      providerInstanceId,
+      childThreadId: ThreadId.make("child-thread"),
+      prompt: "Review",
+      result: null,
+    });
+    yield* updateItem(blockingDelegation);
+    yield* assertBlocked(true);
+    yield* updateItem({ ...blockingDelegation, status: "completed", completedAt: at });
+    yield* assertBlocked(false);
+  }).pipe(Effect.provide(layer)),
+);
+
 it.effect.each([
   ["memory", ProjectionStore.layerMemory],
   ["SQL", layerTest],
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 8448ff8268e1e..b349ff667f5f5 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -72,7 +72,10 @@ import {
   createOrchestrationV2TurnItemVisibility,
   isOrchestrationV2SupersededInterrupt,
 } from "@t3tools/shared/orchestrationV2Timeline";
-import { derivePendingBackgroundWork } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
+import {
+  deriveBlockedOnThreadWait,
+  derivePendingBackgroundWork,
+} from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
@@ -1056,6 +1059,7 @@ type ShellThreadRow = {
   readonly latest_run_started_at: string | null;
   readonly latest_run_completed_at: string | null;
   readonly active_run_id: string | null;
+  readonly active_run_status: string | null;
   readonly activity_run_status: string | null;
   readonly activity_run_started_at: string | null;
   readonly last_error: string | null;
@@ -1595,6 +1599,7 @@ export function threadShellFromProjection(
     latestRunStartedAt: latestRun?.startedAt ?? null,
     latestRunCompletedAt: latestRun?.completedAt ?? null,
     activeRunId: activeRun?.id ?? null,
+    blockedOnThreadWait: deriveBlockedOnThreadWait({ activeRun, turnItems: projection.turnItems }),
     activityRunStatus: activityRun?.status ?? null,
     activityRunStartedAt:
       activityRun === null ? null : orchestrationV2RunWorkStartedAt(activityRun),
@@ -1693,6 +1698,7 @@ type ShellThreadState = {
   readonly latestRunStartedAt: DateTime.Utc | null;
   readonly latestRunCompletedAt: DateTime.Utc | null;
   readonly activeRunId: RunId | null;
+  readonly blockedOnThreadWait: boolean;
   readonly activityRunStatus: ShellActivityRunStatus | null;
   readonly activityRunStartedAt: DateTime.Utc | null;
   readonly lastError: string | null;
@@ -1845,6 +1851,7 @@ function shellFromState(input: {
     latestRunStartedAt: input.state.latestRunStartedAt,
     latestRunCompletedAt: input.state.latestRunCompletedAt,
     activeRunId: input.state.activeRunId,
+    blockedOnThreadWait: input.state.blockedOnThreadWait,
     activityRunStatus: input.state.activityRunStatus,
     activityRunStartedAt: input.state.activityRunStartedAt,
     status: input.state.latestRunStatus,
@@ -5565,14 +5572,8 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
               presented.requested_at AS latest_run_requested_at,
               json_extract(presented.payload_json, '$.startedAt') AS latest_run_started_at,
               presented.completed_at AS latest_run_completed_at,
-              (
-                SELECT r.run_id
-                FROM orchestration_v2_projection_runs r
-                WHERE r.thread_id = t.thread_id
-                  AND r.status IN ('preparing', 'starting', 'running')
-                ORDER BY r.ordinal DESC, r.run_id DESC
-                LIMIT 1
-              ) AS active_run_id,
+              active.run_id AS active_run_id,
+              active.status AS active_run_status,
               (
                 SELECT r.status
                 FROM orchestration_v2_projection_runs r
@@ -5697,6 +5698,14 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
                   AND i.run_id IS NULL
               ) AS runless_item_count
             FROM orchestration_v2_projection_threads t
+            LEFT JOIN orchestration_v2_projection_runs active ON active.run_id = (
+              SELECT r.run_id
+              FROM orchestration_v2_projection_runs r
+              WHERE r.thread_id = t.thread_id
+                AND r.status IN ('preparing', 'starting', 'running')
+              ORDER BY r.ordinal DESC, r.run_id DESC
+              LIMIT 1
+            )
             -- The newest run not waiting in a held queue, matching latestUnheldRun.
             LEFT JOIN orchestration_v2_projection_runs presented ON presented.run_id = (
               SELECT candidate.run_id
@@ -5780,34 +5789,34 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
             WHERE thread_id IN ${sql.in(threadIds)}
           `;
 
-    const selectShellPendingTurnItemRows = (threadIds?: ReadonlyArray<ThreadId>) =>
-      threadIds === undefined
-        ? sql<ShellPendingTurnItemRow>`
-            SELECT i.thread_id, i.payload_json, p.provider_instance_id AS owning_provider_instance_id
-            FROM orchestration_v2_projection_turn_items i
-            LEFT JOIN orchestration_v2_projection_provider_threads p
-              ON p.provider_thread_id = i.provider_thread_id
-            LEFT JOIN orchestration_v2_projection_runs r
-              ON r.run_id = i.run_id
-            WHERE i.type IN ('command_execution', 'dynamic_tool', 'subagent')
-              AND i.status NOT IN ('completed', 'interrupted', 'failed', 'cancelled')
-              -- A rolled-back run's items are abandoned, not pending. Without
-              -- this the shell reports Waiting for work no one will finish,
-              -- matching the item_count query's exclusion above.
-              AND (i.run_id IS NULL OR r.status <> 'rolled_back')
-          `
-        : sql<ShellPendingTurnItemRow>`
-            SELECT i.thread_id, i.payload_json, p.provider_instance_id AS owning_provider_instance_id
-            FROM orchestration_v2_projection_turn_items i
-            LEFT JOIN orchestration_v2_projection_provider_threads p
-              ON p.provider_thread_id = i.provider_thread_id
-            LEFT JOIN orchestration_v2_projection_runs r
-              ON r.run_id = i.run_id
-            WHERE i.type IN ('command_execution', 'dynamic_tool', 'subagent')
-              AND i.status NOT IN ('completed', 'interrupted', 'failed', 'cancelled')
-              AND (i.run_id IS NULL OR r.status <> 'rolled_back')
-              AND i.thread_id IN ${sql.in(threadIds)}
-          `;
+    const selectShellPendingTurnItemRows = (
+      threadIds?: ReadonlyArray<ThreadId>,
+      activeRunIds: ReadonlyArray<string> = [],
+    ) => sql<ShellPendingTurnItemRow>`
+      SELECT i.thread_id, i.payload_json, p.provider_instance_id AS owning_provider_instance_id
+      FROM orchestration_v2_projection_turn_items i
+      LEFT JOIN orchestration_v2_projection_provider_threads p
+        ON p.provider_thread_id = i.provider_thread_id
+      LEFT JOIN orchestration_v2_projection_runs r
+        ON r.run_id = i.run_id
+      WHERE i.type IN ('command_execution', 'dynamic_tool', 'subagent')
+        AND i.status NOT IN ('completed', 'interrupted', 'failed', 'cancelled')
+        AND (i.run_id IS NULL OR r.status <> 'rolled_back')
+        ${threadIds === undefined ? sql`` : sql`AND i.thread_id IN ${sql.in(threadIds)}`}
+      ${
+        activeRunIds.length === 0
+          ? sql``
+          : sql`
+        -- Preserve the pending-item partial index; read other work only from running runs.
+        UNION ALL
+        SELECT i.thread_id, i.payload_json, NULL AS owning_provider_instance_id
+        FROM orchestration_v2_projection_turn_items i
+        WHERE i.run_id IN ${sql.in(activeRunIds)}
+          AND i.type IN ('file_change', 'file_search', 'web_search', 'compaction')
+          AND i.status IN ('running', 'waiting')
+      `
+      }
+    `;
 
     const runMapsByThreadId = (input: {
       readonly runRows: ReadonlyArray<ShellRunRow>;
@@ -6137,6 +6146,13 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
           latestRunStartedAt,
           latestRunCompletedAt,
           activeRunId: row.active_run_id === null ? null : RunId.make(row.active_run_id),
+          blockedOnThreadWait: deriveBlockedOnThreadWait({
+            activeRun:
+              row.active_run_id === null || row.active_run_status !== "running"
+                ? null
+                : { id: RunId.make(row.active_run_id), status: "running" },
+            turnItems: pendingTurnItemsByThreadId.get(thread.id) ?? [],
+          }),
           activityRunStartedAt:
             row.activity_run_started_at === null
               ? null
@@ -6223,7 +6239,16 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
           AND aggregate_kind = 'thread'
       `,
           readForThreadIds(selectShellProviderThreadRows),
-          readForThreadIds(selectShellPendingTurnItemRows),
+          readForThreadIds((ids) =>
+            selectShellPendingTurnItemRows(
+              ids,
+              threadRows.flatMap((row) =>
+                row.active_run_id !== null && row.active_run_status === "running"
+                  ? [row.active_run_id]
+                  : [],
+              ),
+            ),
+          ),
         ]);
       return {
         targetThreadIds,
@@ -6329,7 +6354,14 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
                   ? Effect.succeed([] as ReadonlyArray<ShellRunItemCountRow>)
                   : selectShellRunItemCounts(forkSourceIds),
                 selectShellProviderThreadRows(threadIds),
-                selectShellPendingTurnItemRows(threadIds),
+                selectShellPendingTurnItemRows(
+                  threadIds,
+                  [...rowsByThreadId.values()].flatMap((row) =>
+                    row.active_run_id !== null && row.active_run_status === "running"
+                      ? [row.active_run_id]
+                      : [],
+                  ),
+                ),
               ]);
             const { runOrdinalsByThreadId, itemCountsByThreadId } = runMapsByThreadId({
               runRows,
diff --git a/apps/server/src/orchestration-v2/PullRequestSyncReactor.test.ts b/apps/server/src/orchestration-v2/PullRequestSyncReactor.test.ts
index 364ff7d09ba87..64c40a545e88c 100644
--- a/apps/server/src/orchestration-v2/PullRequestSyncReactor.test.ts
+++ b/apps/server/src/orchestration-v2/PullRequestSyncReactor.test.ts
@@ -662,6 +662,86 @@ describe("PullRequestSyncReactor", () => {
     ),
   );
 
+  it.effect.each([
+    {
+      change: "ghe.com token rotation",
+      host: "avatars.example.ghe.com",
+      nextPath: "/u/1?token=new&v=4&s=40&format=png",
+      expectedSyncs: 1,
+    },
+    {
+      change: "avatar version",
+      host: "avatars.example.ghe.com",
+      nextPath: "/u/1?token=old&v=5&s=40&format=png",
+      expectedSyncs: 2,
+    },
+    {
+      change: "avatar size",
+      host: "avatars.example.ghe.com",
+      nextPath: "/u/1?token=old&v=4&s=80&format=png",
+      expectedSyncs: 2,
+    },
+    {
+      change: "another avatar query parameter",
+      host: "avatars.example.ghe.com",
+      nextPath: "/u/1?token=old&v=4&s=40&format=webp",
+      expectedSyncs: 2,
+    },
+    {
+      change: "avatar path",
+      host: "avatars.example.ghe.com",
+      nextPath: "/u/2?token=old&v=4&s=40&format=png",
+      expectedSyncs: 2,
+    },
+    {
+      change: "token outside ghe.com",
+      host: "avatars.example.com",
+      nextPath: "/u/1?token=new&v=4&s=40&format=png",
+      expectedSyncs: 2,
+    },
+  ])("syncs avatar changes selectively: $change", ({ host, nextPath, expectedSyncs }) =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        yield* TestClock.setTime(Date.parse(NOW));
+        const avatarUrl = yield* Ref.make(`https://${host}/u/1?token=old&v=4&s=40&format=png`);
+        const fixture = yield* makeHarness({
+          snapshot: makeSnapshot([makeThread("one", { pullRequests: [makeLink(42)] })]),
+          summary: (input) =>
+            Ref.get(avatarUrl).pipe(
+              Effect.map((avatarUrl) =>
+                makeSummary(input, {
+                  updatedAt: NOW,
+                  author: { login: "octocat", name: null, avatarUrl },
+                }),
+              ),
+            ),
+        });
+
+        yield* Effect.gen(function* () {
+          const reactor = yield* startAndSweep(fixture);
+          const firstSweep = yield* Ref.get(fixture.syncCommands);
+          assert.strictEqual(firstSweep.length, 1);
+          assert.strictEqual(firstSweep[0]?.snapshot.author?.avatarUrl, yield* Ref.get(avatarUrl));
+          yield* Ref.update(fixture.snapshots, (snapshot) => applySync(snapshot, firstSweep));
+
+          yield* Ref.set(avatarUrl, `https://${host}${nextPath}`);
+          yield* sweepAgain(fixture, reactor);
+
+          assert.strictEqual((yield* Ref.get(fixture.summaryCalls)).length, 2);
+          assert.strictEqual((yield* Ref.get(fixture.stackCalls)).length, expectedSyncs);
+          const commands = yield* Ref.get(fixture.syncCommands);
+          assert.strictEqual(commands.length, expectedSyncs);
+          if (expectedSyncs === 2) {
+            assert.strictEqual(
+              commands.at(-1)?.snapshot.author?.avatarUrl,
+              yield* Ref.get(avatarUrl),
+            );
+          }
+        }).pipe(Effect.provide(fixture.layer));
+      }),
+    ),
+  );
+
   it.effect("refreshes closed links through each project after reopening elsewhere", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/apps/server/src/orchestration-v2/PullRequestSyncReactor.ts b/apps/server/src/orchestration-v2/PullRequestSyncReactor.ts
index 2f2e982dd3fb8..64452882e3027 100644
--- a/apps/server/src/orchestration-v2/PullRequestSyncReactor.ts
+++ b/apps/server/src/orchestration-v2/PullRequestSyncReactor.ts
@@ -73,6 +73,17 @@ function snapshotFieldsOf(summary: PullRequestSummary): SnapshotFields {
   };
 }
 
+// Rotating ghe.com avatar tokens should not make otherwise identical snapshots differ.
+function avatarIdentity(avatarUrl: string | null | undefined): string | null {
+  if (avatarUrl === null || avatarUrl === undefined) return null;
+  const url = URL.parse(avatarUrl);
+  if (url === null || (url.hostname !== "ghe.com" && !url.hostname.endsWith(".ghe.com"))) {
+    return avatarUrl;
+  }
+  url.searchParams.delete("token");
+  return url.href;
+}
+
 function snapshotFieldsEqual(left: SnapshotFields, right: SnapshotFields): boolean {
   return (
     left.state === right.state &&
@@ -84,7 +95,7 @@ function snapshotFieldsEqual(left: SnapshotFields, right: SnapshotFields): boole
     (left.closedAt ?? null) === (right.closedAt ?? null) &&
     (left.mergedAt ?? null) === (right.mergedAt ?? null) &&
     (left.author?.login ?? null) === (right.author?.login ?? null) &&
-    (left.author?.avatarUrl ?? null) === (right.author?.avatarUrl ?? null) &&
+    avatarIdentity(left.author?.avatarUrl) === avatarIdentity(right.author?.avatarUrl) &&
     left.additions === right.additions &&
     left.deletions === right.deletions &&
     left.changedFiles === right.changedFiles &&
diff --git a/apps/server/src/orchestration-v2/RestartContinuation.test.ts b/apps/server/src/orchestration-v2/RestartContinuation.test.ts
index 60f55d8689ec4..80d9aadeced0d 100644
--- a/apps/server/src/orchestration-v2/RestartContinuation.test.ts
+++ b/apps/server/src/orchestration-v2/RestartContinuation.test.ts
@@ -56,6 +56,8 @@ function makeProjection() {
         providerThreadId,
         activeAttemptId: attemptId,
         status: "running",
+        requestedAt: now,
+        completedAt: null,
       },
     ],
     providerThreads: [
@@ -945,6 +947,7 @@ const cutMidTurn = (extra: Record<string, unknown> = {}) => {
       {
         ...base.runs[0]!,
         status: "cancelled",
+        completedAt: now,
         userMessageId: MessageId.make("message:user"),
         ...extra,
       },
@@ -1142,7 +1145,7 @@ it.effect("prepares later threads' continuations when one thread fails", () =>
   }),
 );
 
-it.effect("stops continuing after three automatic restart continuations in a row", () =>
+it.effect("stops rapid restart loops but allows repeated restarts after normal work", () =>
   Effect.gen(function* () {
     const first = RunId.make("run:first-continuation");
     const second = RunId.make("run:second-continuation");
@@ -1163,7 +1166,24 @@ it.effect("stops continuing after three automatic restart continuations in a row
         run.id === first ? { ...run, restartContinuationOfRunId: RunId.make("run:root") } : run,
       ),
     } as unknown as OrchestrationV2ThreadProjection;
-    assert.lengthOf(yield* continuationTexts(withThreeLinks), 0);
+    for (const { completedAt, oldestRequestAge, expected } of [
+      { completedAt: null, oldestRequestAge: { minutes: 6 }, expected: 0 },
+      { completedAt: null, oldestRequestAge: { minutes: 6, milliseconds: 1 }, expected: 1 },
+      { completedAt: now, oldestRequestAge: { minutes: 6 }, expected: 1 },
+    ]) {
+      const projection = {
+        ...withThreeLinks,
+        runs: withThreeLinks.runs.map((run, index) => ({
+          ...run,
+          completedAt,
+          requestedAt: DateTime.subtract(
+            now,
+            run.id === first ? oldestRequestAge : { minutes: index + 1 },
+          ),
+        })),
+      };
+      assert.lengthOf(yield* continuationTexts(projection), expected);
+    }
   }),
 );
 
diff --git a/apps/server/src/orchestration-v2/RestartContinuation.ts b/apps/server/src/orchestration-v2/RestartContinuation.ts
index 3339133c9a969..1343fed42c58d 100644
--- a/apps/server/src/orchestration-v2/RestartContinuation.ts
+++ b/apps/server/src/orchestration-v2/RestartContinuation.ts
@@ -31,6 +31,7 @@ import {
 const CONTINUE_PROMPT = "Continue where you left off.";
 
 const MAX_CONTINUATION_CHAIN = 3;
+const CONTINUATION_LOOP_WINDOW_MS = 5 * 60 * 1_000;
 
 function restartContinuationBlocked(
   projection: Pick<
@@ -228,11 +229,15 @@ export const continueRestartedRun = Effect.fn("RestartContinuation.continueResta
     if (projection.thread.providerInstanceId !== source.providerInstanceId) return;
     // A turn that keeps crashing the server would otherwise restart it forever.
     let chainLength = 0;
+    const loopWindowStart =
+      DateTime.toEpochMillis(source.completedAt ?? source.requestedAt) -
+      CONTINUATION_LOOP_WINDOW_MS;
     for (
       let run: OrchestrationV2Run | undefined = source;
       run?.restartContinuationOfRunId !== undefined && chainLength < MAX_CONTINUATION_CHAIN;
       run = projection.runs.find((candidate) => candidate.id === run?.restartContinuationOfRunId)
     ) {
+      if (DateTime.toEpochMillis(run.requestedAt) < loopWindowStart) break;
       chainLength += 1;
     }
     if (chainLength >= MAX_CONTINUATION_CHAIN) {
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/multi_turn/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/multi_turn/muse_transcript.ndjson
index 78f74648311d1..fb6046b8533bd 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/multi_turn/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/multi_turn/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6b-707e-7000-9bb5-4079c7772ad0/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:30:11.238412Z","updatedAt":"2026-10-08T07:30:11.238416Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791444611408}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6b-707e-7000-9bb5-4079c7772ad0/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:30:11.238412Z","updatedAt":"2026-10-08T07:30:11.238416Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:1","sourceRange":{"stream":{"kind":"session","id":"01a11a6b-707e-7000-9bb5-4079c7772ad0"},"first":{"id":"37b19bd1-b212-4532-a0c9-a6677f303e26","sequence":5},"last":{"id":"37b19bd1-b212-4532-a0c9-a6677f303e26","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a11a6b-707e-7001-b2f4-23db74e60097","clientName":"t3_code"},"emittedAtMs":1791444611412}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with exactly: first fixture turn complete"}],"displayText":"Respond with exactly: first fixture turn complete","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6b-722c-7000-a73a-1d49a3a7f4c4"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with exactly: first fixture turn complete"}],"displayText":"Respond with exactly: first fixture turn complete","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6b-722c-7000-a73a-1d49a3a7f4c4"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:2","sourceRange":{"stream":{"kind":"session","id":"01a11a6b-707e-7000-9bb5-4079c7772ad0"},"first":{"id":"2c530748-943b-4467-8473-da8b04c511c3","sequence":16},"last":{"id":"2c530748-943b-4467-8473-da8b04c511c3","sequence":16}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444611661}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a11a6b-722c-7000-a73a-1d49a3a7f4c4","status":"accepted","turnId":"01a11a6b-722c-7000-a73a-1d49a3a7f4c4","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","status":"running","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:3"},"emittedAtMs":1791444611674}}
@@ -29,7 +29,7 @@
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","status":"idle","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:16"},"emittedAtMs":1791444621046}}
 {"type":"emit_inbound","label":"turn/completed","frame":{"jsonrpc":"2.0","method":"turn/completed","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:16","sourceRange":{"stream":{"kind":"session","id":"01a11a6b-707e-7000-9bb5-4079c7772ad0"},"first":{"id":"688a69c5-e353-4db9-bd8c-1beb033902ba","sequence":79},"last":{"id":"688a69c5-e353-4db9-bd8c-1beb033902ba","sequence":79}},"turnId":"01a11a6b-722c-7000-a73a-1d49a3a7f4c4","terminal":"completed","durationMs":9378,"timeToFirstTokenMs":6406},"emittedAtMs":1791444621047}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:17","sourceRange":{"stream":{"kind":"session","id":"01a11a6b-707e-7000-9bb5-4079c7772ad0"},"first":{"id":"36753b8a-26ce-4935-8127-bc9191cb328b","sequence":80},"last":{"id":"36753b8a-26ce-4935-8127-bc9191cb328b","sequence":80}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444621054}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":4,"method":"turn/start","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with exactly: second fixture turn complete"}],"displayText":"Respond with exactly: second fixture turn complete","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6b-97ec-7000-bd1b-d7afbea11045"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":4,"method":"turn/start","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with exactly: second fixture turn complete"}],"displayText":"Respond with exactly: second fixture turn complete","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6b-97ec-7000-bd1b-d7afbea11045"}}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":4,"result":{"commandId":"01a11a6b-97ec-7000-bd1b-d7afbea11045","status":"accepted","turnId":"01a11a6b-97ec-7000-bd1b-d7afbea11045","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","status":"running","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:18"},"emittedAtMs":1791444621333}}
 {"type":"emit_inbound","label":"turn/started","frame":{"jsonrpc":"2.0","method":"turn/started","params":{"sessionId":"01a11a6b-707e-7000-9bb5-4079c7772ad0","viewCursor":"v:01a11a6b-707e-7000-9bb5-4079c7772ad0:18","sourceRange":{"stream":{"kind":"session","id":"01a11a6b-707e-7000-9bb5-4079c7772ad0"},"first":{"id":"4aba96d5-f984-4bc0-bda4-7fb97f527686","sequence":87},"last":{"id":"4aba96d5-f984-4bc0-bda4-7fb97f527686","sequence":87}},"turnId":"01a11a6b-97ec-7000-bd1b-d7afbea11045","commandId":"01a11a6b-97ec-7000-bd1b-d7afbea11045"},"emittedAtMs":1791444621334}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/muse_permission/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/muse_permission/muse_transcript.ndjson
index 33bc408411cde..8b425ec292683 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/muse_permission/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/muse_permission/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6d-39bb-7000-8c93-4594c98e6a11/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:32:08.30084Z","updatedAt":"2026-10-08T07:32:08.300844Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"promptUnmatched","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791444728496}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6d-39bb-7000-8c93-4594c98e6a11/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:32:08.30084Z","updatedAt":"2026-10-08T07:32:08.300844Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"promptUnmatched","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:1","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-39bb-7000-8c93-4594c98e6a11"},"first":{"id":"b05fb8ec-7b58-4cf7-a369-379938395230","sequence":5},"last":{"id":"b05fb8ec-7b58-4cf7-a369-379938395230","sequence":5}},"mode":"promptUnmatched","source":"approvalReconfigure","commandId":"01a11a6d-39bb-7001-923e-425cc6129ce7","clientName":"t3_code"},"emittedAtMs":1791444728501}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Run the shell command `touch muse-approved.txt` with your shell tool, then reply DONE."}],"displayText":"Run the shell command `touch muse-approved.txt` with your shell tool, then reply DONE.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-3b9f-7000-b6ad-ab05e6b973b6"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Run the shell command `touch muse-approved.txt` with your shell tool, then reply DONE."}],"displayText":"Run the shell command `touch muse-approved.txt` with your shell tool, then reply DONE.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-3b9f-7000-b6ad-ab05e6b973b6"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:2","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-39bb-7000-8c93-4594c98e6a11"},"first":{"id":"6159e84a-ae1e-4fae-ae8b-49f41ca34509","sequence":16},"last":{"id":"6159e84a-ae1e-4fae-ae8b-49f41ca34509","sequence":16}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444728769}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a11a6d-3b9f-7000-b6ad-ab05e6b973b6","status":"accepted","turnId":"01a11a6d-3b9f-7000-b6ad-ab05e6b973b6","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","status":"running","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:3"},"emittedAtMs":1791444728783}}
@@ -42,7 +42,7 @@
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","status":"idle","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:23"},"emittedAtMs":1791444747386}}
 {"type":"emit_inbound","label":"turn/completed","frame":{"jsonrpc":"2.0","method":"turn/completed","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:23","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-39bb-7000-8c93-4594c98e6a11"},"first":{"id":"7c29ac76-7e09-48c1-a18f-f336126e27d1","sequence":120},"last":{"id":"7c29ac76-7e09-48c1-a18f-f336126e27d1","sequence":120}},"turnId":"01a11a6d-3b9f-7000-b6ad-ab05e6b973b6","terminal":"completed","durationMs":18608,"timeToFirstTokenMs":4791},"emittedAtMs":1791444747387}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:24","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-39bb-7000-8c93-4594c98e6a11"},"first":{"id":"1e4afe30-d924-444c-8665-5e763f524e70","sequence":121},"last":{"id":"1e4afe30-d924-444c-8665-5e763f524e70","sequence":121}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444747394}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":5,"method":"turn/start","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Run the shell command `touch muse-declined.txt` with your shell tool once. If it is rejected, do not retry; reply REJECTED."}],"displayText":"Run the shell command `touch muse-declined.txt` with your shell tool once. If it is rejected, do not retry; reply REJECTED.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-8566-7000-8ad1-6269ac187a29"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":5,"method":"turn/start","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Run the shell command `touch muse-declined.txt` with your shell tool once. If it is rejected, do not retry; reply REJECTED."}],"displayText":"Run the shell command `touch muse-declined.txt` with your shell tool once. If it is rejected, do not retry; reply REJECTED.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-8566-7000-8ad1-6269ac187a29"}}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":5,"result":{"commandId":"01a11a6d-8566-7000-8ad1-6269ac187a29","status":"accepted","turnId":"01a11a6d-8566-7000-8ad1-6269ac187a29","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","status":"running","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:25"},"emittedAtMs":1791444747660}}
 {"type":"emit_inbound","label":"turn/started","frame":{"jsonrpc":"2.0","method":"turn/started","params":{"sessionId":"01a11a6d-39bb-7000-8c93-4594c98e6a11","viewCursor":"v:01a11a6d-39bb-7000-8c93-4594c98e6a11:25","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-39bb-7000-8c93-4594c98e6a11"},"first":{"id":"4a1cf90d-7457-448d-a2b5-d82108636b3b","sequence":128},"last":{"id":"4a1cf90d-7457-448d-a2b5-d82108636b3b","sequence":128}},"turnId":"01a11a6d-8566-7000-8ad1-6269ac187a29","commandId":"01a11a6d-8566-7000-8ad1-6269ac187a29"},"emittedAtMs":1791444747660}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_approval/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_approval/muse_transcript.ndjson
index 21b68a4ba72ef..c1462a92c2ccc 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_approval/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_approval/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","path":"~/.local/share/muse/sessions/2026/10/11/01a12d1d-a1b7-7000-9697-d430c2e2afd8/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:37:59.14136Z","updatedAt":"2026-10-11T22:37:59.141364Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"promptUnmatched","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791758279294}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","path":"~/.local/share/muse/sessions/2026/10/11/01a12d1d-a1b7-7000-9697-d430c2e2afd8/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:37:59.14136Z","updatedAt":"2026-10-11T22:37:59.141364Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"promptUnmatched","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a12d1d-a1b7-7000-9697-d430c2e2afd8:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","viewCursor":"v:01a12d1d-a1b7-7000-9697-d430c2e2afd8:1","sourceRange":{"stream":{"kind":"session","id":"01a12d1d-a1b7-7000-9697-d430c2e2afd8"},"first":{"id":"ed95a9db-eada-4751-a7e6-22ccc9bdabd5","sequence":5},"last":{"id":"ed95a9db-eada-4751-a7e6-22ccc9bdabd5","sequence":5}},"mode":"promptUnmatched","source":"approvalReconfigure","commandId":"01a12d1d-a1b8-7000-8d6c-f1324b724cdb","clientName":"t3_code"},"emittedAtMs":1791758279297}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Do not run any commands yourself. Spawn one subagent whose only task is to run this exact shell command: printf 'subagent approval fixture' > subagent-approval.txt and then reply with exactly: Written. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Do not run any commands yourself. Spawn one subagent whose only task is to run this exact shell command: printf 'subagent approval fixture' > subagent-approval.txt and then reply with exactly: Written. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d1d-a348-7000-ae97-9d27b5f80bce"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Do not run any commands yourself. Spawn one subagent whose only task is to run this exact shell command: printf 'subagent approval fixture' > subagent-approval.txt and then reply with exactly: Written. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Do not run any commands yourself. Spawn one subagent whose only task is to run this exact shell command: printf 'subagent approval fixture' > subagent-approval.txt and then reply with exactly: Written. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d1d-a348-7000-ae97-9d27b5f80bce"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","viewCursor":"v:01a12d1d-a1b7-7000-9697-d430c2e2afd8:2","sourceRange":{"stream":{"kind":"session","id":"01a12d1d-a1b7-7000-9697-d430c2e2afd8"},"first":{"id":"4f170229-d428-4a64-9516-7a355ff3bcdb","sequence":15},"last":{"id":"4f170229-d428-4a64-9516-7a355ff3bcdb","sequence":15}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791758279531}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a12d1d-a348-7000-ae97-9d27b5f80bce","status":"accepted","turnId":"01a12d1d-a348-7000-ae97-9d27b5f80bce","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a12d1d-a1b7-7000-9697-d430c2e2afd8","status":"running","viewCursor":"v:01a12d1d-a1b7-7000-9697-d430c2e2afd8:3"},"emittedAtMs":1791758279541}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_interrupt/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_interrupt/muse_transcript.ndjson
index 1d663c7a9a152..d73fa8b51bf5d 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_interrupt/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/muse_subagent_interrupt/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","path":"~/.local/share/muse/sessions/2026/10/11/01a12d28-7788-7000-a946-c407f380868e/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:49:49.235205Z","updatedAt":"2026-10-11T22:49:49.235209Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791758989388}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","path":"~/.local/share/muse/sessions/2026/10/11/01a12d28-7788-7000-a946-c407f380868e/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:49:49.235205Z","updatedAt":"2026-10-11T22:49:49.235209Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a12d28-7788-7000-a946-c407f380868e:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","viewCursor":"v:01a12d28-7788-7000-a946-c407f380868e:1","sourceRange":{"stream":{"kind":"session","id":"01a12d28-7788-7000-a946-c407f380868e"},"first":{"id":"29d4e769-78f7-48fa-90cd-3ac9f8fa04bf","sequence":5},"last":{"id":"29d4e769-78f7-48fa-90cd-3ac9f8fa04bf","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a12d28-7788-7001-a223-c10e52187cdf","clientName":"t3_code"},"emittedAtMs":1791758989391}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Spawn one subagent whose only task is to run the shell command `sleep 30` and then reply with exactly: Done. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Spawn one subagent whose only task is to run the shell command `sleep 30` and then reply with exactly: Done. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d28-7912-7000-993a-afd019e6ac5c"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Spawn one subagent whose only task is to run the shell command `sleep 30` and then reply with exactly: Done. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Spawn one subagent whose only task is to run the shell command `sleep 30` and then reply with exactly: Done. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d28-7912-7000-993a-afd019e6ac5c"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","viewCursor":"v:01a12d28-7788-7000-a946-c407f380868e:2","sourceRange":{"stream":{"kind":"session","id":"01a12d28-7788-7000-a946-c407f380868e"},"first":{"id":"660e2cfd-318a-4d2d-87bb-0b1375d79fdf","sequence":15},"last":{"id":"660e2cfd-318a-4d2d-87bb-0b1375d79fdf","sequence":15}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791758989619}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a12d28-7912-7000-993a-afd019e6ac5c","status":"accepted","turnId":"01a12d28-7912-7000-993a-afd019e6ac5c","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a12d28-7788-7000-a946-c407f380868e","status":"running","viewCursor":"v:01a12d28-7788-7000-a946-c407f380868e:3"},"emittedAtMs":1791758989632}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/muse_workflow/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/muse_workflow/muse_transcript.ndjson
index bf8a2da7960e0..714b315bf2281 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/muse_workflow/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/muse_workflow/muse_transcript.ndjson
@@ -8,7 +8,7 @@
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","path":"~/.local/share/muse/sessions/2026/10/11/01a12d5d-405f-7000-89a3-5aa62af6ea23/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T23:47:28.587276Z","updatedAt":"2026-10-11T23:47:28.587281Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a12d5d-405f-7000-89a3-5aa62af6ea23:2"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","viewCursor":"v:01a12d5d-405f-7000-89a3-5aa62af6ea23:1","sourceRange":{"stream":{"kind":"session","id":"01a12d5d-405f-7000-89a3-5aa62af6ea23"},"first":{"id":"0c13b14b-877c-4c5b-b05f-8ad250dfd381","sequence":5},"last":{"id":"0c13b14b-877c-4c5b-b05f-8ad250dfd381","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a12d5d-4060-7000-b6cd-aaabe26f80de","clientName":"t3_code"},"emittedAtMs":1791762448807}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","viewCursor":"v:01a12d5d-405f-7000-89a3-5aa62af6ea23:2","sourceRange":{"stream":{"kind":"session","id":"01a12d5d-405f-7000-89a3-5aa62af6ea23"},"first":{"id":"28b1f3f4-4448-4a21-a1a0-2df72ad1d326","sequence":6},"last":{"id":"28b1f3f4-4448-4a21-a1a0-2df72ad1d326","sequence":6}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791762448807}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Use your workflow tool to launch a workflow with exactly TWO agents: one labeled 'ping' that replies with the word PING, and one labeled 'pong' that replies with the word PONG. Launch it and end your turn; do not wait for it."}],"displayText":"Use your workflow tool to launch a workflow with exactly TWO agents: one labeled 'ping' that replies with the word PING, and one labeled 'pong' that replies with the word PONG. Launch it and end your turn; do not wait for it.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d5d-42c3-7000-ab94-c7f56ea457e5"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Use your workflow tool to launch a workflow with exactly TWO agents: one labeled 'ping' that replies with the word PING, and one labeled 'pong' that replies with the word PONG. Launch it and end your turn; do not wait for it."}],"displayText":"Use your workflow tool to launch a workflow with exactly TWO agents: one labeled 'ping' that replies with the word PING, and one labeled 'pong' that replies with the word PONG. Launch it and end your turn; do not wait for it.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d5d-42c3-7000-ab94-c7f56ea457e5"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","viewCursor":"v:01a12d5d-405f-7000-89a3-5aa62af6ea23:3","sourceRange":{"stream":{"kind":"session","id":"01a12d5d-405f-7000-89a3-5aa62af6ea23"},"first":{"id":"3f1880e1-81a0-4f21-b536-6b4fa5cf9d12","sequence":16},"last":{"id":"3f1880e1-81a0-4f21-b536-6b4fa5cf9d12","sequence":16}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791762449097}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a12d5d-42c3-7000-ab94-c7f56ea457e5","status":"accepted","turnId":"01a12d5d-42c3-7000-ab94-c7f56ea457e5","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a12d5d-405f-7000-89a3-5aa62af6ea23","status":"running","viewCursor":"v:01a12d5d-405f-7000-89a3-5aa62af6ea23:4"},"emittedAtMs":1791762449102}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/simple/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/simple/muse_transcript.ndjson
index 593a6f98ab539..8890613a9d774 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/simple/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/simple/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6a-bbb5-7000-ad0b-0c9e728406e5/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:29:25.018803Z","updatedAt":"2026-10-08T07:29:25.018807Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791444565334}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6a-bbb5-7000-ad0b-0c9e728406e5/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:29:25.018803Z","updatedAt":"2026-10-08T07:29:25.018807Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a11a6a-bbb5-7000-ad0b-0c9e728406e5:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","viewCursor":"v:01a11a6a-bbb5-7000-ad0b-0c9e728406e5:1","sourceRange":{"stream":{"kind":"session","id":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5"},"first":{"id":"cfd043e8-8728-493d-ba28-252ef91e8a80","sequence":5},"last":{"id":"cfd043e8-8728-493d-ba28-252ef91e8a80","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a11a6a-bbb6-7000-b1a4-a01ea59676ef","clientName":"t3_code"},"emittedAtMs":1791444565340}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with the following text: fixture simple ok"}],"displayText":"Respond with the following text: fixture simple ok","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6a-be41-7000-8db9-1d84c1b8be48"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Respond with the following text: fixture simple ok"}],"displayText":"Respond with the following text: fixture simple ok","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6a-be41-7000-8db9-1d84c1b8be48"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","viewCursor":"v:01a11a6a-bbb5-7000-ad0b-0c9e728406e5:2","sourceRange":{"stream":{"kind":"session","id":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5"},"first":{"id":"0f64f4ea-a08c-43e1-af53-cf85cee1a11c","sequence":16},"last":{"id":"0f64f4ea-a08c-43e1-af53-cf85cee1a11c","sequence":16}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444565612}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a11a6a-be41-7000-8db9-1d84c1b8be48","status":"accepted","turnId":"01a11a6a-be41-7000-8db9-1d84c1b8be48","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a11a6a-bbb5-7000-ad0b-0c9e728406e5","status":"running","viewCursor":"v:01a11a6a-bbb5-7000-ad0b-0c9e728406e5:3"},"emittedAtMs":1791444565635}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/subagent_v2/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/subagent_v2/muse_transcript.ndjson
index 3b8ebe4065b00..965d0f17acdf2 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/subagent_v2/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/subagent_v2/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","path":"~/.local/share/muse/sessions/2026/10/11/01a12d17-75fa-7000-9157-e8365ce94492/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:31:14.73121Z","updatedAt":"2026-10-11T22:31:14.731214Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791757874894}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","path":"~/.local/share/muse/sessions/2026/10/11/01a12d17-75fa-7000-9157-e8365ce94492/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-11T22:31:14.73121Z","updatedAt":"2026-10-11T22:31:14.731214Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"sideFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a12d17-75fa-7000-9157-e8365ce94492:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","viewCursor":"v:01a12d17-75fa-7000-9157-e8365ce94492:1","sourceRange":{"stream":{"kind":"session","id":"01a12d17-75fa-7000-9157-e8365ce94492"},"first":{"id":"94d1e1ed-1d3e-4cd5-91bf-a51394fc8a0a","sequence":5},"last":{"id":"94d1e1ed-1d3e-4cd5-91bf-a51394fc8a0a","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a12d17-75fa-7001-a940-79b5d7c648a4","clientName":"t3_code"},"emittedAtMs":1791757874898}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Spawn one subagent whose only task is to reply with exactly: Hello. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Spawn one subagent whose only task is to reply with exactly: Hello. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d17-7790-7000-967d-3f2246f38a60"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Spawn one subagent whose only task is to reply with exactly: Hello. Wait for it to finish, then reply with exactly what it said."}],"displayText":"Spawn one subagent whose only task is to reply with exactly: Hello. Wait for it to finish, then reply with exactly what it said.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a12d17-7790-7000-967d-3f2246f38a60"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","viewCursor":"v:01a12d17-75fa-7000-9157-e8365ce94492:2","sourceRange":{"stream":{"kind":"session","id":"01a12d17-75fa-7000-9157-e8365ce94492"},"first":{"id":"1dc98410-05c3-4618-a431-3638055e20df","sequence":15},"last":{"id":"1dc98410-05c3-4618-a431-3638055e20df","sequence":15}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791757875120}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a12d17-7790-7000-967d-3f2246f38a60","status":"accepted","turnId":"01a12d17-7790-7000-967d-3f2246f38a60","startedNewTurn":true,"disposition":"started"}}}
 {"type":"emit_inbound","label":"session/statusChanged","frame":{"jsonrpc":"2.0","method":"session/statusChanged","params":{"sessionId":"01a12d17-75fa-7000-9157-e8365ce94492","status":"running","viewCursor":"v:01a12d17-75fa-7000-9157-e8365ce94492:3"},"emittedAtMs":1791757875131}}
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/turn_interrupt/muse_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/turn_interrupt/muse_transcript.ndjson
index d155dfaef693e..0d72ecd0dcb4e 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/turn_interrupt/muse_transcript.ndjson
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/turn_interrupt/muse_transcript.ndjson
@@ -7,7 +7,7 @@
 {"type":"emit_inbound","label":"session/started","frame":{"jsonrpc":"2.0","method":"session/started","params":{"session":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6d-2d3d-7000-8178-411fdb90bc34/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:32:05.094285Z","updatedAt":"2026-10-08T07:32:05.094289Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"}},"emittedAtMs":1791444725265}}
 {"type":"emit_inbound","label":"response:session/start","frame":{"jsonrpc":"2.0","id":2,"result":{"session":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","path":"~/.local/share/muse/sessions/2026/10/08/01a11a6d-2d3d-7000-8178-411fdb90bc34/session.jsonl","status":"idle","activeTurnId":null,"createdAt":"2026-10-08T07:32:05.094285Z","updatedAt":"2026-10-08T07:32:05.094289Z","workspaceRoot":"<workspace>","providerId":"meta","modelId":"muse-spark-1.3-contributor","turnCount":0,"forkedFrom":null,"approvalMode":{"mode":"allowAll","source":"startup","lastCommandId":null},"createdByClient":{"name":"t3_code","version":"1"},"kind":"root"},"viewCursor":"v:01a11a6d-2d3d-7000-8178-411fdb90bc34:1"}}}
 {"type":"emit_inbound","label":"session/approvalModeChanged","frame":{"jsonrpc":"2.0","method":"session/approvalModeChanged","params":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","viewCursor":"v:01a11a6d-2d3d-7000-8178-411fdb90bc34:1","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-2d3d-7000-8178-411fdb90bc34"},"first":{"id":"9865268e-0a39-43a0-89d0-251a820ec8a3","sequence":5},"last":{"id":"9865268e-0a39-43a0-89d0-251a820ec8a3","sequence":5}},"mode":"allowAll","source":"approvalReconfigure","commandId":"01a11a6d-2d3e-7000-b0e7-f04c53ee070b","clientName":"t3_code"},"emittedAtMs":1791444725268}}
-{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Do not answer immediately. First run the local shell command `sleep 30`, then respond with exactly: interrupt fixture should not finish naturally."}],"displayText":"Do not answer immediately. First run the local shell command `sleep 30`, then respond with exactly: interrupt fixture should not finish naturally.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-2ee0-7000-be19-f20eda7ce5d5"}}}
+{"type":"expect_outbound","label":"turn/start","frame":{"jsonrpc":"2.0","id":3,"method":"turn/start","params":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","input":[{"type":"text","text":"<runtime_info>In case you're asked: you are running in T3 Code through the Muse Code harness, as muse-spark-1.3-contributor with high reasoning effort. No need to mention this otherwise. You can embed images and videos in your response using Markdown with absolute file paths.</runtime_info>\n\n<pull_request_linking>\nWhen the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.\n</pull_request_linking>"},{"type":"text","text":"Do not answer immediately. First run the local shell command `sleep 30`, then respond with exactly: interrupt fixture should not finish naturally."}],"displayText":"Do not answer immediately. First run the local shell command `sleep 30`, then respond with exactly: interrupt fixture should not finish naturally.","workspaceRoots":["<workspace>"],"ifBusy":"queue","reasoningEffort":"high","commandId":"01a11a6d-2ee0-7000-be19-f20eda7ce5d5"}}}
 {"type":"emit_inbound","label":"session/branchChanged","frame":{"jsonrpc":"2.0","method":"session/branchChanged","params":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","viewCursor":"v:01a11a6d-2d3d-7000-8178-411fdb90bc34:2","sourceRange":{"stream":{"kind":"session","id":"01a11a6d-2d3d-7000-8178-411fdb90bc34"},"first":{"id":"531b0e9e-c96d-4fa5-a6dd-5cc7d4569543","sequence":16},"last":{"id":"531b0e9e-c96d-4fa5-a6dd-5cc7d4569543","sequence":16}},"workspaceRoot":"<workspace>","branch":"main","vcs":"git"},"emittedAtMs":1791444725509}}
 {"type":"emit_inbound","label":"response:turn/start","frame":{"jsonrpc":"2.0","id":3,"result":{"commandId":"01a11a6d-2ee0-7000-be19-f20eda7ce5d5","status":"accepted","turnId":"01a11a6d-2ee0-7000-be19-f20eda7ce5d5","startedNewTurn":true,"disposition":"started"}}}
 {"type":"expect_outbound","label":"turn/interrupt","frame":{"jsonrpc":"2.0","id":4,"method":"turn/interrupt","params":{"sessionId":"01a11a6d-2d3d-7000-8178-411fdb90bc34","turnId":"01a11a6d-2ee0-7000-be19-f20eda7ce5d5","commandId":"01a11a6d-2f0b-7000-a1d4-359cf54e471a"}}}
diff --git a/apps/server/src/process/agentScope.test.ts b/apps/server/src/process/agentScope.test.ts
index 6f9c161e95ae5..6de4207778734 100644
--- a/apps/server/src/process/agentScope.test.ts
+++ b/apps/server/src/process/agentScope.test.ts
@@ -238,6 +238,21 @@ describe("AgentScope service", () => {
     ),
   );
 
+  it.effect("requests OOM continuation only for shared scopes when systemd supports it", () =>
+    withFakeSystemd(({ scope }) =>
+      Effect.gen(function* () {
+        const server = yield* scope.wrap({ command: "agent", args: [], name: "s", shared: true });
+        const agent = yield* scope.wrap({ command: "agent", args: [], name: "t", threadId: "a" });
+        expect(server.args.filter((arg) => arg.startsWith("--property=OOMPolicy="))).toEqual([
+          "--property=OOMPolicy=continue",
+        ]);
+        expect(agent.args.filter((arg) => arg.startsWith("--property=OOMPolicy="))).toEqual([
+          "--property=OOMPolicy=stop",
+        ]);
+      }),
+    ),
+  );
+
   it.effect("leaves a quiet slice alone", () =>
     withFakeSystemd(({ scope, calls }) =>
       Effect.gen(function* () {
diff --git a/apps/server/src/process/externalLauncher.test.ts b/apps/server/src/process/externalLauncher.test.ts
index 8ac601738bba3..0dedda030dcbb 100644
--- a/apps/server/src/process/externalLauncher.test.ts
+++ b/apps/server/src/process/externalLauncher.test.ts
@@ -465,16 +465,21 @@ it.effect("reveals a file in File Explorer through PowerShell on Windows", () =>
     const decodedCommand = Buffer.from(encodedCommand, "base64").toString("utf16le");
     assert.equal(
       decodedCommand,
-      "$ProgressPreference = 'SilentlyContinue'; Start-Process 'explorer.exe' -ArgumentList ('/select,\"' + 'C:\\workspace with spaces\\media\\author''s clip.mp4' + '\"')",
+      "$ProgressPreference = 'SilentlyContinue'; $folderVerb = (Get-ItemProperty -LiteralPath 'Registry::HKEY_CLASSES_ROOT\\Directory\\shell' -ErrorAction SilentlyContinue).'(default)'; if ($folderVerb -and $folderVerb -ne 'none') { Invoke-Item -LiteralPath 'C:\\workspace with spaces\\media' } else { Start-Process 'explorer.exe' -ArgumentList ('/select,\"' + 'C:\\workspace with spaces\\media\\author''s clip.mp4' + '\"') }",
     );
     assert.equal(spawned.options.shell, false);
     assert.equal(spawned.options.detached, false);
   }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
 );
 
-for (const kind of ["browser", "reveal"] as const) {
+for (const { kind, folderVerb } of [
+  { kind: "browser", folderVerb: "none" },
+  { kind: "reveal", folderVerb: "none" },
+  { kind: "reveal", folderVerb: "" },
+  { kind: "reveal", folderVerb: "open" },
+] as const) {
   it.live.skipIf(!windowsHost)(
-    `completes a ${kind} launch through real PowerShell after the launcher scope closes`,
+    `completes a ${kind} launch through real PowerShell after the launcher scope closes (folder verb: ${folderVerb || "empty"})`,
     () =>
       Effect.gen(function* () {
         const tempDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-reveal-smoke-"));
@@ -499,22 +504,28 @@ for (const kind of ["browser", "reveal"] as const) {
             );
           });
 
-          const target = "C:/workspace with spaces/media/author's clip.mp4";
+          const target = "C:/workspace with spaces/author's media/clip.mp4";
           yield* Effect.all(
             [
               Effect.gen(function* () {
                 const realSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
                 const recordingSpawner = ChildProcessSpawner.make((command) => {
                   assert.ok(ChildProcess.isStandardCommand(command));
+                  const recorderLiteral = `'${recorderPath.replaceAll("'", "''")}'`;
                   const source = Buffer.from(command.args.at(-1) ?? "", "base64")
                     .toString("utf16le")
-                    .replace("'explorer.exe'", `'${recorderPath.replaceAll("'", "''")}'`);
+                    .replace("'explorer.exe'", recorderLiteral);
+                  // Control the association without changing the host registry or opening its file manager.
+                  const handlers =
+                    kind === "reveal"
+                      ? `function Get-ItemProperty { [CmdletBinding()] param([string]$LiteralPath); if ($LiteralPath -ne 'Registry::HKEY_CLASSES_ROOT\\Directory\\shell') { throw 'Unexpected registry path' }; @{ '(default)' = '${folderVerb}' } }; function Invoke-Item { param([string]$LiteralPath); Start-Process ${recorderLiteral} -ArgumentList ('"' + $LiteralPath + '"') }; `
+                      : "";
                   return realSpawner.spawn(
                     ChildProcess.make(
                       command.command,
                       [
                         ...command.args.slice(0, -1),
-                        Buffer.from(source, "utf16le").toString("base64"),
+                        Buffer.from(handlers + source, "utf16le").toString("base64"),
                       ],
                       command.options,
                     ),
@@ -537,7 +548,11 @@ for (const kind of ["browser", "reveal"] as const) {
                 recorded.then((value) => {
                   assert.equal(
                     value,
-                    kind === "browser" ? "" : `/select,"${target.replaceAll("/", "\\")}"`,
+                    kind === "browser"
+                      ? ""
+                      : folderVerb === "open"
+                        ? `"C:\\workspace with spaces\\author's media"`
+                        : `/select,"${target.replaceAll("/", "\\")}"`,
                   );
                 }),
               ),
@@ -606,7 +621,7 @@ it.effect.skipIf(windowsHost)(
         const editors = yield* launcher.resolveAvailableEditors();
         yield* launcher.launchEditor({
           editor: "file-manager",
-          cwd: "/home/t3/workspace/media/clip.mp4",
+          cwd: "/home/t3/workspace [draft]/author's $media/clip|draft.mp4",
           reveal: true,
         });
         return { kind, editors };
@@ -635,7 +650,7 @@ it.effect.skipIf(windowsHost)(
       const decodedCommand = Buffer.from(encodedCommand, "base64").toString("utf16le");
       assert.equal(
         decodedCommand,
-        "$ProgressPreference = 'SilentlyContinue'; Start-Process 'explorer.exe' -ArgumentList ('/select,\"' + '\\\\wsl.localhost\\Ubuntu-24.04\\home\\t3\\workspace\\media\\clip.mp4' + '\"')",
+        "$ProgressPreference = 'SilentlyContinue'; $folderVerb = (Get-ItemProperty -LiteralPath 'Registry::HKEY_CLASSES_ROOT\\Directory\\shell' -ErrorAction SilentlyContinue).'(default)'; if ($folderVerb -and $folderVerb -ne 'none') { Invoke-Item -LiteralPath '\\\\wsl.localhost\\Ubuntu-24.04\\home\\t3\\workspace [draft]\\author''s $media' } else { Start-Process 'explorer.exe' -ArgumentList ('/select,\"' + '\\\\wsl.localhost\\Ubuntu-24.04\\home\\t3\\workspace [draft]\\author''s $media\\clip|draft.mp4' + '\"') }",
       );
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
 );
@@ -798,7 +813,7 @@ it.effect.skipIf(windowsHost)(
         const launcher = yield* ExternalLauncher.ExternalLauncher;
         yield* launcher.launchEditor({
           editor: "file-manager",
-          cwd: '/home/t3/work "quoted"/clip.mp4',
+          cwd: '/home/t3/work/clip "quoted".mp4',
           reveal: true,
         });
       }).pipe(
@@ -818,8 +833,14 @@ it.effect.skipIf(windowsHost)(
       );
 
       assert.ok(spawned);
-      assert.equal(spawned.command, "explorer.exe");
-      assert.deepEqual(spawned.args, ['\\\\wsl.localhost\\Ubuntu-24.04\\home\\t3\\work "quoted"']);
+      assert.equal(spawned.command, "powershell.exe");
+      assert.equal(spawned.options.detached, true);
+      assert.equal(spawned.options.shell, false);
+      const source = Buffer.from(spawned.args.at(-1) ?? "", "base64").toString("utf16le");
+      assert.equal(
+        source,
+        `Invoke-Item -LiteralPath '\\\\wsl.localhost\\Ubuntu-24.04\\home\\t3\\work'`,
+      );
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
 );
 
diff --git a/apps/server/src/process/externalLauncher.ts b/apps/server/src/process/externalLauncher.ts
index aec18ea4c731e..2c24857555bb6 100644
--- a/apps/server/src/process/externalLauncher.ts
+++ b/apps/server/src/process/externalLauncher.ts
@@ -1,3 +1,4 @@
+import * as NodePath from "@effect/platform-node/NodePath";
 import {
   EDITORS,
   ExternalLauncherError,
@@ -561,30 +562,24 @@ const resolveEditorLaunch = Effect.fn("resolveEditorLaunch")(function* (
   };
 });
 
-/**
- * Explorer's contract is the single argument `/select,"<path>"` with only the
- * path quoted; Node's default spawn quoting wraps the whole argument when the
- * path has spaces and Explorer misparses it, silently opening a fallback
- * folder. A single `-ArgumentList` string in Windows PowerShell 5.1 reaches the
- * child's command line verbatim, preserving the raw switch.
- */
-function buildFileExplorerRevealPowerShellSource(explorerCommand: string, target: string): string {
-  return `$ProgressPreference = 'SilentlyContinue'; Start-Process ${escapePowerShellStringLiteral(explorerCommand)} -ArgumentList ('/select,"' + ${escapePowerShellStringLiteral(target)} + '"')`;
+// A replacement manager registers a default Directory shell verb; stock Windows
+// uses "none". Explorer needs its /select argument passed verbatim through
+// PowerShell because Node's argument quoting changes how Explorer parses it.
+function buildFileManagerRevealPowerShellSource(target: string, parent: string): string {
+  const literal = escapePowerShellStringLiteral(target);
+  return `$ProgressPreference = 'SilentlyContinue'; $folderVerb = (Get-ItemProperty -LiteralPath 'Registry::HKEY_CLASSES_ROOT\\Directory\\shell' -ErrorAction SilentlyContinue).'(default)'; if ($folderVerb -and $folderVerb -ne 'none') { Invoke-Item -LiteralPath ${escapePowerShellStringLiteral(parent)} } else { Start-Process 'explorer.exe' -ArgumentList ('/select,"' + ${literal} + '"') }`;
 }
 
-function fileExplorerRevealLaunch(
+function powerShellFileManagerLaunch(
   target: string,
-  explorerTarget: string,
+  source: string,
   powershellCommand: string,
 ): EditorLaunch {
   return {
     editor: "file-manager",
     target,
     command: powershellCommand,
-    args: [
-      ...POWERSHELL_ARGUMENTS_PREFIX,
-      encodeUtf16LeBase64(buildFileExplorerRevealPowerShellSource("explorer.exe", explorerTarget)),
-    ],
+    args: [...POWERSHELL_ARGUMENTS_PREFIX, encodeUtf16LeBase64(source)],
   };
 }
 
@@ -607,10 +602,12 @@ const resolveFileManagerRevealLaunch = Effect.fn("resolveFileManagerRevealLaunch
   }
 
   if (platform === "win32") {
+    const path = yield* Path.Path.pipe(Effect.provide(NodePath.layerWin32));
+    const windowsTarget = normalizeWindowsFileManagerPath(target);
     return {
-      ...fileExplorerRevealLaunch(
+      ...powerShellFileManagerLaunch(
         target,
-        normalizeWindowsFileManagerPath(target),
+        buildFileManagerRevealPowerShellSource(windowsTarget, path.dirname(windowsTarget)),
         resolvePowerShellPath(env),
       ),
       detached: WINDOWS_POWERSHELL_DETACHED,
@@ -624,20 +621,15 @@ const resolveFileManagerRevealLaunch = Effect.fn("resolveFileManagerRevealLaunch
   ) {
     const explorerTarget = resolveWslFileManagerPath(target, env.WSL_DISTRO_NAME);
     if (yield* isCommandAvailable(WSL_POWERSHELL_COMMAND, { env })) {
-      // Explorer's raw switch cannot express a double quote, and unlike
-      // Windows paths a WSL path may legally contain one: open the containing
-      // directory in File Explorer instead, matching the advertised
-      // "file-explorer" kind.
-      if (explorerTarget.includes('"')) {
-        const path = yield* Path.Path;
-        return {
-          editor: "file-manager",
-          target,
-          command: "explorer.exe",
-          args: [resolveWslFileManagerPath(path.dirname(target), env.WSL_DISTRO_NAME)],
-        };
-      }
-      return fileExplorerRevealLaunch(target, explorerTarget, WSL_POWERSHELL_COMMAND);
+      // WSL names may contain quotes that Explorer's /select cannot encode.
+      // Open the parent through the shell so replacement managers still apply.
+      const path = yield* Path.Path;
+      // .NET path parsing rejects characters that are legal in WSL filenames.
+      const parent = resolveWslFileManagerPath(path.dirname(target), env.WSL_DISTRO_NAME);
+      const source = explorerTarget.includes('"')
+        ? `Invoke-Item -LiteralPath ${escapePowerShellStringLiteral(parent)}`
+        : buildFileManagerRevealPowerShellSource(explorerTarget, parent);
+      return powerShellFileManagerLaunch(target, source, WSL_POWERSHELL_COMMAND);
     }
     if (hasGraphicalLinuxSession(env) && (yield* isUsableFileManagerCommand("xdg-open", env))) {
       const path = yield* Path.Path;
diff --git a/apps/server/src/project/AgentSessionScanner.test.ts b/apps/server/src/project/AgentSessionScanner.test.ts
index 956157751961d..6ae48ebbd52ac 100644
--- a/apps/server/src/project/AgentSessionScanner.test.ts
+++ b/apps/server/src/project/AgentSessionScanner.test.ts
@@ -2808,6 +2808,40 @@ describe("parseAgentSessionTranscript", () => {
     });
   });
 
+  it.each([
+    { customTitles: ["Refactor auth module"], expected: "Refactor auth module" },
+    // Claude writes an empty customTitle when the user clears a rename.
+    { customTitles: ["Refactor auth module", ""], expected: "Generated title" },
+  ])("uses Claude custom titles $customTitles over the AI title", ({ customTitles, expected }) => {
+    const aiTitle = JSON.stringify({
+      type: "ai-title",
+      aiTitle: "Generated title",
+      sessionId: "claude-session",
+    });
+    const thread = AgentSessionScanner.parseAgentSessionTranscript({
+      contents: [
+        JSON.stringify({
+          type: "user",
+          sessionId: "claude-session",
+          timestamp: "2026-08-24T10:00:00.000Z",
+          message: { role: "user", content: "<command-name>/effort</command-name>" },
+        }),
+        // Claude rewrites both records on every metadata flush with ai-title
+        // last, so a later ai-title must not override the user's rename.
+        ...customTitles.flatMap((customTitle) => [
+          JSON.stringify({ type: "custom-title", customTitle, sessionId: "claude-session" }),
+          aiTitle,
+        ]),
+      ].join("\n"),
+      source: "claudeAgent",
+      providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+      fallbackSessionId: "fallback",
+      lastActiveAtMs: Date.parse("2026-08-24T12:00:00.000Z"),
+    });
+
+    expect(thread?.title).toBe(expected);
+  });
+
   it("drops injected Codex instructions while keeping the visible user event", () => {
     const thread = AgentSessionScanner.parseAgentSessionTranscript({
       contents: [
diff --git a/apps/server/src/project/AgentSessionScanner.ts b/apps/server/src/project/AgentSessionScanner.ts
index d2fdd3fb33f8c..ab13adcc069ad 100644
--- a/apps/server/src/project/AgentSessionScanner.ts
+++ b/apps/server/src/project/AgentSessionScanner.ts
@@ -89,6 +89,7 @@ const TranscriptRecord = Schema.Struct({
   cwd: Schema.optional(Schema.String),
   sessionId: Schema.optional(Schema.String),
   aiTitle: Schema.optional(Schema.String),
+  customTitle: Schema.optional(Schema.String),
   isSidechain: Schema.optional(Schema.Boolean),
   isMeta: Schema.optional(Schema.Boolean),
   isCompactSummary: Schema.optional(Schema.Boolean),
@@ -278,6 +279,7 @@ function parseAgentSessionRecords(
   // timestamp text, so only transcript metadata can provide a resumable ID.
   let providerSessionId = input.source === "codex" ? "" : input.fallbackSessionId;
   let title: string | null = null;
+  let customTitle: string | null = null;
   let derivedTitle: string | undefined;
   let model: string | null = null;
   let hasCodexSessionId = false;
@@ -380,6 +382,10 @@ function parseAgentSessionRecords(
       }
       if (record.sessionId?.trim()) providerSessionId = record.sessionId.trim();
       if (record.aiTitle?.trim()) title = record.aiTitle.trim();
+      // Claude rewrites both title records on every flush, so the user's
+      // rename is tracked separately instead of racing the later ai-title.
+      // An empty customTitle is how Claude clears a rename.
+      if (record.customTitle !== undefined) customTitle = record.customTitle.trim() || null;
       const messageModel = record.message?.model?.trim();
       // Claude uses this sentinel for local error responses. It is not a
       // model ID that can be selected when the imported session resumes.
@@ -472,7 +478,7 @@ function parseAgentSessionRecords(
     source: input.source,
     providerInstanceId: input.providerInstanceId,
     providerSessionId,
-    title: title ?? derivedTitle ?? "Imported thread",
+    title: customTitle ?? title ?? derivedTitle ?? "Imported thread",
     model,
     createdAt: retainedMessages[0]?.createdAt ?? fallbackTimestamp,
     updatedAt: fallbackTimestamp,
@@ -496,6 +502,7 @@ function shouldRetainDecodedRecord(
       record.type === "assistant" ||
       record.sessionId !== undefined ||
       record.aiTitle !== undefined ||
+      record.customTitle !== undefined ||
       record.message?.model !== undefined
     );
   }
diff --git a/apps/server/src/provider/ClaudeModelCatalog.testFixtures.ts b/apps/server/src/provider/ClaudeModelCatalog.testFixtures.ts
index 1a686b62c38c8..a04672d88c3cd 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.testFixtures.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.testFixtures.ts
@@ -71,7 +71,9 @@ export const SYNTHETIC_CLAUDE_MODEL_CATALOG: ClaudeModelCatalog = {
         name: "Claude Synthetic Thinking",
         isCustom: false,
         capabilities: {
-          optionDescriptors: [{ id: "thinking", label: "Thinking", type: "boolean" }],
+          optionDescriptors: [
+            { id: "thinking", label: "Thinking", type: "boolean", currentValue: true },
+          ],
         },
       },
       runtime: {},
diff --git a/apps/server/src/provider/ClaudeProvider.ts b/apps/server/src/provider/ClaudeProvider.ts
index 3923053f9a09a..a9ff1d301503d 100644
--- a/apps/server/src/provider/ClaudeProvider.ts
+++ b/apps/server/src/provider/ClaudeProvider.ts
@@ -224,6 +224,8 @@ const isConfiguredClaudeTokenRejected = Effect.fn("isConfiguredClaudeTokenReject
 // Amazon Bedrock initializes far slower than first-party auth: the SDK boots the Bedrock
 // backend and runs the `awsAuthRefresh` credential hook before returning account info.
 const CAPABILITIES_PROBE_TIMEOUT_MS = 25_000;
+// Native CLI startup on Windows can exceed the shared probe deadline.
+const CLAUDE_VERSION_CHECK_TIMEOUT_MS = 20_000;
 
 export const CLAUDE_CAPABILITIES_PROBE_SETTING_SOURCES = [
   "user",
@@ -547,7 +549,7 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
     ["--version"],
     resolvedEnvironment,
     cwd,
-  ).pipe(Effect.timeoutOption(DEFAULT_TIMEOUT_MS), Effect.result);
+  ).pipe(Effect.timeoutOption(CLAUDE_VERSION_CHECK_TIMEOUT_MS), Effect.result);
 
   if (Result.isFailure(versionProbe)) {
     const error = versionProbe.failure;
@@ -653,7 +655,14 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
     });
   }
 
-  if (claudeAuthStatus(capabilities) === "unauthenticated") {
+  // First-party account fields cannot verify custom endpoint credentials.
+  const endpoint = URL.parse(resolvedEnvironment.ANTHROPIC_BASE_URL?.trim() ?? "");
+  const customApiEndpoint =
+    endpoint !== null &&
+    (endpoint.protocol === "http:" || endpoint.protocol === "https:") &&
+    endpoint.hostname !== "" &&
+    endpoint.hostname !== "api.anthropic.com";
+  if (!customApiEndpoint && claudeAuthStatus(capabilities) === "unauthenticated") {
     return buildServerProvider({
       presentation: CLAUDE_PRESENTATION,
       enabled: claudeSettings.enabled,
@@ -694,7 +703,9 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
     claudeAuthMetadata({
       subscriptionType: capabilities.subscriptionType,
       authMethod: capabilities.tokenSource,
-    }) ?? apiProviderAuthMetadata(capabilities.apiProvider);
+    }) ??
+    apiProviderAuthMetadata(capabilities.apiProvider) ??
+    (customApiEndpoint ? { type: "customEndpoint", label: "Custom API endpoint" } : undefined);
   const usageLimits = !capabilities.usage
     ? makeUnavailableUsageLimits({ checkedAt, reason: "probeFailed" })
     : scopedLimitNames
diff --git a/apps/server/src/provider/Drivers/codexUsage.test.ts b/apps/server/src/provider/Drivers/codexUsage.test.ts
index 4136aba3f3698..f60c39389489e 100644
--- a/apps/server/src/provider/Drivers/codexUsage.test.ts
+++ b/apps/server/src/provider/Drivers/codexUsage.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@effect/vitest";
 
-import { initialCodexScanState, parseCodexLine } from "./codexUsage.ts";
+import { codexUsageFormat, initialCodexScanState, parseCodexLine } from "./codexUsage.ts";
 
 describe("parseCodexLine", () => {
   const sessionMeta = JSON.stringify({
@@ -30,6 +30,23 @@ describe("parseCodexLine", () => {
         },
       },
     });
+  const counters = (input: number, output: number) => ({
+    input_tokens: input,
+    cached_input_tokens: 0,
+    cache_write_input_tokens: 0,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: input + output,
+  });
+  const counted = (last: unknown, total?: unknown, extra = {}) =>
+    JSON.stringify({
+      type: "event_msg",
+      timestamp: "2026-08-01T05:17:49.919Z",
+      payload: {
+        type: "token_count",
+        info: { last_token_usage: last, total_token_usage: total, ...extra },
+      },
+    });
 
   it("attributes usage to the model from the preceding turn context", () => {
     const state = initialCodexScanState();
@@ -60,11 +77,158 @@ describe("parseCodexLine", () => {
     expect(parseCodexLine(tokenCount(100, 0, 10, 0), state)).toBeNull();
   });
 
-  it("does not let a pre-model event poison the duplicate signature", () => {
+  it("does not consume counters before the model and timestamp are valid", () => {
     const state = initialCodexScanState();
     expect(parseCodexLine(tokenCount(100, 0, 10, 0), state)).toBeNull();
     parseCodexLine(turnContext, state);
     expect(parseCodexLine(tokenCount(100, 0, 10, 0), state)).not.toBeNull();
+
+    const cumulativeState = initialCodexScanState();
+    const line = counted(counters(100, 20), counters(100, 20));
+    expect(parseCodexLine(line, cumulativeState)).toBeNull();
+    parseCodexLine(turnContext, cumulativeState);
+    expect(
+      parseCodexLine(line.replace("2026-08-01T05:17:49.919Z", "invalid"), cumulativeState),
+    ).toBeNull();
+    expect(parseCodexLine(line, cumulativeState)?.totals.outputTokens).toBe(20);
+    expect(codexUsageFormat.readMalformedRecords?.(cumulativeState)).toBe(0);
+  });
+
+  it("ignores stale changed requests but counts equal requests when totals advance across contexts", () => {
+    const state = initialCodexScanState();
+    parseCodexLine(turnContext, state);
+    const request = counters(100, 20);
+    expect(parseCodexLine(counted(request, request), state)?.totals.outputTokens).toBe(20);
+    expect(parseCodexLine(counted(counters(20, 5), request), state)).toBeNull();
+    expect(
+      parseCodexLine(
+        counted({ ...counters(0, 0), total_tokens: 20330 }, request, {
+          model_context_window: 258400,
+        }),
+        state,
+      ),
+    ).toBeNull();
+    expect(parseCodexLine(counted(request, counters(200, 40)), state)?.totals.outputTokens).toBe(
+      20,
+    );
+
+    for (const [index, tier] of ["priority", "ultrafast"].entries()) {
+      parseCodexLine(
+        JSON.stringify({ type: "turn_context", payload: { model: "gpt-6-astra" } }),
+        state,
+      );
+      parseCodexLine(
+        JSON.stringify({
+          type: "event_msg",
+          payload: { type: "thread_settings_applied", thread_settings: { service_tier: tier } },
+        }),
+        state,
+      );
+      const record = parseCodexLine(
+        counted(request, counters(100 * (index + 3), 20 * (index + 3))),
+        state,
+      );
+      expect(record).toMatchObject({
+        model: "gpt-6-astra",
+        speed: tier === "priority" ? "fast" : "ultrafast",
+        totals: { uncachedInputTokens: 100, outputTokens: 20 },
+      });
+    }
+    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
+  });
+
+  it.each([false, true])(
+    "does not rebill legacy requests or drop the next cumulative delta (initial cumulative=%s)",
+    (initialCumulative) => {
+      const state = initialCodexScanState();
+      parseCodexLine(turnContext, state);
+      const first = counters(100, 20);
+      expect(
+        parseCodexLine(counted(first, initialCumulative ? first : undefined), state)?.totals
+          .outputTokens,
+      ).toBe(20);
+      expect(parseCodexLine(counted(first), state)).toBeNull();
+      expect(parseCodexLine(counted(counters(20, 5)), state)?.totals.outputTokens).toBe(5);
+      expect(parseCodexLine(counted(counters(20, 5), counters(120, 25)), state)).toBeNull();
+      expect(
+        parseCodexLine(counted(counters(10, 2), counters(130, 27)), state)?.totals.outputTokens,
+      ).toBe(2);
+      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
+    },
+  );
+
+  it("checks every cumulative component and recovers using an inconsistent pair's valid baseline", () => {
+    const request = {
+      ...counters(100, 20),
+      cached_input_tokens: 30,
+      cache_write_input_tokens: 10,
+      reasoning_output_tokens: 5,
+    };
+    const fields = Object.keys(request) as (keyof typeof request)[];
+    for (const field of fields) {
+      const state = initialCodexScanState();
+      parseCodexLine(turnContext, state);
+      expect(parseCodexLine(counted(request, request), state)?.totals).toEqual({
+        uncachedInputTokens: 60,
+        cachedInputTokens: 30,
+        cacheCreationTokens: 10,
+        outputTokens: 20,
+        reasoningTokens: 5,
+      });
+      const total = { ...request };
+      for (const key of fields) total[key] *= 2;
+      total[field] += 1;
+      if (field === "input_tokens" || field === "output_tokens") total.total_tokens += 1;
+      expect(parseCodexLine(counted(request, total), state), field).toBeNull();
+      expect(codexUsageFormat.readMalformedRecords?.(state), field).toBe(1);
+      for (const key of fields) total[key] += request[key];
+      expect(parseCodexLine(counted(request, total), state)?.totals.outputTokens, field).toBe(20);
+      expect(codexUsageFormat.readMalformedRecords?.(state), field).toBe(1);
+    }
+  });
+
+  it.each(["request", "cumulative"])("skips malformed %s counters and recovers", (malformed) => {
+    const state = initialCodexScanState();
+    parseCodexLine(turnContext, state);
+    const request = counters(100, 20);
+    parseCodexLine(counted(request, request), state);
+    expect(
+      parseCodexLine(
+        counted(
+          malformed === "request" ? { ...request, cached_input_tokens: -1 } : request,
+          malformed === "cumulative"
+            ? { ...counters(200, 40), output_tokens: "40" }
+            : counters(200, 40),
+        ),
+        state,
+      ),
+    ).toBeNull();
+    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(1);
+    expect(
+      parseCodexLine(
+        counted(request, malformed === "request" ? counters(300, 60) : counters(200, 40)),
+        state,
+      )?.totals.outputTokens,
+    ).toBe(20);
+    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(1);
+  });
+
+  it("does not bill a context-window estimate or lose the following real request", () => {
+    const state = initialCodexScanState();
+    parseCodexLine(turnContext, state);
+    parseCodexLine(counted(counters(100, 20), counters(100, 20)), state);
+    const estimate = { ...counters(0, 0), total_tokens: 1000 };
+    expect(
+      parseCodexLine(
+        counted({ ...estimate, total_tokens: 880 }, estimate, { model_context_window: 1000 }),
+        state,
+      ),
+    ).toBeNull();
+    expect(
+      parseCodexLine(counted(counters(10, 2), { ...counters(10, 2), total_tokens: 1012 }), state)
+        ?.totals.outputTokens,
+    ).toBe(2);
+    expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
   });
 
   it("carries the service tier from the latest thread settings", () => {
@@ -139,24 +303,32 @@ describe("parseCodexLine", () => {
       parseCodexLine(stamped(forkInstant, turnContext), state);
 
       expect(
-        parseCodexLine(stamped("2026-08-01T05:00:00.001Z", tokenCount(100, 0, 10, 0)), state),
+        parseCodexLine(
+          stamped("2026-08-01T05:00:00.001Z", counted(counters(100, 10), counters(100, 10))),
+          state,
+        ),
       ).toBeNull();
       expect(
-        parseCodexLine(stamped("2026-08-01T05:00:00.002Z", tokenCount(200, 0, 20, 0)), state),
+        parseCodexLine(
+          stamped("2026-08-01T05:00:00.002Z", counted(counters(200, 20), counters(300, 30))),
+          state,
+        ),
       ).toBeNull();
 
       const real = parseCodexLine(
-        stamped("2026-08-01T05:00:06.000Z", tokenCount(300, 0, 30, 0)),
+        stamped("2026-08-01T05:00:06.000Z", counted(counters(200, 20), counters(500, 50))),
         state,
       );
       expect(real).not.toBeNull();
-      expect(real?.totals.outputTokens).toBe(30);
+      expect(real?.sessionId).toBe("child");
+      expect(real?.totals.outputTokens).toBe(20);
 
       const next = parseCodexLine(
-        stamped("2026-08-01T05:00:06.100Z", tokenCount(400, 0, 40, 0)),
+        stamped("2026-08-01T05:00:06.100Z", counted(counters(400, 40), counters(900, 90))),
         state,
       );
       expect(next).not.toBeNull();
+      expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
     });
 
     it("recognizes subagent spawns without forked_from_id", () => {
diff --git a/apps/server/src/provider/Drivers/codexUsage.ts b/apps/server/src/provider/Drivers/codexUsage.ts
index b737f19a6c884..2cff9eaa0a048 100644
--- a/apps/server/src/provider/Drivers/codexUsage.ts
+++ b/apps/server/src/provider/Drivers/codexUsage.ts
@@ -5,7 +5,6 @@ import * as Schema from "effect/Schema";
 
 import {
   parseTimestampMs,
-  tokenCount,
   totalTokens,
   type ProviderUsageReader,
   type TranscriptUsageFormat,
@@ -16,6 +15,51 @@ import type { UsageTokenTotals } from "@t3tools/contracts";
 
 import { resolveCodexHomeLayout } from "./CodexHomeLayout.ts";
 
+const TokenCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const CodexTokenUsage = Schema.Struct({
+  input_tokens: TokenCount,
+  cached_input_tokens: TokenCount,
+  cache_write_input_tokens: TokenCount,
+  output_tokens: TokenCount,
+  reasoning_output_tokens: TokenCount,
+  total_tokens: TokenCount,
+}).check(
+  Schema.makeFilter(
+    (usage) =>
+      usage.cached_input_tokens + usage.cache_write_input_tokens <= usage.input_tokens &&
+      usage.reasoning_output_tokens <= usage.output_tokens &&
+      usage.total_tokens >= usage.input_tokens + usage.output_tokens,
+  ),
+);
+type CodexTokenUsage = typeof CodexTokenUsage.Type;
+const isCodexTokenUsage = Schema.is(CodexTokenUsage);
+const CODEX_USAGE_FIELDS = Object.keys(CodexTokenUsage.fields) as (keyof CodexTokenUsage)[];
+
+function readCodexTokenUsage(value: unknown): CodexTokenUsage | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value as Record<string, unknown>;
+  const input = raw["input_tokens"];
+  const output = raw["output_tokens"];
+  if (typeof input !== "number" || typeof output !== "number") return null;
+  const usage = {
+    input_tokens: input,
+    cached_input_tokens: raw["cached_input_tokens"] === undefined ? 0 : raw["cached_input_tokens"],
+    cache_write_input_tokens:
+      raw["cache_write_input_tokens"] === undefined ? 0 : raw["cache_write_input_tokens"],
+    output_tokens: output,
+    reasoning_output_tokens:
+      raw["reasoning_output_tokens"] === undefined ? 0 : raw["reasoning_output_tokens"],
+    total_tokens: raw["total_tokens"] === undefined ? input + output : raw["total_tokens"],
+  };
+  return isCodexTokenUsage(usage) ? usage : null;
+}
+
+function advanceCodexUsage(previous: CodexTokenUsage | null, last: CodexTokenUsage) {
+  return readCodexTokenUsage(
+    Object.fromEntries(CODEX_USAGE_FIELDS.map((key) => [key, (previous?.[key] ?? 0) + last[key]])),
+  );
+}
+
 /**
  * Codex `token_count` events carry no model or service tier, so both are carried forward: the model
  * from the most recent `turn_context`, the tier from the most recent `thread_settings_applied`.
@@ -25,6 +69,8 @@ export const CodexScanState = Schema.Struct({
   speed: Schema.mutableKey(Schema.Literals(["standard", "fast", "ultrafast"])),
   sessionId: Schema.mutableKey(Schema.String),
   lastUsageSignature: Schema.mutableKey(Schema.NullOr(Schema.String)),
+  lastCumulativeUsage: Schema.mutableKey(Schema.NullOr(CodexTokenUsage)),
+  malformedRecords: Schema.mutableKey(TokenCount),
   sawSessionMeta: Schema.mutableKey(Schema.Boolean),
   suppressingForkCopies: Schema.mutableKey(Schema.Boolean),
   forkCopyAnchorMs: Schema.mutableKey(Schema.Finite),
@@ -37,6 +83,8 @@ export function initialCodexScanState(): CodexScanState {
     speed: "standard",
     sessionId: "",
     lastUsageSignature: null,
+    lastCumulativeUsage: null,
+    malformedRecords: 0,
     sawSessionMeta: false,
     suppressingForkCopies: false,
     forkCopyAnchorMs: 0,
@@ -63,8 +111,8 @@ function isForkedSessionMeta(payload: Record<string, unknown>): boolean {
 }
 
 /**
- * Deltas come from `last_token_usage`. Summing those across a session reconciles with the session's
- * final `total_token_usage`, provided consecutive duplicate events are dropped, which this does.
+ * Cumulative counters validate request deltas. Older events without cumulative counters use
+ * normalized consecutive-request deduplication.
  */
 export function parseCodexLine(line: string, state: CodexScanState): UsageRecord | null {
   let parsed: unknown;
@@ -118,45 +166,98 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
 
   const info = payloadRecord["info"];
   if (typeof info !== "object" || info === null) return null;
-  const last = (info as Record<string, unknown>)["last_token_usage"];
-  if (typeof last !== "object" || last === null) return null;
-  const lastRecord = last as Record<string, unknown>;
-
-  // Only an event that is otherwise eligible may consume the duplicate
-  // signature. A token_count arriving before its turn_context (no model yet)
-  // must not poison it, or the re-emitted copy after the model is known would
-  // be skipped as a duplicate and those tokens never counted.
+  const infoRecord = info as Record<string, unknown>;
+
+  // Codex may re-emit these counters after the model or timestamp becomes available.
   const timestampMs = parseTimestampMs(record["timestamp"]);
-  if (timestampMs === null) return null;
-  if (state.model.length === 0) return null;
+  if (timestampMs === null || state.model.length === 0) return null;
 
-  // Codex re-emits an unchanged token_count on some stream boundaries. Summing
-  // those would double count, so identical consecutive payloads are skipped.
-  const signature = JSON.stringify(lastRecord);
-  if (signature === state.lastUsageSignature) return null;
-  state.lastUsageSignature = signature;
+  const last = readCodexTokenUsage(infoRecord["last_token_usage"]);
+  const rawCumulative = infoRecord["total_token_usage"];
+  const hasCumulative = rawCumulative !== undefined && rawCumulative !== null;
+  const cumulative = hasCumulative ? readCodexTokenUsage(rawCumulative) : null;
 
   if (state.suppressingForkCopies) {
     if (timestampMs - state.forkCopyAnchorMs < FORK_COPY_MAX_GAP_MS) {
       state.forkCopyAnchorMs = timestampMs;
+      // Copied history is already billed in the parent, but establishes the child's baseline.
+      const signature = last === null ? null : JSON.stringify(last);
+      if (cumulative !== null) state.lastCumulativeUsage = cumulative;
+      else if (!hasCumulative && last !== null && signature !== state.lastUsageSignature) {
+        state.lastCumulativeUsage = advanceCodexUsage(state.lastCumulativeUsage, last);
+      }
+      state.lastUsageSignature = signature;
       return null;
     }
     state.suppressingForkCopies = false;
+    state.lastUsageSignature = null;
+  }
+
+  const previous = state.lastCumulativeUsage;
+  // A valid snapshot remains the next baseline even when its paired request is malformed.
+  if (cumulative !== null) state.lastCumulativeUsage = cumulative;
+  if (last === null || (hasCumulative && cumulative === null)) {
+    state.malformedRecords += 1;
+    return null;
+  }
+
+  // fill_to_context_window uses zero components and synthetic totals, then offsets future totals.
+  if (
+    cumulative !== null &&
+    last.input_tokens + last.output_tokens === 0 &&
+    cumulative.input_tokens + cumulative.output_tokens === 0 &&
+    cumulative.total_tokens === infoRecord["model_context_window"]
+  ) {
+    state.lastUsageSignature = null;
+    return null;
   }
 
-  const inputTokens = tokenCount(lastRecord["input_tokens"]);
-  const cachedInputTokens = tokenCount(lastRecord["cached_input_tokens"]);
-  const cacheCreationTokens = tokenCount(lastRecord["cache_write_input_tokens"]);
-  const outputTokens = tokenCount(lastRecord["output_tokens"]);
+  if (
+    cumulative !== null &&
+    previous !== null &&
+    CODEX_USAGE_FIELDS.every((key) => cumulative[key] === previous[key])
+  ) {
+    return null;
+  }
+
+  if (last.total_tokens !== last.input_tokens + last.output_tokens) {
+    state.malformedRecords += 1;
+    return null;
+  }
+
+  const signature = JSON.stringify(last);
+  if (cumulative !== null) {
+    if (
+      !CODEX_USAGE_FIELDS.every((key) => cumulative[key] - (previous?.[key] ?? 0) === last[key])
+    ) {
+      state.malformedRecords += 1;
+      return null;
+    }
+  } else {
+    if (signature === state.lastUsageSignature) return null;
+    // Advance expected totals for billed legacy requests so a cumulative re-emission is stale.
+    const advanced = advanceCodexUsage(previous, last);
+    if (advanced === null) {
+      state.malformedRecords += 1;
+      return null;
+    }
+    state.lastCumulativeUsage = advanced;
+  }
+  state.lastUsageSignature = signature;
+
+  const inputTokens = last.input_tokens;
+  const cachedInputTokens = last.cached_input_tokens;
+  const cacheCreationTokens = last.cache_write_input_tokens;
+  const outputTokens = last.output_tokens;
 
   const totals: UsageTokenTotals = {
     // Codex reports `input_tokens` inclusive of the cached portion.
-    uncachedInputTokens: Math.max(0, inputTokens - cachedInputTokens - cacheCreationTokens),
+    uncachedInputTokens: inputTokens - cachedInputTokens - cacheCreationTokens,
     cachedInputTokens,
     cacheCreationTokens,
     outputTokens,
     // Reported inside output_tokens, surfaced separately for the token mix.
-    reasoningTokens: Math.min(outputTokens, tokenCount(lastRecord["reasoning_output_tokens"])),
+    reasoningTokens: last.reasoning_output_tokens,
   };
 
   if (totalTokens(totals) === 0) return null;
@@ -198,7 +299,7 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
       thread_settings: { service_tier: true },
       forked_from_id: true,
       source: { subagent: { thread_spawn: { parent_thread_id: true } } },
-      info: { last_token_usage: true },
+      info: { last_token_usage: true, total_token_usage: true, model_context_window: true },
     },
   },
   // `turn_context`, `thread_settings_applied` and `session_meta` lines hold no
@@ -207,6 +308,7 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
   parseLine: (line, state) => orEmpty(parseCodexLine(line, state)),
   parseProjected: (projected, state) => orEmpty(parseCodexRecord(projected, state)),
   state: { initial: initialCodexScanState, schema: CodexScanState },
+  readMalformedRecords: (state) => state.malformedRecords,
   // A rollout that moved after it was read leaves a copy in both places.
   sharedSessionsAcrossFiles: true,
 };
diff --git a/apps/server/src/provider/GrokProvider.test.ts b/apps/server/src/provider/GrokProvider.test.ts
index 6f532f00bbb54..314d8c59ebda3 100644
--- a/apps/server/src/provider/GrokProvider.test.ts
+++ b/apps/server/src/provider/GrokProvider.test.ts
@@ -402,8 +402,9 @@ it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => {
 
   // A stand-in for the Grok CLI: `--version` and `models` print canned text,
   // and `agent stdio` execs the mock ACP agent so `initialize` returns model metadata.
+  // A list of `models` outputs is served in call order, repeating the last one.
   const writeFakeGrokCli = (input: {
-    readonly modelsOutput: string;
+    readonly modelsOutput: string | ReadonlyArray<string>;
     readonly acp: boolean;
     readonly updateLogPath?: string;
   }) =>
@@ -428,7 +429,12 @@ it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => {
           "  process.exit(0);",
           "}",
           'if (process.argv[2] === "models") {',
-          `  process.stdout.write(${JSON.stringify(input.modelsOutput)});`,
+          '  const fs = await import("node:fs");',
+          `  const callsPath = ${JSON.stringify(NodePath.join(dir, "models-calls"))};`,
+          '  const calls = fs.existsSync(callsPath) ? fs.readFileSync(callsPath, "utf8").length : 0;',
+          '  fs.appendFileSync(callsPath, ".");',
+          `  const outputs = ${JSON.stringify([input.modelsOutput].flat())};`,
+          "  process.stdout.write(outputs[Math.min(calls, outputs.length - 1)]);",
           "  process.exit(0);",
           "}",
           'if (process.argv[2] !== "agent") process.exit(1);',
@@ -498,6 +504,28 @@ it.layer(NodeServices.layer)("checkGrokProviderStatus", (it) => {
     }),
   );
 
+  // An expired access token prints the logged-out banner, then the CLI refreshes it in the
+  // same run, so the next `grok models` reports the login (#14285).
+  it.effect("reports authenticated when `grok models` logs in after refreshing a token", () =>
+    Effect.gen(function* () {
+      const snapshot = yield* Effect.scoped(
+        Effect.gen(function* () {
+          const grokPath = yield* writeFakeGrokCli({
+            modelsOutput: [LOGGED_OUT_MODELS_OUTPUT, LOGGED_IN_MODELS_OUTPUT],
+            acp: true,
+          });
+          return yield* checkGrokProviderStatus(
+            decodeGrokSettings({ enabled: true, binaryPath: grokPath }),
+            { ...process.env, XAI_API_KEY: "" },
+          );
+        }),
+      );
+
+      expect(snapshot.status).toBe("ready");
+      expect(snapshot.auth.status).toBe("authenticated");
+    }),
+  );
+
   it.effect("falls back to CLI-listed models with a warning when ACP initialize fails", () =>
     Effect.gen(function* () {
       const snapshot = yield* Effect.scoped(
diff --git a/apps/server/src/provider/ProviderRegistry.test.ts b/apps/server/src/provider/ProviderRegistry.test.ts
index ecc1b8fab4bd1..ba94802034a23 100644
--- a/apps/server/src/provider/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/ProviderRegistry.test.ts
@@ -73,6 +73,7 @@ import { ProviderSecretResolver } from "./ProviderSecretResolver.ts";
 import * as ProviderRegistry from "./ProviderRegistry.ts";
 import { literalProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
 import { ProviderDriverError } from "./Errors.ts";
+import { mergeProviderInstanceEnvironment } from "@t3tools/provider-core/server/instanceEnvironment";
 import {
   makeManualOnlyProviderMaintenanceCapabilities,
   makeProviderMaintenanceCapabilities,
@@ -460,6 +461,7 @@ it.layer(
         assert.strictEqual(status.auth.type, "chatgpt");
         assert.strictEqual(status.auth.label, "ChatGPT Pro 20x Subscription");
         assert.strictEqual(status.auth.email, "test@example.com");
+        assert.deepStrictEqual(status.setup, { canAuthenticate: false, canInstall: false });
         assert.deepStrictEqual(status.models, [
           {
             slug: "gpt-live-codex",
@@ -606,6 +608,7 @@ it.layer(
         assert.strictEqual(status.status, "error");
         assert.strictEqual(status.installed, false);
         assert.strictEqual(status.auth.status, "unknown");
+        assert.deepStrictEqual(status.setup, { canAuthenticate: false, canInstall: false });
         assert.include(status.message, binaryPath);
         assert.include(status.message, "Settings → Providers → Codex → Binary path on the server");
         assert.strictEqual(
@@ -2783,6 +2786,44 @@ it.layer(
             [latestSkills],
           );
 
+          // With no cached snapshot, an older scan must leave publication and
+          // request deduplication to the forced scan even when it finishes first.
+          const olderStarted = yield* Deferred.make<void>();
+          const releaseOlder = yield* Deferred.make<void>();
+          yield* Ref.set(scanGate, { started: olderStarted, release: releaseOlder });
+          yield* Ref.set(scopedResult, scopedProvider);
+          const olderScan = yield* registry
+            .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace2" })
+            .pipe(Effect.forkChild);
+          yield* Deferred.await(olderStarted);
+          const newerStarted = yield* Deferred.make<void>();
+          const releaseNewer = yield* Deferred.make<void>();
+          yield* Ref.set(scanGate, { started: newerStarted, release: releaseNewer });
+          yield* Ref.set(scopedResult, { ...scopedProvider, skills: latestSkills });
+          const newerScan = yield* registry
+            .refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace2", fresh: true })
+            .pipe(Effect.forkChild);
+          yield* Deferred.await(newerStarted);
+          yield* Deferred.succeed(releaseOlder, undefined);
+          yield* Fiber.join(olderScan);
+          assert.strictEqual(
+            (yield* registry.getProviders)[0]?.workspaceSnapshots?.find(
+              (snapshot) => snapshot.cwd === "/workspace2",
+            ),
+            undefined,
+          );
+          const callsWhileForced = yield* Ref.get(snapshotCalls);
+          yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace2" });
+          assert.strictEqual(yield* Ref.get(snapshotCalls), callsWhileForced);
+          yield* Deferred.succeed(releaseNewer, undefined);
+          yield* Fiber.join(newerScan);
+          assert.deepStrictEqual(
+            (yield* registry.getProviders)[0]?.workspaceSnapshots?.find(
+              (snapshot) => snapshot.cwd === "/workspace2",
+            )?.skills,
+            latestSkills,
+          );
+
           yield* Ref.set(instancesRef, [rebuiltInstance]);
           yield* PubSub.publish(registryChanges, undefined);
           let rebuilt = yield* registry.getProviders;
@@ -4142,6 +4183,7 @@ it.layer(
           assert.notStrictEqual(ghost, undefined);
           assert.strictEqual(ghost?.driver, "ghostDriver");
           assert.strictEqual(ghost?.availability, "unavailable");
+          assert.strictEqual(Object.hasOwn(ghost ?? {}, "setup"), false);
           assert.match(ghost?.unavailableReason ?? "", /ghostDriver/);
         }).pipe(Effect.provide(runtimeServices));
       }),
@@ -4430,6 +4472,66 @@ it.layer(
       ),
     );
 
+    it.effect.each([
+      {
+        name: "accepts a healthy claude --version response after 19 seconds",
+        answer: Effect.sleep("19 seconds"),
+        elapsed: 19_000,
+        status: "ready",
+        version: "1.0.0",
+      },
+      {
+        name: "bounds a hung claude --version probe",
+        answer: Effect.never,
+        elapsed: 21_000,
+        status: "error",
+        version: null,
+      },
+    ])("$name", ({ answer, elapsed, status: expectedStatus, version }) =>
+      Effect.gen(function* () {
+        const started = yield* Deferred.make<void>();
+        const statusFiber = yield* checkClaudeProviderStatus(
+          defaultClaudeSettings,
+          claudeCapabilities(),
+        ).pipe(
+          Effect.provide(
+            Layer.succeed(
+              ChildProcessSpawner.ChildProcessSpawner,
+              ChildProcessSpawner.make((command) => {
+                assert.deepStrictEqual(
+                  (command as unknown as { args: ReadonlyArray<string> }).args,
+                  ["--version"],
+                );
+                return Effect.succeed(
+                  ChildProcessSpawner.makeHandle({
+                    ...mockHandle({ stdout: "", stderr: "", code: 0 }),
+                    exitCode: answer.pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
+                    stdout: Stream.fromEffect(
+                      Deferred.succeed(started, undefined).pipe(
+                        Effect.andThen(answer),
+                        Effect.as(encoder.encode("1.0.0\n")),
+                      ),
+                    ),
+                  }),
+                );
+              }),
+            ),
+          ),
+          Effect.forkChild,
+        );
+        yield* Deferred.await(started);
+        yield* TestClock.adjust(elapsed);
+
+        const status = yield* Fiber.join(statusFiber);
+        assert.strictEqual(status.status, expectedStatus);
+        assert.strictEqual(status.installed, true);
+        assert.strictEqual(status.version, version);
+        if (expectedStatus === "error") {
+          assert.include(status.message, "Timed out while running command.");
+        }
+      }),
+    );
+
     it.effect("returns ready and labels Bedrock-backed Claude as authenticated", () =>
       Effect.gen(function* () {
         // Bedrock authenticates via external AWS credentials, so the SDK init
@@ -4465,6 +4567,7 @@ it.layer(
             apiKeySource: "none",
             apiProvider: "firstParty",
           }),
+          { ANTHROPIC_BASE_URL: "" },
         );
         assert.strictEqual(status.status, "error");
         assert.strictEqual(status.auth.status, "unauthenticated");
@@ -4617,6 +4720,80 @@ it.layer(
       ),
     );
 
+    it.effect.each([
+      { source: "inherited HTTPS endpoint", baseUrl: "https://proxy.example/api", overrides: [] },
+      {
+        source: "instance HTTP endpoint overriding Anthropic",
+        baseUrl: "https://api.anthropic.com",
+        overrides: [
+          { name: "ANTHROPIC_BASE_URL", value: "http://localhost:8080", sensitive: false },
+        ],
+      },
+    ])("keeps Claude ready with an empty first-party account: $source", ({ baseUrl, overrides }) =>
+      Effect.gen(function* () {
+        const environment = yield* mergeProviderInstanceEnvironment(overrides, {
+          ANTHROPIC_BASE_URL: baseUrl,
+        });
+        const status = yield* checkClaudeProviderStatus(
+          defaultClaudeSettings,
+          claudeCapabilities({
+            tokenSource: "none",
+            apiKeySource: "none",
+            apiProvider: "firstParty",
+          }),
+          environment,
+        );
+        assert.strictEqual(status.status, "ready");
+        assert.strictEqual(status.auth.status, "authenticated");
+        assert.strictEqual(status.auth.type, "customEndpoint");
+        assert.strictEqual(status.auth.label, "Custom API endpoint");
+      }).pipe(
+        Effect.provide(
+          layerMockSpawner((args) => {
+            const joined = args.join(" ");
+            if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 };
+            throw new Error(`Unexpected args: ${joined}`);
+          }),
+        ),
+      ),
+    );
+
+    it.effect.each([
+      "https://api.anthropic.com",
+      "https://api.anthropic.com:443",
+      "https://api.anthropic.com:8443",
+      "openrouter.ai/api",
+      "localhost:8080",
+      "ftp://proxy.example",
+    ])("keeps Claude logged out when the instance endpoint is %s", (baseUrl) =>
+      Effect.gen(function* () {
+        const environment = yield* mergeProviderInstanceEnvironment(
+          [{ name: "ANTHROPIC_BASE_URL", value: baseUrl, sensitive: false }],
+          { ANTHROPIC_BASE_URL: "https://proxy.example/api" },
+        );
+        const status = yield* checkClaudeProviderStatus(
+          defaultClaudeSettings,
+          claudeCapabilities({
+            tokenSource: "none",
+            apiKeySource: "none",
+            apiProvider: "firstParty",
+          }),
+          environment,
+        );
+        assert.strictEqual(status.status, "error");
+        assert.strictEqual(status.auth.status, "unauthenticated");
+        assert.strictEqual(status.auth.type, undefined);
+      }).pipe(
+        Effect.provide(
+          layerMockSpawner((args) => {
+            const joined = args.join(" ");
+            if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 };
+            throw new Error(`Unexpected args: ${joined}`);
+          }),
+        ),
+      ),
+    );
+
     it.effect("keeps an API key install authenticated when it reports no token source", () =>
       Effect.gen(function* () {
         // `ANTHROPIC_API_KEY` never populates `tokenSource`, so reading that
diff --git a/apps/server/src/provider/ProviderRegistry.ts b/apps/server/src/provider/ProviderRegistry.ts
index 99b768bb5ec7d..d5e77ff9d1a6e 100644
--- a/apps/server/src/provider/ProviderRegistry.ts
+++ b/apps/server/src/provider/ProviderRegistry.ts
@@ -457,7 +457,7 @@ export const layer = Layer.effect(
       cachedProviders.map((provider) => classifyCompatibility(provider, initialManifest)),
     );
     const workspaceRefreshesRef = yield* Ref.make<
-      ReadonlyMap<ProviderInstance, ReadonlySet<string>>
+      ReadonlyMap<ProviderInstance, ReadonlyMap<string, symbol>>
     >(new Map());
     const maintenanceActionStatesRef = yield* Ref.make<
       ReadonlyMap<ProviderInstanceId, { readonly update?: ServerProviderUpdateState | undefined }>
@@ -1036,14 +1036,15 @@ export const layer = Layer.effect(
       const scannedAt = DateTime.formatIso(now);
       const instance = yield* instanceRegistry.getInstance(input.instanceId);
       if (!instance?.snapshotForCwd) return providers;
+      const token = Symbol();
       const claimed = yield* Ref.modify(workspaceRefreshesRef, (refreshes) => {
         const current = refreshes.get(instance);
-        if (current?.has(input.cwd)) return [false, refreshes] as const;
+        if (!input.fresh && current?.has(input.cwd)) return [false, refreshes] as const;
         const next = new Map(refreshes);
-        next.set(instance, new Set(current).add(input.cwd));
+        next.set(instance, new Map(current).set(input.cwd, token));
         return [true, next] as const;
       });
-      if (!claimed && !input.fresh) return yield* Ref.get(providersRef);
+      if (!claimed) return yield* Ref.get(providersRef);
       const refreshMachineSnapshot = input.fresh
         ? (instance.invalidateCaches ?? Effect.void).pipe(
             Effect.andThen(refreshInstance(input.instanceId)),
@@ -1057,8 +1058,12 @@ export const layer = Layer.effect(
           instanceRegistry.getInstance(input.instanceId).pipe(
             Effect.flatMap((currentInstance) => {
               if (currentInstance !== instance) return Ref.get(providersRef);
-              return updateProviders((currentProviders) =>
-                currentProviders.map((candidate) =>
+              return updateProviders((currentProviders) => {
+                // Read ownership inside the update so a newer claim cannot race publication.
+                if (Ref.getUnsafe(workspaceRefreshesRef).get(instance)?.get(input.cwd) !== token) {
+                  return currentProviders;
+                }
+                return currentProviders.map((candidate) =>
                   candidate.instanceId === input.instanceId &&
                   Equal.equals(workspaceSnapshotOf(candidate), scannedFrom)
                     ? upsertProviderWorkspaceSnapshot(candidate, input.cwd, {
@@ -1071,22 +1076,22 @@ export const layer = Layer.effect(
                           scopedSnapshot.slashCommandsPending ?? scopedSnapshot.status === "error",
                       })
                     : candidate,
-                ),
-              );
+                );
+              });
             }),
           ),
         ),
         Effect.ensuring(
-          claimed
-            ? Ref.update(workspaceRefreshesRef, (refreshes) => {
-                const next = new Map(refreshes);
-                const current = new Set(next.get(instance));
-                current.delete(input.cwd);
-                if (current.size) next.set(instance, current);
-                else next.delete(instance);
-                return next;
-              })
-            : Effect.void,
+          Ref.update(workspaceRefreshesRef, (refreshes) => {
+            const current = refreshes.get(instance);
+            if (current?.get(input.cwd) !== token) return refreshes;
+            const next = new Map(refreshes);
+            const nextCwds = new Map(current);
+            nextCwds.delete(input.cwd);
+            if (nextCwds.size) next.set(instance, nextCwds);
+            else next.delete(instance);
+            return next;
+          }),
         ),
       );
     });
diff --git a/apps/server/src/provider/antigravityAuthSupport.test.ts b/apps/server/src/provider/antigravityAuthSupport.test.ts
index dad00aa760344..16a7df9633744 100644
--- a/apps/server/src/provider/antigravityAuthSupport.test.ts
+++ b/apps/server/src/provider/antigravityAuthSupport.test.ts
@@ -556,6 +556,82 @@ describe("Antigravity stderr compatibility", () => {
 });
 
 it.layer(NodeServices.layer)("Antigravity profile preparation", (it) => {
+  const prepareSpawn = Effect.fn(function* (
+    bundles: ReadonlyArray<string>,
+    baseEnv: NodeJS.ProcessEnv = {},
+    platform: NodeJS.Platform = "linux",
+  ) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const directory = yield* fs.makeTempDirectoryScoped();
+    const profile = yield* prepareAntigravityProfile({
+      profileDirectory: path.join(directory, "profile"),
+      userHome: path.join(directory, "home"),
+      runtimeExecutablePath: process.execPath,
+      platform,
+      baseEnv,
+    }).pipe(
+      Effect.provideService(FileSystem.FileSystem, {
+        ...fs,
+        exists: (candidate) => Effect.succeed(bundles.includes(candidate)),
+      }),
+    );
+    return buildAntigravityAcpSpawnInput({
+      installation: { executablePath: "/release/acp", harnessPath: "/release/harness" },
+      profile,
+      cwd: directory,
+      baseEnv,
+    }).env;
+  });
+
+  // A Windows Node path cannot preflight the browser helper as a POSIX host.
+  const caTest = it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32");
+
+  caTest(
+    "launches Linux agents with the first available CA bundle, preferring absolute Nix paths",
+    () =>
+      Effect.gen(function* () {
+        const systemBundles = ["/etc/pki/tls/certs/ca-bundle.crt", "/etc/ssl/cert.pem"];
+        const nixBundle = "/nix/store/nss-cacert/etc/ssl/certs/ca-bundle.crt";
+        expect((yield* prepareSpawn(systemBundles))?.SSL_CERT_FILE).toBe(systemBundles[0]);
+        expect(
+          (yield* prepareSpawn([nixBundle, ...systemBundles], { NIX_SSL_CERT_FILE: nixBundle }))
+            ?.SSL_CERT_FILE,
+        ).toBe(nixBundle);
+        expect(
+          (yield* prepareSpawn(systemBundles, { NIX_SSL_CERT_FILE: nixBundle }))?.SSL_CERT_FILE,
+        ).toBe(systemBundles[0]);
+        expect(
+          (yield* prepareSpawn(["certs/local.pem", ...systemBundles], {
+            NIX_SSL_CERT_FILE: "certs/local.pem",
+          }))?.SSL_CERT_FILE,
+        ).toBe(systemBundles[0]);
+        expect((yield* prepareSpawn([]))?.SSL_CERT_FILE).toBeUndefined();
+      }),
+  );
+
+  caTest("preserves explicit certificate files and directories in Linux launches", () =>
+    Effect.gen(function* () {
+      const bundles = ["/etc/ssl/certs/ca-certificates.crt"];
+      expect(
+        (yield* prepareSpawn(bundles, { SSL_CERT_FILE: "/custom/ca.pem" }))?.SSL_CERT_FILE,
+      ).toBe("/custom/ca.pem");
+      const directoryEnv = yield* prepareSpawn(bundles, { SSL_CERT_DIR: "/custom/certs" });
+      expect(directoryEnv?.SSL_CERT_DIR).toBe("/custom/certs");
+      expect(directoryEnv?.SSL_CERT_FILE).toBeUndefined();
+    }),
+  );
+
+  caTest("leaves non-Linux certificate defaults unchanged even when a bundle exists", () =>
+    Effect.gen(function* () {
+      const bundle = "/etc/ssl/certs/ca-certificates.crt";
+      for (const platform of ["darwin", "win32"] as const) {
+        const env = yield* prepareSpawn([bundle], { NIX_SSL_CERT_FILE: bundle }, platform);
+        expect(env?.SSL_CERT_FILE).toBeUndefined();
+      }
+    }),
+  );
+
   it.effect("runs the browser helper with installed Node in standalone builds", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
diff --git a/apps/server/src/provider/antigravityAuthSupport.ts b/apps/server/src/provider/antigravityAuthSupport.ts
index 216dbc7aa8585..c32975dc7066a 100644
--- a/apps/server/src/provider/antigravityAuthSupport.ts
+++ b/apps/server/src/provider/antigravityAuthSupport.ts
@@ -87,6 +87,7 @@ export interface AntigravityProfile {
   readonly tokenPath: string;
   readonly tempDirectory: string;
   readonly browserCommand: string;
+  readonly caBundlePath?: string;
 }
 
 export interface AntigravityAuthConfig {
@@ -221,6 +222,11 @@ function antigravityEnvironment(
   return {
     ...environment,
     ...credential,
+    ...(profile.caBundlePath !== undefined &&
+    baseEnv.SSL_CERT_FILE === undefined &&
+    baseEnv.SSL_CERT_DIR === undefined
+      ? { SSL_CERT_FILE: profile.caBundlePath }
+      : {}),
     GEMINI_HOME: profile.geminiHome,
     AGY_ACP_FORCE_FILE_STORAGE: "1",
     BROWSER: profile.browserCommand,
@@ -327,6 +333,27 @@ export const prepareAntigravityProfile = Effect.fn("prepareAntigravityProfile")(
   const geminiHome = path.resolve(input.profileDirectory);
   const acpDirectory = path.join(geminiHome, "antigravity-acp");
   const tempDirectory = input.tempDirectory ?? path.join(acpDirectory, "tmp");
+  let caBundlePath: string | undefined;
+  if (platform === "linux") {
+    // Bundled Python may look for certificates at paths absent on this distribution.
+    // Relative paths would resolve differently when the agent runs in the project directory.
+    for (const candidate of [
+      (input.baseEnv ?? process.env).NIX_SSL_CERT_FILE,
+      "/etc/ssl/certs/ca-bundle.crt",
+      "/etc/ssl/certs/ca-certificates.crt",
+      "/etc/pki/tls/certs/ca-bundle.crt",
+      "/etc/ssl/cert.pem",
+    ]) {
+      if (
+        candidate &&
+        path.isAbsolute(candidate) &&
+        (yield* fs.exists(candidate).pipe(Effect.orElseSucceed(() => false)))
+      ) {
+        caBundlePath = candidate;
+        break;
+      }
+    }
+  }
   const profile: AntigravityProfile = {
     platform,
     geminiHome,
@@ -334,6 +361,7 @@ export const prepareAntigravityProfile = Effect.fn("prepareAntigravityProfile")(
     tokenPath: path.join(acpDirectory, "acp_token.json"),
     tempDirectory,
     browserCommand,
+    ...(caBundlePath === undefined ? {} : { caBundlePath }),
   };
   const environment = antigravityEnvironment(profile, input.baseEnv ?? process.env, auth);
   yield* Effect.gen(function* () {
diff --git a/apps/server/src/provider/claudeUsageLimits.test.ts b/apps/server/src/provider/claudeUsageLimits.test.ts
index 99c3eb163f1b5..ac47781a8963f 100644
--- a/apps/server/src/provider/claudeUsageLimits.test.ts
+++ b/apps/server/src/provider/claudeUsageLimits.test.ts
@@ -126,6 +126,121 @@ describe("claudeUsageResponseToLimits", () => {
       },
     ]);
   });
+
+  const enterpriseResponse = {
+    rate_limits_available: true,
+    rate_limits: {
+      five_hour: null,
+      seven_day: null,
+      spend: {
+        enabled: true,
+        used: { amount_minor: 4_631, currency: "USD", exponent: 2 },
+        limit: { amount_minor: 50_000, currency: "USD", exponent: 2 },
+        percent: 9,
+      },
+      extra_usage: {
+        is_enabled: true,
+        used_credits: 4_631,
+        monthly_limit: 50_000,
+        utilization: 9.261999999999999,
+        currency: "USD",
+        decimal_places: 2,
+      },
+    },
+  };
+  const monthlyWindow = {
+    id: "monthly_spend",
+    kind: "monthly",
+    label: "Monthly spend",
+    usedPercent: expect.closeTo(9.262, 10),
+  };
+
+  it("maps the captured Enterprise budget precisely, preferring spend beside rolling windows", () => {
+    expect(claudeUsageResponseToLimits({ checkedAt, response: enterpriseResponse }).limits).toEqual(
+      {
+        checkedAt,
+        windows: [monthlyWindow],
+      },
+    );
+    const response = {
+      ...enterpriseResponse,
+      rate_limits: {
+        ...enterpriseResponse.rate_limits,
+        five_hour: { utilization: 12, resets_at: null },
+        extra_usage: {
+          ...enterpriseResponse.rate_limits.extra_usage,
+          used_credits: 30_000,
+          utilization: 60,
+        },
+      },
+    };
+    expect(claudeUsageResponseToLimits({ checkedAt, response }).limits.windows).toEqual([
+      {
+        id: "five_hour",
+        kind: "session",
+        label: "Session",
+        usedPercent: 12,
+        windowDurationMins: 300,
+      },
+      monthlyWindow,
+    ]);
+  });
+
+  it("falls back to enabled extra usage amounts or utilization when spend is unusable", () => {
+    const response = {
+      ...enterpriseResponse,
+      rate_limits: {
+        ...enterpriseResponse.rate_limits,
+        spend: {
+          ...enterpriseResponse.rate_limits.spend,
+          enabled: false,
+          used: { amount_minor: 30_000, currency: "USD", exponent: 2 },
+        },
+        extra_usage: { ...enterpriseResponse.rate_limits.extra_usage, utilization: 9 },
+      },
+    };
+    expect(claudeUsageResponseToLimits({ checkedAt, response }).limits.windows).toEqual([
+      monthlyWindow,
+    ]);
+    const utilizationOnly = {
+      ...response,
+      rate_limits: {
+        ...response.rate_limits,
+        spend: { enabled: true, used: null, limit: null, percent: 9 },
+        extra_usage: {
+          ...enterpriseResponse.rate_limits.extra_usage,
+          used_credits: null,
+          monthly_limit: null,
+        },
+      },
+    };
+    expect(
+      claudeUsageResponseToLimits({ checkedAt, response: utilizationOnly }).limits.windows,
+    ).toEqual([monthlyWindow]);
+  });
+
+  it("omits disabled budgets and refuses invalid money without an enabled fallback", () => {
+    const rateLimits = enterpriseResponse.rate_limits;
+    const response = {
+      ...enterpriseResponse,
+      rate_limits: {
+        ...rateLimits,
+        spend: { ...rateLimits.spend, enabled: false },
+        extra_usage: { ...rateLimits.extra_usage, is_enabled: false },
+      },
+    };
+    expect(claudeUsageResponseToLimits({ checkedAt, response }).limits.windows).toEqual([]);
+    response.rate_limits.spend = {
+      ...rateLimits.spend,
+      limit: { ...rateLimits.spend.limit, currency: "EUR" },
+    };
+    expect(claudeUsageResponseToLimits({ checkedAt, response }).limits.windows).toEqual([]);
+    response.rate_limits.spend = {
+      ...rateLimits.spend,
+      limit: { ...rateLimits.spend.limit, amount_minor: 0 },
+    };
+    expect(claudeUsageResponseToLimits({ checkedAt, response }).limits.windows).toEqual([]);
+  });
 });
 
 describe("claudeRateLimitEventToUpdate", () => {
diff --git a/apps/server/src/provider/claudeUsageLimits.ts b/apps/server/src/provider/claudeUsageLimits.ts
index de6379090e62a..e41dac250aceb 100644
--- a/apps/server/src/provider/claudeUsageLimits.ts
+++ b/apps/server/src/provider/claudeUsageLimits.ts
@@ -8,6 +8,7 @@ import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
 
 import {
   clampPercent,
@@ -34,6 +35,16 @@ const WINDOWS: Readonly<
  */
 const OVERAGE_INCLUDED_EVENT_TYPE = "seven_day_overage_included";
 
+// The SDK does not yet type the spend budget returned by `get_usage`.
+const SpendMoney = Schema.Struct({
+  amount_minor: Schema.Natural,
+  currency: Schema.NonEmptyString,
+  exponent: Schema.Natural,
+});
+const decodeSpendBudget = Schema.decodeUnknownOption(
+  Schema.Struct({ enabled: Schema.Boolean, used: SpendMoney, limit: SpendMoney }),
+);
+
 export interface ClaudeScopedLimitNames {
   readonly overageIncluded: string | undefined;
 }
@@ -61,6 +72,44 @@ function scopedWindow(
   };
 }
 
+function percentFromAmounts(used: number | null | undefined, limit: number | null | undefined) {
+  if (
+    typeof used !== "number" ||
+    typeof limit !== "number" ||
+    !Number.isFinite(used) ||
+    !Number.isFinite(limit) ||
+    used < 0 ||
+    limit <= 0
+  ) {
+    return undefined;
+  }
+  const percent = (used / limit) * 100;
+  return Number.isFinite(percent) ? clampPercent(percent) : undefined;
+}
+
+function readSpendPercent(rateLimits: NonNullable<SDKControlGetUsageResponse["rate_limits"]>) {
+  const spend = Option.getOrUndefined(
+    decodeSpendBudget((rateLimits as { readonly spend?: unknown }).spend),
+  );
+  // Minor-unit ratios require matching currency and scale; spend.percent is rounded.
+  if (
+    spend?.enabled &&
+    spend.used.currency.trim().length > 0 &&
+    spend.used.currency.trim() === spend.limit.currency.trim() &&
+    spend.used.exponent === spend.limit.exponent
+  ) {
+    const percent = percentFromAmounts(spend.used.amount_minor, spend.limit.amount_minor);
+    if (percent !== undefined) return percent;
+  }
+
+  const extra = rateLimits.extra_usage;
+  if (extra?.is_enabled !== true) return undefined;
+  const percent = percentFromAmounts(extra.used_credits, extra.monthly_limit) ?? extra.utilization;
+  return typeof percent === "number" && Number.isFinite(percent) && percent >= 0
+    ? clampPercent(percent)
+    : undefined;
+}
+
 /**
  * `model_scoped` shipped in the CLI after the SDK typings we pin, so it is
  * read structurally until the `.d.ts` catches up.
@@ -165,6 +214,15 @@ export function claudeUsageResponseToLimits(input: {
     );
     overageIncluded ??= entry.display_name;
   }
+  const spendPercent = readSpendPercent(response.rate_limits);
+  if (spendPercent !== undefined) {
+    windows.push({
+      id: "monthly_spend",
+      kind: "monthly",
+      label: "Monthly spend",
+      usedPercent: spendPercent,
+    });
+  }
   return {
     limits: makeUsageLimits({ checkedAt, windows }),
     names: { overageIncluded },
diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json
index 6b950ed2d060e..54be975b18346 100644
--- a/apps/server/src/provider/model-manifest.json
+++ b/apps/server/src/provider/model-manifest.json
@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "updatedAt": "2026-10-09T23:31:10Z",
+  "updatedAt": "2026-10-19T07:21:38Z",
   "compatibility": [
     {
       "driver": "codex",
@@ -653,7 +653,8 @@
               {
                 "id": "thinking",
                 "label": "Thinking",
-                "type": "boolean"
+                "type": "boolean",
+                "currentValue": true
               }
             ]
           },
diff --git a/apps/server/src/provider/unavailableProviderSnapshot.ts b/apps/server/src/provider/unavailableProviderSnapshot.ts
index d1888278ab3cd..8d34deab87b1c 100644
--- a/apps/server/src/provider/unavailableProviderSnapshot.ts
+++ b/apps/server/src/provider/unavailableProviderSnapshot.ts
@@ -25,7 +25,8 @@ export const buildUnavailableProviderSnapshot = Effect.fn(
   const checkedAt = input.checkedAt ?? (yield* nowIso);
   const displayName = input.displayName?.trim() || (input.driverKind as string);
 
-  const base = buildServerProvider({
+  // No driver ran, so its setup capabilities are still unknown.
+  const { setup: _setup, ...base } = buildServerProvider({
     presentation: { displayName },
     enabled: false,
     checkedAt,
diff --git a/apps/server/src/pullRequest/PullRequestReadCache.test.ts b/apps/server/src/pullRequest/PullRequestReadCache.test.ts
index a4c0c8b178798..c6d55b8a24fa1 100644
--- a/apps/server/src/pullRequest/PullRequestReadCache.test.ts
+++ b/apps/server/src/pullRequest/PullRequestReadCache.test.ts
@@ -13,6 +13,7 @@ import * as Queue from "effect/Queue";
 import * as TestClock from "effect/testing/TestClock";
 import * as KeyValueStore from "effect/persistence/KeyValueStore";
 import * as ServerConfig from "../config.ts";
+import { ServerActivation } from "../serverActivation.ts";
 import * as PullRequestReadCache from "./PullRequestReadCache.ts";
 
 const cacheLayer = (directory: string) =>
@@ -61,6 +62,96 @@ it.layer(NodeServices.layer)("PR filesystem cache", (it) => {
     }),
   );
 
+  it.effect("shares one scoped prune loop across cache layer consumers", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const activation = yield* Deferred.make<void>();
+      let scans = 0;
+      const observedFs = FileSystem.FileSystem.of({
+        ...fs,
+        // An empty directory keeps every sweep synchronous under the test clock.
+        readDirectory: () =>
+          Effect.sync(() => {
+            scans++;
+            return [];
+          }),
+      });
+      const caches: Array<PullRequestReadCache.PullRequestReadCache["Service"]> = [];
+      const sharedLayer = PullRequestReadCache.layer.pipe(
+        Layer.provide(Layer.succeed(FileSystem.FileSystem, observedFs)),
+      );
+      const consumers = Array.from({ length: 6 }, () =>
+        Layer.effectDiscard(
+          Effect.gen(function* () {
+            caches.push(yield* PullRequestReadCache.PullRequestReadCache);
+          }),
+        ).pipe(Layer.provide(sharedLayer)),
+      );
+      const scanCounts: Array<number> = [];
+
+      yield* Effect.scoped(
+        Effect.gen(function* () {
+          yield* Layer.build(Layer.mergeAll(consumers[0]!, ...consumers.slice(1)));
+          assert.strictEqual(caches.length, 6);
+          assert.strictEqual(new Set(caches).size, 1);
+          scanCounts.push(scans);
+          yield* Deferred.succeed(activation, undefined);
+          yield* TestClock.adjust(Duration.zero);
+          scanCounts.push(scans);
+          yield* TestClock.adjust("59 minutes");
+          scanCounts.push(scans);
+          yield* TestClock.adjust("1 minute");
+          scanCounts.push(scans);
+          yield* TestClock.adjust("1 hour");
+          scanCounts.push(scans);
+        }).pipe(Effect.provideService(ServerActivation, Deferred.await(activation))),
+      );
+      yield* TestClock.adjust("2 hours");
+      assert.deepStrictEqual([...scanCounts, scans], [0, 1, 1, 2, 3, 3]);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-pr-cache-shared-" })),
+    ),
+  );
+
+  it.effect("uses memory without starting cleanup when the cache directory is unavailable", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const { providerStatusCacheDir } = yield* ServerConfig.ServerConfig;
+      yield* fs.remove(providerStatusCacheDir, { recursive: true });
+      yield* fs.writeFileString(providerStatusCacheDir, "blocks the cache directory");
+      let scans = 0;
+      const observedFs = FileSystem.FileSystem.of({
+        ...fs,
+        readDirectory: () =>
+          Effect.sync(() => {
+            scans++;
+            return [];
+          }),
+      });
+      yield* Effect.gen(function* () {
+        const cache = yield* PullRequestReadCache.PullRequestReadCache;
+        let reads = 0;
+        const lookup = Effect.sync(() => String(++reads));
+        assert.strictEqual(yield* cache.get("summary", lookup, ["pr"]), "1");
+        assert.strictEqual(yield* cache.get("summary", lookup, ["pr"]), "1");
+        yield* cache.invalidate("pr");
+        assert.strictEqual(yield* cache.get("summary", lookup, ["pr"]), "2");
+        yield* TestClock.adjust("1 hour");
+        assert.strictEqual(scans, 0);
+      }).pipe(
+        Effect.provide(
+          PullRequestReadCache.layer.pipe(
+            Layer.provide(Layer.succeed(FileSystem.FileSystem, observedFs)),
+          ),
+        ),
+      );
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-pr-cache-fallback-" })),
+    ),
+  );
+
   it.effect("sweeps the cache directory every hour once the layer is built", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
diff --git a/apps/server/src/pullRequest/PullRequestReadCache.ts b/apps/server/src/pullRequest/PullRequestReadCache.ts
index 6f2c107f7f9d0..62466e1827311 100644
--- a/apps/server/src/pullRequest/PullRequestReadCache.ts
+++ b/apps/server/src/pullRequest/PullRequestReadCache.ts
@@ -214,17 +214,18 @@ export const layer = Layer.unwrap(
     const directory = path.join(config.providerStatusCacheDir, "pull-requests");
     return Layer.effect(PullRequestReadCache, make).pipe(
       Layer.provide(
-        KeyValueStore.layerFileSystem(directory).pipe(
-          Layer.tap(() =>
-            forkParked(
-              pruneExpiredEntryFiles(directory).pipe(
-                Effect.catch((cause) =>
-                  Effect.logWarning("Failed to prune PR cache files", { cause }),
-                ),
-                Effect.repeat(Schedule.spaced(Duration.hours(1))),
+        // Memoize cleanup acquisition with the store; Layer.tap runs per consumer.
+        Layer.effectDiscard(
+          forkParked(
+            pruneExpiredEntryFiles(directory).pipe(
+              Effect.catch((cause) =>
+                Effect.logWarning("Failed to prune PR cache files", { cause }),
               ),
+              Effect.repeat(Schedule.spaced(Duration.hours(1))),
             ),
           ),
+        ).pipe(
+          Layer.provideMerge(KeyValueStore.layerFileSystem(directory)),
           Layer.catch(() =>
             Layer.effectDiscard(
               Effect.logWarning("PR cache directory unavailable; using memory cache"),
diff --git a/apps/server/src/resourceTelemetry/ProcessGroupMetrics.test.ts b/apps/server/src/resourceTelemetry/ProcessGroupMetrics.test.ts
new file mode 100644
index 0000000000000..694803b648420
--- /dev/null
+++ b/apps/server/src/resourceTelemetry/ProcessGroupMetrics.test.ts
@@ -0,0 +1,59 @@
+import { assert, describe, it } from "@effect/vitest";
+import type { ResourceTelemetryProcess } from "@t3tools/contracts";
+
+import { groupProcesses } from "./ProcessGroupMetrics.ts";
+
+const process = (
+  pid: number,
+  ppid: number,
+  name: string,
+  category: ResourceTelemetryProcess["category"] = "server-child",
+  command = name,
+) =>
+  ({
+    identity: { pid, startTimeMs: 1 },
+    ppid,
+    name,
+    command,
+    category,
+    residentBytes: pid * 1_000,
+    cpuPercent: pid,
+  }) as ResourceTelemetryProcess;
+
+describe("groupProcesses", () => {
+  it("sums each direct child of the server with its whole subtree", () => {
+    const totals = groupProcesses([
+      process(10, 1, "node", "server"),
+      process(11, 10, "t3-resource-mon", "resource-monitor"),
+      process(20, 10, "claude"),
+      process(21, 20, "bash"),
+      process(22, 21, "cargo"),
+      process(30, 10, "codex"),
+      process(40, 10, "zsh"),
+      process(50, 10, "chrome-headless"),
+      process(60, 10, "git", "server-child", "git checkout claude/fix"),
+      process(70, 99, "orphan"),
+      // An older Claude package runs as a script under node.
+      process(
+        80,
+        10,
+        "node",
+        "server-child",
+        "node /opt/node_modules/@anthropic-ai/claude-code/cli.js",
+      ),
+      process(90, 10, "node", "server-child", "node /srv/tools/report.js"),
+    ]);
+
+    assert.deepStrictEqual(Object.fromEntries(totals), {
+      server: { residentBytes: 10_000, cpuPercent: 10, count: 1 },
+      "resource-monitor": { residentBytes: 11_000, cpuPercent: 11, count: 1 },
+      // The agent's shell and the build it ran belong to the agent, not the terminal group.
+      claude: { residentBytes: 143_000, cpuPercent: 143, count: 4 },
+      codex: { residentBytes: 30_000, cpuPercent: 30, count: 1 },
+      terminal: { residentBytes: 40_000, cpuPercent: 40, count: 1 },
+      browser: { residentBytes: 50_000, cpuPercent: 50, count: 1 },
+      // `git` whose arguments mention claude, a parentless process, and a node script.
+      other: { residentBytes: 220_000, cpuPercent: 220, count: 3 },
+    });
+  });
+});
diff --git a/apps/server/src/resourceTelemetry/ProcessGroupMetrics.ts b/apps/server/src/resourceTelemetry/ProcessGroupMetrics.ts
new file mode 100644
index 0000000000000..6f8f29c37161f
--- /dev/null
+++ b/apps/server/src/resourceTelemetry/ProcessGroupMetrics.ts
@@ -0,0 +1,125 @@
+import type { ResourceTelemetryProcess } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Metric from "effect/Metric";
+
+import * as ServerConfig from "../config.ts";
+import { metricAttributes } from "../observability/Metrics.ts";
+import * as ResourceTelemetry from "./ResourceTelemetry.ts";
+
+const SAMPLE_INTERVAL = "1 minute";
+
+const residentBytes = Metric.gauge("t3_process_group_resident_bytes", {
+  description: "Resident memory of the server's processes, summed by group.",
+  attributes: { unit: "By" },
+});
+const cpuPercent = Metric.gauge("t3_process_group_cpu_percent", {
+  description: "CPU use of the server's processes, summed by group; 100 is one full core.",
+  attributes: { unit: "%" },
+});
+const processCount = Metric.gauge("t3_process_group_count", {
+  description: "Processes in each group.",
+  attributes: { unit: "{process}" },
+});
+
+// Each direct child of the server names the group of its whole subtree. A fixed set keeps one
+// series per group per server, however many agents and processes come and go.
+const PROVIDER_GROUPS: ReadonlyArray<readonly [RegExp, string]> = [
+  [/codex/, "codex"],
+  [/claude/, "claude"],
+  [/cursor/, "cursor"],
+  [/opencode/, "opencode"],
+  [/grok/, "grok"],
+  [/antigravity|gemini/, "antigravity"],
+];
+const OTHER_GROUPS: ReadonlyArray<readonly [RegExp, string]> = [
+  [/chrom/, "browser"],
+  [/^(?:ba|z|fi|da|c)?sh(?:\.exe)?$|^pwsh|^powershell|^cmd\.exe$/, "terminal"],
+];
+// A CLI shipped as a script runs under a JavaScript runtime, so its process name is the
+// runtime's (older Claude packages run `node .../@anthropic-ai/claude-code/cli.js`). Only those
+// are matched by command line; any other name is matched by name alone, so a shell or `git`
+// whose arguments mention a provider stays in its own group.
+const SCRIPT_RUNTIME = /^(?:node|bun|deno)(?:\.exe)?$/;
+
+const match = (groups: ReadonlyArray<readonly [RegExp, string]>, text: string) =>
+  groups.find(([pattern]) => pattern.test(text))?.[1];
+
+const childGroup = (name: string, command: string) => {
+  const lowerName = name.toLowerCase();
+  if (SCRIPT_RUNTIME.test(lowerName))
+    return match(PROVIDER_GROUPS, command.toLowerCase()) ?? "other";
+  return match(PROVIDER_GROUPS, lowerName) ?? match(OTHER_GROUPS, lowerName) ?? "other";
+};
+
+export interface ProcessGroupTotals {
+  readonly residentBytes: number;
+  readonly cpuPercent: number;
+  readonly count: number;
+}
+
+export function groupProcesses(
+  processes: ReadonlyArray<ResourceTelemetryProcess>,
+): ReadonlyMap<string, ProcessGroupTotals> {
+  const byPid = new Map(processes.map((process) => [process.identity.pid, process]));
+  const serverPid = processes.find((process) => process.category === "server")?.identity.pid;
+  const groupOf = (process: ResourceTelemetryProcess): string => {
+    if (process.category === "server") return "server";
+    if (process.category === "resource-monitor") return "resource-monitor";
+    if (process.category.startsWith("electron-")) return "electron";
+    let current = process;
+    // Bounded by the table size, in case a reused PID makes the parent chain loop.
+    for (let step = 0; step < processes.length; step++) {
+      if (current.ppid === serverPid) return childGroup(current.name, current.command);
+      const parent = byPid.get(current.ppid);
+      if (parent === undefined) break;
+      current = parent;
+    }
+    return "other";
+  };
+  const totals = new Map<string, ProcessGroupTotals>();
+  for (const process of processes) {
+    const group = groupOf(process);
+    const total = totals.get(group) ?? { residentBytes: 0, cpuPercent: 0, count: 0 };
+    totals.set(group, {
+      residentBytes: total.residentBytes + process.residentBytes,
+      cpuPercent: total.cpuPercent + process.cpuPercent,
+      count: total.count + 1,
+    });
+  }
+  return totals;
+}
+
+/**
+ * Exports process totals by group while OTLP metrics export is on. Sampling walks the process
+ * table, which an idle server otherwise never does, so only a server exporting metrics pays for
+ * it, once a minute.
+ */
+export const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const config = yield* ServerConfig.ServerConfig;
+    if (config.otlpMetricsUrl === undefined) return;
+    const telemetry = yield* ResourceTelemetry.ResourceTelemetry;
+    // A group that empties reads zero rather than holding its last value.
+    const seen = new Set<string>();
+    const sample = Effect.fn("ProcessGroupMetrics.sample")(function* () {
+      const totals = groupProcesses((yield* telemetry.refresh).processes);
+      for (const group of totals.keys()) seen.add(group);
+      for (const group of seen) {
+        const total = totals.get(group) ?? { residentBytes: 0, cpuPercent: 0, count: 0 };
+        const attributes = metricAttributes({ group });
+        yield* Metric.update(Metric.withAttributes(residentBytes, attributes), total.residentBytes);
+        yield* Metric.update(Metric.withAttributes(cpuPercent, attributes), total.cpuPercent);
+        yield* Metric.update(Metric.withAttributes(processCount, attributes), total.count);
+      }
+    });
+    yield* sample().pipe(
+      Effect.catch((error) =>
+        Effect.logDebug("process group metrics sample failed", { error: error.message }),
+      ),
+      Effect.andThen(Effect.sleep(SAMPLE_INTERVAL)),
+      Effect.forever,
+      Effect.forkScoped,
+    );
+  }),
+);
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index efc593492b8ef..1738aad99bf08 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -1,8 +1,6 @@
 import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
 import type { RelayManagedEndpointRuntimeConfig } from "@t3tools/contracts/relay";
-import * as Clock from "effect/Clock";
 import * as Random from "effect/Random";
-import * as Semaphore from "effect/Semaphore";
 import * as DatabaseStorage from "./persistence/DatabaseStorage.ts";
 import * as StorageCleanup from "./storageCleanup.ts";
 import * as PullRequestSyncReactor from "./orchestration-v2/PullRequestSyncReactor.ts";
@@ -22,7 +20,6 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Layer from "effect/Layer";
 import * as Stream from "effect/Stream";
-import * as Schedule from "effect/Schedule";
 import { FetchHttpClient, HttpRouter, HttpServer } from "effect/http";
 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
 
@@ -149,8 +146,9 @@ import * as RelayTracing from "./cloud/relayTracing.ts";
 import * as CloudManagedEndpointRuntime from "./cloud/ManagedEndpointRuntime.ts";
 import {
   MANAGED_TUNNEL_FIRST_REGISTRATION_JITTER,
-  MANAGED_TUNNEL_RECOVERY_COOLDOWN,
+  makeManagedTunnelRecovery,
   managedTunnelStartupAction,
+  retryDesiredLinkReconcile,
   retryManagedTunnelRegistration,
 } from "./cloud/managedTunnelStartup.ts";
 import * as CloudCliTokenManager from "./cloud/CliTokenManager.ts";
@@ -166,6 +164,7 @@ import * as DesktopTelemetryReceiver from "./resourceTelemetry/DesktopTelemetryR
 import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClient.ts";
 import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts";
 import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts";
+import * as ProcessGroupMetrics from "./resourceTelemetry/ProcessGroupMetrics.ts";
 import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts";
 import * as AntigravityUsage from "./provider/Drivers/AntigravityUsage.ts";
 import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
@@ -279,6 +278,7 @@ const layerResourceDiagnostics = Layer.mergeAll(
   layerResourceTelemetry,
   ProcessDiagnostics.layer.pipe(Layer.provide(layerResourceTelemetry)),
   ProcessResourceMonitor.layer.pipe(Layer.provide(layerResourceTelemetry)),
+  ProcessGroupMetrics.layer.pipe(Layer.provide(layerResourceTelemetry)),
 );
 
 const layerRelayClient = Layer.unwrap(
@@ -860,42 +860,26 @@ const layerMakeServer = Layer.unwrap(
             if (typeof address === "string" || !("port" in address)) return;
             const localOrigin = `http://127.0.0.1:${address.port}`;
             const endpointRuntime = yield* CloudManagedEndpointRuntime.CloudManagedEndpointRuntime;
-            const recoveryLock = yield* Semaphore.make(1);
-            let lastRecoveryAtMillis = 0;
+            const runManagedTunnelRecovery = yield* makeManagedTunnelRecovery({
+              recover: (config: RelayManagedEndpointRuntimeConfig) =>
+                cloudLink.recoverManagedTunnel(localOrigin, config, {
+                  retryRuntimeFailures: true,
+                }),
+              isRetryable: (error) =>
+                CloudLink.shouldRetryCloudLink(error) &&
+                error._tag !== "CloudLinkEndpointUnavailableError",
+            });
             const recoverManagedTunnel = (config: RelayManagedEndpointRuntimeConfig) =>
-              recoveryLock.withPermits(1)(
-                Effect.gen(function* () {
-                  const elapsed = (yield* Clock.currentTimeMillis) - lastRecoveryAtMillis;
-                  const wait = Duration.toMillis(MANAGED_TUNNEL_RECOVERY_COOLDOWN) - elapsed;
-                  if (wait > 0) yield* Effect.sleep(Duration.millis(wait));
-                  lastRecoveryAtMillis = yield* Clock.currentTimeMillis;
-                }).pipe(
-                  Effect.andThen(
-                    cloudLink.recoverManagedTunnel(localOrigin, config, {
-                      retryRuntimeFailures: true,
-                    }),
-                  ),
-                  Effect.retry({
-                    while: (error) =>
-                      CloudLink.shouldRetryCloudLink(error) &&
-                      error._tag !== "CloudLinkEndpointUnavailableError",
-                    schedule: Schedule.exponential("1 second").pipe(
-                      Schedule.modifyDelay(({ duration }) =>
-                        Effect.succeed(Duration.min(duration, Duration.seconds(30))),
-                      ),
-                      Schedule.jittered,
-                    ),
-                  }),
-                  Effect.tap((recovered) =>
-                    recovered ? Effect.logInfo("T3 Connect managed tunnel recovered") : Effect.void,
-                  ),
-                  Effect.catchCause((cause) =>
-                    Cause.hasInterrupts(cause)
-                      ? Effect.interrupt
-                      : Effect.logWarning("Failed to recover the T3 Connect managed tunnel", {
-                          cause,
-                        }),
-                  ),
+              runManagedTunnelRecovery(config).pipe(
+                Effect.tap((recovered) =>
+                  recovered ? Effect.logInfo("T3 Connect managed tunnel recovered") : Effect.void,
+                ),
+                Effect.catchCause((cause) =>
+                  Cause.hasInterrupts(cause)
+                    ? Effect.interrupt
+                    : Effect.logWarning("Failed to recover the T3 Connect managed tunnel", {
+                        cause,
+                      }),
                 ),
               );
             yield* endpointRuntime.recoveryRequests.pipe(
@@ -997,15 +981,13 @@ const layerMakeServer = Layer.unwrap(
               const reconciledMode = yield* cloudLink
                 .reconcileDesiredLinkIfStillDesired(localOrigin)
                 .pipe(
-                  Effect.retry({
-                    while: CloudLink.shouldRetryCloudLink,
-                    schedule: Schedule.exponential("1 second").pipe(
-                      Schedule.modifyDelay(({ duration }) =>
-                        Effect.succeed(Duration.min(duration, Duration.seconds(30))),
+                  (reconcile) =>
+                    retryDesiredLinkReconcile(reconcile, CloudLink.shouldRetryCloudLink, (cause) =>
+                      Effect.logWarning(
+                        "T3 Connect relay is still unavailable; retrying the desired link in the background",
+                        { cause },
                       ),
-                      Schedule.upTo({ duration: "10 minutes" }),
                     ),
-                  }),
                   Effect.tap((mode) =>
                     mode === null
                       ? Effect.void
diff --git a/apps/server/src/storageCleanup.test.ts b/apps/server/src/storageCleanup.test.ts
index fe2c8b86fb208..1f5645c87f783 100644
--- a/apps/server/src/storageCleanup.test.ts
+++ b/apps/server/src/storageCleanup.test.ts
@@ -896,6 +896,7 @@ describe("orphan worktree reports", () => {
               outcome: "kept",
               reason: "No thread uses this worktree",
               path: orphan,
+              projectPath: null,
               threadId: null,
               threadTitle: null,
               bytes: sizes.reduce((sum, size) => sum + size, 0),
@@ -1472,7 +1473,7 @@ describe("storage cleanup reports and local file policies", () => {
   it.live("compares the checked-out branch without a full status", () =>
     runCleanupTest(
       Effect.gen(function* () {
-        const { service, fs, worktree, command, setThreads, fullStatusCalls } =
+        const { service, fs, repo, worktree, command, setThreads, fullStatusCalls } =
           yield* cleanupFixture();
         const changed = { outcome: "kept", reason: "Repository or branch changed" };
         yield* command(worktree, ["checkout", "--detach"]);
@@ -1490,8 +1491,15 @@ describe("storage cleanup reports and local file policies", () => {
         const index = (yield* command(worktree, ["rev-parse", "--git-path", "index"])).stdout;
         yield* fs.writeFileString(`${index.trim()}.lock`, "");
         const locked = (yield* service.runNow).entries[0];
-        expect(locked).toMatchObject({ outcome: "failed" });
+        expect(locked).toMatchObject({
+          outcome: "failed",
+          projectPath: repo,
+          path: worktree,
+          threadId: "thread-1",
+          threadTitle: "Thread",
+        });
         expect(locked?.reason).toContain("Git index is locked");
+        expect(yield* fs.readFileString(`${worktree}/tracked.txt`)).toBe("original\n");
         yield* fs.remove(`${index.trim()}.lock`);
         const gitFile = yield* fs.readFileString(`${worktree}/.git`);
         yield* fs.writeFileString(`${worktree}/.git`, "gitdir: /missing-git-directory\n");
@@ -1502,7 +1510,7 @@ describe("storage cleanup reports and local file policies", () => {
       }),
     ),
   );
-  it("decodes reports from servers without size fields", () => {
+  it("decodes reports from servers without size or project fields", () => {
     const report = decodeCleanupReport({
       trigger: "manual",
       startedAt: "2026-06-10T12:00:00.000Z",
@@ -1521,7 +1529,7 @@ describe("storage cleanup reports and local file policies", () => {
       omittedCount: 0,
     });
     expect(report.bytesFreed).toBe(0);
-    expect(report.entries[0]).toMatchObject({ bytes: null, files: null });
+    expect(report.entries[0]).toMatchObject({ bytes: null, files: null, projectPath: null });
   });
   it.live.each([
     ["any-local-files", ".env", "kept"],
diff --git a/apps/server/src/storageCleanup.ts b/apps/server/src/storageCleanup.ts
index 098f53cc254bf..55275e5976b07 100644
--- a/apps/server/src/storageCleanup.ts
+++ b/apps/server/src/storageCleanup.ts
@@ -414,6 +414,7 @@ const make = Effect.gen(function* () {
             ? "No thread uses this worktree"
             : "No thread uses this folder, and it isn't a git worktree",
           path: worktreePath,
+          projectPath: null,
           threadId: null,
           threadTitle: null,
           bytes,
@@ -616,6 +617,7 @@ const make = Effect.gen(function* () {
         outcome: "kept",
         reason: "",
         path: worktreePath,
+        projectPath: project?.workspaceRoot ?? null,
         threadId: thread.id,
         threadTitle: thread.title,
         bytes: null,
@@ -947,6 +949,7 @@ const make = Effect.gen(function* () {
             outcome: "failed",
             reason: cleanupFailureReason(error),
             path: null,
+            projectPath: null,
             threadId: null,
             threadTitle: null,
             bytes: null,
@@ -979,6 +982,7 @@ const make = Effect.gen(function* () {
             outcome: files > 0 ? "removed" : "kept",
             reason: files === 0 ? "No expired files" : `Removed ${files} ${category.label}`,
             path: null,
+            projectPath: null,
             threadId: null,
             threadTitle: null,
             bytes: files > 0 ? bytes : null,
@@ -992,6 +996,7 @@ const make = Effect.gen(function* () {
               outcome: "failed",
               reason: cleanupFailureReason(error),
               path: null,
+              projectPath: null,
               threadId: null,
               threadTitle: null,
               bytes: removed.files > 0 ? removed.bytes : null,
diff --git a/apps/server/src/terminal/Manager.test.ts b/apps/server/src/terminal/Manager.test.ts
index d7babfbeac866..94af3c5bfca1c 100644
--- a/apps/server/src/terminal/Manager.test.ts
+++ b/apps/server/src/terminal/Manager.test.ts
@@ -2081,6 +2081,53 @@ it.layer(
     }),
   );
 
+  it.effect.each([
+    {
+      label: "subagent",
+      threadId:
+        "thread:provider:claudeAgent:native-thread:provider-thread%3Aprovider%3AclaudeAgent%3Anative-thread%3Apending%253Arun%253Athread%253A9175fb53-52d7-4d4d-9be7-25a76cf84b91%253Aordinal%253A7%3Aad899ae84c7a131b0",
+    },
+    // Also too long for the legacy `<sanitized id>.log` lookup.
+    { label: "300-character", threadId: "x".repeat(300) },
+  ])("persists history for a $label thread id too long to encode into a filename", ({ threadId }) =>
+    Effect.gen(function* () {
+      const terminalId = "t".repeat(128);
+      const { manager, ptyAdapter, logsDir } = yield* createManager();
+      const fs = yield* FileSystem.FileSystem;
+      yield* manager.open(openInput({ threadId }));
+      yield* manager.open(openInput({ threadId, terminalId }));
+      ptyAdapter.processes[0]!.emitData("default\n");
+      ptyAdapter.processes[1]!.emitData("long\n");
+      yield* manager.close({ threadId });
+
+      expect((yield* manager.open(openInput({ threadId }))).history).toBe("default\n");
+      expect((yield* manager.open(openInput({ threadId, terminalId }))).history).toBe("long\n");
+
+      yield* manager.close({ threadId, deleteHistory: true });
+      expect(yield* fs.readDirectory(logsDir)).toEqual([]);
+    }),
+  );
+
+  it.effect("keeps reading and deleting history at an encoded path that already fit", () =>
+    Effect.gen(function* () {
+      const threadId = "x".repeat(120);
+      const { manager, logsDir } = yield* createManager();
+      const fs = yield* FileSystem.FileSystem;
+      const logPath = yield* historyLogPath(logsDir, threadId);
+      yield* fs.makeDirectory(logsDir, { recursive: true });
+      yield* fs.writeFileString(logPath, "before upgrade\n");
+
+      expect((yield* manager.open(openInput({ threadId }))).history).toBe("before upgrade\n");
+      // A long terminal id pushes only this terminal's name past the limit, so the thread's
+      // history is split across both forms and deleting the thread must remove both.
+      yield* manager.open(openInput({ threadId, terminalId: "t".repeat(128) }));
+
+      yield* manager.close({ threadId, deleteHistory: true });
+      expect(yield* fs.exists(logPath)).toBe(false);
+      expect(yield* fs.readDirectory(logsDir)).toEqual([]);
+    }),
+  );
+
   it.effect("closes all terminals for a thread when close omits terminalId", () =>
     Effect.gen(function* () {
       const { manager, ptyAdapter, logsDir } = yield* createManager();
diff --git a/apps/server/src/terminal/Manager.ts b/apps/server/src/terminal/Manager.ts
index b47abfba424fe..6428dd70f000c 100644
--- a/apps/server/src/terminal/Manager.ts
+++ b/apps/server/src/terminal/Manager.ts
@@ -1,3 +1,6 @@
+// @effect-diagnostics-next-line nodeBuiltinImport:off -- Effect's Crypto digest is effectful; a sync hash keeps historyPath a plain function.
+import * as NodeCrypto from "node:crypto";
+
 import { withWorkspaceLease } from "../workspace/workspaceLease.ts";
 import {
   DEFAULT_TERMINAL_ID,
@@ -1256,12 +1259,23 @@ function legacySafeThreadId(threadId: string): string {
   return threadId.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 
-function toSafeThreadId(threadId: string): string {
+const MAX_FILE_NAME_BYTES = 255;
+
+function encodedHistoryThreadPart(threadId: string): string {
   return `terminal_${Base64Url.encode(threadId)}`;
 }
 
-function toSafeTerminalId(terminalId: string): string {
-  return Base64Url.encode(terminalId);
+function hashId(id: string): string {
+  return NodeCrypto.createHash("sha256").update(id).digest("base64url");
+}
+
+// "." is outside the base64url alphabet, so a hashed name can never collide with an encoded one.
+function hashedHistoryThreadPart(threadId: string): string {
+  return `terminal_sha256.${hashId(threadId)}`;
+}
+
+function joinHistoryFileName(threadPart: string, terminalPart: string | null): string {
+  return terminalPart === null ? `${threadPart}.log` : `${threadPart}_${terminalPart}.log`;
 }
 
 function toSessionKey(threadId: string, terminalId: string): string {
@@ -1605,16 +1619,28 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
       }
     });
 
+  // Nested subagent thread ids can encode past the filename limit. Only names that would not fit
+  // switch to hashed ids, so every history file that already exists keeps its path.
   const historyPath = (threadId: string, terminalId: string) => {
-    const threadPart = toSafeThreadId(threadId);
-    if (terminalId === DEFAULT_TERMINAL_ID) {
-      return path.join(logsDir, `${threadPart}.log`);
+    const isDefault = terminalId === DEFAULT_TERMINAL_ID;
+    const encodedName = joinHistoryFileName(
+      encodedHistoryThreadPart(threadId),
+      isDefault ? null : Base64Url.encode(terminalId),
+    );
+    if (encodedName.length <= MAX_FILE_NAME_BYTES) {
+      return path.join(logsDir, encodedName);
     }
-    return path.join(logsDir, `${threadPart}_${toSafeTerminalId(terminalId)}.log`);
+    return path.join(
+      logsDir,
+      joinHistoryFileName(hashedHistoryThreadPart(threadId), isDefault ? null : hashId(terminalId)),
+    );
   };
 
-  const legacyHistoryPath = (threadId: string) =>
-    path.join(logsDir, `${legacySafeThreadId(threadId)}.log`);
+  const legacyHistoryName = (threadId: string) => `${legacySafeThreadId(threadId)}.log`;
+  const legacyHistoryPath = (threadId: string) => path.join(logsDir, legacyHistoryName(threadId));
+  // Ids this long could never have been written under the legacy name.
+  const hasLegacyHistoryPath = (threadId: string) =>
+    Buffer.byteLength(legacyHistoryName(threadId)) <= MAX_FILE_NAME_BYTES;
 
   const readManagerState = SynchronizedRef.get(managerStateRef);
 
@@ -1877,7 +1903,7 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
       return history;
     }
 
-    if (terminalId !== DEFAULT_TERMINAL_ID) {
+    if (terminalId !== DEFAULT_TERMINAL_ID || !hasLegacyHistoryPath(threadId)) {
       return new BoundedTerminalHistory(historyLineLimit, "", historyByteLimit);
     }
 
@@ -1935,7 +1961,7 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
         }),
       ),
     );
-    if (terminalId === DEFAULT_TERMINAL_ID) {
+    if (terminalId === DEFAULT_TERMINAL_ID && hasLegacyHistoryPath(threadId)) {
       yield* fileSystem.remove(legacyHistoryPath(threadId), { force: true }).pipe(
         Effect.catch((error) =>
           Effect.logWarning("failed to delete terminal history", {
@@ -1951,16 +1977,15 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
   const deleteAllHistoryForThread = Effect.fn("terminal.deleteAllHistoryForThread")(function* (
     threadId: string,
   ) {
-    const threadPrefix = `${toSafeThreadId(threadId)}_`;
+    const threadParts = [encodedHistoryThreadPart(threadId), hashedHistoryThreadPart(threadId)];
     const entries = yield* fileSystem
       .readDirectory(logsDir, { recursive: false })
       .pipe(Effect.orElseSucceed(() => [] as Array<string>));
     yield* Effect.forEach(
       entries.filter(
         (name) =>
-          name === `${toSafeThreadId(threadId)}.log` ||
           name === `${legacySafeThreadId(threadId)}.log` ||
-          name.startsWith(threadPrefix),
+          threadParts.some((part) => name === `${part}.log` || name.startsWith(`${part}_`)),
       ),
       (name) =>
         fileSystem.remove(path.join(logsDir, name), { force: true }).pipe(
diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts
index 6d8ee7d7a3144..d6dd27e7d6e8e 100644
--- a/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts
+++ b/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts
@@ -224,7 +224,11 @@ it.layer(layerClaudeTextGenerationTest)("ClaudeTextGeneration", (it) => {
     }),
   );
 
-  it.effect("forwards Claude thinking settings without passing unsupported effort", () =>
+  it.effect.each([
+    { thinking: true, settings: '{"disableAllHooks":true,"alwaysThinkingEnabled":true}' },
+    { thinking: false, settings: '{"disableAllHooks":true,"alwaysThinkingEnabled":false}' },
+    { thinking: undefined, settings: '{"disableAllHooks":true}' },
+  ])("forwards only the explicit thinking choice ($thinking)", ({ thinking, settings }) =>
     withFakeClaudeEnv(
       {
         output: JSON.stringify({
@@ -233,7 +237,7 @@ it.layer(layerClaudeTextGenerationTest)("ClaudeTextGeneration", (it) => {
             body: "",
           },
         }),
-        argsMustContain: '--settings {"disableAllHooks":true,"alwaysThinkingEnabled":false}',
+        argsMustContain: `--settings ${settings}`,
         argsMustNotContain: "--effort",
       },
       (textGeneration) =>
@@ -243,16 +247,14 @@ it.layer(layerClaudeTextGenerationTest)("ClaudeTextGeneration", (it) => {
             branch: "feature/claude-effect",
             stagedSummary: "M README.md",
             stagedPatch: "diff --git a/README.md b/README.md",
-            modelSelection: {
-              ...createModelSelection(
-                ProviderInstanceId.make("claudeAgent"),
-                SYNTHETIC_CLAUDE_THINKING_MODEL,
-                [
-                  { id: "thinking", value: false },
-                  { id: "effort", value: "high" },
-                ],
-              ),
-            },
+            modelSelection: createModelSelection(
+              ProviderInstanceId.make("claudeAgent"),
+              SYNTHETIC_CLAUDE_THINKING_MODEL,
+              [
+                ...(thinking === undefined ? [] : [{ id: "thinking", value: thinking }]),
+                { id: "effort", value: "high" },
+              ],
+            ),
           });
 
           expect(generated.subject).toBe("Add important change");
diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
index 4e1df3067d989..b20e07e65e1b2 100644
--- a/apps/server/src/textGeneration/ClaudeTextGeneration.ts
+++ b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
@@ -14,6 +14,7 @@ import {
   toJsonSchemaObject,
 } from "@t3tools/provider-core/server/textGenerationUtils";
 import {
+  getModelSelectionBooleanOptionValue,
   getModelSelectionStringOptionValue,
   getProviderOptionDescriptors,
 } from "@t3tools/shared/model";
@@ -167,8 +168,11 @@ export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(fu
     const ultracode = isClaudeCatalogUltracodeEffort(resolvedEffort);
     const thinkingDescriptor = findDescriptor("thinking");
     const fastModeDescriptor = findDescriptor("fastMode");
+    // Only a chosen value; otherwise Claude Code's own default applies, as in chat turns.
     const thinking =
-      thinkingDescriptor?.type === "boolean" ? thinkingDescriptor.currentValue : undefined;
+      thinkingDescriptor?.type === "boolean"
+        ? getModelSelectionBooleanOptionValue(resolvedModelSelection, "thinking")
+        : undefined;
     const fastMode =
       fastModeDescriptor?.type === "boolean" ? fastModeDescriptor.currentValue : undefined;
     const settings = {
diff --git a/apps/server/src/usage/UsageService.test.ts b/apps/server/src/usage/UsageService.test.ts
index 667a71dd0c398..f211251adceb9 100644
--- a/apps/server/src/usage/UsageService.test.ts
+++ b/apps/server/src/usage/UsageService.test.ts
@@ -7,6 +7,7 @@ import * as NodePath from "node:path";
 import * as NodeSqlite from "node:sqlite";
 
 import { assert, describe, it } from "@effect/vitest";
+import { vi } from "vite-plus/test";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import { mergeUsage } from "@t3tools/shared/usageMerge";
@@ -16,9 +17,11 @@ import {
   ProviderInstanceId,
   UsageDay,
   type UsageSource,
+  type UsageSummary,
   type UsageSummaryInput,
 } from "@t3tools/contracts";
 import * as Duration from "effect/Duration";
+import * as Clock from "effect/Clock";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -42,6 +45,9 @@ import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
 import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
 import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
 import * as UsageService from "./UsageService.ts";
+import { encodeScanCache, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
+
+vi.mock("node:fs/promises", { spy: true });
 
 const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
 const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
@@ -1526,6 +1532,129 @@ describe("UsageService", () => {
     }).pipe(Effect.scoped),
   );
 
+  it.live(
+    "retains Codex reconciliation and partial coverage through persisted restart, append and repair",
+    () =>
+      Effect.gen(function* () {
+        const { home, settings } = yield* setup;
+        const dir = NodePath.join(home, "codex", "sessions");
+        const transcript = NodePath.join(dir, "rollout.jsonl");
+        const usage = (input: number, output: number) => ({
+          input_tokens: input,
+          output_tokens: output,
+          total_tokens: input + output,
+        });
+        const counted = (input: number, output: number, totalInput: number, totalOutput: number) =>
+          encodeUnknownJsonString({
+            type: "event_msg",
+            timestamp: "2026-08-01T10:00:00Z",
+            payload: {
+              type: "token_count",
+              info: {
+                last_token_usage: usage(input, output),
+                total_token_usage: usage(totalInput, totalOutput),
+              },
+            },
+          });
+        const tier = (service_tier: string) =>
+          encodeUnknownJsonString({
+            type: "event_msg",
+            payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
+          });
+        const bad = counted(10, 2, 130, 28);
+        // Cross the reader's projection threshold so cumulative fields must survive selection.
+        const stale = counted(20, 5, 100, 20).replace(
+          '"payload":',
+          '"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"payload":',
+        );
+        let content = [
+          encodeUnknownJsonString({ type: "turn_context", payload: { model: "gpt-6-astra" } }),
+          counted(100, 20, 100, 20),
+          stale,
+          tier("priority"),
+          bad,
+        ].join("\n");
+        yield* Effect.promise(async () => {
+          await NodeFSP.mkdir(dir, { recursive: true });
+          await NodeFSP.writeFile(transcript, content);
+        });
+        yield* Effect.gen(function* () {
+          const verify = (
+            summary: UsageSummary,
+            output: number,
+            cost: number,
+            malformed: number,
+          ) => {
+            assert.strictEqual(totalOutputTokens(summary), output);
+            assert.strictEqual(
+              summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
+              cost,
+            );
+            const source = summary.sources.find(
+              (source) => source.fingerprint.provider === "codex",
+            );
+            assert.strictEqual(source?.status, malformed === 0 ? "ok" : "partial");
+            assert.strictEqual(source?.malformedRecords, malformed);
+            if (malformed > 0) assert.match(source?.message ?? "", /1 malformed or inconsistent/);
+            else assert.notMatch(source?.message ?? "", /malformed|inconsistent/);
+          };
+          const open = vi.spyOn(NodeFSP, "open");
+          open.mockClear();
+          yield* Effect.addFinalizer(() => Effect.sync(() => open.mockRestore()));
+          const first = yield* UsageService.make;
+          const cold = yield* first.readSummary(WINDOW);
+          assert.isTrue(open.mock.calls.some(([path]) => path === transcript));
+          verify(cold, 20, 20, 1);
+          yield* first.awaitPersisted;
+          const restarted = yield* UsageService.make;
+          open.mockClear();
+          verify(yield* first.readSummary(WINDOW), 20, 20, 1);
+          verify(yield* restarted.readSummary(WINDOW), 20, 20, 1);
+          assert.isFalse(open.mock.calls.some(([path]) => path === transcript));
+          open.mockRestore();
+
+          const append = "\n" + counted(10, 2, 140, 30) + "\n";
+          content += append;
+          yield* Effect.promise(() => NodeFSP.appendFile(transcript, append));
+          verify(yield* restarted.readSummary(WINDOW), 22, 24, 1);
+          yield* restarted.awaitPersisted;
+          const resumed = yield* UsageService.make;
+          verify(yield* resumed.readSummary(WINDOW), 22, 24, 1);
+          const next = tier("ultrafast") + "\n" + counted(10, 2, 150, 32) + "\n";
+          content += next;
+          yield* Effect.promise(() => NodeFSP.appendFile(transcript, next));
+          verify(yield* resumed.readSummary(WINDOW), 24, 36, 1);
+
+          const repaired = content.replace(bad, counted(30, 8, 130, 28));
+          assert.strictEqual(Buffer.byteLength(repaired), Buffer.byteLength(content));
+          yield* Effect.promise(async () => {
+            const stat = await NodeFSP.stat(transcript);
+            await NodeFSP.writeFile(transcript, repaired);
+            await NodeFSP.utimes(transcript, stat.atime, stat.mtimeMs / 1000 + 1);
+          });
+          verify(yield* resumed.readSummary(WINDOW), 32, 52, 0);
+        }).pipe(
+          Effect.provide(
+            layerService({
+              prefix: "usage-codex-reconciliation",
+              home,
+              settings,
+              ratesDocument: {
+                "gpt-6-astra": {
+                  input_cost_per_token: 0,
+                  output_cost_per_token: 1,
+                  input_cost_per_token_priority: 0,
+                  output_cost_per_token_priority: 2,
+                  input_cost_per_token_ultrafast: 0,
+                  output_cost_per_token_ultrafast: 6,
+                },
+              },
+            }),
+          ),
+        );
+      }).pipe(Effect.scoped),
+  );
+
   it.live(
     "keeps large-record totals and costs exact through append, dedupe, restart and cleanup",
     () =>
@@ -1581,9 +1710,9 @@ describe("UsageService", () => {
       }).pipe(Effect.scoped),
   );
 
-  it.live(
-    "upgrades a v4 cache: reprices live Codex tiers, keeps deleted rollouts, leaves v4 intact",
-    () =>
+  it.live.each([4, 5])(
+    "upgrades a v%s cache: reparses live Codex usage, keeps deleted rollouts and the old file",
+    (version) =>
       Effect.gen(function* () {
         const { home, settings } = yield* setup;
         const sessions = NodePath.join(home, "codex", "sessions");
@@ -1619,33 +1748,46 @@ describe("UsageService", () => {
 
         yield* Effect.gen(function* () {
           const { stateDir } = yield* ServerConfig.ServerConfig;
-          const cachePath = NodePath.join(stateDir, "usage-scan-cache-v5.json");
-          const legacyPath = NodePath.join(stateDir, "usage-scan-cache.json");
+          const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
+          const legacyPath = NodePath.join(
+            stateDir,
+            version === 4 ? "usage-scan-cache.json" : "usage-scan-cache-v5.json",
+          );
           const first = yield* UsageService.make;
           yield* first.readSummary(WINDOW);
           yield* first.awaitPersisted;
 
           const legacy = yield* Effect.promise(async () => {
             const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
-              files: Record<string, { r: unknown[][]; cs: { speed?: unknown } }>;
+              files: Record<string, { r: unknown[][]; cs: Record<string, unknown> }>;
             };
-            for (const file of Object.values(document.files)) {
-              file.r = file.r.map((row) => [...row.slice(0, 10), 0]);
-              delete file.cs.speed;
+            for (const [path, file] of Object.entries(document.files)) {
+              file.r = file.r.map((row) => [
+                ...row.slice(0, 6),
+                path === live ? 99 : row[6],
+                ...row.slice(7, 10),
+                version === 4 ? 0 : 1,
+              ]);
+              if (version === 4) delete file.cs.speed;
+              delete file.cs.lastCumulativeUsage;
+              delete file.cs.malformedRecords;
             }
-            const text = encodeUnknownJsonString({ ...document, version: 4 });
-            await NodeFSP.writeFile(legacyPath, text);
+            const text = encodeUnknownJsonString({ ...document, version });
             await NodeFSP.rm(cachePath);
+            await NodeFSP.writeFile(legacyPath, text);
             await NodeFSP.rm(deleted);
             return text;
           });
 
-          const summary = yield* (yield* UsageService.make).readSummary(WINDOW);
+          const upgraded = yield* UsageService.make;
+          const summary = yield* upgraded.readSummary(WINDOW);
           assert.strictEqual(totalOutputTokens(summary), 30);
           assert.strictEqual(
             summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
-            80,
+            60 + 20 * (version === 4 ? 1 : 2),
           );
+          yield* upgraded.awaitPersisted;
+          assert.strictEqual(SCAN_CACHE_FILE_NAME, "usage-scan-cache-v6.json");
           assert.strictEqual(
             yield* Effect.promise(() => NodeFSP.readFile(legacyPath, "utf8")),
             legacy,
@@ -1653,13 +1795,15 @@ describe("UsageService", () => {
         }).pipe(
           Effect.provide(
             layerService({
-              prefix: "usage-service-v4-upgrade-test",
+              prefix: "usage-service-cache-upgrade-test",
               home,
               settings,
               ratesDocument: {
                 "gpt-6-astra": {
                   input_cost_per_token: 0,
                   output_cost_per_token: 1,
+                  input_cost_per_token_priority: 0,
+                  output_cost_per_token_priority: 2,
                   input_cost_per_token_ultrafast: 0,
                   output_cost_per_token_ultrafast: 6,
                 },
@@ -1881,6 +2025,51 @@ describe("UsageService", () => {
       }).pipe(Effect.scoped),
   );
 
+  it.live("keeps an absent directory missing when its cached files only contain diagnostics", () =>
+    Effect.gen(function* () {
+      const { transcript, settings, home } = yield* setup;
+      yield* Effect.promise(() =>
+        NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
+      );
+      yield* Effect.gen(function* () {
+        const { stateDir } = yield* ServerConfig.ServerConfig;
+        const mtimeMs = yield* Clock.currentTimeMillis;
+        const cache = encodeScanCache(
+          new Map([
+            [
+              transcript,
+              {
+                size: 0,
+                mtimeMs,
+                provider: "claude" as const,
+                records: [],
+                tailRecords: [],
+                malformedRecords: 2,
+                position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
+              },
+            ],
+          ]),
+        );
+        yield* Effect.promise(async () => {
+          await NodeFSP.mkdir(stateDir, { recursive: true });
+          await NodeFSP.writeFile(
+            NodePath.join(stateDir, SCAN_CACHE_FILE_NAME),
+            encodeUnknownJsonString(cache),
+          );
+        });
+        const summary = yield* (yield* UsageService.make).readSummary(WINDOW);
+        const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
+        assert.strictEqual(source?.status, "missing");
+        assert.strictEqual(source?.scannedFiles, 0);
+        assert.strictEqual(source?.malformedRecords, 2);
+      }).pipe(
+        Effect.provide(
+          layerService({ prefix: "usage-service-missing-diagnostics", home, settings }),
+        ),
+      );
+    }).pipe(Effect.scoped),
+  );
+
   it.live("reports saved usage of a removed directory only for windows it reaches", () =>
     Effect.gen(function* () {
       const { transcript, settings, home } = yield* setup;
diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts
index 5c7403799873c..83833e1dd0ede 100644
--- a/apps/server/src/usage/UsageService.ts
+++ b/apps/server/src/usage/UsageService.ts
@@ -53,7 +53,7 @@ import {
 import {
   decodeScanCache,
   dedupeWithinFile,
-  LEGACY_SCAN_CACHE_FILE_NAME,
+  LEGACY_SCAN_CACHE_FILE_NAMES,
   makeScanCacheWriter,
   pruneScanCache,
   SCAN_CACHE_FILE_NAME,
@@ -207,7 +207,6 @@ export const make = Effect.gen(function* () {
 
   const ratesCachePath = path.join(config.stateDir, "usage-model-rates.json");
   const scanCachePath = path.join(config.stateDir, SCAN_CACHE_FILE_NAME);
-  const legacyScanCachePath = path.join(config.stateDir, LEGACY_SCAN_CACHE_FILE_NAME);
   const writeCacheFile = (filePath: string, contents: string) =>
     writeFileStringAtomically({ filePath, contents }).pipe(
       Effect.provideService(FileSystem.FileSystem, fileSystem),
@@ -356,7 +355,7 @@ export const make = Effect.gen(function* () {
             ([filePath, entry]) =>
               entry.provider === provider &&
               entry.mtimeMs >= retentionCutoffMs &&
-              entry.records.length + entry.tailRecords.length > 0 &&
+              (entry.records.length + entry.tailRecords.length > 0 || entry.malformedRecords > 0) &&
               isWithinDirectory(filePath, dir),
           );
         const volumeId =
@@ -395,8 +394,9 @@ export const make = Effect.gen(function* () {
           Effect.catchCause(() => Effect.succeed(null)),
         );
       let document = yield* readDocument(scanCachePath);
-      if (document === null) {
-        document = yield* readDocument(legacyScanCachePath);
+      for (const fileName of LEGACY_SCAN_CACHE_FILE_NAMES) {
+        if (document !== null) break;
+        document = yield* readDocument(path.join(config.stateDir, fileName));
         cacheDirty = document !== null;
       }
       if (document === null) return;
@@ -462,6 +462,7 @@ export const make = Effect.gen(function* () {
     format: TranscriptUsageFormat<unknown>,
   ): Effect.fn.Return<{
     readonly records: readonly UsageRecord[];
+    readonly malformedRecords: number;
     readonly failed?: true;
     readonly update?: { readonly entry: CachedFile; readonly replaces: CachedFile | undefined };
   }> {
@@ -479,6 +480,7 @@ export const make = Effect.gen(function* () {
           cached.tailRecords.length === 0
             ? cached.records
             : [...cached.records, ...cached.tailRecords],
+        malformedRecords: cached.malformedRecords,
       };
     }
 
@@ -495,6 +497,7 @@ export const make = Effect.gen(function* () {
     if (parsed === null)
       return {
         records: cached?.provider === provider ? [...cached.records, ...cached.tailRecords] : [],
+        malformedRecords: cached?.provider === provider ? cached.malformedRecords : 0,
         failed: true,
       };
 
@@ -505,8 +508,17 @@ export const make = Effect.gen(function* () {
 
     return {
       records: tailRecords.length === 0 ? records : [...records, ...tailRecords],
+      malformedRecords: parsed.malformedRecords,
       update: {
-        entry: { size, mtimeMs, provider, records, tailRecords, position: parsed.position },
+        entry: {
+          size,
+          mtimeMs,
+          provider,
+          records,
+          tailRecords,
+          malformedRecords: parsed.malformedRecords,
+          position: parsed.position,
+        },
         replaces: cached,
       },
     };
@@ -521,7 +533,11 @@ export const make = Effect.gen(function* () {
     readonly message?: string;
     readonly action?: UsageSource["action"];
     readonly files:
-      | readonly { readonly path: string; readonly records: readonly UsageRecord[] }[]
+      | readonly {
+          readonly path: string;
+          readonly records: readonly UsageRecord[];
+          readonly malformedRecords: number;
+        }[]
       | null;
     readonly refreshing?: true;
   }
@@ -546,8 +562,8 @@ export const make = Effect.gen(function* () {
         ),
       { concurrency: TRANSCRIPT_READ_CONCURRENCY },
     );
-    const parsedFiles = read.map(({ path, records, update }) => {
-      if (update === undefined) return { path, records };
+    const parsedFiles = read.map(({ path, records, malformedRecords, update }) => {
+      if (update === undefined) return { path, records, malformedRecords };
       // A scan of another window may have cached its own read of this file
       // meanwhile. Then keep whichever read saw the later file, so a slower
       // scan never replaces newer usage with older.
@@ -560,7 +576,7 @@ export const make = Effect.gen(function* () {
         fileCache.set(path, update.entry);
         cacheDirty = true;
       }
-      return { path, records };
+      return { path, records, malformedRecords };
     });
     const unread = failedPaths + read.filter((file) => file.failed).length;
     return {
@@ -605,6 +621,7 @@ export const make = Effect.gen(function* () {
                     : Effect.succeed(volumeId),
                   (resolved): ScannedDir => ({
                     ...source,
+                    files: source.files?.map((file) => ({ ...file, malformedRecords: 0 })) ?? null,
                     provider: reader.provider,
                     volumeId: resolved,
                   }),
@@ -713,7 +730,11 @@ export const make = Effect.gen(function* () {
           !isWithinDirectory(filePath, dir)
         )
           continue;
-        retainedFiles.push({ path: filePath, records: [...entry.records, ...entry.tailRecords] });
+        retainedFiles.push({
+          path: filePath,
+          records: [...entry.records, ...entry.tailRecords],
+          malformedRecords: entry.malformedRecords,
+        });
       }
       return retainedFiles;
     });
@@ -725,11 +746,13 @@ export const make = Effect.gen(function* () {
     ] of scannedDirs.entries()) {
       let scannedFiles = 0;
       let skippedFiles = 0;
+      let malformedRecords = 0;
       // Distinct per directory. Buckets carry per-cell session counts, but a
       // session spans days and models, so clients total this figure instead.
       const sessionIds = new Set<string>();
 
       for (const file of filesByDir[index] ?? []) {
+        malformedRecords += file.malformedRecords;
         if (file.records.length === 0) {
           skippedFiles += 1;
           continue;
@@ -761,15 +784,31 @@ export const make = Effect.gen(function* () {
         }
       }
 
+      const sourceMessage =
+        message ?? (files === null ? "No transcript directory on this environment." : null);
       sources.push({
         fingerprint: { hostId: sourceHostId ?? hostId, provider, resolvedHomePath: dir, volumeId },
-        status: files === null && scannedFiles === 0 ? "missing" : (status ?? "ok"),
+        status:
+          files === null && scannedFiles === 0
+            ? "missing"
+            : malformedRecords > 0
+              ? status === undefined || status === "ok"
+                ? "partial"
+                : status
+              : (status ?? "ok"),
         scannedFiles,
         skippedFiles,
-        malformedRecords: 0,
+        malformedRecords,
         distinctSessions: sessionIds.size,
         message:
-          message ?? (files === null ? "No transcript directory on this environment." : null),
+          malformedRecords > 0
+            ? [
+                sourceMessage,
+                `${malformedRecords} malformed or inconsistent usage record(s) were skipped; usage may be incomplete.`,
+              ]
+                .filter(Boolean)
+                .join(" ")
+            : sourceMessage,
         ...(action ? { action } : {}),
         ...(refreshing ? { refreshing } : {}),
       });
diff --git a/apps/server/src/usage/usageScanCache.test.ts b/apps/server/src/usage/usageScanCache.test.ts
index f7edc7f86b441..ddacde80fdac2 100644
--- a/apps/server/src/usage/usageScanCache.test.ts
+++ b/apps/server/src/usage/usageScanCache.test.ts
@@ -12,6 +12,7 @@ import {
 import type { UsageRecord } from "@t3tools/provider-core/server/usage";
 
 import { TEST_FORMAT_MAP } from "./usageTestFormats.ts";
+import { initialCodexScanState } from "../provider/Drivers/codexUsage.ts";
 
 function record(overrides: Partial<UsageRecord> = {}): UsageRecord {
   return {
@@ -52,6 +53,7 @@ function cacheWith(entries: readonly [string, number, readonly UsageRecord[]][])
       provider: "claude",
       records,
       tailRecords: [],
+      malformedRecords: 0,
       position: position(),
     });
   }
@@ -86,6 +88,7 @@ describe("scan cache round trip", () => {
     ]);
     original.set("/grok.jsonl", {
       size: 40,
+      malformedRecords: 2,
       mtimeMs: 300,
       provider: "grok",
       records: [
@@ -97,6 +100,7 @@ describe("scan cache round trip", () => {
     });
     original.set("/codex.jsonl", {
       size: 80,
+      malformedRecords: 3,
       mtimeMs: 400,
       provider: "codex",
       records: [
@@ -105,13 +109,12 @@ describe("scan cache round trip", () => {
       tailRecords: [],
       position: position({
         state: {
+          ...initialCodexScanState(),
           model: "gpt-6-astra",
           speed: "ultrafast",
           sessionId: "session-c",
           lastUsageSignature: '{"input_tokens":1}',
           sawSessionMeta: true,
-          suppressingForkCopies: false,
-          forkCopyAnchorMs: 0,
         },
       }),
     });
@@ -135,9 +138,58 @@ describe("scan cache round trip", () => {
       TEST_FORMAT_MAP,
     );
 
+    expect(restored.size).toBe(4);
     expect(restored).toEqual(original);
   });
 
+  it("retains v5 history and stateless positions but invalidates obsolete Codex state", () => {
+    const original = cacheWith([["/gone.jsonl", 100, [record({ speed: "fast" })]]]);
+    original.set("/gone-codex.jsonl", {
+      ...original.get("/gone.jsonl")!,
+      provider: "codex",
+      records: [record({ provider: "codex", speed: "fast", dedupeKey: null })],
+      position: position({
+        state: {
+          model: "gpt-6-astra",
+          speed: "fast",
+          sessionId: "session-a",
+          lastUsageSignature: null,
+          sawSessionMeta: true,
+          suppressingForkCopies: false,
+          forkCopyAnchorMs: 0,
+        },
+      }),
+    });
+    const encoded = encodeScanCache(original);
+    const entry = encoded.files["/gone.jsonl"]!;
+    const legacy = {
+      ...encoded,
+      version: 5,
+      files: {
+        ...encoded.files,
+        "/gone.jsonl": {
+          s: entry.s,
+          m: entry.m,
+          p: entry.p,
+          r: entry.r,
+          t: entry.t,
+          o: entry.o,
+          gl: entry.gl,
+          gh: entry.gh,
+          cs: entry.cs,
+        },
+      },
+    };
+
+    const restored = decodeScanCache(JSON.parse(JSON.stringify(legacy)), TEST_FORMAT_MAP);
+    expect(restored.get("/gone.jsonl")).toEqual(original.get("/gone.jsonl"));
+    expect(restored.get("/gone-codex.jsonl")).toEqual({
+      ...original.get("/gone-codex.jsonl"),
+      size: -1,
+      position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
+    });
+  });
+
   it("drops an entry whose persisted parse state is corrupt", () => {
     const encoded = encodeScanCache(cacheWith([["/a.jsonl", 100, [record()]]]));
     const poisoned = {
@@ -190,12 +242,14 @@ describe("scan cache round trip", () => {
       ["/a.jsonl", 100, [record()]],
       ["/b.jsonl", 200, [record({ sessionId: "session-b" })]],
     ]);
+    cache.set("/b.jsonl", { ...cache.get("/b.jsonl")!, malformedRecords: 2 });
     const sources = { "claude\u0000/projects": { dir: "/projects", volumeId: "1:2" } };
     expect(decodeScanCache(JSON.parse(write(cache, { sources })), TEST_FORMAT_MAP)).toEqual(cache);
 
     cache.set("/b.jsonl", {
       ...cache.get("/b.jsonl")!,
       size: 30,
+      malformedRecords: 4,
       records: [record({ sessionId: "session-c", model: "claude-opus-5-5", dedupeKey: "msg_3:" })],
     });
     const document = JSON.parse(write(cache, { sources }));
diff --git a/apps/server/src/usage/usageScanCache.ts b/apps/server/src/usage/usageScanCache.ts
index 43b3a548a519c..921158a38abd6 100644
--- a/apps/server/src/usage/usageScanCache.ts
+++ b/apps/server/src/usage/usageScanCache.ts
@@ -9,7 +9,7 @@ import * as Schema from "effect/Schema";
 import { CLAUDE_SYNTHETIC_MODEL } from "../provider/Drivers/claudeUsage.ts";
 import { GUARD_LENGTH, type TranscriptParsePosition } from "./usageTranscriptReader.ts";
 
-const USAGE_SCAN_CACHE_VERSION = 5 as const;
+const USAGE_SCAN_CACHE_VERSION = 6 as const;
 const SPEED_COMPATIBLE_SINCE_VERSION = 4;
 
 /**
@@ -17,8 +17,11 @@ const SPEED_COMPATIBLE_SINCE_VERSION = 4;
  * replace it, dropping saved usage for deleted transcripts. Separate files keep
  * both.
  */
-export const SCAN_CACHE_FILE_NAME = "usage-scan-cache-v5.json";
-export const LEGACY_SCAN_CACHE_FILE_NAME = "usage-scan-cache.json";
+export const SCAN_CACHE_FILE_NAME = "usage-scan-cache-v6.json";
+export const LEGACY_SCAN_CACHE_FILE_NAMES = [
+  "usage-scan-cache-v5.json",
+  "usage-scan-cache.json",
+] as const;
 
 const SPEEDS: readonly UsageSpeed[] = ["standard", "fast", "ultrafast"];
 
@@ -33,6 +36,8 @@ export interface CachedFile {
    * re-reads that segment and would otherwise double count it.
    */
   readonly tailRecords: readonly UsageRecord[];
+  /** Whole-file count, including diagnostics from the tentative tail. */
+  readonly malformedRecords: number;
   readonly position: TranscriptParsePosition;
 }
 
@@ -59,6 +64,7 @@ interface SerializedFile {
   readonly p: UsageProviderKind;
   readonly r: readonly SerializedRecord[];
   readonly t: readonly SerializedRecord[];
+  readonly mr: number;
   readonly o: number;
   readonly gl: number;
   readonly gh: number;
@@ -115,6 +121,7 @@ function serializeFile(entry: CachedFile, tables: InternTables): SerializedFile
     p: entry.provider,
     r: entry.records.map(serializeRecord),
     t: entry.tailRecords.map(serializeRecord),
+    mr: entry.malformedRecords,
     o: entry.position.resumeOffset,
     gl: entry.position.guardLength,
     gh: entry.position.guardHash,
@@ -271,6 +278,8 @@ export function decodeScanCache(
     const format = formats.get(entry.p);
     if (format === undefined) continue;
     if (!isRecordArray(entry.r) || !isRecordArray(entry.t)) continue;
+    const malformedRecords = entry.mr === undefined ? 0 : entry.mr;
+    if (!Number.isSafeInteger(malformedRecords) || malformedRecords < 0) continue;
     // Position fields feed byte offsets and a Buffer allocation in the reader,
     // so anything outside their real ranges must reject the entry: a bogus
     // guard length would otherwise fail every parse of the file, silently
@@ -289,10 +298,8 @@ export function decodeScanCache(
     ) {
       continue;
     }
-    // v4 records of stateful formats (Codex) predate service tiers, so they
-    // all priced as standard. Keep them, because the rollout may be gone, but
-    // make a live rollout re-parse whole: no file has size -1, and a zero
-    // position cannot resume.
+    // Older stateful reducers have different semantics. Keep their history for deleted rollouts,
+    // but force live files to re-parse: no file has size -1 and a zero position cannot resume.
     const legacy = format.state !== undefined && version < USAGE_SCAN_CACHE_VERSION;
     // A corrupt state disqualifies the entry: resuming with it would attach
     // appended usage to the wrong model or replay fork-copied history.
@@ -309,6 +316,7 @@ export function decodeScanCache(
       provider,
       records,
       tailRecords,
+      malformedRecords,
       position: legacy
         ? { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null }
         : {
diff --git a/apps/server/src/usage/usageTranscriptReader.test.ts b/apps/server/src/usage/usageTranscriptReader.test.ts
index 3cd49d1cd1c98..79014bfc222dd 100644
--- a/apps/server/src/usage/usageTranscriptReader.test.ts
+++ b/apps/server/src/usage/usageTranscriptReader.test.ts
@@ -6,6 +6,8 @@ import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
 
 import { afterEach, assert, beforeEach, describe, it } from "@effect/vitest";
+import type { TranscriptUsageFormat } from "@t3tools/provider-core/server/usage";
+import * as Schema from "effect/Schema";
 
 import { TEST_FORMATS } from "./usageTestFormats.ts";
 import { readTranscriptRecords, transcriptLineGate } from "./usageTranscriptReader.ts";
@@ -70,6 +72,71 @@ function codexUsageLine(outputTokens: number, secondsOffset: number): string {
 }
 
 describe("readTranscriptRecords resume", () => {
+  it.each([
+    { mode: "buffered", streamingThresholdBytes: Infinity },
+    { mode: "streaming", streamingThresholdBytes: 0 },
+  ])("counts malformed tails once across $mode reads and resume", async (options) => {
+    const format: TranscriptUsageFormat<{ errors: number }> = {
+      ...TEST_FORMATS.claude,
+      selectFields: { ...TEST_FORMATS.claude.selectFields, usage: true },
+      state: {
+        initial: () => ({ errors: 0 }),
+        schema: Schema.Struct({ errors: Schema.Number }),
+      },
+      parseLine(line, state) {
+        return this.parseProjected(JSON.parse(line), state);
+      },
+      parseProjected(value, state) {
+        if (
+          typeof value === "object" &&
+          value !== null &&
+          "usage" in value &&
+          value.usage === "malformed"
+        ) {
+          state.errors += 1;
+          return [];
+        }
+        return TEST_FORMATS.claude.parseProjected(value, undefined);
+      },
+      readMalformedRecords: (state: { errors: number }) => state.errors,
+    };
+    const path = NodePath.join(dir, "diagnostics.jsonl");
+    const malformed = JSON.stringify({ usage: "malformed" });
+    // Completed lines enter the projected parser only when they cross a stream chunk.
+    const committed = `${JSON.stringify({ usage: "malformed", padding: "x".repeat(256 * 1024) })}\n${claudeLine(1, 5)}`;
+    await NodeFSP.writeFile(path, committed + malformed);
+
+    const first = await readTranscriptRecords(path, format, undefined, options);
+    assert.isNotNull(first);
+    assert.deepStrictEqual(
+      first.records.map((record) => record.totals.outputTokens),
+      [5],
+    );
+    assert.deepStrictEqual(first.tailRecords, []);
+    assert.strictEqual(first.position.resumeOffset, Buffer.byteLength(committed));
+    assert.deepStrictEqual(first.position.state, { errors: 1 });
+    assert.strictEqual(first.malformedRecords, 2);
+
+    const savedPosition = JSON.parse(JSON.stringify(first.position));
+    await NodeFSP.appendFile(path, `\n${claudeLine(2, 7)}${malformed}\n`);
+    const resumed = await readTranscriptRecords(path, format, savedPosition, options);
+    assert.isNotNull(resumed);
+    assert.isTrue(resumed.resumed);
+    assert.deepStrictEqual(
+      resumed.records.map((record) => record.totals.outputTokens),
+      [7],
+    );
+    assert.deepStrictEqual(resumed.position.state, { errors: 3 });
+    assert.strictEqual(resumed.malformedRecords, 3);
+
+    const full = await readTranscriptRecords(path, format, undefined, options);
+    assert.isNotNull(full);
+    assert.deepStrictEqual([...first.records, ...resumed.records], full.records);
+    assert.deepStrictEqual(resumed.tailRecords, full.tailRecords);
+    assert.deepStrictEqual(resumed.position, full.position);
+    assert.strictEqual(resumed.malformedRecords, full.malformedRecords);
+  });
+
   it("parses only appended lines when resuming a grown file", async () => {
     const path = NodePath.join(dir, "claude.jsonl");
     await NodeFSP.writeFile(path, claudeLine(1, 5) + claudeLine(2, 7));
@@ -77,6 +144,7 @@ describe("readTranscriptRecords resume", () => {
     assert.isNotNull(first);
     assert.strictEqual(first.records.length, 2);
     assert.isFalse(first.resumed);
+    assert.strictEqual(first.malformedRecords, 0);
 
     await NodeFSP.appendFile(path, claudeLine(3, 11));
     const second = await readTranscriptRecords(path, TEST_FORMATS.claude, first.position);
diff --git a/apps/server/src/usage/usageTranscriptReader.ts b/apps/server/src/usage/usageTranscriptReader.ts
index d3f19afd20a94..1131b95bc7e91 100644
--- a/apps/server/src/usage/usageTranscriptReader.ts
+++ b/apps/server/src/usage/usageTranscriptReader.ts
@@ -45,6 +45,8 @@ export interface TranscriptParseResult {
    * segment: the next scan re-reads it once the writer finishes the line.
    */
   readonly tailRecords: readonly UsageRecord[];
+  /** Includes tentative tail diagnostics; position.state only includes committed lines. */
+  readonly malformedRecords: number;
   readonly position: TranscriptParsePosition;
   readonly resumed: boolean;
 }
@@ -306,10 +308,9 @@ export async function readTranscriptRecords<State>(
     // `resumeOffset` and the next scan replays the tail from it.
     const encodedState = encodeState === undefined ? null : encodeState(state);
     const tailRecords: UsageRecord[] = [];
-    finish(
-      decodeState === undefined ? state : Option.getOrThrow(decodeState(encodedState)),
-      tailRecords,
-    );
+    const tailState =
+      decodeState === undefined ? state : Option.getOrThrow(decodeState(encodedState));
+    finish(tailState, tailRecords);
 
     const guardLength = Math.min(GUARD_LENGTH, resumeOffset);
     let guardHash = 0;
@@ -322,6 +323,7 @@ export async function readTranscriptRecords<State>(
     return {
       records,
       tailRecords,
+      malformedRecords: format.readMalformedRecords?.(tailState) ?? 0,
       position: {
         resumeOffset,
         guardLength,
diff --git a/apps/server/src/vcs/GitVcsDriver.test.ts b/apps/server/src/vcs/GitVcsDriver.test.ts
index c4c3e7a253736..44b3ad5ab853e 100644
--- a/apps/server/src/vcs/GitVcsDriver.test.ts
+++ b/apps/server/src/vcs/GitVcsDriver.test.ts
@@ -17,6 +17,7 @@ import { assert, it } from "@effect/vitest";
 
 import { CheckpointRef, GitCommandError, VcsProcessExitError } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
+import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
 import * as ServerConfig from "../config.ts";
 import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
 import * as ProcessRunner from "../processRunner.ts";
@@ -196,6 +197,54 @@ it.effect("checkpoint capture skips untracked nested repositories without a comm
   }).pipe(Effect.scoped, Effect.provide(layerGitContract)),
 );
 
+it.effect.skipIf(!symlinksSupported)(
+  "checkpoint capture writes its index into the real git dir when cwd is a symlinked subdirectory",
+  () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const liveRunner = yield* ProcessRunner.ProcessRunner;
+      const indexFiles: string[] = [];
+      const captureProcess = yield* VcsProcess.make.pipe(
+        Effect.provideService(ProcessRunner.ProcessRunner, {
+          run: (input) => {
+            const indexFile = input.env?.GIT_INDEX_FILE;
+            if (indexFile !== undefined) indexFiles.push(indexFile);
+            return liveRunner.run(input);
+          },
+        }),
+      );
+      const driver = yield* GitVcsDriver.makeVcsDriverShape().pipe(
+        Effect.provideService(VcsProcess.VcsProcess, captureProcess),
+      );
+      const sandbox = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-checkpoint-symlink-",
+      });
+      const repo = path.join(sandbox, "repo");
+      const subdir = path.join(repo, "sub", "dir");
+      const link = path.join(sandbox, "nest", "link");
+      yield* fileSystem.makeDirectory(subdir, { recursive: true });
+      yield* fileSystem.makeDirectory(path.dirname(link), { recursive: true });
+      yield* fileSystem.symlink(subdir, link);
+      const { git, checkpointRef } = yield* makeCheckpointFixture(driver, repo);
+      // Git returns ../../.git from the target; resolving it against the link reaches the decoy.
+      yield* git(["-C", sandbox, "init"]);
+      yield* fileSystem.writeFileString(path.join(subdir, "nested.txt"), "from-link\n");
+      const realCommonDir = yield* fileSystem.realPath(path.join(repo, ".git"));
+
+      yield* driver.checkpoints.captureCheckpoint({ cwd: link, checkpointRef });
+
+      assert.isTrue(indexFiles.length > 0);
+      for (const indexFile of indexFiles) {
+        assert.strictEqual(yield* fileSystem.realPath(path.dirname(indexFile)), realCommonDir);
+      }
+      assert.strictEqual(
+        (yield* git(["show", `${checkpointRef}:sub/dir/nested.txt`])).stdout,
+        "from-link\n",
+      );
+    }).pipe(Effect.scoped, Effect.provide(layerGitCaptureContract)),
+);
+
 it.effect("checkpoint capture keeps the shared index a split index still uses", () =>
   Effect.gen(function* () {
     const fileSystem = yield* FileSystem.FileSystem;
@@ -1277,6 +1326,47 @@ it.effect("GitVcsDriver forwards execute env to the VCS process", () => {
   );
 });
 
+// The real VCS process, spawning `command` wherever the driver runs git.
+const vcsProcessSpawning = (command: string) =>
+  Layer.effect(
+    VcsProcess.VcsProcess,
+    Effect.map(VcsProcess.make, (vcsProcess) =>
+      VcsProcess.VcsProcess.of({ run: (input) => vcsProcess.run({ ...input, command }) }),
+    ),
+  ).pipe(Layer.provide(ProcessRunner.layer), Layer.provideMerge(NodeServices.layer));
+
+it.effect("GitVcsDriver treats a missing git executable as outside any repository", () =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-missing-git-" });
+    const driver = yield* GitVcsDriver.makeVcsDriverShape().pipe(
+      Effect.provide(vcsProcessSpawning(path.join(cwd, "git"))),
+    );
+
+    assert.strictEqual(yield* driver.isInsideWorkTree(cwd), false);
+    assert.strictEqual(yield* driver.detectRepository(cwd), null);
+  }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);
+
+it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
+  "GitVcsDriver still fails detection when git exists but cannot be spawned",
+  () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      // A file without the execute bit fails to spawn with a permission error.
+      const notExecutable = yield* fileSystem.makeTempFileScoped({ prefix: "t3-git-" });
+      const driver = yield* GitVcsDriver.makeVcsDriverShape().pipe(
+        Effect.provide(vcsProcessSpawning(notExecutable)),
+      );
+
+      const error = yield* driver.isInsideWorkTree(process.cwd()).pipe(Effect.flip);
+      assert.strictEqual(error._tag, "VcsProcessSpawnError");
+      const detectionError = yield* driver.detectRepository(process.cwd()).pipe(Effect.flip);
+      assert.strictEqual(detectionError._tag, "VcsProcessSpawnError");
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);
+
 it.effect("GitVcsDriver flushes checkpoint objects and refs to disk before publishing them", () => {
   const observedArgs: ReadonlyArray<string>[] = [];
 
diff --git a/apps/server/src/vcs/GitVcsDriver.ts b/apps/server/src/vcs/GitVcsDriver.ts
index 5c7b20b34c557..28a105c346003 100644
--- a/apps/server/src/vcs/GitVcsDriver.ts
+++ b/apps/server/src/vcs/GitVcsDriver.ts
@@ -33,6 +33,7 @@ import {
   type VcsStatusResult,
   type WorktreeSubmodules,
 } from "@t3tools/contracts";
+import { isMissingExecutable } from "@t3tools/source-control-core/server/discovery";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import {
   makeGitVcsDriverCore,
@@ -50,6 +51,7 @@ export interface ExecuteGitInput {
   readonly env?: NodeJS.ProcessEnv;
   readonly allowNonZeroExit?: boolean;
   readonly timeoutMs?: number | null;
+  readonly forceKillAfterMs?: number;
   readonly maxOutputBytes?: number;
   readonly appendTruncationMarker?: boolean;
   /**
@@ -560,7 +562,10 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* (
         timeoutMs: 5_000,
         maxOutputBytes: 4_096,
       },
-    ).pipe(Effect.map((result) => result.exitCode === 0 && result.stdout.trim() === "true"));
+    ).pipe(
+      Effect.map((result) => result.exitCode === 0 && result.stdout.trim() === "true"),
+      Effect.catchIf(isMissingExecutable, () => Effect.succeed(false)),
+    );
 
   const execute: VcsDriver.VcsDriver["Service"]["execute"] = (input) =>
     gitCommand(vcsProcess, input.operation, input.cwd, input.args, {
@@ -783,6 +788,7 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* (
       }),
     );
 
+  // Git reports relative paths from the physical cwd, which can differ from a symlink.
   const resolveGitCommonDir = Effect.fn("GitVcsDriver.resolveGitCommonDir")(function* (
     cwd: string,
   ) {
@@ -792,7 +798,9 @@ export const makeVcsDriverShape = Effect.fn("makeGitVcsDriverShape")(function* (
       args: ["rev-parse", "--git-common-dir"],
     });
     const gitCommonDir = result.stdout.trim();
-    return path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(cwd, gitCommonDir);
+    if (path.isAbsolute(gitCommonDir)) return gitCommonDir;
+    const physicalCwd = yield* fileSystem.realPath(cwd).pipe(Effect.orElseSucceed(() => cwd));
+    return path.resolve(physicalCwd, gitCommonDir);
   });
 
   // Git renames loose objects and refs into place without fsync by default, so
diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts
index 1384043a37b6e..2b75d824e636f 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.test.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts
@@ -2,6 +2,7 @@
 import * as NodeFS from "node:fs";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as HostProcess from "@t3tools/shared/HostProcess";
+import { writeFakeCli } from "@t3tools/provider-testing/fakeCli";
 import { assert, it, describe } from "@effect/vitest";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
@@ -29,6 +30,7 @@ import {
   type ReviewDiffPreviewResult,
   type WorktreeSubmodules,
 } from "@t3tools/contracts";
+import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
 import * as ServerConfig from "../config.ts";
 import { gitCommandDuration } from "../observability/Metrics.ts";
 import {
@@ -39,6 +41,7 @@ import {
 } from "./GitVcsDriverCore.ts";
 import * as GitVcsDriver from "./GitVcsDriver.ts";
 import { gitConfigEnv } from "./VcsProcess.ts";
+import { makeProcessProbe, processProbeSource } from "../testUtils/processProbe.ts";
 
 const encodeGitCommandError = Schema.encodeEffect(Schema.fromJsonString(GitCommandError));
 
@@ -492,10 +495,259 @@ it.effect("coalesces concurrent ref pages into one repository snapshot", () =>
   ).pipe(Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer)))),
 );
 
-describe("pull output beyond the output cap", () => {
+describe("pullCurrentBranch", () => {
+  const controlledStatusFetch = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const cwd = yield* makeTmpDir();
+    yield* fs.makeDirectory(`${cwd}/.git`);
+    const started = yield* Queue.unbounded<{
+      cwd: string;
+      release: Deferred.Deferred<ChildProcessSpawner.ExitCode>;
+    }>();
+    const finalized = yield* Queue.unbounded<string>();
+    const warnings = yield* Queue.unbounded<void>();
+    const attempts = yield* Ref.make(0);
+    const pulls = yield* Ref.make(0);
+    const fetching = yield* Ref.make(false);
+    const head = yield* Ref.make("before");
+    const pullRemoteRead = yield* Deferred.make<void>();
+    const logger = Logger.make<unknown, void>(() => {
+      Queue.offerUnsafe(warnings, undefined);
+    });
+    const spawner = ChildProcessSpawner.make((command) =>
+      Effect.gen(function* () {
+        if (!ChildProcess.isStandardCommand(command)) return makeNonRepositoryHandle();
+        const workingDirectory = command.options.cwd ?? cwd;
+        const args = command.args;
+        if (args.includes("fetch")) {
+          const release = yield* Deferred.make<ChildProcessSpawner.ExitCode>();
+          yield* Ref.set(fetching, true);
+          yield* Ref.update(attempts, (count) => count + 1);
+          yield* Queue.offer(started, { cwd: workingDirectory, release });
+          yield* Effect.addFinalizer(() => Queue.offer(finalized, workingDirectory));
+          yield* Effect.addFinalizer(() => Ref.set(fetching, false));
+          return ChildProcessSpawner.makeHandle({
+            ...makeSuccessfulHandle(""),
+            stderr: Stream.encodeText(Stream.make("fatal: remote unavailable\n")),
+            exitCode: Deferred.await(release),
+          });
+        }
+        if (args[0] === "pull") {
+          yield* Ref.update(pulls, (count) => count + 1);
+          if (yield* Ref.get(fetching)) {
+            return ChildProcessSpawner.makeHandle({
+              ...makeSuccessfulHandle(""),
+              exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)),
+              stderr: Stream.encodeText(
+                Stream.make("error: cannot lock ref 'refs/remotes/origin/main': File exists\n"),
+              ),
+            });
+          }
+          yield* Ref.set(head, "after");
+          return makeSuccessfulHandle("");
+        }
+        if (args.includes("branch.main.remote")) {
+          yield* Deferred.succeed(pullRemoteRead, undefined);
+          return makeSuccessfulHandle("origin\n");
+        }
+        if (args[0] === "status")
+          return makeSuccessfulHandle(
+            "# branch.oid before\0# branch.head main\0# branch.upstream origin/main\0# branch.ab +0 -1\0",
+          );
+        if (args[0] === "diff-index") return makeSuccessfulHandle("");
+        if (args.length === 2 && args[0] === "rev-parse" && args[1] === "HEAD")
+          return makeSuccessfulHandle(`${yield* Ref.get(head)}\n`);
+        if (args.includes("--git-common-dir"))
+          return makeSuccessfulHandle(`${workingDirectory}/.git\n`);
+        if (args.includes("--show-toplevel")) return makeSuccessfulHandle(`${workingDirectory}\n`);
+        if (args.includes("@{upstream}")) return makeSuccessfulHandle("origin/main\n");
+        if (args[0] === "remote") return makeSuccessfulHandle("origin\n");
+        if (args[0] === "rev-list") return makeSuccessfulHandle("0\t0\n");
+        if (args.includes("refs/remotes/origin/HEAD"))
+          return makeSuccessfulHandle("refs/remotes/origin/main\n");
+        return makeSuccessfulHandle("main\n");
+      }),
+    );
+    const driver = yield* makeGitVcsDriverCore().pipe(
+      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+    );
+    const status = Effect.fn("test.controlledStatusFetch.status")((directory = cwd) =>
+      driver
+        .statusDetailsRemote(directory)
+        .pipe(Effect.provideService(Logger.CurrentLoggers, new Set([logger]))),
+    );
+    return { cwd, driver, status, started, finalized, warnings, attempts, pulls, pullRemoteRead };
+  });
+
+  it.effect.each([0, 128])(
+    "waits for an existing status fetch before pulling after fetch exit %s",
+    (exitCode) =>
+      Effect.gen(function* () {
+        const fixture = yield* controlledStatusFetch;
+        const status = yield* fixture.status().pipe(Effect.forkScoped);
+        const fetch = yield* Queue.take(fixture.started);
+        yield* TestClock.adjust("5 seconds");
+        yield* Fiber.join(status);
+
+        const pull = yield* fixture.driver.pullCurrentBranch(fixture.cwd).pipe(Effect.forkScoped);
+        yield* Deferred.await(fixture.pullRemoteRead);
+        yield* TestClock.adjust("30 seconds");
+        assert.equal(yield* Ref.get(fixture.pulls), 0);
+        yield* Deferred.succeed(fetch.release, ChildProcessSpawner.ExitCode(exitCode));
+
+        assert.equal((yield* Fiber.join(pull)).status, "pulled");
+        assert.equal(yield* Ref.get(fixture.pulls), 1);
+        assert.equal(yield* Ref.get(fixture.attempts), 1);
+      }).pipe(
+        Effect.scoped,
+        Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer))),
+      ),
+  );
+
+  it.effect("does not start a status fetch while pulling", () =>
+    Effect.gen(function* () {
+      const fixture = yield* controlledStatusFetch;
+
+      assert.equal((yield* fixture.driver.pullCurrentBranch(fixture.cwd)).status, "pulled");
+      assert.equal(yield* Ref.get(fixture.pulls), 1);
+      assert.equal(yield* Ref.get(fixture.attempts), 0);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer))),
+    ),
+  );
+
+  it.effect("backs off failures after the status waiter has returned", () =>
+    Effect.gen(function* () {
+      const fixture = yield* controlledStatusFetch;
+      const firstStatus = yield* fixture.status().pipe(Effect.forkScoped);
+      const first = yield* Queue.take(fixture.started);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(firstStatus);
+      yield* Deferred.succeed(first.release, ChildProcessSpawner.ExitCode(128));
+      yield* Queue.take(fixture.finalized);
+      yield* Queue.take(fixture.warnings);
+
+      yield* TestClock.adjust("15 seconds");
+      yield* fixture.status();
+      assert.equal(yield* Ref.get(fixture.attempts), 1);
+
+      yield* TestClock.adjust("15 seconds");
+      const secondStatus = yield* fixture.status().pipe(Effect.forkScoped);
+      const second = yield* Queue.take(fixture.started);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(secondStatus);
+      yield* Deferred.succeed(second.release, ChildProcessSpawner.ExitCode(128));
+      yield* Queue.take(fixture.finalized);
+      yield* Queue.take(fixture.warnings);
+
+      for (let i = 0; i < 3; i++) {
+        yield* TestClock.adjust("15 seconds");
+        yield* fixture.status();
+        assert.equal(yield* Ref.get(fixture.attempts), 2);
+      }
+      yield* TestClock.adjust("15 seconds");
+      const recoveredStatus = yield* fixture.status().pipe(Effect.forkScoped);
+      const recovered = yield* Queue.take(fixture.started);
+      yield* Deferred.succeed(recovered.release, ChildProcessSpawner.ExitCode(0));
+      yield* Fiber.join(recoveredStatus);
+      assert.equal(yield* Ref.get(fixture.attempts), 3);
+
+      yield* TestClock.adjust("15 seconds");
+      const failedAgainStatus = yield* fixture.status().pipe(Effect.forkScoped);
+      const failedAgain = yield* Queue.take(fixture.started);
+      yield* Deferred.succeed(failedAgain.release, ChildProcessSpawner.ExitCode(128));
+      yield* Fiber.join(failedAgainStatus);
+      yield* Queue.take(fixture.warnings);
+      yield* TestClock.adjust("15 seconds");
+      yield* fixture.status();
+      assert.equal(yield* Ref.get(fixture.attempts), 4);
+
+      yield* TestClock.adjust("15 seconds");
+      const resetStatus = yield* fixture.status().pipe(Effect.forkScoped);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(resetStatus);
+      assert.equal(yield* Ref.get(fixture.attempts), 5);
+      const reset = yield* Queue.take(fixture.started);
+      yield* Deferred.succeed(reset.release, ChildProcessSpawner.ExitCode(0));
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer))),
+    ),
+  );
+
+  it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
+    "bounds cleanup when a Git subprocess ignores SIGTERM",
+    () =>
+      Effect.gen(function* () {
+        const driver = yield* GitVcsDriver.GitVcsDriver;
+        const directory = yield* makeTmpDir();
+        const probe = yield* makeProcessProbe;
+        writeFakeCli({
+          directory,
+          name: "git",
+          source: `process.on("SIGTERM", () => {}); ${processProbeSource(probe.port)}`,
+        });
+        const run = yield* driver
+          .execute({
+            operation: "test.stalledStatusFetch",
+            cwd: directory,
+            args: ["fetch"],
+            env: { PATH: `${directory}:${process.env.PATH ?? ""}` },
+            timeoutMs: 1_000,
+            forceKillAfterMs: 100,
+          })
+          .pipe(Effect.flip, Effect.forkScoped);
+        yield* probe.started;
+
+        yield* TestClock.adjust("1 second");
+
+        yield* probe.exited;
+        assert.equal((yield* Fiber.join(run)).detail, "Git command timed out.");
+      }).pipe(Effect.scoped, Effect.provide(layerTest)),
+  );
+
+  it.effect("releases stalled background worker slots at their lifetime limit", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const fixture = yield* controlledStatusFetch;
+      yield* fixture.driver.listRefs({ cwd: fixture.cwd });
+      const statuses = [];
+      for (let i = 0; i < 4; i++) {
+        const cwd = `${fixture.cwd}/repo-${i}`;
+        yield* fs.makeDirectory(`${cwd}/.git`, { recursive: true });
+        statuses.push(yield* fixture.status(cwd).pipe(Effect.forkScoped));
+        yield* Queue.take(fixture.started);
+      }
+      yield* TestClock.adjust("5 seconds");
+      yield* Effect.forEach(statuses, Fiber.join);
+      const waiting = yield* fixture.status().pipe(Effect.forkScoped);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(waiting);
+      assert.equal(yield* Ref.get(fixture.attempts), 4);
+
+      yield* TestClock.adjust(290_000);
+      assert.equal(yield* Ref.get(fixture.attempts), 5);
+      for (let i = 0; i < 4; i++) yield* Queue.take(fixture.finalized);
+      const healthy = yield* Queue.take(fixture.started);
+      assert.equal(
+        NodeFS.realpathSync.native(healthy.cwd),
+        NodeFS.realpathSync.native(fixture.cwd),
+      );
+      yield* Deferred.succeed(healthy.release, ChildProcessSpawner.ExitCode(0));
+      yield* Queue.take(fixture.finalized);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer))),
+    ),
+  );
+
   // A fast-forward that prints over 1 MB takes thousands of files, so the real pull's output is
   // padded past the cap instead.
-  const withPaddedPull = (stream: "stdout" | "stderr") =>
+  const withPaddedPull = (
+    stream: "stdout" | "stderr",
+    onPull?: (args: ReadonlyArray<string>) => void,
+  ) =>
     Effect.gen(function* () {
       const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
       const padding = new Uint8Array(1_000_001).fill(0x20);
@@ -506,6 +758,7 @@ describe("pull output beyond the output cap", () => {
             ChildProcess.isStandardCommand(command) &&
             command.args.includes("pull") &&
             command.args.includes("--ff-only");
+          if (isPull) onPull?.(command.args);
           return isPull
             ? ChildProcessSpawner.makeHandle({
                 ...handle,
@@ -534,9 +787,235 @@ describe("pull output beyond the output cap", () => {
     yield* git(updater, ["add", "remote.txt"]);
     yield* git(updater, ["commit", "-m", "remote commit"]);
     yield* git(updater, ["push", "origin", initialBranch]);
-    return { cwd, remoteHead: yield* git(updater, ["rev-parse", "HEAD"]) };
+    return {
+      cwd,
+      remote,
+      updater,
+      initialBranch,
+      remoteHead: yield* git(updater, ["rev-parse", "HEAD"]),
+    };
   });
 
+  it.effect("still fetches other branches on the first pull", () =>
+    Effect.gen(function* () {
+      const driver = yield* GitVcsDriver.GitVcsDriver;
+      const { cwd, updater, remoteHead } = yield* cloneBehindRemote;
+      yield* git(updater, ["push", "origin", "HEAD:refs/heads/other"]);
+
+      const result = yield* driver.pullCurrentBranch(cwd);
+
+      assert.equal(result.status, "pulled");
+      assert.equal(yield* git(cwd, ["rev-parse", "HEAD"]), remoteHead);
+      assert.equal(yield* git(cwd, ["rev-parse", "refs/remotes/origin/other"]), remoteHead);
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect.each([false, true])(
+    "pulls past an unrelated lock with custom fetch mapping=%s",
+    (customMapping) =>
+      Effect.gen(function* () {
+        const driver = yield* GitVcsDriver.GitVcsDriver;
+        const fs = yield* FileSystem.FileSystem;
+        const { cwd, updater, initialBranch, remoteHead } = yield* cloneBehindRemote;
+        yield* git(updater, ["push", "origin", "HEAD:refs/heads/other"]);
+        const remoteName = customMapping ? "team/upstream" : "origin";
+        const refPrefix = customMapping
+          ? `refs/remotes/${remoteName}/mapped`
+          : "refs/remotes/origin";
+        if (customMapping) {
+          yield* git(cwd, ["remote", "rename", "origin", remoteName]);
+          yield* git(cwd, ["config", `remote.${remoteName}.fetch`, `+refs/heads/*:${refPrefix}/*`]);
+          yield* git(cwd, ["update-ref", `${refPrefix}/${initialBranch}`, "HEAD"]);
+        }
+        const lock = `.git/${refPrefix}/other.lock`;
+        yield* writeTextFile(cwd, lock, "");
+
+        const result = yield* driver.pullCurrentBranch(cwd);
+
+        assert.equal(result.status, "pulled");
+        assert.equal(yield* git(cwd, ["rev-parse", "HEAD"]), remoteHead);
+        assert.equal(yield* git(cwd, ["rev-parse", `${refPrefix}/${initialBranch}`]), remoteHead);
+        assert.isTrue(yield* fs.exists(`${cwd}/${lock}`));
+        assert.equal(yield* fs.readFileString(`${cwd}/${lock}`), "");
+      }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("reports an upstream lock after the fallback without removing it", () =>
+    Effect.gen(function* () {
+      const driver = yield* GitVcsDriver.GitVcsDriver;
+      const fs = yield* FileSystem.FileSystem;
+      const { cwd, initialBranch } = yield* cloneBehindRemote;
+      const before = yield* git(cwd, ["rev-parse", "HEAD"]);
+      const lock = `.git/refs/remotes/origin/${initialBranch}.lock`;
+      yield* writeTextFile(cwd, lock, "");
+
+      const error = yield* Effect.flip(driver.pullCurrentBranch(cwd));
+
+      assert.include(error.detail, "could not update a local reference");
+      assert.equal(yield* git(cwd, ["rev-parse", "HEAD"]), before);
+      assert.isTrue(yield* fs.exists(`${cwd}/${lock}`));
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect.each(["branch", "HEAD"] as const)(
+    "does not retry a failed fetch if another operation moved %s",
+    (moved) =>
+      Effect.gen(function* () {
+        const fixtureDriver = yield* GitVcsDriver.GitVcsDriver;
+        const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const { cwd, updater } = yield* cloneBehindRemote;
+        yield* git(updater, ["push", "origin", "HEAD:refs/heads/other"]);
+        yield* writeTextFile(cwd, ".git/refs/remotes/origin/other.lock", "");
+        let pulls = 0;
+        const spawner = ChildProcessSpawner.make((command) =>
+          Effect.gen(function* () {
+            const handle = yield* delegate.spawn(command);
+            if (!ChildProcess.isStandardCommand(command) || !command.args.includes("pull")) {
+              return handle;
+            }
+            pulls += 1;
+            return ChildProcessSpawner.makeHandle({
+              ...handle,
+              exitCode: handle.exitCode.pipe(
+                Effect.tap(() =>
+                  git(
+                    cwd,
+                    moved === "branch"
+                      ? ["checkout", "-b", "moved"]
+                      : ["commit", "--allow-empty", "-m", "concurrent commit"],
+                  ).pipe(
+                    Effect.provideService(GitVcsDriver.GitVcsDriver, fixtureDriver),
+                    Effect.orDie,
+                  ),
+                ),
+              ),
+            });
+          }),
+        );
+        const driver = yield* makeGitVcsDriverCore().pipe(
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        );
+
+        const error = yield* Effect.flip(driver.pullCurrentBranch(cwd));
+
+        assert.include(error.detail, "could not update a local reference");
+        assert.equal(pulls, 1);
+      }).pipe(Effect.scoped, Effect.provide(layerServerConfig.pipe(Layer.provideMerge(layerTest)))),
+  );
+
+  it.effect.each(["deadline", "subscriber cancellation"] as const)(
+    "lets a background fetch finish after %s without leaving its lock behind",
+    (interruption) =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const { cwd } = yield* cloneBehindRemote;
+        const lockPath = `${cwd}/.git/refs/remotes/origin/in-flight.lock`;
+        const started = yield* Deferred.make<void>();
+        const release = yield* Deferred.make<void>();
+        const finalized = yield* Deferred.make<void>();
+        const spawner = ChildProcessSpawner.make((command) =>
+          Effect.gen(function* () {
+            if (!ChildProcess.isStandardCommand(command) || !command.args.includes("fetch")) {
+              return yield* delegate.spawn(command);
+            }
+            // Model Git's gap between creating a lock and registering signal cleanup.
+            yield* fs.writeFileString(lockPath, "");
+            yield* Effect.addFinalizer(() => Deferred.succeed(finalized, undefined));
+            yield* Deferred.succeed(started, undefined);
+            return ChildProcessSpawner.makeHandle({
+              ...makeSuccessfulHandle(""),
+              exitCode: Deferred.await(release).pipe(
+                Effect.andThen(fs.remove(lockPath)),
+                Effect.as(ChildProcessSpawner.ExitCode(0)),
+              ),
+            });
+          }),
+        );
+        const driver = yield* makeGitVcsDriverCore().pipe(
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        );
+        const status = yield* driver.statusDetailsRemote(cwd).pipe(Effect.forkScoped);
+        yield* Deferred.await(started);
+
+        if (interruption === "deadline") {
+          yield* TestClock.adjust("5 seconds");
+          yield* Fiber.join(status);
+        } else {
+          yield* Fiber.interrupt(status);
+        }
+
+        assert.isFalse(yield* Deferred.isDone(finalized));
+        assert.isTrue(yield* fs.exists(lockPath));
+
+        yield* Deferred.succeed(release, undefined);
+        yield* Deferred.await(finalized);
+        assert.isFalse(yield* fs.exists(lockPath));
+      }).pipe(Effect.scoped, Effect.provide(layerServerConfig.pipe(Layer.provideMerge(layerTest)))),
+  );
+
+  it.effect("reuses a background fetch across status wait deadlines", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const cwd = yield* makeTmpDir();
+      yield* fs.makeDirectory(`${cwd}/.git`);
+      const started = yield* Deferred.make<void>();
+      const release = yield* Deferred.make<void>();
+      const finalized = yield* Deferred.make<void>();
+      const attempts = yield* Ref.make(0);
+      const spawner = ChildProcessSpawner.make((command) =>
+        Effect.gen(function* () {
+          if (!ChildProcess.isStandardCommand(command)) return makeNonRepositoryHandle();
+          if (command.args.includes("fetch")) {
+            yield* Ref.update(attempts, (count) => count + 1);
+            yield* Deferred.succeed(started, undefined);
+            yield* Effect.addFinalizer(() => Deferred.succeed(finalized, undefined));
+            return ChildProcessSpawner.makeHandle({
+              ...makeSuccessfulHandle(""),
+              exitCode: Deferred.await(release).pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
+            });
+          }
+          const args = command.args;
+          return makeSuccessfulHandle(
+            args.includes("--git-common-dir")
+              ? `${cwd}/.git\n`
+              : args.includes("--show-toplevel")
+                ? `${cwd}\n`
+                : args.includes("@{upstream}")
+                  ? "origin/main\n"
+                  : args[0] === "remote"
+                    ? "origin\n"
+                    : args[0] === "rev-list"
+                      ? "0\t0\n"
+                      : args.includes("refs/remotes/origin/HEAD")
+                        ? "refs/remotes/origin/main\n"
+                        : "main\n",
+          );
+        }),
+      );
+      const driver = yield* makeGitVcsDriverCore().pipe(
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+      );
+      const first = yield* driver.statusDetailsRemote(cwd).pipe(Effect.forkScoped);
+      yield* Deferred.await(started);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(first);
+
+      yield* TestClock.adjust("15 seconds");
+      const second = yield* driver.statusDetailsRemote(cwd).pipe(Effect.forkScoped);
+      yield* TestClock.adjust("5 seconds");
+      yield* Fiber.join(second);
+
+      assert.equal(yield* Ref.get(attempts), 1);
+      assert.isFalse(yield* Deferred.isDone(finalized));
+      yield* Deferred.succeed(release, undefined);
+      yield* Deferred.await(finalized);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer))),
+    ),
+  );
+
   it.effect.each(["stdout", "stderr"] as const)(
     "reports a fast-forward whose %s passes the cap as pulled",
     (stream) =>
@@ -558,7 +1037,8 @@ describe("pull output beyond the output cap", () => {
   it.effect("still fails a pull that Git rejects, whatever its output size", () =>
     Effect.scoped(
       Effect.gen(function* () {
-        const driver = yield* withPaddedPull("stderr");
+        const pulls: ReadonlyArray<string>[] = [];
+        const driver = yield* withPaddedPull("stderr", (args) => pulls.push(args));
         yield* Effect.gen(function* () {
           const { cwd } = yield* cloneBehindRemote;
           yield* writeTextFile(cwd, "local.txt", "local\n");
@@ -570,6 +1050,7 @@ describe("pull output beyond the output cap", () => {
           assert.equal(error.operation, "GitVcsDriver.pullCurrentBranch.pull");
           assert.equal(error.exitCode, 128);
           assert.notInclude(error.detail, "exceeded");
+          assert.lengthOf(pulls, 1);
         }).pipe(Effect.provideService(GitVcsDriver.GitVcsDriver, driver));
       }),
     ).pipe(Effect.provide(layerServerConfig.pipe(Layer.provideMerge(NodeServices.layer)))),
@@ -2673,6 +3154,34 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
       }),
     );
 
+    it.effect.skipIf(!symlinksSupported)(
+      "lists the real repository through a symlink when a decoy repo occupies the lexical common dir",
+      () =>
+        Effect.gen(function* () {
+          const fileSystem = yield* FileSystem.FileSystem;
+          const pathService = yield* Path.Path;
+          const sandbox = yield* makeTmpDir("git-symlink-subdir-");
+          yield* initRepoWithCommit(sandbox);
+          yield* git(sandbox, ["branch", "-M", "decoy-only"]);
+          const repo = pathService.join(sandbox, "repo");
+          const link = pathService.join(sandbox, "nest", "link");
+          yield* fileSystem.makeDirectory(pathService.join(repo, "sub", "dir"), {
+            recursive: true,
+          });
+          yield* fileSystem.makeDirectory(pathService.dirname(link), { recursive: true });
+          yield* fileSystem.symlink(pathService.join(repo, "sub", "dir"), link);
+
+          yield* initRepoWithCommit(repo);
+          yield* git(repo, ["checkout", "-b", "real-only"]);
+
+          // The decoy must exist before the first lookup, which caches repository paths.
+          const refs = yield* (yield* GitVcsDriver.GitVcsDriver).listRefs({ cwd: link });
+          assert.isTrue(refs.isRepo);
+          assert.isFalse(refs.refs.some((ref) => ref.name === "decoy-only"));
+          assert.isTrue(refs.refs.some((ref) => ref.name === "real-only"));
+        }),
+    );
+
     it.effect("reads Changes totals with untracked files when requested", () =>
       Effect.gen(function* () {
         const cwd = yield* makeTmpDir();
@@ -2741,6 +3250,34 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
       }),
     );
 
+    it.effect(
+      "counts many untracked files exactly while collapsing their directory in status",
+      () =>
+        Effect.gen(function* () {
+          const cwd = yield* makeTmpDir();
+          yield* initRepoWithCommit(cwd);
+          const driver = yield* GitVcsDriver.GitVcsDriver;
+          yield* git(cwd, ["branch", "-M", "main"]);
+          yield* git(cwd, ["checkout", "-b", "feature/many-untracked"]);
+          yield* Effect.forEach(
+            Array.from({ length: 1_001 }, (_, index) => `bulk/${index}.txt`),
+            (file) => writeTextFile(cwd, file, "one\ntwo\n"),
+            { concurrency: 32, discard: true },
+          );
+
+          const status = yield* driver.statusDetailsLocal(cwd, { includeBranchChanges: true });
+          assert.deepStrictEqual(status.branchChanges, {
+            baseRef: "main",
+            insertions: 2_002,
+            deletions: 0,
+          });
+          assert.deepStrictEqual(
+            status.workingTree.files.map((file) => file.path),
+            ["bulk/"],
+          );
+        }),
+    );
+
     it.effect("reports non-repository directories without failing", () =>
       Effect.gen(function* () {
         const cwd = yield* makeTmpDir();
@@ -2963,6 +3500,27 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
             aheadOfDefaultCount: 0,
           });
         }
+
+        yield* git(cwd, ["branch", "-f", initialBranch, "HEAD"]);
+        yield* git(cwd, ["update-ref", "refs/remotes/origin/trunk", "HEAD"]);
+        yield* git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/trunk"]);
+        for (const base of [initialBranch, "missing-base"]) {
+          yield* git(cwd, ["config", "branch.feature/local-only.gh-merge-base", base]);
+          commands.length = 0;
+          const status = yield* driver.statusDetailsLocal(cwd, {
+            includeDivergence: false,
+            includeBranchChanges: true,
+          });
+          assert.deepEqual(status.branchChanges, {
+            baseRef: `origin/${base === initialBranch ? initialBranch : "trunk"}`,
+            insertions: base === initialBranch ? 3 : 2,
+            deletions: 0,
+          });
+          assert.lengthOf(
+            commands.filter((args) => args.join(" ") === "symbolic-ref refs/remotes/origin/HEAD"),
+            base === initialBranch ? 0 : 1,
+          );
+        }
       }),
     );
 
@@ -2970,27 +3528,66 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
       Effect.gen(function* () {
         const cwd = yield* makeTmpDir();
         const remote = yield* makeTmpDir("git-vcs-driver-remote-");
-        const { initialBranch } = yield* initRepoWithCommit(cwd);
+        yield* initRepoWithCommit(cwd);
+        yield* git(cwd, ["branch", "-M", "trunk"]);
         yield* git(remote, ["init", "--bare"]);
         yield* git(cwd, ["remote", "add", "origin", remote]);
-        yield* git(cwd, ["push", "-u", "origin", initialBranch]);
+        yield* git(cwd, ["push", "-u", "origin", "trunk"]);
         yield* git(cwd, ["checkout", "-b", "feature/remote-status"]);
         yield* writeTextFile(cwd, "feature.txt", "feature\n");
         yield* git(cwd, ["add", "feature.txt"]);
         yield* git(cwd, ["commit", "-m", "feature commit"]);
         yield* git(cwd, ["push", "-u", "origin", "feature/remote-status"]);
         yield* writeTextFile(cwd, "untracked.txt", "local-only\n");
+        yield* git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/trunk"]);
 
-        const status = yield* (yield* GitVcsDriver.GitVcsDriver).statusDetailsRemote(cwd);
+        const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const commands: ReadonlyArray<string>[] = [];
+        let originHeadReads = 0;
+        let failFirstOriginHead = false;
+        const spawner = ChildProcessSpawner.make((command) =>
+          Effect.gen(function* () {
+            if (!ChildProcess.isStandardCommand(command)) {
+              return yield* Effect.die("expected a standard Git command");
+            }
+            commands.push(command.args);
+            if (command.args.join(" ") === "symbolic-ref refs/remotes/origin/HEAD") {
+              originHeadReads++;
+              if (failFirstOriginHead && originHeadReads === 1) return makeNonRepositoryHandle();
+            }
+            return yield* delegate.spawn(command);
+          }),
+        );
+        const driver = yield* makeGitVcsDriverCore().pipe(
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+          Effect.provide(layerServerConfig),
+        );
+        const status = yield* driver.statusDetailsRemote(cwd, { refreshUpstream: false });
 
         assert.equal(status.isRepo, true);
         assert.equal(status.branch, "feature/remote-status");
+        assert.equal(status.defaultBranch, "trunk");
+        assert.equal(status.isDefaultBranch, false);
+        assert.equal(status.upstreamRef, "origin/feature/remote-status");
         assert.equal(status.hasUpstream, true);
         assert.equal(status.aheadCount, 0);
         assert.equal(status.behindCount, 0);
         assert.equal(status.aheadOfDefaultCount, 1);
         assert.notProperty(status, "workingTree");
         assert.notProperty(status, "hasWorkingTreeChanges");
+        assert.deepEqual(
+          commands.filter((args) => args.length === 1 && args[0] === "remote"),
+          [],
+          `cached remote status should not enumerate remotes: ${JSON.stringify(commands)}`,
+        );
+        assert.equal(originHeadReads, 1);
+
+        // With no main/master fallback, the retry must resolve trunk to preserve the ahead count.
+        originHeadReads = 0;
+        failFirstOriginHead = true;
+        const retried = yield* driver.statusDetailsRemote(cwd, { refreshUpstream: false });
+        assert.deepEqual(retried, { ...status, defaultBranch: null });
+        assert.equal(originHeadReads, 2);
       }),
     );
 
diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts
index 33d9ce1948f96..1630cb96d3ac5 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.ts
@@ -1,5 +1,6 @@
 import * as Cache from "effect/Cache";
 import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
 import * as Data from "effect/Data";
 import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
@@ -7,6 +8,7 @@ import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Hex from "effect/encoding/Hex";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -80,6 +82,7 @@ const REVIEW_DIFF_ARGS = [
 ];
 const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
 const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
+const STATUS_UPSTREAM_FETCH_TIMEOUT = Duration.minutes(5);
 
 const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
 const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
@@ -170,6 +173,7 @@ interface GitRefsSnapshot {
 interface ExecuteGitOptions {
   stdin?: string | undefined;
   timeoutMs?: number | null | undefined;
+  forceKillAfterMs?: number | undefined;
   allowNonZeroExit?: boolean | undefined;
   fallbackErrorDetail?: string | undefined;
   env?: NodeJS.ProcessEnv | undefined;
@@ -928,6 +932,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
   const { worktreesDir } = yield* ServerConfig.ServerConfig;
   const crypto = yield* Crypto.Crypto;
   const hostPlatform = yield* HostProcess.Platform;
+  const serviceScope = yield* Effect.scope;
+  const statusFetches = new Map<string, Fiber.Fiber<void, GitCommandError>>();
+  const statusFetchProcesses = yield* Semaphore.make(4);
 
   const executeRaw: GitVcsDriver.GitVcsDriver["Service"]["execute"] = Effect.fnUntraced(
     function* (input) {
@@ -971,6 +978,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
             ChildProcess.make(executable, commandInput.args, {
               cwd: commandInput.cwd,
               env: spawnEnv,
+              forceKillAfter: input.forceKillAfterMs,
             }),
           )
           .pipe(
@@ -1108,6 +1116,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       ...(options.env !== undefined ? { env: options.env } : {}),
       allowNonZeroExit: true,
       ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+      ...(options.forceKillAfterMs !== undefined
+        ? { forceKillAfterMs: options.forceKillAfterMs }
+        : {}),
       ...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
       ...(options.appendTruncationMarker !== undefined
         ? { appendTruncationMarker: options.appendTruncationMarker }
@@ -1234,7 +1245,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     });
   });
 
-  const resolveCurrentUpstream = Effect.fn("resolveCurrentUpstream")(function* (cwd: string) {
+  const readCurrentUpstreamRef = Effect.fn("readCurrentUpstreamRef")(function* (cwd: string) {
     const upstreamRef = yield* runGitStdout(
       "GitVcsDriver.resolveCurrentUpstream",
       cwd,
@@ -1245,6 +1256,17 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     if (upstreamRef.length === 0 || upstreamRef === "@{upstream}") {
       return null;
     }
+    return upstreamRef;
+  });
+
+  const resolveCurrentUpstream = Effect.fn("resolveCurrentUpstream")(function* (
+    cwd: string,
+    knownUpstreamRef?: string,
+  ) {
+    const upstreamRef = knownUpstreamRef ?? (yield* readCurrentUpstreamRef(cwd));
+    if (upstreamRef === null) {
+      return null;
+    }
 
     const remoteNames = yield* runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe(
       Effect.map(parseRemoteNames),
@@ -1256,40 +1278,76 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     );
   });
 
-  const fetchRemoteForStatus = (
+  const fetchRemoteForStatus = Effect.fn("GitVcsDriver.fetchRemoteForStatus.wait")(function* (
     gitCommonDir: string,
     remoteName: string,
-  ): Effect.Effect<void, GitCommandError> => {
+  ) {
     const fetchCwd =
       path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
     // `--no-auto-gc` (a synonym of `--no-auto-maintenance` that older Git also knows) keeps
     // this poll from starting `git gc --auto`. When that gc fails, for example on a repository
     // with missing objects, Git retries it on every fetch and leaves a full-size `tmp_pack_*`
     // behind each time, so a background poll could fill the disk.
-    return executeGit(
-      "GitVcsDriver.fetchRemoteForStatus",
-      fetchCwd,
-      [
-        "--git-dir",
-        gitCommonDir,
-        "fetch",
-        "--quiet",
-        "--no-tags",
-        "--no-auto-gc",
-        "--",
-        remoteName,
-      ],
-      {
-        env: STATUS_UPSTREAM_REFRESH_ENV,
-        fallbackErrorDetail: "Background Git fetch exited with a non-zero status.",
-        timeoutMs: Duration.toMillis(STATUS_UPSTREAM_REFRESH_TIMEOUT),
-      },
-    ).pipe(Effect.asVoid);
-  };
+    const args = [
+      "--git-dir",
+      gitCommonDir,
+      "fetch",
+      "--quiet",
+      "--no-tags",
+      "--no-auto-gc",
+      "--",
+      remoteName,
+    ];
+    const key = `${gitCommonDir}\0${remoteName}`;
+    const failure = statusRemoteRefreshFailures.get(key);
+    if (failure && (yield* Clock.currentTimeMillis) < failure.retryAt) return;
+    const fiber = yield* Effect.uninterruptible(
+      Effect.gen(function* () {
+        const pending = statusFetches.get(key);
+        if (pending) return pending;
+        // Frequent poll deadlines and disconnected clients must not interrupt a
+        // healthy writer. A separate safety limit prevents a hung transport from
+        // occupying its worker slot indefinitely.
+        const started = yield* executeGit("GitVcsDriver.fetchRemoteForStatus", fetchCwd, args, {
+          env: STATUS_UPSTREAM_REFRESH_ENV,
+          fallbackErrorDetail: "Background Git fetch exited with a non-zero status.",
+          timeoutMs: Duration.toMillis(STATUS_UPSTREAM_FETCH_TIMEOUT),
+          forceKillAfterMs: 1_000,
+        }).pipe(
+          Effect.asVoid,
+          Effect.tap(() =>
+            Effect.sync(() => {
+              statusRemoteRefreshFailures.delete(key);
+            }),
+          ),
+          Effect.tapError(() => recordStatusRemoteRefreshFailure(key)),
+          Effect.tapCause((cause) => Effect.logWarning("Background Git fetch failed", cause)),
+          statusFetchProcesses.withPermits(1),
+          Effect.onExit(() =>
+            Effect.sync(() => {
+              statusFetches.delete(key);
+            }),
+          ),
+          Effect.forkIn(serviceScope, { startImmediately: false, uninterruptible: false }),
+        );
+        statusFetches.set(key, started);
+        return started;
+      }),
+    );
+    const result = yield* Fiber.join(fiber).pipe(
+      Effect.timeoutOption(STATUS_UPSTREAM_REFRESH_TIMEOUT),
+    );
+    if (Option.isNone(result)) {
+      yield* Effect.logDebug(
+        "Background Git fetch is still running; using the last fetched references.",
+      );
+    }
+  });
 
   const resolveRepositoryPathsUncached = Effect.fn("resolveRepositoryPathsUncached")(function* (
     cwd: string,
   ) {
+    // Git reports relative paths from the physical cwd, which can differ from a symlink.
     const commonDirResult = yield* executeGitWithStableDiagnostics(
       "GitVcsDriver.resolveRepositoryPaths.commonDir",
       cwd,
@@ -1318,9 +1376,10 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     }
 
     const commonDirOutput = commonDirResult.stdout.trim();
+    const physicalCwd = yield* fileSystem.realPath(cwd).pipe(Effect.orElseSucceed(() => cwd));
     const resolvedGitCommonDir = path.isAbsolute(commonDirOutput)
       ? path.normalize(commonDirOutput)
-      : path.resolve(cwd, commonDirOutput);
+      : path.resolve(physicalCwd, commonDirOutput);
     const gitCommonDir = yield* fileSystem
       .realPath(resolvedGitCommonDir)
       .pipe(Effect.orElseSucceed(() => resolvedGitCommonDir));
@@ -1480,31 +1539,30 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     });
   });
 
-  const statusRemoteRefreshFailureCounts = new Map<string, number>();
+  const statusRemoteRefreshFailures = new Map<string, { count: number; retryAt: number }>();
   const statusRemoteRefreshFailureKey = (cacheKey: StatusRemoteRefreshCacheKey) =>
     `${cacheKey.gitCommonDir}\0${cacheKey.remoteName}`;
-  const recordStatusRemoteRefreshFailure = (cacheKey: StatusRemoteRefreshCacheKey) => {
-    const key = statusRemoteRefreshFailureKey(cacheKey);
-    const nextCount = (statusRemoteRefreshFailureCounts.get(key) ?? 0) + 1;
-    statusRemoteRefreshFailureCounts.delete(key);
-    statusRemoteRefreshFailureCounts.set(key, nextCount);
-    if (statusRemoteRefreshFailureCounts.size > STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY) {
-      const oldestKey = statusRemoteRefreshFailureCounts.keys().next().value;
+  const recordStatusRemoteRefreshFailure = Effect.fn(
+    "GitVcsDriver.recordStatusRemoteRefreshFailure",
+  )(function* (key: string) {
+    const nextCount = (statusRemoteRefreshFailures.get(key)?.count ?? 0) + 1;
+    const now = yield* Clock.currentTimeMillis;
+    statusRemoteRefreshFailures.delete(key);
+    statusRemoteRefreshFailures.set(key, {
+      count: nextCount,
+      retryAt: now + Duration.toMillis(statusUpstreamRefreshFailureCooldown(nextCount)),
+    });
+    if (statusRemoteRefreshFailures.size > STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY) {
+      const oldestKey = statusRemoteRefreshFailures.keys().next().value;
       if (oldestKey !== undefined) {
-        statusRemoteRefreshFailureCounts.delete(oldestKey);
+        statusRemoteRefreshFailures.delete(oldestKey);
       }
     }
-  };
-  const clearStatusRemoteRefreshFailures = (cacheKey: StatusRemoteRefreshCacheKey) => {
-    statusRemoteRefreshFailureCounts.delete(statusRemoteRefreshFailureKey(cacheKey));
-  };
+  });
   const refreshStatusRemoteCacheEntry = Effect.fn("refreshStatusRemoteCacheEntry")(function* (
     cacheKey: StatusRemoteRefreshCacheKey,
   ) {
     return yield* fetchRemoteForStatus(cacheKey.gitCommonDir, cacheKey.remoteName).pipe(
-      Effect.tap(() => Effect.sync(() => clearStatusRemoteRefreshFailures(cacheKey))),
-      Effect.tapError(() => Effect.sync(() => recordStatusRemoteRefreshFailure(cacheKey))),
-      Effect.tapCause((cause) => Effect.logWarning("Background Git fetch failed", cause)),
       Effect.as(true as const),
     );
   });
@@ -1519,7 +1577,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       Exit.isSuccess(exit)
         ? STATUS_UPSTREAM_REFRESH_INTERVAL
         : statusUpstreamRefreshFailureCooldown(
-            statusRemoteRefreshFailureCounts.get(statusRemoteRefreshFailureKey(cacheKey)) ?? 1,
+            statusRemoteRefreshFailures.get(statusRemoteRefreshFailureKey(cacheKey))?.count ?? 1,
           ),
   });
 
@@ -1713,7 +1771,10 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
   const resolveBaseBranchForNoUpstream = Effect.fn("resolveBaseBranchForNoUpstream")(function* (
     cwd: string,
     refName: string,
-    options?: { readonly allowRemoteOfCurrent?: boolean },
+    options?: {
+      readonly allowRemoteOfCurrent?: boolean;
+      readonly knownOriginDefaultBranch?: string | null;
+    },
   ) {
     const configuredBaseRef = yield* readConfigValue(cwd, `branch.${refName}.t3-merge-base-ref`);
     if (
@@ -1747,15 +1808,18 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     const primaryRemoteName = yield* resolvePrimaryRemoteName(cwd).pipe(
       Effect.orElseSucceed(() => null),
     );
-    const defaultBranch =
-      primaryRemoteName === null ? null : yield* resolveDefaultBranchName(cwd, primaryRemoteName);
     const candidates = [
-      configuredBaseBranch.length > 0 ? configuredBaseBranch : null,
-      defaultBranch,
-      ...DEFAULT_BASE_BRANCH_CANDIDATES,
+      Effect.succeed(configuredBaseBranch),
+      primaryRemoteName === null
+        ? Effect.succeed(null)
+        : primaryRemoteName === "origin" && options?.knownOriginDefaultBranch != null
+          ? Effect.succeed(options.knownOriginDefaultBranch)
+          : resolveDefaultBranchName(cwd, primaryRemoteName),
+      ...DEFAULT_BASE_BRANCH_CANDIDATES.map(Effect.succeed),
     ];
 
-    for (const candidate of candidates) {
+    for (const readCandidate of candidates) {
+      const candidate = yield* readCandidate;
       if (!candidate) {
         continue;
       }
@@ -1816,8 +1880,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
   const computeAheadCountAgainstBase = Effect.fn("computeAheadCountAgainstBase")(function* (
     cwd: string,
     refName: string,
+    options?: { readonly knownOriginDefaultBranch: string | null },
   ) {
-    const base = yield* resolveBaseBranchForNoUpstream(cwd, refName);
+    const base = yield* resolveBaseBranchForNoUpstream(cwd, refName, options);
     if (!base) {
       return 0;
     }
@@ -1881,8 +1946,15 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       const branchValue = branchResult.stdout.trim();
       branch = branchValue.length > 0 && branchValue !== "HEAD" ? branchValue : null;
     }
-    const upstream = yield* resolveCurrentUpstream(cwd);
-    const upstreamRef = upstream?.upstreamRef ?? null;
+    const currentUpstreamRef = yield* readCurrentUpstreamRef(cwd);
+    let upstreamRef =
+      currentUpstreamRef === null
+        ? null
+        : (parseUpstreamRefByFirstSeparator(currentUpstreamRef)?.upstreamRef ?? null);
+    // Trimming a remote that starts with Unicode whitespace can leave a leading slash.
+    if (currentUpstreamRef?.startsWith("/")) {
+      upstreamRef = (yield* resolveCurrentUpstream(cwd, currentUpstreamRef))?.upstreamRef ?? null;
+    }
     let aheadCount = 0;
     let behindCount = 0;
 
@@ -1915,7 +1987,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       branch && !isDefaultBranch
         ? upstreamRef === null
           ? aheadCount
-          : yield* computeAheadCountAgainstBase(cwd, branch).pipe(Effect.orElseSucceed(() => 0))
+          : yield* computeAheadCountAgainstBase(cwd, branch, {
+              knownOriginDefaultBranch: defaultBranch,
+            }).pipe(Effect.orElseSucceed(() => 0))
         : 0;
 
     return {
@@ -2607,7 +2681,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
   const pullCurrentBranch: GitVcsDriver.GitVcsDriver["Service"]["pullCurrentBranch"] = Effect.fn(
     "pullCurrentBranch",
   )(function* (cwd) {
-    const details = yield* statusDetails(cwd);
+    const details = yield* readStatusDetailsLocal(cwd);
     const refName = details.branch;
     if (!refName) {
       return yield* new GitCommandError({
@@ -2629,6 +2703,14 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
         detail: "Current branch has no upstream configured. Push with upstream first.",
       });
     }
+    const remote = yield* readConfigValue(cwd, `branch.${refName}.remote`);
+    if (remote) {
+      const gitCommonDir = yield* resolveGitCommonDir(cwd);
+      const pending = statusFetches.get(`${gitCommonDir}\0${remote}`);
+      // The status wait can finish while its fetch still owns reference locks.
+      // Let our existing writer finish before starting the pull's fetch.
+      if (pending) yield* Fiber.await(pending);
+    }
     const beforeSha = yield* runGitStdout(
       "GitVcsDriver.pullCurrentBranch.beforeSha",
       cwd,
@@ -2638,11 +2720,67 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     // After a successful pull, HEAD before and after decides the result, so its output is not
     // needed. A large fast-forward's diffstat can exceed the output cap, which must not fail a
     // pull Git applied.
-    yield* executeGit("GitVcsDriver.pullCurrentBranch.pull", cwd, ["pull", "--ff-only"], {
+    const options = {
       timeoutMs: 30_000,
-      fallbackErrorDetail: "git pull failed",
       appendTruncationMarker: true,
-    });
+      allowNonZeroExit: true,
+    };
+    let args = ["pull", "--ff-only"];
+    let result = yield* executeGitWithStableDiagnostics(
+      "GitVcsDriver.pullCurrentBranch.pull",
+      cwd,
+      args,
+      options,
+    );
+    if (result.exitCode !== 0 && isRefLockFailure(result.stderr)) {
+      const [remote, mergeRefs, currentBranch, currentSha] = yield* Effect.all([
+        readConfigValue(cwd, `branch.${refName}.remote`),
+        runGitStdout(
+          "GitVcsDriver.pullCurrentBranch.mergeRefs",
+          cwd,
+          ["config", "--get-all", `branch.${refName}.merge`],
+          true,
+        ).pipe(Effect.map((stdout) => stdout.trim().split("\n").filter(Boolean))),
+        runGitStdout(
+          "GitVcsDriver.pullCurrentBranch.currentBranch",
+          cwd,
+          ["symbolic-ref", "--quiet", "--short", "HEAD"],
+          true,
+        ).pipe(Effect.map((stdout) => stdout.trim())),
+        runGitStdout("GitVcsDriver.pullCurrentBranch.currentSha", cwd, ["rev-parse", "HEAD"]).pipe(
+          Effect.map((stdout) => stdout.trim()),
+        ),
+      ]);
+      // A full fetch can fail on an unrelated branch's lock. Keep that fetch as the
+      // default, but retry only the configured upstream before any checkout movement.
+      const [mergeRef] = mergeRefs;
+      if (
+        remote &&
+        mergeRef &&
+        mergeRefs.length === 1 &&
+        currentBranch === refName &&
+        currentSha === beforeSha
+      ) {
+        args = ["pull", "--ff-only", "--", remote, mergeRef];
+        result = yield* executeGitWithStableDiagnostics(
+          "GitVcsDriver.pullCurrentBranch.pull",
+          cwd,
+          args,
+          options,
+        );
+      }
+    }
+    if (result.exitCode !== 0) {
+      const reason = classifyGitFailure(result.stderr);
+      return yield* new GitCommandError({
+        ...gitCommandContext({ operation: "GitVcsDriver.pullCurrentBranch.pull", cwd, args }),
+        ...(reason === null ? {} : { reason }),
+        detail: fetchFailureDetail(result.stderr) ?? "git pull failed",
+        exitCode: result.exitCode,
+        stdoutLength: result.stdout.length,
+        stderrLength: result.stderr.length,
+      });
+    }
     const afterSha = yield* runGitStdout(
       "GitVcsDriver.pullCurrentBranch.afterSha",
       cwd,
@@ -2650,7 +2788,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       true,
     ).pipe(Effect.map((stdout) => stdout.trim()));
 
-    const refreshed = yield* statusDetails(cwd);
+    const refreshed = yield* readStatusDetailsLocal(cwd);
     return {
       status: beforeSha.length > 0 && beforeSha === afterSha ? "skipped_up_to_date" : "pulled",
       refName,
@@ -2765,6 +2903,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       cwd,
       [
         ...tempIndexConfig,
+        // Avoid redundant tracked-entry pathspec matching in this disposable index.
+        "-c",
+        "core.preloadIndex=false",
         "--literal-pathspecs",
         "add",
         "--intent-to-add",
diff --git a/apps/server/src/workspace/WorkspaceFileSystem.test.ts b/apps/server/src/workspace/WorkspaceFileSystem.test.ts
index ae956e69d0cbc..89f4167a3aee8 100644
--- a/apps/server/src/workspace/WorkspaceFileSystem.test.ts
+++ b/apps/server/src/workspace/WorkspaceFileSystem.test.ts
@@ -4,9 +4,11 @@ import * as NodeChildProcess from "node:child_process";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { it, describe, expect } from "@effect/vitest";
 import * as Effect from "effect/Effect";
+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 Tracer from "effect/Tracer";
 
 import * as ServerConfig from "../config.ts";
 import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
@@ -274,6 +276,19 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
             resolvedPath,
           });
           expect("cause" in error).toBe(false);
+
+          yield* fileSystem.symlink(outsideDir, path.join(cwd, "linked-dir"));
+          const missingChildError = yield* workspaceFileSystem
+            .readFile(
+              Object.assign(
+                { cwd, relativePath: "linked-dir/missing/t3.json" },
+                { allowMissing: true },
+              ),
+            )
+            .pipe(Effect.flip);
+          expect(missingChildError).toBeInstanceOf(
+            WorkspaceFileSystem.WorkspaceFilePathEscapeError,
+          );
         }),
     );
 
@@ -285,18 +300,20 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
         const cwd = yield* makeTempDir;
         yield* fileSystem.makeDirectory(path.join(cwd, "src"));
 
-        const error = yield* workspaceFileSystem
-          .readFile({ cwd, relativePath: "src" })
-          .pipe(Effect.flip);
         const resolvedPath = yield* fileSystem.realPath(path.join(cwd, "src"));
+        for (const options of [{}, { allowMissing: true }]) {
+          const error = yield* workspaceFileSystem
+            .readFile(Object.assign({ cwd, relativePath: "src" }, options))
+            .pipe(Effect.flip);
 
-        expect(error).toBeInstanceOf(WorkspaceFileSystem.WorkspacePathNotFileError);
-        expect(error).toMatchObject({
-          workspaceRoot: cwd,
-          relativePath: "src",
-          resolvedPath,
-        });
-        expect("cause" in error).toBe(false);
+          expect(error).toBeInstanceOf(WorkspaceFileSystem.WorkspacePathNotFileError);
+          expect(error).toMatchObject({
+            workspaceRoot: cwd,
+            relativePath: "src",
+            resolvedPath,
+          });
+          expect("cause" in error).toBe(false);
+        }
       }),
     );
 
@@ -348,6 +365,44 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
         expect((error.cause as NodeJS.ErrnoException).code).toBe("ENOENT");
       }),
     );
+
+    it.effect("returns an absent optional file without any failed spans", () =>
+      Effect.gen(function* () {
+        const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        const spans: Array<Tracer.NativeSpan> = [];
+        const tracer = Tracer.make({
+          span: (options) => {
+            const span = new Tracer.NativeSpan(options);
+            spans.push(span);
+            return span;
+          },
+        });
+
+        const result = yield* workspaceFileSystem
+          .readFile(Object.assign({ cwd, relativePath: "t3.json" }, { allowMissing: true }))
+          .pipe(Effect.withTracer(tracer), Effect.exit);
+
+        expect(spans.length).toBeGreaterThan(0);
+        // Diagnostics counts nested failures even when the outer read recovers.
+        expect
+          .soft(
+            spans
+              .filter((span) => span.status._tag === "Ended" && Exit.isFailure(span.status.exit))
+              .map((span) => span.name),
+          )
+          .toEqual([]);
+        expect(result).toEqual(
+          Exit.succeed({
+            relativePath: "t3.json",
+            contents: "",
+            byteLength: 0,
+            truncated: false,
+            exists: false,
+          }),
+        );
+      }),
+    );
   });
 
   describe("writeFile", () => {
diff --git a/apps/server/src/workspace/WorkspaceFileSystem.ts b/apps/server/src/workspace/WorkspaceFileSystem.ts
index 96fe5a0d234f8..9f7945cc0a98e 100644
--- a/apps/server/src/workspace/WorkspaceFileSystem.ts
+++ b/apps/server/src/workspace/WorkspaceFileSystem.ts
@@ -240,7 +240,13 @@ export const make = Effect.gen(function* () {
             operation: "realpath-target",
             cause,
           }),
-      });
+      }).pipe(
+        Effect.catchIf(
+          (error) =>
+            input.allowMissing === true && (error.cause as NodeJS.ErrnoException).code === "ENOENT",
+          () => Effect.succeed(null),
+        ),
+      );
       return { relativePath: requestedPath, realTargetPath };
     }
 
@@ -261,8 +267,36 @@ export const make = Effect.gen(function* () {
           cause,
         }),
     });
-    const realTargetPath = yield* Effect.tryPromise({
-      try: () => NodeFSP.realpath(target.absolutePath),
+    const resolved = yield* Effect.tryPromise({
+      try: async () => {
+        let candidate = target.absolutePath;
+        for (;;) {
+          try {
+            return {
+              realTargetPath: path.join(
+                await NodeFSP.realpath(candidate),
+                path.relative(candidate, target.absolutePath),
+              ),
+              exists: candidate === target.absolutePath,
+            };
+          } catch (error) {
+            if (!input.allowMissing || (error as NodeJS.ErrnoException).code !== "ENOENT") {
+              throw error;
+            }
+            // Like writes, missing reads must check the nearest existing ancestor.
+            // An existing entry that cannot resolve is a dangling link, not absence.
+            const exists = await NodeFSP.lstat(candidate).then(
+              () => true,
+              (cause: NodeJS.ErrnoException) => {
+                if (cause.code !== "ENOENT") throw cause;
+                return false;
+              },
+            );
+            if (exists || path.dirname(candidate) === candidate) throw error;
+            candidate = path.dirname(candidate);
+          }
+        }
+      },
       catch: (cause) =>
         new WorkspaceFileSystemOperationError({
           workspaceRoot: input.cwd,
@@ -273,22 +307,33 @@ export const make = Effect.gen(function* () {
           cause,
         }),
     });
-    if (!isInsideRealRoot(realWorkspaceRoot, realTargetPath)) {
+    if (!isInsideRealRoot(realWorkspaceRoot, resolved.realTargetPath)) {
       return yield* new WorkspaceFilePathEscapeError({
         workspaceRoot: input.cwd,
         relativePath: input.relativePath,
         resolvedWorkspaceRoot: realWorkspaceRoot,
-        resolvedPath: realTargetPath,
+        resolvedPath: resolved.realTargetPath,
       });
     }
-    return { relativePath: target.relativePath, realTargetPath };
+    return {
+      relativePath: target.relativePath,
+      realTargetPath: resolved.exists ? resolved.realTargetPath : null,
+    };
   });
 
   const readFile: WorkspaceFileSystem["Service"]["readFile"] = Effect.fn(
     "WorkspaceFileSystem.readFile",
   )(function* (input) {
     const target = yield* resolveReadTarget(input);
+    const absentResult = {
+      relativePath: target.relativePath,
+      contents: "",
+      byteLength: 0,
+      truncated: false,
+      exists: false,
+    };
     const realTargetPath = target.realTargetPath;
+    if (realTargetPath === null) return absentResult;
 
     return yield* Effect.acquireUseRelease(
       Effect.tryPromise({
@@ -308,9 +353,16 @@ export const make = Effect.gen(function* () {
             operation: "open",
             cause,
           }),
-      }),
+      }).pipe(
+        Effect.catchIf(
+          (error) =>
+            input.allowMissing === true && (error.cause as NodeJS.ErrnoException).code === "ENOENT",
+          () => Effect.succeed(null),
+        ),
+      ),
       (handle) =>
         Effect.gen(function* () {
+          if (handle === null) return absentResult;
           const stat = yield* Effect.tryPromise({
             try: () => handle.stat(),
             catch: (cause) =>
@@ -362,18 +414,20 @@ export const make = Effect.gen(function* () {
           };
         }),
       (handle) =>
-        Effect.tryPromise({
-          try: () => handle.close(),
-          catch: (cause) =>
-            new WorkspaceFileSystemOperationError({
-              workspaceRoot: input.cwd,
-              relativePath: input.relativePath,
-              resolvedPath: realTargetPath,
-              operationPath: realTargetPath,
-              operation: "close",
-              cause,
+        handle === null
+          ? Effect.void
+          : Effect.tryPromise({
+              try: () => handle.close(),
+              catch: (cause) =>
+                new WorkspaceFileSystemOperationError({
+                  workspaceRoot: input.cwd,
+                  relativePath: input.relativePath,
+                  resolvedPath: realTargetPath,
+                  operationPath: realTargetPath,
+                  operation: "close",
+                  cause,
+                }),
             }),
-        }),
     );
   });
 
diff --git a/apps/web/package.json b/apps/web/package.json
index 7eb1909a54c54..dbb889a1bb8ef 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -45,6 +45,7 @@
     "@tiptap/extension-code-block": "^3.31.3",
     "@tiptap/extension-heading": "^3.31.3",
     "@tiptap/extension-horizontal-rule": "^3.31.3",
+    "@tiptap/extension-italic": "^3.31.3",
     "@tiptap/extension-list": "^3.31.3",
     "@tiptap/extension-task-item": "^3.31.3",
     "@tiptap/extension-task-list": "^3.31.3",
diff --git a/apps/web/src/cloud/publicConfig.test.ts b/apps/web/src/cloud/publicConfig.test.ts
index d42aa34baa26c..bab63e8260c1f 100644
--- a/apps/web/src/cloud/publicConfig.test.ts
+++ b/apps/web/src/cloud/publicConfig.test.ts
@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
 
 import {
   CloudPublicConfigMissingError,
@@ -8,6 +8,7 @@ import {
 
 afterEach(() => {
   vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
 });
 
 describe("hasCloudPublicConfig", () => {
@@ -35,6 +36,80 @@ describe("hasCloudPublicConfig", () => {
     expect(hasCloudPublicConfig()).toBe(false);
   });
 
+  describe("browser origins", () => {
+    beforeEach(() => {
+      vi.stubEnv("VITE_CLERK_PUBLISHABLE_KEY", `pk_live_${btoa("clerk.example.com$")}`);
+      vi.stubEnv("VITE_CLERK_JWT_TEMPLATE", "t3-relay");
+      vi.stubEnv("VITE_T3CODE_RELAY_URL", "https://relay.example.test");
+    });
+
+    it.each(["https://example.com", "https://nightly.app.example.com:443"])(
+      "enables production auth on the configured root and subdomains: %s",
+      (origin) => {
+        vi.stubGlobal("window", { location: new URL(origin) });
+
+        expect(hasCloudPublicConfig()).toBe(true);
+      },
+    );
+
+    it.each(["http://localhost:3773", "https://machine.example.ts.net"])(
+      "disables production auth on private browser origins: %s",
+      (origin) => {
+        vi.stubGlobal("window", { location: new URL(origin) });
+
+        expect(hasCloudPublicConfig()).toBe(false);
+      },
+    );
+
+    it.each(["http://app.example.com:443", "https://app.example.com:3773"])(
+      "rejects unsupported schemes and ports even on the configured domain: %s",
+      (origin) => {
+        vi.stubGlobal("window", { location: new URL(origin) });
+
+        expect(hasCloudPublicConfig()).toBe(false);
+      },
+    );
+
+    it.each(["https://notexample.com", "https://example.com.evil.test"])(
+      "rejects domain lookalikes: %s",
+      (origin) => {
+        vi.stubGlobal("window", { location: new URL(origin) });
+
+        expect(hasCloudPublicConfig()).toBe(false);
+      },
+    );
+
+    it.each([
+      ["https://tenant.clerk.accounts.dev", true],
+      ["https://other.clerk.accounts.dev", false],
+    ])("keeps a provider hostname scoped to its own instance: %s", (origin, expected) => {
+      vi.stubEnv("VITE_CLERK_PUBLISHABLE_KEY", `pk_live_${btoa("tenant.clerk.accounts.dev$")}`);
+      vi.stubGlobal("window", { location: new URL(origin) });
+
+      expect(hasCloudPublicConfig()).toBe(expected);
+    });
+
+    it("keeps development keys available on private browser origins", () => {
+      vi.stubEnv("VITE_CLERK_PUBLISHABLE_KEY", `pk_test_${btoa("tenant.clerk.accounts.dev$")}`);
+      vi.stubGlobal("window", { location: new URL("http://localhost:3773") });
+
+      expect(hasCloudPublicConfig()).toBe(true);
+    });
+
+    it("keeps production keys available in the Electron auth shell", () => {
+      vi.stubGlobal("window", { location: new URL("file:///app/index.html"), desktopBridge: {} });
+
+      expect(hasCloudPublicConfig()).toBe(true);
+    });
+
+    it("disables cloud auth for an invalid production key without throwing", () => {
+      vi.stubEnv("VITE_CLERK_PUBLISHABLE_KEY", "pk_live_!");
+      vi.stubGlobal("window", { location: new URL("https://app.example.com") });
+
+      expect(hasCloudPublicConfig()).toBe(false);
+    });
+  });
+
   it("reports the missing Clerk JWT template as structured configuration", () => {
     vi.stubEnv("VITE_CLERK_JWT_TEMPLATE", "");
 
diff --git a/apps/web/src/cloud/publicConfig.ts b/apps/web/src/cloud/publicConfig.ts
index 13dd7fa53bb4a..9f1238b858a5c 100644
--- a/apps/web/src/cloud/publicConfig.ts
+++ b/apps/web/src/cloud/publicConfig.ts
@@ -1,4 +1,7 @@
-import { relayClerkTokenOptions } from "@t3tools/shared/relayAuth";
+import {
+  clerkFrontendApiHostnameFromPublishableKey,
+  relayClerkTokenOptions,
+} from "@t3tools/shared/relayAuth";
 import { normalizeSecureRelayUrl } from "@t3tools/shared/relayUrl";
 import * as Schema from "effect/Schema";
 
@@ -78,7 +81,34 @@ export function resolveRelayTracingConfig() {
 
 export function hasCloudPublicConfig(): boolean {
   const config = resolveCloudPublicConfig();
-  return Boolean(config.clerkPublishableKey && config.clerkJwtTemplate && config.relayUrl);
+  if (!config.clerkPublishableKey || !config.clerkJwtTemplate || !config.relayUrl) {
+    return false;
+  }
+
+  // Electron has its own auth runtime; development keys also support private browser origins.
+  if (
+    typeof window === "undefined" ||
+    window.desktopBridge !== undefined ||
+    !config.clerkPublishableKey.startsWith("pk_live_")
+  ) {
+    return true;
+  }
+
+  try {
+    // Custom Frontend API hosts use clerk.<production domain>.
+    const domain = clerkFrontendApiHostnameFromPublishableKey(config.clerkPublishableKey).replace(
+      /^clerk\./u,
+      "",
+    );
+    const { hostname, protocol, port } = window.location;
+    return (
+      protocol === "https:" &&
+      port === "" &&
+      (hostname === domain || hostname.endsWith(`.${domain}`))
+    );
+  } catch {
+    return false;
+  }
 }
 
 export function resolveRelayClerkTokenOptions() {
diff --git a/apps/web/src/components/AppSidebarLayout.tsx b/apps/web/src/components/AppSidebarLayout.tsx
index 89d52c87b2827..c991a9003514f 100644
--- a/apps/web/src/components/AppSidebarLayout.tsx
+++ b/apps/web/src/components/AppSidebarLayout.tsx
@@ -321,6 +321,7 @@ export function AppSidebarLayout({ children }: { children: ReactNode }) {
         className="h-dvh! min-h-0!"
         data-panel-animations={routePanelAnimationsActive ? "true" : "false"}
         defaultOpen
+        mobileBreakpoint={sidebarMinimumWidth + THREAD_MAIN_CONTENT_MIN_WIDTH}
         style={sidebarProviderStyle}
       >
         <SidebarBrandWidthProbe onWidthChange={setBrandWidth} />
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index f5b2f29990c86..e615ae91e1459 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -158,7 +158,7 @@ import {
   useState,
 } from "react";
 import { flushSync } from "react-dom";
-import { useLocation, useNavigate } from "@tanstack/react-router";
+import { useLocation, useNavigate, useRouter } from "@tanstack/react-router";
 import { assistantCitationFromLocation } from "../lib/assistantCitationNavigation";
 import { isMacPlatform } from "../lib/utils";
 import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
@@ -391,9 +391,10 @@ import {
   useThreadRefs,
   useThreadVisibleTurnItems,
   useThreadCheckpointSummaries,
+  readThreadShell,
   waitForThreadShell,
 } from "../state/entities";
-import { useEnvironmentShellHasSnapshot } from "../state/shell";
+import { environmentShell, useEnvironmentShellHasSnapshot } from "../state/shell";
 import { ChatComposer, type ChatComposerHandle } from "./chat/ChatComposer";
 import { createPageScrollController, type PageScrollKey } from "./chat/pageScrollController";
 import { isTimelineScrollTarget } from "./chat/timelineScrollTarget";
@@ -541,12 +542,9 @@ import { useOrchestrationCommand } from "../state/use-orchestration-command";
 import { useAtomQueryRunner } from "../state/use-atom-query-runner";
 import { Button, InlineButton } from "./ui/button";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
-import { ServerUpdateAction } from "./ServerUpdateAction";
+import { ServerUpdateAction, serverUpdateStageLabel } from "./ServerUpdateAction";
 import { useAutoBalanceUpdateBanner } from "./chat/useAutoBalanceUpdateBanner";
-import {
-  ComposerServerUpdateIcon,
-  ComposerServerUpdateStatus,
-} from "./chat/ComposerServerUpdateStatus";
+import { ComposerServerUpdateIcon } from "./chat/ComposerServerUpdateStatus";
 import {
   dismissServerUpdateFailure,
   isServerUpdateFailureDismissed,
@@ -574,6 +572,7 @@ const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = [];
 // second, and every server-side visit is a full command dispatch plus a
 // broadcast to all shell subscribers.
 const VISIT_DISPATCH_THROTTLE_MS = 10_000;
+const RELATED_THREAD_SHELL_WAIT_MS = 1_000;
 const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];
 const EMPTY_AUTO_UPDATE_ENVIRONMENTS: ReadonlyArray<EnvironmentPresentation> = [];
 function useDraftHeroLayoutTransition(
@@ -1198,6 +1197,7 @@ export default function ChatView(props: ChatViewProps) {
   );
   const timestampFormat = settings.timestampFormat;
   const navigate = useNavigate();
+  const router = useRouter();
   // Selects primitives: an object here is new on every router store update, which
   // re-renders ChatView on unrelated navigation state changes.
   const citationHref = useLocation({ select: (location) => location.href });
@@ -2325,12 +2325,11 @@ export default function ChatView(props: ChatViewProps) {
         variant: updateFailed ? "error" : "default",
         priority: updateInProgress ? "urgent" : "notice",
         icon: <ComposerServerUpdateIcon status={serverUpdateState.status} />,
-        title: (
-          <ComposerServerUpdateStatus
-            state={serverUpdateState}
-            serverLabel={versionMismatchServerLabel}
-          />
-        ),
+        title: `${updateFailed ? "Could not update" : "Updating"} ${versionMismatchServerLabel}`,
+        description:
+          serverUpdateState.status === "failed"
+            ? serverUpdateState.message
+            : serverUpdateStageLabel(serverUpdateState.stage),
         actions: updateInProgress ? (
           disconnectAction
         ) : !versionMismatch ||
@@ -4668,11 +4667,22 @@ export default function ChatView(props: ChatViewProps) {
             modelStrip.offsetHeight + Number.parseFloat(getComputedStyle(modelStrip).marginTop),
           )
         : 0;
+    const noticeStack = composerOverlayElement?.querySelector<HTMLElement>(
+      '[data-composer-banner-stack="true"]',
+    );
+    const expandedNoticesHeight = noticeStack
+      ? Math.max(
+          0,
+          noticeStack.getBoundingClientRect().height -
+            Number.parseFloat(getComputedStyle(noticeStack).minHeight),
+        )
+      : 0;
     const nextInset = resolveComposerTimelineInset({
       currentInset: composerTimelineInsetRef.current,
-      overlayHeight: nextHeight,
+      overlayHeight: height,
       isResting,
       restingOnlyHeight,
+      expandedNoticesHeight,
     });
     if (composerTimelineInsetRef.current !== nextInset) {
       composerTimelineInsetRef.current = nextInset;
@@ -5033,10 +5043,32 @@ export default function ChatView(props: ChatViewProps) {
     }
   };
   const handleStopBackgroundWorkStable = useStableCallback(handleStopBackgroundWork);
-  const onOpenRelatedThread = (threadId: ThreadId) => {
+  const openRelatedThreadGenerationRef = useRef(0);
+  const onOpenRelatedThread = async (threadId: ThreadId) => {
+    const generation = ++openRelatedThreadGenerationRef.current;
+    const threadRef = scopeThreadRef(environmentId, threadId);
+    const isEnvironmentLive = () =>
+      appAtomRegistry.get(environmentShell.stateValueAtom(environmentId)).status === "live";
+    // A just-launched child can reach this timeline before its shell syncs.
+    if (isEnvironmentLive() && readThreadShell(threadRef) === null) {
+      const location = router.latestLocation;
+      await waitForThreadShell(threadRef, RELATED_THREAD_SHELL_WAIT_MS);
+      if (
+        generation !== openRelatedThreadGenerationRef.current ||
+        currentRouteThreadKeyRef.current !== routeThreadKey ||
+        router.latestLocation !== location
+      ) {
+        return;
+      }
+    }
+    const shell = readThreadShell(threadRef);
+    if (shell === null ? isEnvironmentLive() : shell.deletedAt != null) {
+      toastManager.add({ type: "info", title: "This thread is no longer available" });
+      return;
+    }
     void navigate({
       to: "/$environmentId/$threadId",
-      params: buildThreadRouteParams(scopeThreadRef(environmentId, threadId)),
+      params: buildThreadRouteParams(threadRef),
     });
   };
   const onOpenRelatedThreadStable = useStableCallback(onOpenRelatedThread);
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index 986647cdd032d..4d567bdaf2159 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -2957,14 +2957,26 @@ function OpenCommandPaletteDialog(props: {
   function handleKeyDown(event: KeyboardEvent<HTMLInputElement>): void {
     const command = resolveShortcutCommand(event, keybindings, {
       platform: navigator.platform,
-      context: { modelPickerOpen: false },
+      context: { modelPickerOpen: false, editableFocus: true },
     });
-    if (threadJumpIndexFromCommand(command ?? "") !== null) {
+    // Global new-thread handlers ignore shortcuts while the palette is open.
+    const isJump = threadJumpIndexFromCommand(command ?? "") !== null;
+    const isNewThread =
+      !event.nativeEvent.isComposing &&
+      event.keyCode !== 229 &&
+      (command === "chat.new" ||
+        command === "chat.newLocal" ||
+        command === "chat.newWithoutProject");
+    const matchingItem =
+      isJump || isNewThread
+        ? displayedGroups
+            .flatMap((group) => group.items)
+            .find((item) => item.shortcutCommand === command)
+        : undefined;
+    if (isJump || matchingItem) {
+      (event as typeof event & { preventBaseUIHandler?: () => void }).preventBaseUIHandler?.();
       event.preventDefault();
       event.stopPropagation();
-      const matchingItem = displayedGroups
-        .flatMap((group) => group.items)
-        .find((item) => item.shortcutCommand === command);
       if (matchingItem) {
         executeItem(matchingItem);
       }
diff --git a/apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx b/apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx
index 63e9fde86f3a0..ef92903cd00ab 100644
--- a/apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx
+++ b/apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx
@@ -116,6 +116,42 @@ function typeText(editor: Editor, from: number, to: number, text: string) {
   }
 }
 
+function textWithMark(editor: Editor, name: string) {
+  const text: string[] = [];
+  editor.state.doc.descendants((node) => {
+    if (node.isText && node.marks.some((mark) => mark.type.name === name)) {
+      text.push(node.textContent);
+    }
+  });
+  return text;
+}
+
+it.each([
+  { value: "clean _build and node", code: [] },
+  { value: "clean `_build` and `node", code: ["_build"] },
+])("keeps a typed underscore literal after $value", async ({ value, code }) => {
+  const editor = await mountEditor(value);
+  await act(async () => {
+    editor.commands.focus("end");
+    const { from, to } = editor.state.selection;
+    typeText(editor, from, to, "_");
+  });
+  expect(serializeEditorDoc(editor.state.doc).value).toBe(`${value}_`);
+  expect(textWithMark(editor, "italic")).toEqual([]);
+  expect(textWithMark(editor, "code")).toEqual(code);
+});
+
+it("still italicizes text when typing a closing asterisk", async () => {
+  const editor = await mountEditor("clean *build");
+  await act(async () => {
+    editor.commands.focus("end");
+    const { from, to } = editor.state.selection;
+    typeText(editor, from, to, "*");
+  });
+  expect(serializeEditorDoc(editor.state.doc).value).toBe("clean *build*");
+  expect(textWithMark(editor, "italic")).toEqual(["build"]);
+});
+
 it.each([false, true])(
   "composes an umlaut without wrapping the preedit text (rich text: %s)",
   async (richTextEnabled) => {
diff --git a/apps/web/src/components/ComposerPromptEditorTiptap.tsx b/apps/web/src/components/ComposerPromptEditorTiptap.tsx
index 341852377ee72..0d25b930cd597 100644
--- a/apps/web/src/components/ComposerPromptEditorTiptap.tsx
+++ b/apps/web/src/components/ComposerPromptEditorTiptap.tsx
@@ -68,6 +68,7 @@ import {
   caretTakesMarksBefore,
   convertBulletItemToTask,
   ComposerCodeExtension,
+  ComposerItalicExtension,
   ComposerTaskItemExtension,
   ComposerTaskListExtension,
   flatToMarkdown,
@@ -843,7 +844,8 @@ function createComposerExtensions(richText: boolean) {
       code: false,
       listKeymap: false,
       undoRedo: { newGroupDelay: COMPOSER_UNDO_GROUP_DELAY },
-      ...(richText ? {} : { bold: false, italic: false, strike: false }),
+      italic: false,
+      ...(richText ? {} : { bold: false, strike: false }),
     }),
     ComposerUndoGroupingExtension,
     ComposerMentionExtension,
@@ -853,6 +855,7 @@ function createComposerExtensions(richText: boolean) {
     ComposerMarkersExtension,
     ...(richText
       ? [
+          ComposerItalicExtension,
           ComposerCodeExtension,
           ComposerCodeBlockExtension.extend({
             addNodeView() {
diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsx
index ed05d56deea97..94542eb625a7e 100644
--- a/apps/web/src/components/DiffPanel.tsx
+++ b/apps/web/src/components/DiffPanel.tsx
@@ -188,12 +188,14 @@ interface DiffPanelProps {
   mode?: DiffPanelMode;
   composerDraftTarget: ScopedThreadRef | DraftId;
   workspaceMutationId: string | null;
+  visible: boolean;
 }
 
 export default function DiffPanel({
   mode = "inline",
   composerDraftTarget,
   workspaceMutationId,
+  visible,
 }: DiffPanelProps) {
   const { resolvedTheme } = useTheme();
   const settings = useClientSettings((settings) => ({
@@ -466,6 +468,38 @@ export default function DiffPanel({
     preview: renderablePatch,
   });
   const refreshBranchDiffPreview = refreshPreviewQuery;
+  const previewOpenHandledRef = useRef(false);
+  const refreshDiffForWorkspaceMutation = useStableCallback(() => {
+    previewOpenHandledRef.current = true;
+    refreshBranchDiffPreview();
+  });
+
+  // A mutation refresh also satisfies revalidation for the current opening.
+  useWorkspaceMutationRefresh({
+    enabled: canRefreshGitDiff,
+    mutationId: workspaceMutationId,
+    refresh: refreshDiffForWorkspaceMutation,
+    resourceKey: `diff:${activeThreadRefreshKey ?? ""}`,
+  });
+
+  useEffect(() => {
+    if (!visible || !canReadFiles || !canRefreshGitDiff) {
+      previewOpenHandledRef.current = false;
+      return;
+    }
+    if (previewOpenHandledRef.current) return;
+    previewOpenHandledRef.current = true;
+    if (branchDiffPreview.data !== null && !branchDiffPreview.isPending) {
+      refreshBranchDiffPreview();
+    }
+  }, [
+    branchDiffPreview.data,
+    branchDiffPreview.isPending,
+    canReadFiles,
+    canRefreshGitDiff,
+    refreshBranchDiffPreview,
+    visible,
+  ]);
 
   useEffect(() => {
     if (!canRefreshGitDiff) return;
@@ -474,13 +508,6 @@ export default function DiffPanel({
     return () => window.removeEventListener("focus", refreshOnFocus);
   }, [canRefreshGitDiff, refreshBranchDiffPreview]);
 
-  useWorkspaceMutationRefresh({
-    enabled: canRefreshGitDiff,
-    mutationId: workspaceMutationId,
-    refresh: refreshBranchDiffPreview,
-    resourceKey: `diff:${activeThreadRefreshKey ?? ""}`,
-  });
-
   const isRefreshingDiff = branchDiffPreview.isPending || areFilePatchesPending;
   const renderableFileEntries = renderableFiles.map(getCachedFileEntry);
   const diffFileKeys = renderableFileEntries.map((file) => file.fileKey);
diff --git a/apps/web/src/components/LegacySidebar.tsx b/apps/web/src/components/LegacySidebar.tsx
index 30cbea2378a18..70c7d7b0c1f8c 100644
--- a/apps/web/src/components/LegacySidebar.tsx
+++ b/apps/web/src/components/LegacySidebar.tsx
@@ -185,6 +185,7 @@ import {
   archiveSelectedThreadEntries,
   buildMultiSelectThreadContextMenuItems,
   deleteSelectedThreadEntries,
+  filterSidebarV2VisibleThreads,
   getSidebarThreadIdsToPrewarm,
   resolveAdjacentThreadId,
   isContextMenuPointerDown,
@@ -203,7 +204,6 @@ import {
 import { sortThreads } from "../lib/threadSort";
 import { SidebarChromeFooter, SidebarChromeHeader } from "./sidebar/SidebarChrome";
 import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
-import { useIsMobile } from "~/hooks/useMediaQuery";
 import { CommandDialogTrigger } from "./ui/command";
 import { useClientSettings, updateClientSettings } from "~/hooks/useSettings";
 import { primaryServerKeybindingsAtom } from "../state/server";
@@ -419,7 +419,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThreadRowP
     environmentId: thread.environmentId,
     threadId: thread.id,
   });
-  const isMobile = useIsMobile();
+  const { isMobile } = useSidebar();
   const discoveredPorts = useThreadDiscoveredPorts({
     environmentId: thread.environmentId,
     threadId: thread.id,
@@ -1157,7 +1157,7 @@ function useProjectThreads(project: SidebarProjectSnapshot) {
     ]),
   );
   const visibleProjectThreads = sortThreads(
-    sidebarThreads.filter((thread) => thread.archivedAt === null),
+    filterSidebarV2VisibleThreads(sidebarThreads, null),
     threadSortOrder,
   );
   const projectStatus = resolveProjectStatusIndicator(
@@ -3103,18 +3103,16 @@ function useSortedLegacySidebarProjects(input: {
     ...project,
     id: project.projectKey,
   }));
-  const sortableThreads = sidebarThreads
-    .filter((thread) => thread.archivedAt === null)
-    .map((thread) => {
-      const physicalKey =
-        projectPhysicalKeyByScopedRef.get(
-          scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)),
-        ) ?? scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId));
-      return {
-        ...thread,
-        projectId: (physicalToLogicalKey.get(physicalKey) ?? physicalKey) as ProjectId,
-      };
-    });
+  const sortableThreads = filterSidebarV2VisibleThreads(sidebarThreads, null).map((thread) => {
+    const physicalKey =
+      projectPhysicalKeyByScopedRef.get(
+        scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)),
+      ) ?? scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId));
+    return {
+      ...thread,
+      projectId: (physicalToLogicalKey.get(physicalKey) ?? physicalKey) as ProjectId,
+    };
+  });
   const sortedProjects = sortProjectsForSidebar(
     sortableProjects,
     sortableThreads,
@@ -3178,9 +3176,7 @@ function useLegacySidebarThreads(input: {
   }
   const visibleSidebarThreadKeys = sortedProjects.flatMap((project) => {
     const projectThreads = sortThreads(
-      (threadsByProjectKey.get(project.projectKey) ?? []).filter(
-        (thread) => thread.archivedAt === null,
-      ),
+      filterSidebarV2VisibleThreads(threadsByProjectKey.get(project.projectKey) ?? [], null),
       sidebarThreadSortOrder,
     );
     const projectExpanded = resolveProjectExpanded(
diff --git a/apps/web/src/components/RightPanelTabs.keyboard.browser.test.tsx b/apps/web/src/components/RightPanelTabs.keyboard.browser.test.tsx
index adbe0d586b231..c036977acba36 100644
--- a/apps/web/src/components/RightPanelTabs.keyboard.browser.test.tsx
+++ b/apps/web/src/components/RightPanelTabs.keyboard.browser.test.tsx
@@ -218,6 +218,7 @@ describe("right panel new-tab shortcut", () => {
     expect((await press("t", { metaKey: true, isComposing: true })).defaultPrevented).toBe(false);
     const dialog = document.createElement("div");
     dialog.dataset.slot = "dialog-popup";
+    dialog.dataset.open = "";
     container.append(dialog);
     for (const state of ["data-open", "data-ending-style"]) {
       dialog.setAttribute(state, "");
@@ -229,6 +230,35 @@ describe("right panel new-tab shortcut", () => {
     }
   });
 
+  it("blocks panel shortcuts until a mounted popup finishes closing", async () => {
+    await renderPanel();
+    const popover = document.createElement("div");
+    popover.dataset.slot = "popover-popup";
+    popover.dataset.open = "";
+    container.append(popover);
+
+    expect((await press("t", { metaKey: true })).defaultPrevented).toBe(false);
+    expect((await press("f")).defaultPrevented).toBe(false);
+    expect(document.querySelector('[role="menu"]')).toBeNull();
+    expect(addFiles).not.toHaveBeenCalled();
+
+    delete popover.dataset.open;
+    popover.dataset.closed = "";
+    popover.dataset.endingStyle = "";
+    expect((await press("t", { metaKey: true })).defaultPrevented).toBe(false);
+    expect((await press("f")).defaultPrevented).toBe(false);
+    expect(document.querySelector('[role="menu"]')).toBeNull();
+    expect(addFiles).not.toHaveBeenCalled();
+
+    delete popover.dataset.endingStyle;
+    popover.hidden = true;
+    expect((await press("f")).defaultPrevented).toBe(true);
+    expect(addFiles).toHaveBeenCalledOnce();
+    expect((await press("t", { metaKey: true })).defaultPrevented).toBe(true);
+    expect(document.querySelector('[role="menu"]')?.textContent).toContain("Files");
+    expect(document.activeElement?.closest('[role="menu"]')).not.toBeNull();
+  });
+
   it("supports arrow keys with an existing tab in sheet mode and clears the menu on close", async () => {
     const panel = {
       mode: "sheet" as const,
@@ -249,3 +279,34 @@ describe("right panel new-tab shortcut", () => {
     expect(document.querySelector('[role="menu"]:not([data-closed])')).toBeNull();
   });
 });
+
+describe("right panel tab middle click", () => {
+  it("cancels middle-button defaults and closes once while preserving other buttons", async () => {
+    const onActivate = vi.fn();
+    const onCloseSurface = vi.fn();
+    const files = { id: "files" as const, kind: "files" as const };
+    await renderPanel({ surfaces: [files], activeSurfaceId: files.id, onActivate, onCloseSurface });
+    const tabLabel = container.querySelector("[data-active-tab] span.truncate")!;
+    const mouse = async (type: string, button: number) => {
+      const event = new MouseEvent(type, { button, bubbles: true, cancelable: true });
+      await act(() => tabLabel.dispatchEvent(event));
+      return event;
+    };
+
+    expect((await mouse("mousedown", 0)).defaultPrevented).toBe(false);
+    expect((await mouse("mouseup", 0)).defaultPrevented).toBe(false);
+    expect((await mouse("click", 0)).defaultPrevented).toBe(false);
+    expect(onActivate).toHaveBeenCalledExactlyOnceWith(files);
+    expect((await mouse("mousedown", 2)).defaultPrevented).toBe(false);
+    expect((await mouse("mouseup", 2)).defaultPrevented).toBe(false);
+    expect((await mouse("auxclick", 2)).defaultPrevented).toBe(false);
+    expect(onCloseSurface).not.toHaveBeenCalled();
+
+    expect((await mouse("mousedown", 1)).defaultPrevented).toBe(true);
+    expect((await mouse("mouseup", 1)).defaultPrevented).toBe(true);
+    expect(onCloseSurface).not.toHaveBeenCalled();
+    expect((await mouse("auxclick", 1)).defaultPrevented).toBe(true);
+    expect(onCloseSurface).toHaveBeenCalledExactlyOnceWith(files);
+    expect(onActivate).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx
index 5a705cbc6fcf5..d105ed1972b64 100644
--- a/apps/web/src/components/RightPanelTabs.tsx
+++ b/apps/web/src/components/RightPanelTabs.tsx
@@ -802,7 +802,8 @@ interface RightPanelTabHandlers {
   onFinishRename: (surfaceId: string, title: string) => void;
 }
 
-function handleTabMouseDown(event: ReactMouseEvent) {
+// Chromium on Linux only suppresses primary-selection paste when mouseup is cancelled.
+function preventTabMiddleButtonDefault(event: ReactMouseEvent) {
   if (event.button !== 1) return;
   event.preventDefault();
 }
@@ -938,7 +939,8 @@ function RightPanelTab(
   return (
     <div
       data-active-tab={props.active}
-      onMouseDown={handleTabMouseDown}
+      onMouseDown={preventTabMiddleButtonDefault}
+      onMouseUp={preventTabMiddleButtonDefault}
       onAuxClick={(event) => onAuxClick(event, surface)}
       onContextMenu={(event) => onContextMenu(event, surface)}
       {...listeners}
diff --git a/apps/web/src/components/ThreadStatusIndicators.subscriptions.browser.test.tsx b/apps/web/src/components/ThreadStatusIndicators.subscriptions.browser.test.tsx
index 9d5a2c1229348..09d3c38231051 100644
--- a/apps/web/src/components/ThreadStatusIndicators.subscriptions.browser.test.tsx
+++ b/apps/web/src/components/ThreadStatusIndicators.subscriptions.browser.test.tsx
@@ -1,7 +1,16 @@
-import { ProjectId, ThreadId, type VcsStatusResult } from "@t3tools/contracts";
-import { act } from "react";
+import {
+  ProjectId,
+  ThreadId,
+  type ThreadPullRequestLink,
+  type VcsStatusResult,
+} from "@t3tools/contracts";
+import { act, type MouseEvent } from "react";
 import { createRoot } from "react-dom/client";
 import { afterEach, expect, it, vi } from "vite-plus/test";
+import { page, userEvent } from "vite-plus/test/browser";
+
+import "../index.css";
+import { Button } from "./ui/button";
 
 import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
 import { makeThreadFixture } from "../test-fixtures";
@@ -75,7 +84,7 @@ vi.mock(import("../state/pullRequests"), async (importOriginal) => {
       summaries(input.number)) as never,
   };
 });
-import { ThreadRowLeadingStatus } from "./ThreadStatusIndicators";
+import { ThreadPullRequestBadgeControl, ThreadRowLeadingStatus } from "./ThreadStatusIndicators";
 
 afterEach(() => {
   vi.unstubAllGlobals();
@@ -174,3 +183,66 @@ it("leases only visible palette results while retaining observed and cached PR b
     container.remove();
   }
 });
+
+it("keeps a long PR hover list in the viewport and lets the last row be selected", async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  const previousViewport = { width: window.innerWidth, height: window.innerHeight };
+  await page.viewport(800, 480);
+  const pullRequests = Array.from({ length: 40 }, (_, index): ThreadPullRequestLink => ({
+    host: "github.com",
+    repository: "example/repo",
+    number: index + 1,
+    url: `https://github.com/example/repo/pull/${index + 1}`,
+    source: "manual",
+    linkedAt: "2026-01-01T00:00:00Z",
+    snapshot: null,
+    stack: null,
+  }));
+  const onOpenPullRequest = vi.fn((event: MouseEvent<HTMLElement>) => event.preventDefault());
+  const container = document.createElement("div");
+  document.body.append(container);
+  const root = createRoot(container);
+  try {
+    await act(async () =>
+      root.render(
+        <div style={{ position: "fixed", top: 220, left: 300 }}>
+          <ThreadPullRequestBadgeControl
+            render={<Button size="xs" />}
+            badge={{ kind: "pull-request", others: 39, state: "open" }}
+            pullRequests={pullRequests}
+            number={1}
+            url={pullRequests[0]!.url}
+            status={null}
+            onOpenList={() => {}}
+            onOpenPullRequest={onOpenPullRequest}
+          />
+        </div>,
+      ),
+    );
+    await act(() => userEvent.hover(container.querySelector("button")!));
+    const popup = () => document.querySelector<HTMLElement>('[data-slot="tooltip-popup"]')!;
+    await expect.poll(() => popup()?.querySelectorAll("a").length).toBe(40);
+    await expect.poll(() => popup().getBoundingClientRect().top).toBeGreaterThanOrEqual(0);
+    await expect
+      .poll(() => popup().getBoundingClientRect().bottom)
+      .toBeLessThanOrEqual(window.innerHeight);
+
+    const lastRow = popup().querySelector<HTMLAnchorElement>("li:last-child a")!;
+    expect(lastRow.getBoundingClientRect().top).toBeGreaterThan(
+      popup().getBoundingClientRect().bottom,
+    );
+    await act(() => userEvent.wheel(popup(), { delta: { y: 10_000 } }));
+    await expect
+      .poll(() => lastRow.getBoundingClientRect().bottom)
+      .toBeLessThanOrEqual(popup().getBoundingClientRect().bottom);
+    expect(lastRow.getBoundingClientRect().top).toBeGreaterThanOrEqual(
+      popup().getBoundingClientRect().top,
+    );
+    await act(() => userEvent.click(lastRow));
+    expect(onOpenPullRequest).toHaveBeenCalledExactlyOnceWith(expect.anything(), lastRow.href);
+  } finally {
+    await act(async () => root.unmount());
+    container.remove();
+    await page.viewport(previousViewport.width, previousViewport.height);
+  }
+});
diff --git a/apps/web/src/components/ThreadStatusIndicators.tsx b/apps/web/src/components/ThreadStatusIndicators.tsx
index 6ec5aec1ec10a..6688e06d1ab23 100644
--- a/apps/web/src/components/ThreadStatusIndicators.tsx
+++ b/apps/web/src/components/ThreadStatusIndicators.tsx
@@ -298,7 +298,7 @@ function PullRequestBadge({
         variant="glass"
         className="pointer-events-auto w-80 max-w-[calc(100vw-2rem)] text-left whitespace-normal"
       >
-        <div className="-mx-1">
+        <div className="-mx-1 max-h-[calc(var(--available-height)-0.5rem-2px)] overflow-y-auto overscroll-contain">
           {visibleThreadPullRequests(pullRequests).length > 0 ? (
             <ThreadPullRequestsMiniList
               pullRequests={pullRequests}
@@ -398,7 +398,7 @@ function ThreadPullRequestMiniListItem({
           href={url}
           target="_blank"
           rel="noopener noreferrer"
-          className="flex min-w-0 items-center gap-2 rounded-sm px-1 py-1 hover:bg-accent focus-visible:bg-accent focus-visible:outline-2 focus-visible:outline-ring"
+          className="flex min-w-0 items-center gap-2 rounded-sm px-1 py-1 hover:bg-accent focus-visible:bg-accent focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-ring"
           onPointerDown={(event) => event.stopPropagation()}
           onClick={(event) => onOpenPullRequest(event, url)}
         >
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index f87ddab1371ff..b613b8c9a5bc1 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -3178,6 +3178,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const importContextRecords = (
     records: ReadonlyArray<ComposerContextRecord>,
     sourceEnvironmentId: EnvironmentId | null,
+    threadDraftTarget = attachmentDraftTarget,
   ): ReadonlyMap<string, string> => {
     const rewritten = new Map<string, string>();
     const dependentAttachmentLocalIds = new Map<string, string>();
@@ -3232,7 +3233,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
                 : existing
                   ? (uploadedContextRecordFromDraft(existing) ?? undefined)
                   : undefined;
-      if (existingRecord && isSameComposerContextPayload(existingRecord, record)) {
+      if (
+        existingRecord &&
+        isSameComposerContextPayload(existingRecord, record) &&
+        (record.kind !== "thread" || threadDraftTarget === attachmentDraftTarget)
+      ) {
         if (record.kind === "preview-annotation" && record.screenshotContextId) {
           skippedDependentAttachmentIds.add(record.screenshotContextId);
         }
@@ -3279,7 +3284,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
         case "thread": {
           // The agent can only read threads on its own server; a pasted foreign one is dropped.
           if (record.environmentId !== environmentId) break;
-          addComposerDraftThreadContexts(attachmentDraftTarget, [record], {
+          addComposerDraftThreadContexts(threadDraftTarget, [record], {
             appendReference: false,
           });
           rewritten.set(record.contextId, record.contextId);
@@ -4344,7 +4349,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     }
 
     const rewrittenContextIds = entry.records
-      ? importContextRecords(entry.records, null)
+      ? importContextRecords(entry.records, null, composerDraftTarget)
       : new Map<string, string>();
     const restoredPrompt = replaceComposerContextReferences(entry.prompt, (reference) => {
       const contextId = rewrittenContextIds.get(reference.contextId);
@@ -4597,6 +4602,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     const images = [...composerImagesRef.current];
     const files = [...composerFilesRef.current];
     const stashedRecords: ComposerContextRecord[] = [
+      ...composerThreadContexts,
       ...composerTerminalContextsRef.current.map(terminalContextRecord),
       ...composerReviewComments.map(reviewCommentContextRecord),
       ...composerPreviewAnnotations.map((annotation) =>
@@ -4702,6 +4708,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       promptRef.current = "";
       clearComposerDraftPromptAndImages(stashTarget);
       clearComposerDraftTerminalContexts(stashTarget);
+      setComposerDraftThreadContexts(stashTarget, []);
       for (const comment of composerReviewComments) {
         removeComposerDraftReviewComment(stashTarget, comment.id);
       }
diff --git a/apps/web/src/components/chat/ChatOverlayHosts.tsx b/apps/web/src/components/chat/ChatOverlayHosts.tsx
index 94dad6e78f9df..f2ff3b83a9c4c 100644
--- a/apps/web/src/components/chat/ChatOverlayHosts.tsx
+++ b/apps/web/src/components/chat/ChatOverlayHosts.tsx
@@ -213,11 +213,12 @@ export function RevertConfirmHost(props: {
           <AlertDialogTitle>Edit from here?</AlertDialogTitle>
           <AlertDialogDescription>
             Rewind chat to before this message. Your prompt and attachments return to the composer.
+            “Revert files too” also undoes your own edits.
           </AlertDialogDescription>
         </AlertDialogHeader>
         <AlertDialogFooter>
           <AlertDialogClose render={<Button variant="outline" />}>Cancel</AlertDialogClose>
-          <Button variant="destructive" onClick={() => confirm(true)}>
+          <Button variant="destructive-outline" onClick={() => confirm(true)}>
             Revert files too
           </Button>
           <Button onClick={() => confirm(false)}>Revert and keep changes</Button>
diff --git a/apps/web/src/components/chat/ComposerBannerStack.browser.test.tsx b/apps/web/src/components/chat/ComposerBannerStack.browser.test.tsx
index 9e03a177ad3c9..ecb56eab5debd 100644
--- a/apps/web/src/components/chat/ComposerBannerStack.browser.test.tsx
+++ b/apps/web/src/components/chat/ComposerBannerStack.browser.test.tsx
@@ -109,3 +109,35 @@ it("keeps only the usage limit attached while an active goal waits in the collap
   await expect.element(limit).toBeVisible();
   expect(visibleBanners()).toHaveLength(1);
 });
+
+it("reveals the full running command only while its title is clipped", async () => {
+  const command =
+    "Running: /usr/bin/zsh -lc 'sleep 600 > /tmp/t3-background-command-with-a-long-log-filename-for-truncation.log 2>&1'";
+  container.style.width = "240px";
+  await act(async () =>
+    root.render(
+      <ComposerBannerStack
+        items={[
+          {
+            id: "background-work",
+            variant: "default",
+            priority: "activity",
+            icon: null,
+            title: command,
+          },
+        ]}
+      />,
+    ),
+  );
+
+  const details = page.getByRole("button", { name: "Show title details", exact: true });
+  await expect.element(details).toBeVisible();
+  await userEvent.hover(details);
+  const popup = page.getByRole("dialog", { name: "Notice details", exact: true });
+  await expect.element(popup).toBeVisible();
+  await expect.element(popup).toHaveTextContent(command);
+
+  container.style.width = "4000px";
+  await expect.element(details).not.toBeInTheDocument();
+  await expect.element(popup).not.toBeInTheDocument();
+});
diff --git a/apps/web/src/components/chat/ComposerBannerStack.tsx b/apps/web/src/components/chat/ComposerBannerStack.tsx
index dd9d7c570db37..fc309c5352a67 100644
--- a/apps/web/src/components/chat/ComposerBannerStack.tsx
+++ b/apps/web/src/components/chat/ComposerBannerStack.tsx
@@ -121,6 +121,7 @@ export function ComposerBannerStack({ className, items, attachedAbove }: Compose
       {hasStack ? (
         <div
           ref={noticesRef}
+          data-composer-banner-stack="true"
           data-chat-composer-collapsed-controls="true"
           className={cn("relative z-20 min-h-3", stackExpanded && "z-50")}
           onPointerEnter={(event) => {
@@ -249,30 +250,38 @@ export function ComposerBannerStack({ className, items, attachedAbove }: Compose
   );
 }
 
-function NoticeDescription({ children }: { children: ReactNode }) {
-  const descriptionRef = useRef<HTMLSpanElement>(null);
+function NoticeText({
+  children,
+  className,
+  detailsLabel,
+}: {
+  readonly children: ReactNode;
+  readonly className: string;
+  readonly detailsLabel: string;
+}) {
+  const textRef = useRef<HTMLSpanElement>(null);
   const detailsRef = useRef<HTMLButtonElement>(null);
   const [showDetails, setShowDetails] = useState(false);
 
   useLayoutEffect(() => {
-    const description = descriptionRef.current;
-    if (!description) return;
+    const text = textRef.current;
+    if (!text) return;
     const measure = () => {
       // Ignore the space taken by the details button itself so it cannot
-      // sustain its own overflow after the description would otherwise fit.
+      // sustain its own overflow after the text would otherwise fit.
       const recoveredWidth = detailsRef.current ? detailsRef.current.offsetWidth + 4 : 0;
-      const hidden = getComputedStyle(description).position === "absolute";
+      const hidden = getComputedStyle(text).position === "absolute";
       setShowDetails(
         hidden ||
-          [description, ...description.querySelectorAll("*")].some(
+          [text, ...text.querySelectorAll("*")].some(
             (element) => element.scrollWidth > element.clientWidth + recoveredWidth,
           ),
       );
     };
     measure();
-    const stopObserving = observeResize(description, measure);
+    const stopObserving = observeResize(text, measure);
     const mutations = new MutationObserver(measure);
-    mutations.observe(description, { childList: true, subtree: true, characterData: true });
+    mutations.observe(text, { childList: true, subtree: true, characterData: true });
     return () => {
       stopObserving();
       mutations.disconnect();
@@ -281,10 +290,7 @@ function NoticeDescription({ children }: { children: ReactNode }) {
 
   return (
     <span className="contents">
-      <span
-        ref={descriptionRef}
-        className="w-0 min-w-0 grow truncate text-muted-foreground @max-[400px]:sr-only"
-      >
+      <span ref={textRef} className={className}>
         {children}
       </span>
       {showDetails ? (
@@ -296,7 +302,7 @@ function NoticeDescription({ children }: { children: ReactNode }) {
                 ref={detailsRef}
                 size="icon-xs"
                 variant="ghost-muted"
-                aria-label="Show notice details"
+                aria-label={detailsLabel}
                 className="flex-none"
               />
             }
@@ -353,8 +359,20 @@ function ComposerBannerStackAlert({
           {item.icon}
         </ComposerBanner.Icon>
         <ComposerBanner.Content className="whitespace-nowrap">
-          <span className="min-w-0 truncate font-medium leading-7 sm:leading-6">{item.title}</span>
-          {item.description ? <NoticeDescription>{item.description}</NoticeDescription> : null}
+          <NoticeText
+            detailsLabel="Show title details"
+            className="min-w-0 truncate font-medium leading-7 sm:leading-6"
+          >
+            {item.title}
+          </NoticeText>
+          {item.description ? (
+            <NoticeText
+              detailsLabel="Show notice details"
+              className="w-0 min-w-0 grow truncate text-muted-foreground @max-[400px]:sr-only"
+            >
+              {item.description}
+            </NoticeText>
+          ) : null}
         </ComposerBanner.Content>
         {item.actions || item.onDismiss ? (
           <ComposerBanner.Actions>
diff --git a/apps/web/src/components/chat/ComposerPendingUserInputPanel.navigation.browser.test.tsx b/apps/web/src/components/chat/ComposerPendingUserInputPanel.navigation.browser.test.tsx
index b0d14d5047266..1dc2a99a41c97 100644
--- a/apps/web/src/components/chat/ComposerPendingUserInputPanel.navigation.browser.test.tsx
+++ b/apps/web/src/components/chat/ComposerPendingUserInputPanel.navigation.browser.test.tsx
@@ -11,9 +11,11 @@ import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
 
 import {
+  setPendingUserInputCustomAnswer,
   togglePendingUserInputOptionSelection,
   type PendingUserInputDraftAnswer,
 } from "../../pendingUserInput";
+import type { PendingUserInput } from "../../session-logic";
 
 vi.mock(import("../ChatMarkdown"), async (importOriginal) => ({
   ...(await importOriginal()),
@@ -40,17 +42,48 @@ const prompt = {
   })),
 };
 
-function Questions({ initialIndex = 0 }: { initialIndex?: number }) {
+const previewPrompt = {
+  ...prompt,
+  questions: prompt.questions.map((question, index) => ({
+    ...question,
+    options: ["First", "Second"].map((label) => ({
+      label,
+      value: index === 1 ? label : "same-answer",
+      description: "",
+      preview: `Preview body: ${label}, question ${index + 1}`,
+    })),
+  })),
+};
+
+function Questions({
+  initialIndex = 0,
+  pendingPrompt = prompt,
+}: {
+  initialIndex?: number;
+  pendingPrompt?: PendingUserInput;
+}) {
   const [questionIndex, setQuestionIndex] = useState(initialIndex);
   const [answers, setAnswers] = useState<Record<string, PendingUserInputDraftAnswer>>({});
+  const question = pendingPrompt.questions[questionIndex]!;
   const advance = () => setQuestionIndex(questionIndex + 1);
   return (
     <>
       <output>{questionIndex}</output>
       <button onClick={advance}>Next</button>
       <button onClick={() => setQuestionIndex(questionIndex - 1)}>Previous</button>
+      <input
+        aria-label="Custom answer"
+        value={answers[question.id]?.customAnswer ?? ""}
+        onChange={(event) => {
+          const value = event.currentTarget.value;
+          setAnswers((existing) => ({
+            ...existing,
+            [question.id]: setPendingUserInputCustomAnswer(existing[question.id], value, question),
+          }));
+        }}
+      />
       <ComposerPendingUserInputPanel
-        pendingUserInputs={[prompt]}
+        pendingUserInputs={[pendingPrompt]}
         cwd="/repo"
         threadRef={threadRef}
         disabled={false}
@@ -59,7 +92,7 @@ function Questions({ initialIndex = 0 }: { initialIndex?: number }) {
         questionIndex={questionIndex}
         onAdvance={advance}
         onToggleOption={(questionId, value) => {
-          const question = prompt.questions.find((entry) => entry.id === questionId)!;
+          const question = pendingPrompt.questions.find((entry) => entry.id === questionId)!;
           setAnswers((existing) => ({
             ...existing,
             [questionId]: togglePendingUserInputOptionSelection(
@@ -292,3 +325,94 @@ it("isolates drafts by environment, thread and request and discards only resolve
     );
   }
 });
+
+function expectPreview(text: string | null) {
+  const previews = [...container.querySelectorAll("p")]
+    .map((element) => element.textContent)
+    .filter((content) => content?.startsWith("Preview body:"));
+  expect(previews).toEqual(text === null ? [] : [`Preview body: ${text}`]);
+}
+
+async function typeCustomAnswer(value: string) {
+  const input = container.querySelector("input")!;
+  await act(async () => {
+    input.focus();
+    Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")!.set!.call(input, value);
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+  });
+}
+
+it("previews options by focus, click, and shortcut index but only restores unambiguous saved selections", async () => {
+  await act(async () => root.render(<Questions pendingPrompt={previewPrompt} />));
+  expectPreview("First, question 1");
+
+  await act(async () => buttonWithText("Second").focus());
+  expectPreview("Second, question 1");
+  await act(async () => buttonWithText("First").focus());
+  expectPreview("First, question 1");
+
+  await act(async () => buttonWithText("Second").click());
+  expectPreview("Second, question 1");
+  await act(async () => document.dispatchEvent(new KeyboardEvent("keydown", { key: "1" })));
+  expectPreview("First, question 1");
+  await act(async () => document.dispatchEvent(new KeyboardEvent("keydown", { key: "2" })));
+  expectPreview("Second, question 1");
+
+  await act(async () => vi.advanceTimersByTime(200));
+  expect(activeIndex()).toBe("1");
+  expectPreview("First, question 2");
+
+  await act(async () => buttonWithText("Second").focus());
+  expectPreview("Second, question 2");
+  await act(async () =>
+    root.render(
+      <Questions
+        pendingPrompt={{ ...previewPrompt, requestId: RuntimeRequestId.make("replacement") }}
+      />,
+    ),
+  );
+  expectPreview("First, question 2");
+
+  await act(async () => buttonWithText("Second").click());
+  expectPreview("Second, question 2");
+  await navigate("Next");
+  expectPreview("First, question 3");
+  await navigate("Previous");
+  expectPreview("Second, question 2");
+
+  await navigate("Previous");
+  expectPreview(null);
+  await act(async () =>
+    root.render(
+      <Questions
+        pendingPrompt={{ ...previewPrompt, requestId: RuntimeRequestId.make("remounted") }}
+      />,
+    ),
+  );
+  expectPreview(null);
+  await act(async () => buttonWithText("Second").click());
+  expectPreview("Second, question 1");
+});
+
+it("hides and clears hovered or focused previews while a custom answer is active", async () => {
+  await act(async () => root.render(<Questions pendingPrompt={previewPrompt} />));
+  await act(async () =>
+    buttonWithText("Second").dispatchEvent(new MouseEvent("mouseover", { bubbles: true })),
+  );
+  expectPreview("Second, question 1");
+
+  await typeCustomAnswer("Use a different approach");
+  expectPreview(null);
+  await typeCustomAnswer("");
+  expectPreview("First, question 1");
+
+  await typeCustomAnswer("Use a different approach");
+  await act(async () => buttonWithText("Second").focus());
+  expectPreview(null);
+  await act(async () =>
+    buttonWithText("Second").dispatchEvent(new MouseEvent("mouseover", { bubbles: true })),
+  );
+  expectPreview(null);
+  await typeCustomAnswer("");
+  expectPreview("First, question 1");
+});
diff --git a/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx b/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
index bfcfa49050612..f35e1c5b0c2c7 100644
--- a/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
+++ b/apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx
@@ -91,6 +91,10 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
     questionId: string;
     optionValue: string;
   } | null>(null);
+  const [focusedOption, setFocusedOption] = useState<{
+    questionId: string;
+    optionIndex: number;
+  } | null>(null);
   const [collapsedQuestionId, setCollapsedQuestionId] = useState<string | null>(null);
   // The active question keys the shortcut listener, so it must keep its identity across renders.
   const progress = derivePendingUserInputProgress(prompt.questions, answers, questionIndex);
@@ -102,6 +106,23 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
       !customAnswerActive && progress.selectedOptionValues.includes(option.value ?? option.label),
   );
   const isCollapsed = collapsedQuestionId !== null && collapsedQuestionId === activeQuestion?.id;
+  const selectedOptionValue = progress.selectedOptionValues.at(-1);
+  const savedOptionMatches = activeQuestion?.options.filter(
+    (option) => (option.value ?? option.label) === selectedOptionValue,
+  );
+  const previewOption = customAnswerActive
+    ? undefined
+    : focusedOption && focusedOption.questionId === activeQuestion?.id
+      ? activeQuestion?.options[focusedOption.optionIndex]
+      : selectedOptionValue === undefined
+        ? activeQuestion?.options[0]
+        : savedOptionMatches?.length === 1
+          ? savedOptionMatches[0]
+          : undefined;
+
+  if (focusedOption && (focusedOption.questionId !== activeQuestion?.id || customAnswerActive)) {
+    setFocusedOption(null);
+  }
 
   // The optimistic pick is dropped once the draft confirms it or the question moves on.
   if (
@@ -127,8 +148,9 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
     return clearAutoAdvance;
   }, [activeQuestion?.id, disabled]);
 
-  const handleOptionSelection = (questionId: string, optionValue: string) => {
+  const handleOptionSelection = (questionId: string, optionValue: string, optionIndex: number) => {
     if (disabled || isResponding) return;
+    setFocusedOption({ questionId, optionIndex });
     if (activeQuestion?.multiSelect) {
       onToggleOption(questionId, optionValue);
       return;
@@ -167,7 +189,7 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
       const option = activeQuestion.options[optionIndex];
       if (!option) return;
       event.preventDefault();
-      selectOptionFromShortcut(activeQuestion.id, option.value ?? option.label);
+      selectOptionFromShortcut(activeQuestion.id, option.value ?? option.label, optionIndex);
     };
     document.addEventListener("keydown", handler);
     return () => document.removeEventListener("keydown", handler);
@@ -283,11 +305,19 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
                 );
                 return (
                   <button
-                    key={`${activeQuestion.id}:${optionValue}`}
+                    // Options keep their positions within a question and may share answer values.
+                    // oxlint-disable-next-line react/no-array-index-key
+                    key={`${activeQuestion.id}:${index}`}
                     type="button"
                     disabled={disabled || isResponding}
+                    onMouseEnter={() =>
+                      setFocusedOption({ questionId: activeQuestion.id, optionIndex: index })
+                    }
+                    onFocus={() =>
+                      setFocusedOption({ questionId: activeQuestion.id, optionIndex: index })
+                    }
                     onClick={() => {
-                      handleOptionSelection(activeQuestion.id, optionValue);
+                      handleOptionSelection(activeQuestion.id, optionValue, index);
                     }}
                     className={className}
                   >
@@ -296,6 +326,23 @@ const ComposerPendingUserInputCard = memo(function ComposerPendingUserInputCard(
                 );
               })}
             </div>
+            {previewOption?.preview?.trim() ? (
+              <section
+                aria-label={`Preview: ${previewOption.label}`}
+                className="mt-2 min-w-0 rounded-md border border-border/60 bg-muted/25 p-2.5"
+              >
+                <p className="mb-1.5 text-3xs font-medium text-muted-foreground">
+                  Preview · {previewOption.label}
+                </p>
+                <ChatMarkdown
+                  key={`${activeQuestion.id}:${activeQuestion.options.indexOf(previewOption)}`}
+                  text={previewOption.preview}
+                  cwd={cwd}
+                  threadRef={threadRef}
+                  parseRawHtml={false}
+                />
+              </section>
+            ) : null}
           </ComposerBanner.Body>
         </ComposerBanner.Scroll>
       </CollapsiblePanel>
diff --git a/apps/web/src/components/chat/ComposerServerUpdateStatus.tsx b/apps/web/src/components/chat/ComposerServerUpdateStatus.tsx
index 79b86384c6f4e..fa74f196680c5 100644
--- a/apps/web/src/components/chat/ComposerServerUpdateStatus.tsx
+++ b/apps/web/src/components/chat/ComposerServerUpdateStatus.tsx
@@ -1,11 +1,6 @@
 import { Spinner } from "~/components/ui/spinner";
 import type { ServerUpdateState } from "@t3tools/client-runtime/state/server";
 import { CircleAlertIcon, DownloadIcon } from "lucide-react";
-import { useId, useState } from "react";
-
-import { serverUpdateStageLabel } from "../ServerUpdateAction";
-import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
-import { ComposerBanner } from "./ComposerBanner";
 
 export function ComposerServerUpdateIcon({
   status,
@@ -20,45 +15,3 @@ export function ComposerServerUpdateIcon({
   }
   return <DownloadIcon aria-hidden />;
 }
-
-export function ComposerServerUpdateStatus({
-  state,
-  serverLabel = "server",
-}: {
-  readonly state: Exclude<ServerUpdateState, { status: "idle" }>;
-  readonly serverLabel?: string;
-}) {
-  const [detailsOpen, setDetailsOpen] = useState(false);
-  const triggerId = useId();
-  const title = `${state.status === "failed" ? "Could not update" : "Updating"} ${serverLabel}`;
-  const detail = state.status === "failed" ? state.message : serverUpdateStageLabel(state.stage);
-  return (
-    <span
-      role={state.status === "failed" ? "alert" : "status"}
-      className="min-w-0"
-      data-composer-server-update-status={state.status}
-    >
-      <Tooltip open={detailsOpen} onOpenChange={setDetailsOpen} triggerId={triggerId}>
-        <TooltipTrigger
-          id={triggerId}
-          closeOnClick={false}
-          render={
-            <button
-              type="button"
-              aria-label={`${title}: ${detail}`}
-              className="block max-w-full cursor-help truncate rounded-sm text-left outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
-              onClick={() => setDetailsOpen(true)}
-            >
-              {title}
-              <ComposerBanner.Separator />
-              <span className="font-normal text-muted-foreground">{detail}</span>
-            </button>
-          }
-        />
-        <TooltipPopup side="top">
-          {title}: {detail}
-        </TooltipPopup>
-      </Tooltip>
-    </span>
-  );
-}
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 195e6cf061fe4..2105454784721 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -2353,6 +2353,7 @@ function UserTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "message"
                       mimeType={image.mimeType}
                       src={image.previewUrl}
                       alt={image.name}
+                      decoding="async"
                       className="block size-full object-cover"
                     />
                   </button>
diff --git a/apps/web/src/components/chat/OpenInPicker.tsx b/apps/web/src/components/chat/OpenInPicker.tsx
index 050725964af8d..5c6ddc06746f8 100644
--- a/apps/web/src/components/chat/OpenInPicker.tsx
+++ b/apps/web/src/components/chat/OpenInPicker.tsx
@@ -208,6 +208,7 @@ export const OpenInPicker = memo(function OpenInPicker({
   keybindings,
   availableEditors,
   openInCwd,
+  openInCwdIsFile = false,
   presentation = "toolbar",
   compact = false,
   enableShortcut = true,
@@ -218,6 +219,7 @@ export const OpenInPicker = memo(function OpenInPicker({
   keybindings: ResolvedKeybindingsConfig;
   availableEditors: ReadonlyArray<EditorId>;
   openInCwd: string | null;
+  openInCwdIsFile?: boolean;
   presentation?: "toolbar" | "menu";
   compact?: boolean;
   enableShortcut?: boolean;
@@ -251,6 +253,7 @@ export const OpenInPicker = memo(function OpenInPicker({
         editor,
         host: remote.host.host,
         absolutePath: openInCwd,
+        isFile: openInCwdIsFile,
       });
       if (url === undefined) return;
       // Only record hint-seen/preferred when the shell actually accepted
diff --git a/apps/web/src/components/chat/RightPanelSurfaceContent.tsx b/apps/web/src/components/chat/RightPanelSurfaceContent.tsx
index 3fed509f5dd9b..d8f512726de9f 100644
--- a/apps/web/src/components/chat/RightPanelSurfaceContent.tsx
+++ b/apps/web/src/components/chat/RightPanelSurfaceContent.tsx
@@ -111,6 +111,7 @@ export function RightPanelSurfaceContent(props: {
             mode="embedded"
             composerDraftTarget={props.composerDraftTarget}
             workspaceMutationId={props.workspaceMutationId}
+            visible={visible}
           />
         </Suspense>
       );
diff --git a/apps/web/src/components/chat/SubagentTooltipContent.tsx b/apps/web/src/components/chat/SubagentTooltipContent.tsx
index 65b3731673ec4..21057c9af4755 100644
--- a/apps/web/src/components/chat/SubagentTooltipContent.tsx
+++ b/apps/web/src/components/chat/SubagentTooltipContent.tsx
@@ -11,6 +11,7 @@ import {
   resolveSubagentMetadata,
   subagentDetailPreview,
 } from "@t3tools/client-runtime/state/subagent-display";
+import { REASONING_EFFORT_OPTION_IDS } from "@t3tools/client-runtime/state/thread-execution";
 import { getModelSelectionStringOptionValue, resolveSelectableModel } from "@t3tools/shared/model";
 import { getTraitsSpeedDisplay, TraitsSpeedIcon } from "./TraitsSpeed";
 import type { ReactNode } from "react";
@@ -72,9 +73,9 @@ export function SubagentTooltipContent(props: {
     childModel === (modelSlug ?? model) && childSelection?.instanceId === props.providerInstanceId
       ? childSelection
       : undefined;
-  const effort = ["reasoningEffort", "effort", "reasoning", "variant"]
-    .map((id) => getModelSelectionStringOptionValue(matchingSelection, id))
-    .find(Boolean);
+  const effort = REASONING_EFFORT_OPTION_IDS.map((id) =>
+    getModelSelectionStringOptionValue(matchingSelection, id),
+  ).find(Boolean);
   const speed = provider
     ? providerModel?.capabilities?.optionDescriptors
         ?.map((descriptor) => {
diff --git a/apps/web/src/components/chat/ThreadAutomationsPanel.tsx b/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
index 94f6ff5b6635c..28fb297b35265 100644
--- a/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
+++ b/apps/web/src/components/chat/ThreadAutomationsPanel.tsx
@@ -37,6 +37,24 @@ const STATUS_DOT_CLASS: Record<ScheduledTask["lastRunStatus"], string> = {
   failed: "bg-destructive",
 };
 
+function taskScheduleLine(task: ScheduledTask) {
+  return (
+    <>
+      {scheduleLabel(task.schedule)}
+      {task.enabled && task.nextRunAt !== null ? (
+        <>
+          {" · next "}
+          <ScheduledRelativeLabel value={task.nextRunAt} />
+        </>
+      ) : task.enabled ? (
+        ""
+      ) : (
+        " · paused"
+      )}
+    </>
+  );
+}
+
 export function ThreadAutomationsPanel(props: {
   readonly environmentId: EnvironmentId;
   readonly threadId: ThreadId;
@@ -162,24 +180,18 @@ export function ThreadAutomationsPanel(props: {
                 aria-hidden
               />
             </span>
-            <div className="min-w-0 flex-1">
-              <span className="block truncate text-sm font-medium text-foreground/80">
-                {task.title}
-              </span>
-              <p className="truncate text-2xs text-muted-foreground">
-                {scheduleLabel(task.schedule)}
-                {task.enabled && task.nextRunAt !== null ? (
-                  <>
-                    {" · next "}
-                    <ScheduledRelativeLabel value={task.nextRunAt} />
-                  </>
-                ) : task.enabled ? (
-                  ""
-                ) : (
-                  " · paused"
-                )}
-              </p>
-            </div>
+            <Tooltip>
+              <TooltipTrigger render={<div className="min-w-0 flex-1" />}>
+                <span className="block truncate text-sm font-medium text-foreground/80">
+                  {task.title}
+                </span>
+                <p className="truncate text-2xs text-muted-foreground">{taskScheduleLine(task)}</p>
+              </TooltipTrigger>
+              <TooltipPopup side="left">
+                <p className="font-medium">{task.title}</p>
+                <p className="text-muted-foreground">{taskScheduleLine(task)}</p>
+              </TooltipPopup>
+            </Tooltip>
             <Tooltip>
               <TooltipTrigger
                 render={
diff --git a/apps/web/src/components/chat/ThreadDetailsControl.tsx b/apps/web/src/components/chat/ThreadDetailsControl.tsx
index 23c3db6a7d208..37f491dfee0c1 100644
--- a/apps/web/src/components/chat/ThreadDetailsControl.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsControl.tsx
@@ -12,6 +12,8 @@ import {
   THREAD_DETAILS_PANEL_ICON_ACTION_CLASS,
   THREAD_DETAILS_PANEL_META_ACTION_CLASS,
   THREAD_DETAILS_PANEL_CHEVRON_CLASS,
+  THREAD_DETAILS_PANEL_SELECT_LABEL_CLASS,
+  THREAD_DETAILS_PANEL_SELECT_ICON_CLASS,
 } from "./threadDetailsPanelStyles";
 import { ChevronDownIcon } from "lucide-react";
 
@@ -63,8 +65,10 @@ export function ThreadDetailsControl({
         children:
           part === "select" ? (
             <>
-              {children}
-              <span data-slot="select-icon">
+              <span data-slot="select-label" className={THREAD_DETAILS_PANEL_SELECT_LABEL_CLASS}>
+                {children}
+              </span>
+              <span data-slot="select-icon" className={THREAD_DETAILS_PANEL_SELECT_ICON_CLASS}>
                 <ChevronDownIcon className={THREAD_DETAILS_PANEL_CHEVRON_CLASS} />
               </span>
             </>
diff --git a/apps/web/src/components/chat/ThreadRelationshipsControl.agents.browser.test.tsx b/apps/web/src/components/chat/ThreadRelationshipsControl.agents.browser.test.tsx
index 4efcb87b7b25b..2beeb669b5b93 100644
--- a/apps/web/src/components/chat/ThreadRelationshipsControl.agents.browser.test.tsx
+++ b/apps/web/src/components/chat/ThreadRelationshipsControl.agents.browser.test.tsx
@@ -893,6 +893,7 @@ it("shows readable models and only differing workspace details in agent tooltips
     [[{ id: "reasoning", value: "low" }], " · low"],
     [[{ id: "variant", value: "high" }], " · high"],
     [[{ id: "reasoningEffort", value: "none" }], " · none"],
+    [[{ id: "reasoning_effort", value: "xhigh" }], " · xhigh"],
     [[{ id: "reasoningEffort", value: true }], ""],
     [[{ id: "serviceTier", value: "fast" }], ""],
     [[], ""],
diff --git a/apps/web/src/components/chat/TraitsPicker.test.ts b/apps/web/src/components/chat/TraitsPicker.test.ts
index 14f4685c91810..e684b4e25bdc4 100644
--- a/apps/web/src/components/chat/TraitsPicker.test.ts
+++ b/apps/web/src/components/chat/TraitsPicker.test.ts
@@ -115,14 +115,15 @@ describe("buildTraitsTriggerDisplay", () => {
       buildTraitsTriggerDisplay({
         provider: ProviderDriverKind.make("cursor"),
         descriptors: [
-          { ...EFFORT, id: "reasoning" },
+          CONTEXT_WINDOW,
+          { ...EFFORT, id: "reasoning_effort" },
           fastModeDescriptor(true),
           { id: "thinking", label: "Thinking", type: "boolean", currentValue: true },
         ],
-        primarySelectDescriptorId: "reasoning",
+        primarySelectDescriptorId: CONTEXT_WINDOW.id,
         ultrathinkPromptControlled: false,
       }),
-    ).toEqual({ label: "High Fast · Thinking On" });
+    ).toEqual({ label: "1M · High Fast · Thinking On" });
   });
 
   it.each([true, false])("keeps boolean thinking %s independent of Fast", (currentValue) => {
diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx
index cc200f1ebd057..b936f5941015c 100644
--- a/apps/web/src/components/chat/TraitsPicker.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.tsx
@@ -16,6 +16,7 @@ import {
   isClaudeUltrathinkPrompt,
   normalizeModelSlug,
 } from "@t3tools/shared/model";
+import { REASONING_EFFORT_OPTION_IDS } from "@t3tools/client-runtime/state/thread-execution";
 import { memo } from "react";
 import { BrainIcon } from "lucide-react";
 import {
@@ -92,10 +93,7 @@ type TraitsPersistence =
 const ULTRATHINK_PROMPT_PREFIX = "Ultrathink:\n";
 
 const REASONING_SELECT_DESCRIPTOR_IDS: ReadonlySet<string> = new Set([
-  "reasoningEffort",
-  "reasoning",
-  "effort",
-  "variant",
+  ...REASONING_EFFORT_OPTION_IDS,
   "thinking",
 ]);
 
diff --git a/apps/web/src/components/chat/composerProviderState.test.tsx b/apps/web/src/components/chat/composerProviderState.test.tsx
index d4cf18396babb..9f13b2497ef7a 100644
--- a/apps/web/src/components/chat/composerProviderState.test.tsx
+++ b/apps/web/src/components/chat/composerProviderState.test.tsx
@@ -616,17 +616,17 @@ describe("getComposerReasoningStep", () => {
       provider: ProviderDriverKind.make("cursor"),
       instanceId: ProviderInstanceId.make("cursor"),
       models: modelWith([
-        selectDescriptor("reasoning", LEVELS),
+        selectDescriptor("reasoning_effort", LEVELS),
         booleanDescriptor("fastMode", true),
       ]),
     };
 
     expect(step({ ...cursor, modelOptions: undefined })?.modelOptions).toStrictEqual(
-      selections(["reasoning", "high"], ["fastMode", false]),
+      selections(["reasoning_effort", "high"], ["fastMode", false]),
     );
     expect(
       step({ ...cursor, modelOptions: selections(["fastMode", true]) })?.modelOptions,
-    ).toStrictEqual(selections(["reasoning", "high"], ["fastMode", true]));
+    ).toStrictEqual(selections(["reasoning_effort", "high"], ["fastMode", true]));
   });
 
   it("steps from the provider-reported level for the same instance and model", () => {
diff --git a/apps/web/src/components/chat/threadDetailsPanelStyles.ts b/apps/web/src/components/chat/threadDetailsPanelStyles.ts
index 2473271414506..11c599ec42c61 100644
--- a/apps/web/src/components/chat/threadDetailsPanelStyles.ts
+++ b/apps/web/src/components/chat/threadDetailsPanelStyles.ts
@@ -3,6 +3,9 @@ const THREAD_DETAILS_PANEL_RESTING_BUTTON_SURFACE_CLASS = "bg-transparent shadow
 const THREAD_DETAILS_PANEL_HOVER_SURFACE_CLASS =
   "hover:!bg-black/[0.035] data-pressed:!bg-black/[0.035] dark:hover:!bg-white/[0.08] dark:data-pressed:!bg-white/[0.08]";
 
+const THREAD_DETAILS_PANEL_HALF_HOVER_SURFACE_CLASS =
+  "hover:bg-black/[0.035] dark:hover:bg-white/[0.08]";
+
 const THREAD_DETAILS_PANEL_ROW_SURFACE_CLASS = `${THREAD_DETAILS_PANEL_RESTING_BUTTON_SURFACE_CLASS} ${THREAD_DETAILS_PANEL_HOVER_SURFACE_CLASS}`;
 const THREAD_DETAILS_PANEL_SPLIT_BUTTON_SURFACE_CLASS = `${THREAD_DETAILS_PANEL_ROW_SURFACE_CLASS} data-popup-open:!bg-black/[0.035] dark:data-popup-open:!bg-white/[0.08]`;
 const THREAD_DETAILS_PANEL_SPLIT_GROUP_SURFACE_CLASS = `${THREAD_DETAILS_PANEL_HOVER_SURFACE_CLASS} has-[[data-popup-open]]:bg-black/[0.035] dark:has-[[data-popup-open]]:bg-white/[0.08]`;
@@ -16,7 +19,12 @@ const THREAD_DETAILS_PANEL_CONTROL_CLASS = `h-8 min-w-0 rounded-lg border-transp
 
 export const THREAD_DETAILS_PANEL_ROW_CLASS = `${THREAD_DETAILS_PANEL_CONTROL_CLASS} w-full justify-start ${THREAD_DETAILS_PANEL_ROW_SURFACE_CLASS}`;
 
-export const THREAD_DETAILS_PANEL_SELECT_ROW_CLASS = `${THREAD_DETAILS_PANEL_ROW_CLASS} pe-0 [&_[data-slot=select-icon]]:-me-px [&_[data-slot=select-icon]]:relative [&_[data-slot=select-icon]]:flex [&_[data-slot=select-icon]]:h-full [&_[data-slot=select-icon]]:w-8 [&_[data-slot=select-icon]]:shrink-0 [&_[data-slot=select-icon]]:items-center [&_[data-slot=select-icon]]:justify-center [&_[data-slot=select-icon]]:before:absolute [&_[data-slot=select-icon]]:before:-left-px [&_[data-slot=select-icon]]:before:top-1/2 [&_[data-slot=select-icon]]:before:h-4 [&_[data-slot=select-icon]]:before:w-px [&_[data-slot=select-icon]]:before:-translate-y-1/2 [&_[data-slot=select-icon]]:before:bg-border/65 [&_[data-slot=select-icon]>svg]:me-0 [&_[data-slot=select-icon]>svg]:size-4 [&_[data-slot=select-icon]>svg]:text-muted-foreground [&_[data-slot=select-icon]>svg]:opacity-100`;
+export const THREAD_DETAILS_PANEL_SELECT_ROW_CLASS = `${THREAD_DETAILS_PANEL_ROW_CLASS} gap-0 px-0 [&_[data-slot=select-icon]]:-me-px [&_[data-slot=select-icon]]:relative [&_[data-slot=select-icon]]:flex [&_[data-slot=select-icon]]:h-full [&_[data-slot=select-icon]]:w-8 [&_[data-slot=select-icon]]:shrink-0 [&_[data-slot=select-icon]]:items-center [&_[data-slot=select-icon]]:justify-center [&_[data-slot=select-icon]]:before:absolute [&_[data-slot=select-icon]]:before:-left-px [&_[data-slot=select-icon]]:before:top-1/2 [&_[data-slot=select-icon]]:before:h-4 [&_[data-slot=select-icon]]:before:w-px [&_[data-slot=select-icon]]:before:-translate-y-1/2 [&_[data-slot=select-icon]]:before:bg-border/65 [&_[data-slot=select-icon]>svg]:me-0 [&_[data-slot=select-icon]>svg]:size-4 [&_[data-slot=select-icon]>svg]:text-muted-foreground [&_[data-slot=select-icon]>svg]:opacity-100`;
+
+// The row keeps its soft fill while each half stacks a second one, like the split controls nearby.
+export const THREAD_DETAILS_PANEL_SELECT_LABEL_CLASS = `flex h-full min-w-0 flex-1 items-center rounded-s-lg ${THREAD_DETAILS_PANEL_ROW_CONTENT_CLASS} ${THREAD_DETAILS_PANEL_HALF_HOVER_SURFACE_CLASS}`;
+
+export const THREAD_DETAILS_PANEL_SELECT_ICON_CLASS = `rounded-e-lg ${THREAD_DETAILS_PANEL_HALF_HOVER_SURFACE_CLASS}`;
 
 export const THREAD_DETAILS_PANEL_LOCKED_ROW_CLASS = `h-8 w-full min-w-0 justify-start rounded-lg border border-transparent ${THREAD_DETAILS_PANEL_ROW_CONTENT_CLASS} text-[13px] font-medium text-foreground/80 sm:h-8 sm:text-[13px]`;
 
diff --git a/apps/web/src/components/chat/usePendingThreadRequests.ts b/apps/web/src/components/chat/usePendingThreadRequests.ts
index 88e8f82dc0bd8..9ce6172a28d59 100644
--- a/apps/web/src/components/chat/usePendingThreadRequests.ts
+++ b/apps/web/src/components/chat/usePendingThreadRequests.ts
@@ -37,6 +37,7 @@ import {
   pendingUserInputRequestKey,
   pruneResolvedUserInputDrafts,
   setPendingUserInputCustomAnswer,
+  threadContextsReferencedByAnswer,
   togglePendingUserInputOptionSelection,
   type PendingUserInputDraftAnswer,
 } from "../../pendingUserInput";
@@ -452,7 +453,10 @@ export function usePendingThreadRequests(input: {
         );
         store.addThreadContexts(
           composerDraftTarget,
-          store.getComposerDraft(questionTarget)?.threadContexts ?? [],
+          threadContextsReferencedByAnswer(
+            displacedAnswer ?? "",
+            store.getComposerDraft(questionTarget)?.threadContexts ?? [],
+          ),
           { appendReference: false },
         );
       }
diff --git a/apps/web/src/components/composerCodeBlockHighlight.test.ts b/apps/web/src/components/composerCodeBlockHighlight.test.ts
index 409db50195615..adc725eae4a45 100644
--- a/apps/web/src/components/composerCodeBlockHighlight.test.ts
+++ b/apps/web/src/components/composerCodeBlockHighlight.test.ts
@@ -1,7 +1,8 @@
 import { Editor } from "@tiptap/core";
-import type { EditorView } from "@tiptap/pm/view";
+import { EditorState, type Plugin, type Transaction } from "@tiptap/pm/state";
+import type { DecorationSet, EditorView } from "@tiptap/pm/view";
 import StarterKit from "@tiptap/starter-kit";
-import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+import { afterEach, describe, expect, it, onTestFinished, vi } from "vite-plus/test";
 
 import { ComposerCodeBlockExtension } from "~/composer-rich-text-doc";
 import type { DiffThemeName } from "~/lib/diffRendering";
@@ -16,7 +17,7 @@ import {
 
 vi.mock("~/lib/syntaxHighlighting", () => ({ getSyntaxHighlighterPromise: vi.fn() }));
 
-const THEME = "github-dark" as DiffThemeName;
+const THEME = "pierre-dark" as DiffThemeName;
 
 function fakeHighlighter(colorFor: (content: string) => string | undefined) {
   return {
@@ -138,3 +139,181 @@ describe("a highlighter that fails to load", () => {
     await expect(repainted).resolves.toBeUndefined();
   });
 });
+
+describe("highlighting edited fences", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  async function mountFence(text: string, resolveTheme = () => THEME) {
+    vi.useFakeTimers();
+    const highlighter = fakeHighlighter((content) =>
+      content.startsWith("x") ? "#ff0000" : undefined,
+    );
+    const tokenize = vi.spyOn(highlighter, "codeToTokens");
+    vi.mocked(getSyntaxHighlighterPromise).mockResolvedValue(highlighter);
+    const editor = new Editor({
+      extensions: [
+        StarterKit.configure({ codeBlock: false, trailingNode: false }),
+        ComposerCodeBlockExtension,
+        composerCodeBlockHighlight({ resolveTheme }),
+      ],
+      content: {
+        type: "doc",
+        content: [
+          { type: "codeBlock", attrs: { language: "ts" }, content: [{ type: "text", text }] },
+        ],
+      },
+    });
+    vi.stubGlobal("document", { documentElement: {} });
+    vi.stubGlobal(
+      "MutationObserver",
+      class {
+        observe() {}
+        disconnect() {}
+      },
+    );
+    const plugin = editor.extensionManager.plugins.find((candidate) =>
+      (candidate as unknown as { key: string }).key.startsWith("composerCodeBlockHighlight"),
+    ) as Plugin<DecorationSet>;
+    // A headless editor holds no plugins in its state, so give this one its own.
+    let state = EditorState.create({ doc: editor.state.doc, plugins: [plugin] });
+    // Like a real view, every dispatch updates the plugin's view.
+    let pluginView: ReturnType<NonNullable<typeof plugin.spec.view>> | undefined;
+    const view = {
+      get state() {
+        return state;
+      },
+      dispatch: (transaction: Transaction) => {
+        const previous = state;
+        state = state.apply(transaction);
+        pluginView?.update?.(view, previous);
+      },
+    } as unknown as EditorView;
+    pluginView = plugin.spec.view!(view);
+    onTestFinished(() => {
+      pluginView?.destroy?.();
+      editor.destroy();
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    return {
+      tokenize,
+      ranges: () =>
+        plugin
+          .getState(state)!
+          .find()
+          .map(({ from, to }) => [from, to]),
+      edit: async (change: (transaction: Transaction) => Transaction) => {
+        view.dispatch(change(state.tr));
+        await vi.advanceTimersByTimeAsync(0);
+      },
+      colored: () =>
+        plugin
+          .getState(state)!
+          .find()
+          .map((decoration) => state.doc.textBetween(decoration.from, decoration.to)),
+    };
+  }
+
+  it("maps colors while typing above 2,000 characters and refreshes 300 ms after the last edit", async () => {
+    const fence = await mountFence(`x ${"y".repeat(1_999)}`);
+    expect(fence.tokenize).toHaveBeenCalledTimes(1);
+
+    await fence.edit((tr) => tr.insertText("x ", 1));
+    await vi.advanceTimersByTimeAsync(250);
+    await fence.edit((tr) => tr.insertText("y ", 1));
+    await vi.advanceTimersByTimeAsync(299);
+
+    expect(fence.tokenize).toHaveBeenCalledTimes(1);
+    expect(fence.colored()).toEqual(["x"]);
+    expect(fence.ranges()).toEqual([[5, 6]]);
+
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(fence.tokenize).toHaveBeenCalledTimes(2);
+    expect(fence.colored()).toEqual(["x", "x"]);
+  });
+
+  it("ignores a pending highlight when its text is edited away and restored", async () => {
+    const fence = await mountFence(`x ${"y".repeat(1_999)}`);
+    const staleHighlighter = fakeHighlighter(() => "#00ff00");
+    const staleTokenize = vi.spyOn(staleHighlighter, "codeToTokens");
+    let finishLoading!: () => void;
+    vi.mocked(getSyntaxHighlighterPromise).mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finishLoading = () => resolve(staleHighlighter);
+        }),
+    );
+
+    await fence.edit((tr) => tr.insertText("x ", 1));
+    await vi.advanceTimersByTimeAsync(300);
+    await fence.edit((tr) => tr.insertText("y ", 1));
+    await fence.edit((tr) => tr.delete(1, 3));
+    finishLoading();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(staleTokenize).not.toHaveBeenCalled();
+    expect(fence.colored()).toEqual(["x"]);
+    await vi.advanceTimersByTimeAsync(300);
+    expect(fence.tokenize).toHaveBeenCalledTimes(2);
+    expect(fence.colored()).toEqual(["x", "x"]);
+  });
+
+  it("refreshes a long fence immediately when the theme changes during a pending edit", async () => {
+    let theme = THEME;
+    const fence = await mountFence(`x ${"y".repeat(1_999)}`, () => theme);
+    await fence.edit((tr) => tr.insertText("x ", 1));
+
+    theme = "pierre-light";
+    await fence.edit((tr) => tr.setMeta("theme", true));
+
+    expect(fence.tokenize).toHaveBeenCalledTimes(2);
+    expect(fence.tokenize).toHaveBeenLastCalledWith(expect.any(String), { lang: "ts", theme });
+    expect(fence.colored()).toEqual(["x", "x"]);
+    await vi.advanceTimersByTimeAsync(300);
+    expect(fence.tokenize).toHaveBeenCalledTimes(2);
+  });
+
+  it("refreshes immediately when an edit leaves the fence at 2,000 characters", async () => {
+    const fence = await mountFence(`x ${"y".repeat(1_996)}`);
+
+    await fence.edit((tr) => tr.insertText("x ", 1));
+
+    expect(fence.tokenize).toHaveBeenCalledTimes(2);
+    expect(fence.colored()).toEqual(["x", "x"]);
+  });
+
+  it("clips a split token to its fences without coloring the paragraph between them", async () => {
+    const fence = await mountFence("x".repeat(6_000));
+
+    await fence.edit((tr) =>
+      tr
+        .split(3_001)
+        .insert(
+          3_002,
+          tr.doc.type.schema.node("paragraph", null, [tr.doc.type.schema.text("plain")]),
+        ),
+    );
+
+    expect(fence.tokenize).toHaveBeenCalledTimes(1);
+    expect(fence.ranges()).toEqual([
+      [1, 3_001],
+      [3_010, 6_010],
+    ]);
+    expect(fence.colored()).toEqual(["x".repeat(3_000), "x".repeat(3_000)]);
+  });
+
+  it("clears retained colors when the new language highlighter fails to load", async () => {
+    const fence = await mountFence(`x ${"y".repeat(1_999)}`);
+    vi.mocked(getSyntaxHighlighterPromise).mockRejectedValue(new Error("Shiki failed to load"));
+
+    await fence.edit((tr) => tr.setNodeMarkup(0, undefined, { language: "py" }));
+    expect(fence.colored()).toEqual(["x"]);
+
+    await vi.advanceTimersByTimeAsync(300);
+
+    expect(fence.colored()).toEqual([]);
+  });
+});
diff --git a/apps/web/src/components/composerCodeBlockHighlight.ts b/apps/web/src/components/composerCodeBlockHighlight.ts
index 91c3a669b99c9..86621f5d787c0 100644
--- a/apps/web/src/components/composerCodeBlockHighlight.ts
+++ b/apps/web/src/components/composerCodeBlockHighlight.ts
@@ -14,13 +14,13 @@ interface HighlightedBlock {
 
 const composerCodeBlockHighlightKey = new PluginKey<DecorationSet>("composerCodeBlockHighlight");
 
-/**
- * Any edit changes a block's signature, so each keystroke re-tokenizes the
- * whole block synchronously on the main thread: a few milliseconds for a couple
- * of hundred lines, but ~80ms at a thousand, which stalls typing.
- */
+// Tokenizing larger fences can stall the main thread.
 export const MAX_HIGHLIGHTED_CODE_BLOCK_LENGTH = 20_000;
 
+// Keep mapped colors while typing in long fences, then refresh after a pause.
+const DEFERRED_HIGHLIGHT_CODE_BLOCK_LENGTH = 2_000;
+const DEFERRED_HIGHLIGHT_DELAY_MS = 300;
+
 export function shouldHighlightCodeBlock(code: string): boolean {
   return code.length <= MAX_HIGHLIGHTED_CODE_BLOCK_LENGTH;
 }
@@ -63,10 +63,11 @@ export function composerCodeBlockHighlight(options: {
           state: {
             init: () => DecorationSet.empty,
             apply(transaction, value, _oldState, newState) {
+              const mapped = value.map(transaction.mapping, transaction.doc);
               if (!transaction.docChanged && !transaction.getMeta(composerCodeBlockHighlightKey)) {
-                return value.map(transaction.mapping, transaction.doc);
+                return mapped;
               }
-              return buildDecorations(newState, cache, options.resolveTheme());
+              return buildDecorations(newState, cache, options.resolveTheme(), mapped);
             },
           },
 
@@ -80,29 +81,41 @@ export function composerCodeBlockHighlight(options: {
             let disposed = false;
             let paintedTheme = options.resolveTheme();
             let scannedDoc: ProseMirrorNode | null = null;
+            let deferredRefresh: ReturnType<typeof setTimeout> | undefined;
 
-            /**
-             * Returning early when nothing is pending is what stops the
-             * dispatch below from re-triggering this on its own update.
-             */
-            const refresh = () => {
+            // Repaint dispatches and selection changes must not restart the debounce.
+            const refresh = (deferLong: boolean) => {
               const theme = options.resolveTheme();
               const themeChanged = theme !== paintedTheme;
               paintedTheme = theme;
               // A selection change cannot alter what needs tokenizing, and
               // building a signature means concatenating every block's text.
               if (!themeChanged && view.state.doc === scannedDoc) return;
+              clearTimeout(deferredRefresh);
               scannedDoc = view.state.doc;
               const blocks = collectCodeBlocks(view.state);
-              live = new Set(blocks.map(({ node }) => blockSignature(node, theme)));
+              const signatures = new Set(blocks.map(({ node }) => blockSignature(node, theme)));
+              live = signatures;
               for (const signature of cache.keys()) {
                 if (!live.has(signature)) cache.delete(signature);
               }
-              const pending = blocks.filter(
+              const missing = blocks.filter(
                 ({ node }) =>
                   shouldHighlightCodeBlock(node.textContent) &&
                   !cache.has(blockSignature(node, theme)),
               );
+              const pending =
+                deferLong && !themeChanged
+                  ? missing.filter(
+                      ({ node }) => node.textContent.length <= DEFERRED_HIGHLIGHT_CODE_BLOCK_LENGTH,
+                    )
+                  : missing;
+              if (pending.length < missing.length) {
+                deferredRefresh = setTimeout(() => {
+                  scannedDoc = null;
+                  refresh(false);
+                }, DEFERRED_HIGHLIGHT_DELAY_MS);
+              }
               if (pending.length === 0) {
                 if (themeChanged) {
                   view.dispatch(view.state.tr.setMeta(composerCodeBlockHighlightKey, true));
@@ -117,31 +130,36 @@ export function composerCodeBlockHighlight(options: {
                   const language =
                     languageOfInfoString(String(node.attrs.language ?? "")) || "text";
                   const signature = blockSignature(node, theme);
-                  const highlighter = await getSyntaxHighlighterPromise(language);
-                  if (disposed || cache.has(signature) || !live.has(signature)) return;
+                  // Cache failure as plain text to clear retained colors.
+                  const highlighter = await getSyntaxHighlighterPromise(language).catch(() => null);
+                  // An older request must not bypass the debounce if its text returns.
+                  if (disposed || live !== signatures || cache.has(signature)) return;
                   cache.set(signature, {
                     signature,
-                    decorations: tokenizeBlock(highlighter, node.textContent, language, theme),
+                    decorations: highlighter
+                      ? tokenizeBlock(highlighter, node.textContent, language, theme)
+                      : [],
                   });
                 }),
               ).then(() => {
-                if (disposed) return;
+                if (disposed || live !== signatures) return;
                 view.dispatch(view.state.tr.setMeta(composerCodeBlockHighlightKey, true));
               });
             };
 
-            refresh();
+            refresh(false);
             // The theme lives on <html>, outside the editor, so nothing would
             // otherwise tell the view a repaint is due.
-            const themeObserver = new MutationObserver(refresh);
+            const themeObserver = new MutationObserver(() => refresh(false));
             themeObserver.observe(document.documentElement, {
               attributeFilter: ["class"],
             });
 
             return {
-              update: refresh,
+              update: () => refresh(true),
               destroy() {
                 disposed = true;
+                clearTimeout(deferredRefresh);
                 themeObserver.disconnect();
               },
             };
@@ -187,12 +205,27 @@ function buildDecorations(
   state: EditorState,
   cache: Map<string, HighlightedBlock>,
   theme: DiffThemeName,
+  previous: DecorationSet,
 ): DecorationSet {
   const decorations: Decoration[] = [];
   for (const { node, pos } of collectCodeBlocks(state)) {
     if (!shouldHighlightCodeBlock(node.textContent)) continue;
     const highlighted = cache.get(blockSignature(node, theme));
-    if (!highlighted) continue;
+    if (!highlighted) {
+      // A mapped token can span split fences and the paragraph between them.
+      const start = pos + 1;
+      const end = start + node.content.size;
+      for (const decoration of previous.find(start, end)) {
+        if (decoration.from >= start && decoration.to <= end) {
+          decorations.push(decoration);
+          continue;
+        }
+        const from = Math.max(decoration.from, start);
+        const to = Math.min(decoration.to, end);
+        if (from < to) decorations.push(colorDecoration(from, to, decoration.spec.color));
+      }
+      continue;
+    }
     // Token offsets index the block's text, which lines up with document
     // positions only because `codeBlock` is `text*` with no marks — one
     // unmarked text node, so `content.size === textContent.length`. Allowing
@@ -201,11 +234,14 @@ function buildDecorations(
     const start = pos + 1;
     for (const decoration of highlighted.decorations) {
       decorations.push(
-        Decoration.inline(start + decoration.from, start + decoration.to, {
-          style: `color:${decoration.color}`,
-        }),
+        colorDecoration(start + decoration.from, start + decoration.to, decoration.color),
       );
     }
   }
   return DecorationSet.create(state.doc, decorations);
 }
+
+// Keep the color available when clipping mapped decorations to a fence.
+function colorDecoration(from: number, to: number, color: string): Decoration {
+  return Decoration.inline(from, to, { style: `color:${color}` }, { color });
+}
diff --git a/apps/web/src/components/composerFooterLayout.test.ts b/apps/web/src/components/composerFooterLayout.test.ts
index f913c04391819..ef021a7dc013f 100644
--- a/apps/web/src/components/composerFooterLayout.test.ts
+++ b/apps/web/src/components/composerFooterLayout.test.ts
@@ -140,6 +140,35 @@ describe("resolveComposerTimelineInset", () => {
       resolveComposerTimelineInset({ currentInset: 0, overlayHeight: 60, isResting: true }),
     ).toBe(60 + COMPOSER_RESTING_EXPANSION_MIN_PX);
   });
+
+  it("keeps the timeline reservation stable through notice expansion and collapse", () => {
+    const collapsed = resolveComposerTimelineInset({
+      currentInset: 0,
+      overlayHeight: 172,
+      isResting: false,
+    });
+    const expanded = resolveComposerTimelineInset({
+      currentInset: collapsed,
+      overlayHeight: 532,
+      isResting: false,
+      expandedNoticesHeight: 360,
+    });
+    expect(expanded).toBe(collapsed);
+    const resting = resolveComposerTimelineInset({
+      currentInset: expanded,
+      overlayHeight: 470,
+      isResting: true,
+      expandedNoticesHeight: 360,
+    });
+    expect(resting).toBe(collapsed);
+    expect(
+      resolveComposerTimelineInset({
+        currentInset: resting,
+        overlayHeight: 110,
+        isResting: true,
+      }),
+    ).toBe(collapsed);
+  });
 });
 
 describe("shouldUseRestingComposerLayout", () => {
diff --git a/apps/web/src/components/composerFooterLayout.ts b/apps/web/src/components/composerFooterLayout.ts
index e0dce39603e01..5ae971f19a344 100644
--- a/apps/web/src/components/composerFooterLayout.ts
+++ b/apps/web/src/components/composerFooterLayout.ts
@@ -59,16 +59,20 @@ export function resolveComposerTimelineInset(input: {
   overlayHeight: number;
   isResting: boolean;
   restingOnlyHeight?: number;
+  expandedNoticesHeight?: number;
 }): number {
+  // Expanded notices temporarily cover the timeline. Remove their growth before
+  // rounding so fractional measurements reserve exactly the collapsed height.
+  const overlayHeight = Math.ceil(input.overlayHeight - (input.expandedNoticesHeight ?? 0));
   return input.isResting
     ? Math.max(
         input.currentInset,
-        input.overlayHeight +
+        overlayHeight +
           (input.currentInset === 0
             ? COMPOSER_RESTING_EXPANSION_MIN_PX - (input.restingOnlyHeight ?? 0)
             : 0),
       )
-    : input.overlayHeight;
+    : overlayHeight;
 }
 
 export function overlayComposerIsResting(input: {
diff --git a/apps/web/src/components/desktop/SshPasswordPromptDialog.tsx b/apps/web/src/components/desktop/SshPasswordPromptDialog.tsx
index b7b995bc33548..0d63558e89626 100644
--- a/apps/web/src/components/desktop/SshPasswordPromptDialog.tsx
+++ b/apps/web/src/components/desktop/SshPasswordPromptDialog.tsx
@@ -25,9 +25,9 @@ function formatRemainingSeconds(seconds: number): string {
 }
 
 function getPromptErrorMessage(error: unknown): string {
-  const message = error instanceof Error ? error.message : "SSH password prompt failed.";
+  const message = error instanceof Error ? error.message : "SSH verification prompt failed.";
   return message.includes("expired") || message.includes("no longer pending")
-    ? "This SSH password prompt expired. Try connecting again."
+    ? "This SSH verification prompt expired. Try connecting again."
     : message;
 }
 
@@ -104,7 +104,7 @@ function ActiveSshPasswordPrompt({
   const remainingLabel =
     remainingSeconds === null ? null : formatRemainingSeconds(remainingSeconds);
   const visibleResponseError = isExpired
-    ? "This SSH password prompt expired. Try connecting again."
+    ? "This SSH verification prompt expired. Try connecting again."
     : responseError;
 
   const respond = async (nextPassword: string | null) => {
@@ -114,7 +114,7 @@ function ActiveSshPasswordPrompt({
 
     const requestId = request.requestId;
     if (nextPassword !== null && isExpired) {
-      setResponseError("This SSH password prompt expired. Try connecting again.");
+      setResponseError("This SSH verification prompt expired. Try connecting again.");
       return;
     }
 
@@ -158,10 +158,11 @@ function ActiveSshPasswordPrompt({
     >
       <DialogPopup className="max-w-md" showCloseButton={false}>
         <DialogHeader>
-          <DialogTitle>SSH Password Required</DialogTitle>
+          <DialogTitle>SSH verification required</DialogTitle>
           <DialogDescription>
-            T3 needs your SSH password to connect to <code>{target}</code>. The password is passed
-            to the local SSH process for this connection attempt and is not saved by T3 Code.
+            Enter the password or verification code required by <code>{target}</code>. T3 Code
+            passes your response to the local SSH process and keeps it in memory to reuse for this
+            host. T3 Code does not write it to disk.
           </DialogDescription>
         </DialogHeader>
         <DialogPanel scrollFade={false}>
@@ -202,7 +203,8 @@ function ActiveSshPasswordPrompt({
               <p className="text-sm text-destructive">{visibleResponseError}</p>
             ) : (
               <p className="text-sm text-muted-foreground">
-                Use SSH keys to avoid repeated password prompts on new SSH sessions.
+                SSH keys may replace a password, but your server can still require a verification
+                code.
               </p>
             )}
           </form>
diff --git a/apps/web/src/components/device/DeviceStreamView.browser.test.tsx b/apps/web/src/components/device/DeviceStreamView.browser.test.tsx
index c6229faaf444c..c0efd1c068980 100644
--- a/apps/web/src/components/device/DeviceStreamView.browser.test.tsx
+++ b/apps/web/src/components/device/DeviceStreamView.browser.test.tsx
@@ -35,6 +35,7 @@ vi.mock(import("./DevicePhoneViewport"), async (original) => ({
     return <></>;
   },
 }));
+import { pasteTextToFocusComposer } from "../chat/composerFocusRedirect";
 import { DeviceStreamView } from "./DeviceStreamView";
 
 // MJPEG frames come from the device hub, so images keep their src without loading it and a
@@ -109,7 +110,7 @@ afterEach(async () => {
   vi.unstubAllGlobals();
 });
 
-async function setup(h264 = false) {
+async function setup(h264 = false, platform: "ios" | "android" = "ios") {
   const touches: unknown[] = [];
   vi.useFakeTimers();
   vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
@@ -160,6 +161,7 @@ async function setup(h264 = false) {
     return Promise.resolve(new Response("prime"));
   });
   const sockets: Array<{ onmessage?: (event: { data: ArrayBuffer }) => void }> = [];
+  const sent: unknown[] = [];
   vi.stubGlobal(
     "WebSocket",
     class {
@@ -169,9 +171,11 @@ async function setup(h264 = false) {
         sockets.push(this);
       }
       onmessage?: (event: { data: ArrayBuffer }) => void;
-      send(packet: Uint8Array) {
-        if (packet[0] === 0x03) {
-          touches.push(JSON.parse(new TextDecoder().decode(packet.subarray(1))));
+      send(message: string | Uint8Array) {
+        if (typeof message === "string") {
+          sent.push(message);
+        } else if (message[0] === 0x03) {
+          touches.push(JSON.parse(new TextDecoder().decode(message.subarray(1))));
         }
       }
       close() {}
@@ -182,7 +186,7 @@ async function setup(h264 = false) {
       hostId="local"
       environmentId={EnvironmentId.make("test")}
       deviceId="test"
-      platform="ios"
+      platform={platform}
       visible={visible}
       allowPhoneView={h264}
     />
@@ -190,6 +194,7 @@ async function setup(h264 = false) {
   await act(async () => root.render(view(true)));
   return {
     images,
+    sent,
     view,
     touches,
     configure() {
@@ -322,3 +327,33 @@ it("keeps the 3D viewer mounted across iOS video recovery and releases it when h
   expect(viewerUnmounts).toBe(1);
   expect(vi.getTimerCount()).toBe(0);
 });
+
+it("types a paste on the Android screen into the device and lets Ctrl+V reach the paste", async () => {
+  const { sent } = await setup(true, "android");
+  const screen = container.querySelector<HTMLElement>('[role="application"]')!;
+  screen.focus();
+  expect(document.activeElement).toBe(screen);
+  const chord = new KeyboardEvent("keydown", {
+    key: "v",
+    code: "KeyV",
+    ctrlKey: true,
+    bubbles: true,
+    cancelable: true,
+  });
+  screen.dispatchEvent(chord);
+  expect(chord.defaultPrevented).toBe(false);
+  const clipboardData = new DataTransfer();
+  clipboardData.setData("text/plain", "pässwörd 1");
+  const composerPastes: Array<string | null> = [];
+  const capturePaste = (event: ClipboardEvent) =>
+    composerPastes.push(pasteTextToFocusComposer(event));
+  window.addEventListener("paste", capturePaste, true);
+  onTestFinished(() => window.removeEventListener("paste", capturePaste, true));
+  const paste = new ClipboardEvent("paste", { clipboardData, bubbles: true, cancelable: true });
+  screen.dispatchEvent(paste);
+  expect(paste.defaultPrevented).toBe(true);
+  expect(sent.map((message) => JSON.parse(message as string) as unknown)).toEqual([
+    { type: "text", text: "pässwörd 1" },
+  ]);
+  expect(composerPastes).toEqual([null]);
+});
diff --git a/apps/web/src/components/device/DeviceStreamView.tsx b/apps/web/src/components/device/DeviceStreamView.tsx
index 299dddb1899d1..18b70e5421a40 100644
--- a/apps/web/src/components/device/DeviceStreamView.tsx
+++ b/apps/web/src/components/device/DeviceStreamView.tsx
@@ -378,6 +378,8 @@ export function DeviceStreamView(props: {
         ref={hostRef}
         className={cn(
           "relative flex min-h-0 min-w-0 flex-1 items-center justify-center overflow-hidden outline-none",
+          // Overlay the stream; focus (including pointer-driven focus) marks keyboard capture.
+          "after:pointer-events-none after:absolute after:inset-0 after:z-10 focus:after:ring-2 focus:after:ring-inset focus:after:ring-ring",
           controlsInset && "pr-14",
         )}
         tabIndex={0}
@@ -386,9 +388,21 @@ export function DeviceStreamView(props: {
         onKeyDown={(event) => {
           if (event.target !== event.currentTarget) return;
           if (event.metaKey && !["r", "R"].includes(event.key)) return;
+          // Let browser paste chords fire the paste event.
+          if (
+            (event.ctrlKey && (event.key === "v" || event.key === "V")) ||
+            (event.shiftKey && event.key === "Insert")
+          ) {
+            return;
+          }
           event.preventDefault();
           clientRef.current?.sendKey(event.nativeEvent, "down");
         }}
+        onPaste={(event) => {
+          if (event.target !== event.currentTarget) return;
+          event.preventDefault();
+          clientRef.current?.sendText(event.clipboardData.getData("text/plain"));
+        }}
         onKeyUp={(event) => {
           if (event.target !== event.currentTarget) return;
           clientRef.current?.sendKey(event.nativeEvent, "up");
diff --git a/apps/web/src/components/files/BrowserDocumentFrame.browser.test.tsx b/apps/web/src/components/files/BrowserDocumentFrame.browser.test.tsx
new file mode 100644
index 0000000000000..5f91fb96ad711
--- /dev/null
+++ b/apps/web/src/components/files/BrowserDocumentFrame.browser.test.tsx
@@ -0,0 +1,39 @@
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { expect, it, onTestFinished, vi } from "vite-plus/test";
+
+import { BrowserDocumentFrame } from "./BrowserDocumentFrame";
+
+it("keeps the loaded HTML page while its signed URL renews, and reloads on a new revision", async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  const container = document.createElement("div");
+  document.body.append(container);
+  const root = createRoot(container);
+  onTestFinished(async () => {
+    await act(async () => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+  const render = (src: string, documentKey?: string) =>
+    act(async () =>
+      root.render(
+        <BrowserDocumentFrame src={src} title="Review" pdf={false} documentKey={documentKey} />,
+      ),
+    );
+
+  await render("about:blank#token-a", "review.html:1");
+  const frame = container.querySelector("iframe");
+  await render("about:blank#token-b", "review.html:1");
+  expect(container.querySelector("iframe")).toBe(frame);
+  expect(frame?.getAttribute("src")).toBe("about:blank#token-a");
+
+  await render("about:blank#token-c", "review.html:2");
+  expect(container.querySelector("iframe")).not.toBe(frame);
+  expect(container.querySelector("iframe")?.getAttribute("src")).toBe("about:blank#token-c");
+
+  await render("about:blank#first");
+  const urlDrivenFrame = container.querySelector("iframe");
+  await render("about:blank#second");
+  expect(container.querySelector("iframe")).not.toBe(urlDrivenFrame);
+  expect(container.querySelector("iframe")?.getAttribute("src")).toBe("about:blank#second");
+});
diff --git a/apps/web/src/components/files/BrowserDocumentFrame.tsx b/apps/web/src/components/files/BrowserDocumentFrame.tsx
index bb5ca593f64cd..c48642b20de04 100644
--- a/apps/web/src/components/files/BrowserDocumentFrame.tsx
+++ b/apps/web/src/components/files/BrowserDocumentFrame.tsx
@@ -71,8 +71,10 @@ export function BrowserDocumentFrame(props: {
   readonly pdf: boolean;
   readonly htmlRender?: boolean;
   readonly threadRef?: ScopedThreadRef | undefined;
+  /** Stable resource identity and revision; defaults to src for callers that reload on URL changes. */
+  readonly documentKey?: string | undefined;
 }) {
-  const className = "min-h-0 flex-1 border-0 bg-white";
+  const key = props.documentKey ?? props.src;
   return props.pdf ? (
     <embed
       key={props.src}
@@ -83,18 +85,25 @@ export function BrowserDocumentFrame(props: {
     />
   ) : props.htmlRender ? (
     <HtmlRenderDocument
-      key={props.src}
+      key={key}
       src={props.src}
       title={props.title}
       threadRef={props.threadRef}
       className="min-h-0 flex-1"
     />
   ) : (
+    <FileDocument key={key} src={props.src} title={props.title} />
+  );
+}
+
+// URL renewals must not discard form input or scroll; a new key mounts a fresh document.
+function FileDocument(props: { readonly src: string; readonly title: string }) {
+  const [src] = useState(props.src);
+  return (
     <iframe
-      key={props.src}
-      src={props.src}
+      src={src}
       title={props.title}
-      className={className}
+      className="min-h-0 flex-1 border-0 bg-white"
       sandbox="allow-scripts allow-forms allow-popups allow-downloads"
     />
   );
diff --git a/apps/web/src/components/files/FileBrowserPanel.browser.test.tsx b/apps/web/src/components/files/FileBrowserPanel.browser.test.tsx
index a09803e9f2fcc..118d1cf0321ba 100644
--- a/apps/web/src/components/files/FileBrowserPanel.browser.test.tsx
+++ b/apps/web/src/components/files/FileBrowserPanel.browser.test.tsx
@@ -15,7 +15,7 @@ const files = vi.hoisted(() => ({
   searchPending: false,
   searchError: null as string | null,
   loadingDirectories: new Set<string>() as ReadonlySet<string>,
-  load: vi.fn(async () => {}),
+  load: vi.fn(async (_directoryPath: string) => {}),
   refresh: vi.fn(),
 }));
 
@@ -52,7 +52,7 @@ vi.mock("~/components/ui/tooltip", () => ({
   TooltipPopup: () => null,
 }));
 
-describe("Files panel search", () => {
+describe("Files panel", () => {
   let root: Root | undefined;
   let container: HTMLDivElement | undefined;
   const props = {
@@ -243,4 +243,89 @@ describe("Files panel search", () => {
     expect(hasMessage("No matching files.")).toBe(false);
     expect(container!.textContent).toContain("Workspace search failed.");
   });
+
+  describe("expand all", () => {
+    const workspace: Record<string, ProjectEntry[]> = {
+      src: [
+        { path: "src/lib", kind: "directory" },
+        { path: "src/index.ts", kind: "file" },
+      ],
+      "src/lib": [{ path: "src/lib/util.ts", kind: "file" }],
+      node_modules: [
+        { path: "node_modules/react", kind: "directory", ignored: true },
+        { path: "node_modules/.modules.yaml", kind: "file", ignored: true },
+      ],
+      "node_modules/react": [{ path: "node_modules/react/index.js", kind: "file", ignored: true }],
+    };
+    const listed = () => files.load.mock.calls.map(([path]) => path);
+
+    // Answer each listing the panel asks for, as the server would, until it asks for no more.
+    async function answerListings() {
+      const answered = new Set<string>();
+      for (;;) {
+        const path = listed().find((requested) => !answered.has(requested));
+        if (path === undefined) return;
+        answered.add(path);
+        files.directoryEntries = [...files.directoryEntries, ...(workspace[path] ?? [])];
+        await render();
+      }
+    }
+
+    function button(label: "Expand all folders" | "Collapse all folders") {
+      const match = container!.querySelector<HTMLButtonElement>(`button[aria-label="${label}"]`);
+      expect(match, label).not.toBeNull();
+      return match!;
+    }
+
+    async function clickRow(path: string) {
+      const row = container!
+        .querySelector("file-tree-container")!
+        .shadowRoot!.querySelector<HTMLElement>(`[data-item-path="${path}"]`);
+      expect(row, path).not.toBeNull();
+      await act(async () => row!.click());
+      await answerListings();
+    }
+
+    beforeEach(() => {
+      files.load.mockClear();
+      files.directoryEntries = [
+        { path: "src", kind: "directory" },
+        { path: "node_modules", kind: "directory", ignored: true },
+        { path: "README.md", kind: "file" },
+      ];
+    });
+
+    it("opens every folder except ignored ones, which it never lists", async () => {
+      await render();
+      await act(async () => button("Expand all folders").click());
+      await answerListings();
+
+      expect(listed().toSorted()).toEqual(["src", "src/lib"]);
+      expect(visiblePaths()).toContain("src/lib/util.ts");
+      expect(visiblePaths()).not.toContain("node_modules/.modules.yaml");
+      button("Collapse all folders");
+
+      // Collapsing a folder by hand ends expand all; reopening it counts as all expanded again,
+      // with the ignored folder still closed.
+      await clickRow("src/lib/");
+      button("Expand all folders");
+      await clickRow("src/lib/");
+      button("Collapse all folders");
+    });
+
+    it("opens an ignored folder by hand without walking into it, and collapses it with the rest", async () => {
+      await render();
+      await act(async () => button("Expand all folders").click());
+      await answerListings();
+
+      await clickRow("node_modules/");
+      expect(listed()).toContain("node_modules");
+      expect(listed()).not.toContain("node_modules/react");
+      expect(visiblePaths()).toContain("node_modules/react/");
+      expect(visiblePaths()).not.toContain("node_modules/react/index.js");
+
+      await act(async () => button("Collapse all folders").click());
+      expect(visiblePaths()).toEqual(["node_modules/", "src/", "README.md"]);
+    });
+  });
 });
diff --git a/apps/web/src/components/files/FileBrowserPanel.tsx b/apps/web/src/components/files/FileBrowserPanel.tsx
index 7b8825d8e0829..94b368446144d 100644
--- a/apps/web/src/components/files/FileBrowserPanel.tsx
+++ b/apps/web/src/components/files/FileBrowserPanel.tsx
@@ -130,8 +130,12 @@ function buildTreeEntries(
     entries.map((entry) => [entry.path, entry.kind] as const),
   );
   const treePaths = entries.map(treePath);
-  const directoryPaths = entries.filter((entry) => entry.kind === "directory").map(treePath);
-  return { entries, entryKinds, treePaths, directoryPaths };
+  const directories = entries.filter((entry) => entry.kind === "directory");
+  const directoryPaths = directories.map(treePath);
+  // Expanding a folder lists it, and an ignored one such as `node_modules` can hold tens of
+  // thousands, so expand all skips ignored folders. They still open by hand.
+  const expandableDirectoryPaths = directories.filter((entry) => !entry.ignored).map(treePath);
+  return { entries, entryKinds, treePaths, directoryPaths, expandableDirectoryPaths };
 }
 
 export default function FileBrowserPanel({
@@ -165,12 +169,8 @@ export default function FileBrowserPanel({
     { environmentId, cwd: hostFolder ? null : cwd, query: query.slice(0, 256) },
     200,
   );
-  const { entries, entryKinds, treePaths, directoryPaths } = buildTreeEntries(
-    directoryEntries,
-    pathSearch.entries,
-    pathSearch.isPending,
-    query,
-  );
+  const { entries, entryKinds, treePaths, directoryPaths, expandableDirectoryPaths } =
+    buildTreeEntries(directoryEntries, pathSearch.entries, pathSearch.isPending, query);
   const entryKindsRef = useRef(entryKinds);
   const previousTreePathsRef = useRef<readonly string[] | null>(null);
   const syncingSelectionRef = useRef(false);
@@ -321,12 +321,16 @@ export default function FileBrowserPanel({
   // Pierre restores the unfiltered tree when a search has no matches.
   const hasNoSearchMatches = search.value.trim().length > 0 && search.matchingPaths.length === 0;
   const allDirectoriesExpanded = useFileTreeSelector(model, (currentModel) =>
-    areAllDirectoriesExpanded(currentModel, directoryPaths),
+    areAllDirectoriesExpanded(currentModel, expandableDirectoryPaths),
   );
   const toggleAllDirectories = () => {
     const expanded = !(expandAll || allDirectoriesExpanded);
     setExpandAll(expanded);
-    setAllDirectoriesExpanded(model, directoryPaths, expanded);
+    setAllDirectoriesExpanded(
+      model,
+      expanded ? expandableDirectoryPaths : directoryPaths,
+      expanded,
+    );
   };
   const closeSearch = () => {
     setQuery("");
@@ -411,8 +415,9 @@ export default function FileBrowserPanel({
   }, [ready, entryKinds, model, treePaths]);
 
   useEffect(() => {
-    if (expandAll && !query.trim()) setAllDirectoriesExpanded(model, directoryPaths, true);
-  }, [directoryPaths, expandAll, model, query]);
+    if (expandAll && !query.trim())
+      setAllDirectoriesExpanded(model, expandableDirectoryPaths, true);
+  }, [expandableDirectoryPaths, expandAll, model, query]);
 
   useEffect(() => {
     if (!selectedPath) {
diff --git a/apps/web/src/components/files/FilePreviewPanel.tsx b/apps/web/src/components/files/FilePreviewPanel.tsx
index 07cee367aae78..a2fb6336ae449 100644
--- a/apps/web/src/components/files/FilePreviewPanel.tsx
+++ b/apps/web/src/components/files/FilePreviewPanel.tsx
@@ -257,6 +257,7 @@ function WorkspaceBrowserPreview(props: {
   return (
     <BrowserDocumentFrame
       src={`${assetUrl.url}${revisionSuffix}`}
+      documentKey={`${props.environmentId}:${resource._tag}:${props.threadRef.threadId}:${props.absolutePath}:${props.workspaceMutationId}`}
       title={props.title}
       pdf={isPdfPreviewFile(props.absolutePath)}
     />
@@ -1243,6 +1244,7 @@ export default function FilePreviewPanel({
               availableEditors={availableEditors}
               enableShortcut={openInShortcutEnabled}
               openInCwd={absolutePath}
+              openInCwdIsFile={file.isFile}
               compact
               revealFileManager={revealsInFileManager}
             />
diff --git a/apps/web/src/components/files/projectFilesQueryState.test.tsx b/apps/web/src/components/files/projectFilesQueryState.test.tsx
index 4a7f70a988f65..3688848460d2a 100644
--- a/apps/web/src/components/files/projectFilesQueryState.test.tsx
+++ b/apps/web/src/components/files/projectFilesQueryState.test.tsx
@@ -8,6 +8,7 @@ import {
 } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
@@ -506,6 +507,51 @@ describe("project query refresh", () => {
     }
   });
 
+  it("confirms files from reads and preserves that identity until a definitive folder result", () => {
+    const contents = file("# readme");
+    const success = AsyncResult.success(contents);
+    const failure = (kind: ProjectReadFileError["failure"], cached = false) =>
+      AsyncResult.failure(
+        Cause.fail(
+          new ProjectReadFileError({ cwd: "/repo", relativePath: "src/preview.ts", failure: kind }),
+        ),
+        { previousSuccess: cached ? Option.some(success) : Option.none() },
+      );
+    const states = [
+      ["initial read", AsyncResult.initial(true), false, false, null],
+      ["unknown path", failure("operation_failed"), false, false, null],
+      ["binary file", failure("binary_file"), true, false, null],
+      ["read success", success, true, false, contents],
+      ["pending refresh", AsyncResult.waiting(success), true, false, contents],
+      ["transient refresh failure", failure("operation_failed", true), true, false, contents],
+      ["became a folder", failure("path_not_file", true), false, true, contents],
+    ] as const;
+    const readAtom = Atom.make<
+      AsyncResult.AsyncResult<ProjectReadFileResult, ProjectReadFileError>
+    >(AsyncResult.initial(true));
+    const registry = AtomRegistry.make();
+    const unmount = registry.mount(readAtom);
+    projectMocks.readFile.mockReturnValue(readAtom);
+    projectMocks.optimisticFile.mockReturnValue(Atom.make(null));
+    atomHooks.registry = registry;
+
+    try {
+      for (const [label, result, isFile, isNotFile, data] of states) {
+        registry.set(readAtom, result);
+        reactHooks.beginRender();
+        const query = useProjectFileQuery(environmentId, "/repo", "src/preview.ts");
+        expect(query.isFile, label).toBe(isFile);
+        expect(query.isNotFile, label).toBe(isNotFile);
+        expect(query.data, label).toBe(data);
+        expect(query.isPending, label).toBe(result.waiting);
+      }
+    } finally {
+      unmount();
+      registry.dispose();
+      atomHooks.registry = null;
+    }
+  });
+
   it("retains decoded read failure context for the connected environment", async () => {
     const error = decodeReadError({
       _tag: "ProjectReadFileError",
diff --git a/apps/web/src/components/files/projectFilesQueryState.ts b/apps/web/src/components/files/projectFilesQueryState.ts
index b4f2b30f4701e..a32e0556d8dc3 100644
--- a/apps/web/src/components/files/projectFilesQueryState.ts
+++ b/apps/web/src/components/files/projectFilesQueryState.ts
@@ -4,6 +4,7 @@ import {
   type ProjectListEntriesResult,
   ProjectReadFileError,
   type ProjectReadFileResult,
+  T3_PROJECT_FILE_NAME,
 } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import * as Option from "effect/Option";
@@ -50,6 +51,7 @@ interface ProjectQueryState<A> {
 interface ProjectFileQueryState extends ProjectQueryState<ProjectReadFileResult> {
   readonly readError: ProjectReadFileError | null;
   readonly isNotFile: boolean;
+  readonly isFile: boolean;
 }
 
 function getProjectEntriesQueryAtom(
@@ -70,7 +72,11 @@ export function getProjectFileQueryAtom(
 ) {
   return projectEnvironment.readFile({
     environmentId,
-    input: { cwd, relativePath: relativePath ?? EMPTY_PROJECT_FILE_PATH },
+    input: {
+      cwd,
+      relativePath: relativePath ?? EMPTY_PROJECT_FILE_PATH,
+      ...(relativePath === T3_PROJECT_FILE_NAME ? { allowMissing: true } : {}),
+    },
   });
 }
 
@@ -111,7 +117,8 @@ export function getProjectFileContents(
   const optimistic = getOptimisticProjectFileQueryData(environmentId, cwd, relativePath);
   if (optimistic) return optimistic.contents;
   const result = appAtomRegistry.get(getProjectFileQueryAtom(environmentId, cwd, relativePath));
-  return Option.getOrUndefined(AsyncResult.value(result))?.contents;
+  const data = Option.getOrUndefined(AsyncResult.value(result));
+  return data?.exists === false ? undefined : data?.contents;
 }
 
 export function getUnsavedProjectFileQueryData(
@@ -258,25 +265,32 @@ export function useProjectFileQuery(
   const result = useAtomValue(atom);
   const refreshAtom = useAtomRefresh(atom);
   const refresh = () => refreshAtom();
-  const data = Option.getOrNull(AsyncResult.value(result));
+  const readData = Option.getOrNull(AsyncResult.value(result));
+  const isMissing = readData?.exists === false;
   const optimisticResult = useAtomValue(
     optimisticFileAtom(environmentId, cwd, relativePath ?? EMPTY_PROJECT_FILE_PATH),
   );
   const optimisticFile = relativePath === null ? null : optimisticResult;
   const cause = failureCause(result);
   const readError = isProjectReadFileError(cause) ? cause : null;
+  const data = canReadFiles ? (optimisticFile?.data ?? (isMissing ? null : readData)) : null;
+  const isNotFile = readError?.failure === "path_not_file";
 
   return {
-    data: canReadFiles ? (optimisticFile?.data ?? data) : null,
+    data,
     error:
       !isQueryEnabled || fileAccess.isPending
         ? null
         : canReadFiles
-          ? errorMessage(cause)
+          ? isMissing && !optimisticFile
+            ? `'${relativePath}' does not exist.`
+            : errorMessage(cause)
           : (fileAccess.error ?? "This connection cannot read host files."),
     isPending: isQueryEnabled && (fileAccess.isPending || result.waiting),
     readError,
-    isNotFile: readError?.failure === "path_not_file",
+    isNotFile,
+    // A folder error overrides cached contents retained across failed refreshes.
+    isFile: !isNotFile && (data !== null || readError?.failure === "binary_file"),
     refresh,
   };
 }
diff --git a/apps/web/src/components/pullRequest/PullRequestChecksPopover.tsx b/apps/web/src/components/pullRequest/PullRequestChecksPopover.tsx
index dd3ac359a8e47..0677e02bc4f6d 100644
--- a/apps/web/src/components/pullRequest/PullRequestChecksPopover.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestChecksPopover.tsx
@@ -74,10 +74,10 @@ function ChecksBody({
   }
   return (
     <>
-      <ScrollArea className="max-h-64">
+      <ScrollArea className="-me-3 w-auto max-h-64">
         <ul
           className={cn(
-            "grid gap-x-2 gap-y-1",
+            "grid gap-x-2 gap-y-1 pe-3",
             hasDetails
               ? "grid-cols-[auto_minmax(0,1fr)_auto_auto]"
               : "grid-cols-[auto_minmax(0,1fr)_auto]",
diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.browser.test.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.browser.test.tsx
index 31fc9a3e4403b..8df76af4a247d 100644
--- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.browser.test.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.browser.test.tsx
@@ -18,16 +18,16 @@ import { DraftId, useComposerDraftStore } from "~/composerDraftStore";
 
 import "~/index.css";
 
-const { newThread, prepareThread, refresh, addToast, updateToast, checkoutState } = vi.hoisted(
-  () => ({
+const { newThread, prepareThread, refresh, update, addToast, updateToast, checkoutState } =
+  vi.hoisted(() => ({
     newThread: vi.fn(),
     prepareThread: vi.fn(),
     refresh: vi.fn(),
+    update: vi.fn(),
     addToast: vi.fn(),
     updateToast: vi.fn(),
     checkoutState: { error: null as Error | null },
-  }),
-);
+  }));
 
 vi.mock(import("~/state/session"), async (original) => ({
   ...(await original()),
@@ -52,7 +52,7 @@ vi.mock(import("~/lib/sourceControlActions"), async (original) => ({
 }));
 vi.mock(import("~/state/use-atom-command"), async (original) => ({
   ...(await original()),
-  useAtomCommand: (() => vi.fn()) as never,
+  useAtomCommand: ((command: unknown) => (command === "update" ? update : vi.fn())) as never,
 }));
 vi.mock(import("~/state/pullRequests"), async (original) => {
   const actual = await original();
@@ -64,6 +64,7 @@ vi.mock(import("~/state/pullRequests"), async (original) => {
       ...actual.pullRequestEnvironment,
       detail: (() => "detail") as never,
       activity: (() => "activity") as never,
+      update: "update" as never,
       reviewGuide: (() => "review-guide") as never,
       generateReviewGuide: {
         ...actual.pullRequestEnvironment.generateReviewGuide,
@@ -267,6 +268,7 @@ beforeEach(() => {
     _tag: "Success",
     value: { branch: "feature", worktreePath: "/workspace/pr" },
   });
+  update.mockReset().mockResolvedValue({ _tag: "Success", value: undefined });
 });
 afterEach(async () => {
   for (const root of roots.splice(0)) await act(async () => root.unmount());
@@ -298,6 +300,36 @@ const unrelatedThread = {
 
 const tab = (name: string) => page.getByRole("button", { name, exact: true });
 
+it.each([
+  { isComposing: true, keyCode: 13 },
+  { isComposing: false, keyCode: 229 },
+])("does not save the PR title during IME composition (%j)", async ({ isComposing, keyCode }) => {
+  await render();
+  await page.getByRole("button", { name: "Edit title" }).click();
+  const titleInput = page.getByRole("textbox", { name: "Pull request title" });
+  const title = "日本語のタイトル";
+  await titleInput.fill(title);
+  const pressEnter = (init: KeyboardEventInit) =>
+    act(async () => {
+      titleInput
+        .element()
+        .dispatchEvent(
+          new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true, ...init }),
+        );
+    });
+
+  await pressEnter({ isComposing, keyCode });
+  expect(update).not.toHaveBeenCalled();
+  await expect.element(titleInput).toHaveValue(title);
+
+  await pressEnter({ keyCode: 13 });
+  expect(update).toHaveBeenCalledExactlyOnceWith({
+    environmentId: threadRef.environmentId,
+    input: { ...surface, title },
+  });
+  await expect.element(titleInput).not.toBeInTheDocument();
+});
+
 async function runAction(action: string) {
   if (action === "Add to agent") {
     await tab("Code").click();
@@ -406,6 +438,43 @@ it("folds the title only for the active tab's own scroller", async () => {
   await vi.waitFor(() => expect(titleFold()).toBe(true));
 });
 
+it("stays collapsed at the bottom after native scroll clamping and reopens at the top", async () => {
+  await render();
+  const title = page.getByRole("heading", { level: 1, name: "Test pull request" });
+  await expect.element(title).toBeVisible();
+  const scroller = page.getByTestId("summary-scroller").element() as HTMLElement;
+  const content = scroller.lastElementChild as HTMLElement;
+  // Leave only a short scroll range so folding the header makes the browser clamp it.
+  content.style.height = `${scroller.clientHeight - 24}px`;
+  const expandedHeight = scroller.clientHeight;
+  const expandedBottom = scroller.scrollHeight - scroller.clientHeight;
+
+  await act(async () => {
+    const scrolled = new Promise<void>((resolve) =>
+      scroller.addEventListener("scroll", () => resolve(), { once: true }),
+    );
+    scroller.scrollTop = scroller.scrollHeight;
+    await scrolled;
+  });
+
+  await vi.waitFor(() => {
+    expect(title.element().closest("[inert]")).not.toBeNull();
+    expect(scroller.clientHeight).toBeGreaterThan(expandedHeight);
+    expect(scroller.scrollTop).toBeGreaterThan(0);
+    expect(scroller.scrollTop).toBeLessThan(expandedBottom);
+    expect(scroller.scrollTop).toBe(scroller.scrollHeight - scroller.clientHeight);
+  });
+
+  await act(async () => {
+    const scrolled = new Promise<void>((resolve) =>
+      scroller.addEventListener("scroll", () => resolve(), { once: true }),
+    );
+    scroller.scrollTop = 0;
+    await scrolled;
+  });
+  await vi.waitFor(() => expect(title.element().closest("[inert]")).toBeNull());
+});
+
 it("shows the current checkout recovery detail on the first failure and on retry", async () => {
   const first = new GitManagerError({
     cwd: "/workspace",
diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
index 27ede48756275..f9eb44bcc2ae5 100644
--- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
@@ -704,10 +704,12 @@ export function PullRequestDetailPanel({
   }));
   const foldRef = useRef<HTMLDivElement | null>(null);
   const condensedRowRef = useRef<HTMLDivElement | null>(null);
+  // Save the target before collapse: the browser may clamp scrollTop as the viewport grows,
+  // so applying a delta afterward would compensate twice.
   const compensationRef = useRef<{
     tab: DetailTab;
     scroller: HTMLDivElement;
-    delta: number;
+    target: number;
   } | null>(null);
   useLayoutEffect(() => {
     const compensation = compensationRef.current;
@@ -719,10 +721,7 @@ export function PullRequestDetailPanel({
       scrollerByTab.current[tab] !== compensation.scroller
     )
       return;
-    compensation.scroller.scrollTop = Math.max(
-      0,
-      compensation.scroller.scrollTop + compensation.delta,
-    );
+    compensation.scroller.scrollTop = Math.max(0, compensation.target);
   }, [condensed, tab]);
   const lastSelectedMergeMethod = useUiStateStore((state) => state.pullRequestMergeMethod);
   const setLastSelectedMergeMethod = useUiStateStore((state) => state.setPullRequestMergeMethod);
@@ -2557,6 +2556,7 @@ export function PullRequestDetailPanel({
                           setTitleScope({ pullRequestKey, text: event.target.value })
                         }
                         onKeyDown={(event) => {
+                          if (event.nativeEvent.isComposing || event.keyCode === 229) return;
                           if (event.key === "Enter") {
                             event.preventDefault();
                             void saveTitle(titleDraft);
@@ -2874,7 +2874,7 @@ export function PullRequestDetailPanel({
             if (top < 4 && foldHeight > 0) next = false;
           } else if (foldHeight > 0 && top > foldHeight + 32) {
             const chromeDelta = foldHeight - (condensedRowRef.current?.scrollHeight ?? 0);
-            compensationRef.current = { tab, scroller, delta: -chromeDelta };
+            compensationRef.current = { tab, scroller, target: top - chromeDelta };
             next = true;
           }
           if (next !== previous) setCondensedByTab({ ...condensedByTab, [tab]: next });
diff --git a/apps/web/src/components/settings/AcpRegistrySearchStep.browser.test.tsx b/apps/web/src/components/settings/AcpRegistrySearchStep.browser.test.tsx
index 095ef3864c85b..7814e3ce0d815 100644
--- a/apps/web/src/components/settings/AcpRegistrySearchStep.browser.test.tsx
+++ b/apps/web/src/components/settings/AcpRegistrySearchStep.browser.test.tsx
@@ -1,4 +1,9 @@
-import { EnvironmentId, ProviderDriverKind, type AcpRegistrySearchAgent } from "@t3tools/contracts";
+import {
+  EnvironmentId,
+  ProviderDriverKind,
+  type AcpRegistrySearchAgent,
+  type AcpRegistrySearchInput,
+} from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
@@ -127,22 +132,37 @@ afterEach(async () => {
   document.body.replaceChildren();
 });
 
-it("loads the catalog immediately and searches only after typing settles", async () => {
+it("shows the full catalog initially and after clearing a debounced search", async () => {
+  const agents = Array.from({ length: 25 }, (_, index) => ({
+    ...gemini,
+    id: `gemini-${index}`,
+    name: `Gemini CLI ${index + 1}`,
+  }));
+  state.search.mockImplementation(({ input }: { input: AcpRegistrySearchInput }) => {
+    state.result = {
+      agents: agents
+        .filter((agent) => agent.name.toLowerCase().includes(input.query.toLowerCase()))
+        .slice(0, input.limit ?? 20),
+    };
+  });
+  const addButtons = () => page.getByRole("button", { name: /^Add Gemini CLI / }).elements();
   await render();
-  expect(state.search).toHaveBeenLastCalledWith({ environmentId, input: { query: "" } });
+  expect(addButtons()).toHaveLength(25);
+  await expect.element(page.getByRole("button", { name: "Add Gemini CLI 25" })).toBeEnabled();
 
   vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
   await userEvent.fill(searchBox(), "  Gemini  ");
   await act(async () => vi.advanceTimersByTime(200));
   await userEvent.fill(searchBox(), "  Gemini CLI  ");
   await act(async () => vi.advanceTimersByTime(299));
-  expect(lastQuery()).toBe("");
+  expect(addButtons()).toHaveLength(25);
   await act(async () => vi.advanceTimersByTime(1));
-  expect(lastQuery()).toBe("Gemini CLI");
+  expect(addButtons()).toHaveLength(20);
 
   await userEvent.clear(searchBox());
   await act(async () => vi.advanceTimersByTime(300));
-  expect(lastQuery()).toBe("");
+  expect(addButtons()).toHaveLength(25);
+  await expect.element(page.getByRole("button", { name: "Add Gemini CLI 25" })).toBeEnabled();
 });
 
 it("shows the loading, error, and empty states", async () => {
diff --git a/apps/web/src/components/settings/AcpRegistrySearchStep.tsx b/apps/web/src/components/settings/AcpRegistrySearchStep.tsx
index 594f9ac3387b6..9449ceba627c9 100644
--- a/apps/web/src/components/settings/AcpRegistrySearchStep.tsx
+++ b/apps/web/src/components/settings/AcpRegistrySearchStep.tsx
@@ -1,4 +1,4 @@
-import { AuthProvidersManageScope } from "@t3tools/contracts";
+import { ACP_REGISTRY_MAX_AGENTS, AuthProvidersManageScope } from "@t3tools/contracts";
 import { readEnvironmentScope, useEnvironmentScope } from "../../state/session";
 import {
   isAtomCommandInterrupted,
@@ -72,7 +72,9 @@ export function AcpRegistrySearchStep({
   const search = useEnvironmentQuery(
     serverEnvironment.searchAcpRegistry({
       environmentId,
-      input: { query: submittedQuery },
+      input: submittedQuery
+        ? { query: submittedQuery }
+        : { query: "", limit: ACP_REGISTRY_MAX_AGENTS },
     }),
   );
   const prepareAgent = useAtomCommand(serverEnvironment.prepareAcpRegistryAgent, {
diff --git a/apps/web/src/components/settings/CodexSetupSection.tsx b/apps/web/src/components/settings/CodexSetupSection.tsx
index caa2ec9138e4b..9feafee33be2f 100644
--- a/apps/web/src/components/settings/CodexSetupSection.tsx
+++ b/apps/web/src/components/settings/CodexSetupSection.tsx
@@ -131,7 +131,7 @@ export function CodexSetupSection(props: CodexSetupSectionProps) {
           ) : null
         }
       />
-    ) : props.mode === "existing" ? null : props.provider?.setup === undefined ? (
+    ) : props.mode === "existing" ? null : !props.provider?.setup?.canAuthenticate ? (
       props.presentation === "onboarding" ? (
         <CodexWelcomeCard
           title={props.displayName || props.provider?.displayName || "Codex"}
diff --git a/apps/web/src/components/settings/ConnectionsSettings.tsx b/apps/web/src/components/settings/ConnectionsSettings.tsx
index ea577b2f1ac59..a3759c0dbeb48 100644
--- a/apps/web/src/components/settings/ConnectionsSettings.tsx
+++ b/apps/web/src/components/settings/ConnectionsSettings.tsx
@@ -3240,9 +3240,16 @@ export function ConnectionsSettings() {
                   Off
                 </SelectItem>
                 {desktopWslState.distros.length === 0 ? (
-                  <SelectItem hideIndicator value={BACKEND_VALUE_DEFAULT_WSL}>
-                    Default distro
-                  </SelectItem>
+                  <>
+                    <SelectItem hideIndicator value={BACKEND_VALUE_DEFAULT_WSL}>
+                      Default distro
+                    </SelectItem>
+                    {desktopWslState.distro !== null ? (
+                      <SelectItem hideIndicator value={desktopWslState.distro}>
+                        {desktopWslState.distro}
+                      </SelectItem>
+                    ) : null}
+                  </>
                 ) : (
                   desktopWslState.distros.map((distro) => (
                     <SelectItem hideIndicator key={distro.name} value={distro.name}>
diff --git a/apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx b/apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx
index cf7f4f2fc9843..53df16f2cf66f 100644
--- a/apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx
+++ b/apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx
@@ -17,6 +17,7 @@ import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
 import {
   createMemoryHistory,
   createRootRoute,
+  createRoute,
   createRouter,
   RouterProvider,
 } from "@tanstack/react-router";
@@ -118,6 +119,8 @@ import { useComposerDraftStore } from "../../composerDraftStore";
 import { appAtomRegistry } from "../../rpc/atomRegistry";
 import { buildSidebarProjectSnapshots } from "../../sidebarProjectGrouping";
 import { ProjectSettingsPanel } from "./ProjectSettingsPanel";
+import type { SettingsScopeSearch } from "./settingsScope";
+import { retainSettingsScope, validateSettingsRouteSearch } from "./settingsScopeNavigation";
 
 const primaryId = EnvironmentId.make("primary");
 const remoteId = EnvironmentId.make("remote");
@@ -210,11 +213,33 @@ function projectKey() {
   })[0]!.projectKey;
 }
 
-async function mountPanel() {
+async function mountPanel(search: Omit<SettingsScopeSearch, "project"> = {}) {
   const key = projectKey();
+  const rootRoute = createRootRoute();
+  const settingsRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: "settings",
+    validateSearch: validateSettingsRouteSearch,
+    search: { middlewares: [retainSettingsScope] },
+  });
+  const projectsRoute = createRoute({
+    getParentRoute: () => settingsRoute,
+    path: "projects",
+    component: () => (
+      <ProjectSettingsPanel
+        projectKey={key}
+        environmentId={search.machine ? EnvironmentId.make(search.machine) : null}
+        checkoutKey={search.checkout ?? null}
+      />
+    ),
+  });
+  const query = new URLSearchParams({ project: key });
+  for (const [name, value] of Object.entries(search)) {
+    if (value !== undefined) query.set(name, value);
+  }
   const router = createRouter({
-    routeTree: createRootRoute({ component: () => <ProjectSettingsPanel projectKey={key} /> }),
-    history: createMemoryHistory({ initialEntries: ["/settings/projects"] }),
+    routeTree: rootRoute.addChildren([settingsRoute.addChildren([projectsRoute])]),
+    history: createMemoryHistory({ initialEntries: [`/settings/projects?${query}`] }),
   });
   await router.load();
   await act(async () =>
@@ -225,6 +250,7 @@ async function mountPanel() {
     ),
   );
   await vi.waitFor(() => expect(nameInput()).not.toBeNull());
+  return router;
 }
 
 const nameInput = () => container.querySelector<HTMLInputElement>('[aria-label="Project name"]')!;
@@ -292,7 +318,8 @@ describe("project settings permissions", () => {
 
   it("removes a writable checkout while removal of the mixed group stays denied", async () => {
     await grant(remoteId, AsyncResult.success(session([])));
-    await mountPanel();
+    const router = await mountPanel();
+    const initialHref = router.state.location.href;
     expect(removeAll().disabled).toBe(true);
 
     await userEvent.click(removeCheckout("/work/primary"));
@@ -303,6 +330,7 @@ describe("project settings permissions", () => {
     });
     await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
     expect(state.clearDraft).toHaveBeenCalledOnce();
+    expect(router.state.location.href).toBe(initialHref);
   });
 
   it("rechecks every removal target after confirmation before deleting or clearing drafts", async () => {
@@ -356,3 +384,18 @@ describe("project settings permissions", () => {
     },
   );
 });
+
+it("returns to the project overview after removal, clearing the selection but keeping the environment", async () => {
+  state.projects = [state.projects[1]!];
+  const router = await mountPanel({ machine: remoteId, checkout: "remote:/work/remote" });
+  const removeProject = [...container.querySelectorAll("button")].find(
+    (button) => button.textContent === "Remove project",
+  )!;
+
+  await act(async () => userEvent.click(removeProject));
+
+  await vi.waitFor(() => {
+    expect(router.state.location.pathname).toBe("/settings/projects");
+    expect(router.state.location.search).toEqual({ machine: remoteId });
+  });
+});
diff --git a/apps/web/src/components/settings/ProjectSettingsPanel.tsx b/apps/web/src/components/settings/ProjectSettingsPanel.tsx
index fbd0b5206ac90..ed0c8569f6ae1 100644
--- a/apps/web/src/components/settings/ProjectSettingsPanel.tsx
+++ b/apps/web/src/components/settings/ProjectSettingsPanel.tsx
@@ -387,7 +387,11 @@ function ProjectDetail({
     }
 
     if (isWholeGroup && !hasOtherMembers) {
-      void navigate({ to: "/", replace: true });
+      void navigate({
+        to: "/settings/projects",
+        search: ({ machine }) => ({ project: undefined, machine, checkout: undefined }),
+        replace: true,
+      });
     }
   };
 
diff --git a/apps/web/src/components/settings/SettingsScopeContext.tsx b/apps/web/src/components/settings/SettingsScopeContext.tsx
index d3200a34a390a..6c170bdd1a049 100644
--- a/apps/web/src/components/settings/SettingsScopeContext.tsx
+++ b/apps/web/src/components/settings/SettingsScopeContext.tsx
@@ -33,7 +33,9 @@ const memberProjectFilesAtom = Atom.family((membersKey: string) => {
         Option.getOrNull(AsyncResult.value(result));
       files.set(
         physicalProjectKey,
-        data === null || data.truncated ? null : parseT3ProjectFile(data.contents),
+        data === null || data.exists === false || data.truncated
+          ? null
+          : parseT3ProjectFile(data.contents),
       );
     }
     return files;
diff --git a/apps/web/src/components/settings/StorageSettings.browser.test.tsx b/apps/web/src/components/settings/StorageSettings.browser.test.tsx
index dacb009d33297..9573f3b3fb497 100644
--- a/apps/web/src/components/settings/StorageSettings.browser.test.tsx
+++ b/apps/web/src/components/settings/StorageSettings.browser.test.tsx
@@ -8,6 +8,7 @@ import {
 import { act, type ReactNode } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
+import { page } from "vite-plus/test/browser";
 
 const state = vi.hoisted(() => ({
   settings: {} as typeof DEFAULT_SERVER_SETTINGS,
@@ -41,7 +42,7 @@ vi.mock(import("./SettingsScopeContext"), async (original) => ({
   useSettingsScope: (() => {
     const environment = {
       environmentId: "env",
-      label: "Machine",
+      label: "Build workstation",
       serverConfig: {
         settings: state.settings,
         environment: {
@@ -188,7 +189,7 @@ it("keeps cleanup disabled when settled retention and all other rules are off",
   expect(state.run).not.toHaveBeenCalled();
 });
 
-it("shows an orphan's full path and size while keeping thread row titles unchanged", async () => {
+it("shows orphan sizes and identifies failed worktrees with one connected machine", async () => {
   state.settings = {
     ...state.settings,
     storageCleanup: { ...state.settings.storageCleanup, worktreeSettledAfterDays: 0 },
@@ -202,6 +203,7 @@ it("shows an orphan's full path and size while keeping thread row titles unchang
         kind: "worktree",
         outcome: "kept",
         path: "/worktrees/repo/orphan",
+        projectPath: null,
         threadId: null,
         threadTitle: null,
         reason: "No thread uses this folder, and it isn't a git worktree",
@@ -210,16 +212,17 @@ it("shows an orphan's full path and size while keeping thread row titles unchang
       },
       {
         kind: "worktree",
-        outcome: "kept",
+        outcome: "failed",
         path: "/worktrees/repo/thread-checkout",
+        projectPath: "/projects/repo",
         threadId: ThreadId.make("thread"),
         threadTitle: "Thread title",
-        reason: "Thread is running or has pending work",
+        reason: "Git index is locked. Status will resume when the index lock is removed.",
         bytes: null,
         files: null,
       },
     ],
-    counts: { removed: 0, kept: 2, failed: 0 },
+    counts: { removed: 0, kept: 1, failed: 1 },
     omittedCount: 0,
     bytesFreed: 0,
   };
@@ -231,6 +234,23 @@ it("shows an orphan's full path and size while keeping thread row titles unchang
   const titles = Array.from(container.querySelectorAll("h3"), (heading) => heading.textContent);
   expect(titles).toContain("/worktrees/repo/orphan");
   expect(titles).toContain("thread-checkout");
+  const failedRow = page.elementLocator(
+    page.getByRole("heading", { name: "thread-checkout", exact: true }).element().parentElement!,
+  );
+  await expect.element(failedRow.getByText("Build workstation", { exact: true })).toBeVisible();
+  await expect.element(failedRow.getByText("/projects/repo", { exact: true })).toBeVisible();
+  await expect
+    .element(failedRow.getByText("/worktrees/repo/thread-checkout", { exact: true }))
+    .toBeVisible();
+  await expect.element(failedRow.getByText("Thread title", { exact: true })).toBeVisible();
+  await expect
+    .element(
+      failedRow.getByText(
+        "Git index is locked. Status will resume when the index lock is removed.",
+        { exact: true },
+      ),
+    )
+    .toBeVisible();
   expect(titles).not.toContain("/worktrees/repo/thread-checkout");
   expect(container.textContent).toContain(
     "No thread uses this folder, and it isn't a git worktree",
diff --git a/apps/web/src/components/settings/StorageSettings.tsx b/apps/web/src/components/settings/StorageSettings.tsx
index 69dc98c1f4de8..78dd750109a1f 100644
--- a/apps/web/src/components/settings/StorageSettings.tsx
+++ b/apps/web/src/components/settings/StorageSettings.tsx
@@ -192,7 +192,7 @@ function CleanupResults({
   environmentLabel,
 }: {
   report: StorageCleanupReport;
-  environmentLabel: string | undefined;
+  environmentLabel: string;
 }) {
   return (
     <>
@@ -208,13 +208,34 @@ function CleanupResults({
         return (
           <SettingsRow
             key={`${entry.path ?? entry.kind}:${entry.threadId ?? index}`}
-            title={environmentLabel ? `${environmentLabel}: ${name}` : name}
+            title={<span className="wrap-anywhere select-text">{name}</span>}
             description={
-              <span
-                className={`wrap-anywhere ${entry.outcome === "failed" ? "text-destructive" : ""}`}
-              >
-                {entry.threadTitle && entry.threadTitle !== name ? `${entry.threadTitle}. ` : ""}
-                {entry.reason}
+              <span className="block space-y-2 wrap-anywhere select-text">
+                <span className={`block ${entry.outcome === "failed" ? "text-destructive" : ""}`}>
+                  {entry.reason}
+                </span>
+                <span className="grid grid-cols-[auto_minmax(0,1fr)] gap-x-3 gap-y-1 border-l border-border/60 pl-3">
+                  <span>Machine</span>
+                  <span className="text-foreground/80">{environmentLabel}</span>
+                  {entry.projectPath && (
+                    <>
+                      <span>Project</span>
+                      <code className="text-foreground/80">{entry.projectPath}</code>
+                    </>
+                  )}
+                  {entry.path && (
+                    <>
+                      <span>Folder</span>
+                      <code className="text-foreground/80">{entry.path}</code>
+                    </>
+                  )}
+                  {entry.threadTitle && (
+                    <>
+                      <span>Thread</span>
+                      <span>{entry.threadTitle}</span>
+                    </>
+                  )}
+                </span>
               </span>
             }
             control={
@@ -237,13 +258,12 @@ function CleanupResults({
       })}
       {report.omittedCount > 0 && (
         <p className="px-3 py-2.5 text-xs text-muted-foreground sm:px-4">
-          {environmentLabel ? `${environmentLabel}: ` : ""}
-          {report.omittedCount.toLocaleString()} more results.
+          {environmentLabel}: {report.omittedCount.toLocaleString()} more results.
         </p>
       )}
       {report.entries.length === 0 && report.omittedCount === 0 && (
         <p className="px-3 py-2.5 text-xs text-muted-foreground sm:px-4">
-          {environmentLabel ? `${environmentLabel}: ` : ""}Nothing needed cleanup.
+          {environmentLabel}: Nothing needed cleanup.
         </p>
       )}
     </>
@@ -392,7 +412,7 @@ function CleanupSection() {
                 <CleanupResults
                   key={environment.environmentId}
                   report={report}
-                  environmentLabel={connectedEnvironments.length > 1 ? label : undefined}
+                  environmentLabel={label}
                 />
               ),
           )}
diff --git a/apps/web/src/components/sidebar/SidebarChrome.tsx b/apps/web/src/components/sidebar/SidebarChrome.tsx
index e7a61f6e9927d..c04edb1799f02 100644
--- a/apps/web/src/components/sidebar/SidebarChrome.tsx
+++ b/apps/web/src/components/sidebar/SidebarChrome.tsx
@@ -36,6 +36,7 @@ export const SidebarChromeHeader = memo(function SidebarChromeHeader({
 }: {
   isElectron: boolean;
 }) {
+  const { isMobile } = useSidebar();
   const stageLabel = useEnvironmentStageLabel();
   const environmentIdentificationMode = useEnvironmentIdentificationMode();
   const backdropVariant = resolveSidebarStageBackdropVariant(
@@ -55,15 +56,17 @@ export const SidebarChromeHeader = memo(function SidebarChromeHeader({
       )}
     >
       {backdropVariant ? <SidebarStageBackdrop variant={backdropVariant} /> : null}
-      <div className="relative top-[calc(var(--workspace-controls-top)-env(safe-area-inset-top))] z-10 ml-[calc(var(--workspace-controls-left)+1px-env(safe-area-inset-left))] flex shrink-0 items-center md:hidden">
-        <SidebarTrigger
-          variant={backdropVariant ? "media-navigation" : "ghost"}
-          className="relative top-auto translate-y-0"
-          aria-label="Toggle main sidebar"
-        />
-      </div>
+      {isMobile ? (
+        <div className="relative top-[calc(var(--workspace-controls-top)-env(safe-area-inset-top))] z-10 ml-[calc(var(--workspace-controls-left)+1px-env(safe-area-inset-left))] flex shrink-0 items-center">
+          <SidebarTrigger
+            variant={backdropVariant ? "media-navigation" : "ghost"}
+            className="relative top-auto translate-y-0"
+            aria-label="Toggle main sidebar"
+          />
+        </div>
+      ) : null}
       <div className="relative z-10 flex h-8 min-w-0 flex-1 flex-wrap content-start items-center gap-x-2 overflow-hidden py-0.5">
-        <SidebarBrand onBackdrop={backdropVariant !== null} />
+        {!isMobile ? <SidebarBrand onBackdrop={backdropVariant !== null} /> : null}
         {pillLabel ? (
           <div className="ml-1 flex h-7 items-center">
             <Badge data-environment-identification="pill" size="sm" variant="secondary">
@@ -105,7 +108,7 @@ function SidebarBrand({ onBackdrop }: { onBackdrop: boolean }) {
     <Link
       aria-label="Go to threads"
       className={cn(
-        "relative z-10 ml-[var(--workspace-titlebar-content-left)] hidden h-7 w-fit min-w-0 shrink-0 items-center overflow-hidden rounded-md outline-hidden ring-ring focus-visible:ring-2 focus-visible:ring-inset md:flex",
+        "relative z-10 ml-[var(--workspace-titlebar-content-left)] flex h-7 w-fit min-w-0 shrink-0 items-center overflow-hidden rounded-md outline-hidden ring-ring focus-visible:ring-2 focus-visible:ring-inset",
         onBackdrop ? "text-white" : "text-foreground",
       )}
       to="/"
diff --git a/apps/web/src/components/ui/sidebar.tsx b/apps/web/src/components/ui/sidebar.tsx
index 570e8299694fe..3e44922a7b9b9 100644
--- a/apps/web/src/components/ui/sidebar.tsx
+++ b/apps/web/src/components/ui/sidebar.tsx
@@ -17,7 +17,7 @@ import {
 } from "~/components/ui/sheet";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
 import { useResizeDrag } from "~/hooks/useResizeDrag";
-import { useIsMobile } from "~/hooks/useMediaQuery";
+import { useMediaQuery } from "~/hooks/useMediaQuery";
 import { getLocalStorageItem, setLocalStorageItem } from "~/hooks/useLocalStorage";
 import { resolveSidebarState, type ResponsiveSidebarState } from "./sidebarState";
 import * as Schema from "effect/Schema";
@@ -96,6 +96,7 @@ function useSidebarVisibility() {
 
 function SidebarProvider({
   defaultOpen = true,
+  mobileBreakpoint,
   open: openProp,
   onOpenChange: setOpenProp,
   className,
@@ -104,11 +105,17 @@ function SidebarProvider({
   ...props
 }: React.ComponentProps<"div"> & {
   defaultOpen?: boolean;
+  mobileBreakpoint?: number;
   open?: boolean;
   onOpenChange?: (open: boolean) => void;
 }) {
-  const isMobile = useIsMobile();
+  const isMobile = useMediaQuery(
+    mobileBreakpoint === undefined ? "max-md" : { max: mobileBreakpoint },
+  );
   const [openMobile, setOpenMobile] = React.useState(false);
+  if (!isMobile && openMobile) {
+    setOpenMobile(false);
+  }
   const [mobileSheetMounted, setMobileSheetMounted] = React.useState(false);
   const setMobileSheetElement = (element: HTMLDivElement | null) => {
     setMobileSheetMounted(element !== null);
@@ -158,6 +165,7 @@ function SidebarProvider({
           SIDEBAR_TITLEBAR_CONTROL_SIZE,
           className,
         )}
+        data-sidebar-mobile={isMobile}
         data-sidebar-state={state}
         data-slot="sidebar-wrapper"
         style={
@@ -298,7 +306,7 @@ function Sidebar({
     <SidebarInstanceContext value={instanceContextValue}>
       <div
         ref={desktopSidebarRef}
-        className="group peer hidden text-sidebar-foreground md:block"
+        className="group peer text-sidebar-foreground"
         data-collapsible={state === "collapsed" ? collapsible : ""}
         data-side={side}
         data-slot="sidebar"
@@ -319,7 +327,7 @@ function Sidebar({
         />
         <div
           className={cn(
-            "fixed inset-y-0 z-10 hidden h-svh w-(--sidebar-width) md:flex",
+            "fixed inset-y-0 z-10 flex h-svh w-(--sidebar-width)",
             "[[data-panel-animations=true]_&]:transition-[left,right,width] [[data-panel-animations=true]_&]:[transition-duration:var(--panel-animation-duration)] [[data-panel-animations=true]_&]:ease-out",
             side === "left"
               ? "left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]"
diff --git a/apps/web/src/components/usage/UsageLimitsPooled.tsx b/apps/web/src/components/usage/UsageLimitsPooled.tsx
index 8fc4b775b850c..1337bd30e52e4 100644
--- a/apps/web/src/components/usage/UsageLimitsPooled.tsx
+++ b/apps/web/src/components/usage/UsageLimitsPooled.tsx
@@ -29,6 +29,7 @@ import {
 
 import { ensureLocalApi } from "../../localApi";
 import { usePrimarySettings } from "../../hooks/useSettings";
+import { observeResize } from "../../lib/observeResize";
 import { cn } from "../../lib/utils";
 import { formatUpcomingTimestamp } from "../../timestampFormat";
 import { ProviderInstanceIcon } from "../chat/ProviderInstanceIcon";
@@ -285,6 +286,7 @@ function PoolSegment({
   readonly color: string;
   readonly now: number;
   readonly index: number;
+  readonly labeled: boolean;
   readonly showAccountName: boolean;
 }) {
   return account.redeem ? (
@@ -330,12 +332,14 @@ function SegmentTriggers({
   color,
   now,
   index,
+  labeled,
   showAccountName,
 }: SegmentPayload & {
   readonly refillPercent: number;
   readonly color: string;
   readonly now: number;
   readonly index: number;
+  readonly labeled: boolean;
   readonly showAccountName: boolean;
 }) {
   const popover = use(SegmentPopoverContext) ?? undefined;
@@ -355,7 +359,10 @@ function SegmentTriggers({
             type="button"
             style={{ gridColumn: index, gridRow: 1 }}
             aria-label={`${account.displayName ?? (account.email ? accountInitials(account.email) : account.driver)}: ${remaining}% left${resetsIn ? `, ${resetsIn}` : ""}${timeLeft === null ? "" : `, ${timeLeft}% of the window left`}${credits ? `, ${credits} reset ${credits === 1 ? "credit" : "credits"} banked` : ""}`}
-            className="relative h-5 min-w-0 cursor-pointer rounded-md bg-muted text-start outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background data-[popup-open]:ring-1 data-[popup-open]:ring-inset data-[popup-open]:ring-border @2xl/pool:h-8"
+            className={cn(
+              "relative min-w-0 cursor-pointer rounded-md bg-muted text-start outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background data-[popup-open]:ring-1 data-[popup-open]:ring-inset data-[popup-open]:ring-border",
+              labeled ? "h-8" : "h-5",
+            )}
           />
         }
       >
@@ -385,11 +392,19 @@ function SegmentTriggers({
         ) : null}
         <span
           aria-hidden
-          className="absolute inset-0 flex items-center justify-center overflow-hidden rounded-md text-3xs leading-none font-semibold text-foreground/80 tabular-nums @2xl/pool:hidden"
+          className={cn(
+            "absolute inset-0 flex items-center justify-center overflow-hidden rounded-md text-3xs leading-none font-semibold text-foreground/80 tabular-nums",
+            labeled && "hidden",
+          )}
         >
           {index}
         </span>
-        <div className="relative hidden h-full min-w-0 items-center gap-1.5 overflow-hidden rounded-md px-2 text-xs @2xl/pool:flex">
+        <div
+          className={cn(
+            "relative h-full min-w-0 items-center gap-1.5 overflow-hidden rounded-md px-2 text-xs",
+            labeled ? "flex" : "hidden",
+          )}
+        >
           {showAccountName ? (
             <AccountName
               account={account}
@@ -417,7 +432,7 @@ function SegmentTriggers({
           ) : null}
         </div>
       </PopoverTrigger>
-      <LegendRow payload={payload} color={color} now={now} index={index} />
+      {labeled ? null : <LegendRow payload={payload} color={color} now={now} index={index} />}
     </>
   );
 }
@@ -444,7 +459,7 @@ function LegendRow({
       payload={payload}
       style={{ gridColumn: "1 / -1", gridRow: index + 1 }}
       render={<Button variant="ghost" size="compact" />}
-      className="min-w-0 @2xl/pool:hidden"
+      className="min-w-0"
     >
       <span className="relative inline-flex size-4 shrink-0 items-center justify-center rounded-sm text-3xs leading-none font-semibold text-foreground/80 tabular-nums">
         <span
@@ -479,6 +494,8 @@ function LegendRow({
   );
 }
 
+const LABELED_SEGMENT_MIN_WIDTH = 224;
+
 function PoolBar({
   pool,
   color,
@@ -489,11 +506,32 @@ function PoolBar({
   readonly now: number;
 }) {
   const restores = new Map(pool.resets.map((reset) => [reset.member.account.key, reset]));
+  const columns = pool.columns.length;
+  const [dimensions, setDimensions] = useState({ width: 0, gap: 0 });
+  const probeRef = useRef<HTMLDivElement>(null);
+  const gridRef = useRef<HTMLDivElement>(null);
+  useLayoutEffect(() => {
+    const probe = probeRef.current;
+    const grid = gridRef.current;
+    if (!probe || !grid) return;
+    return observeResize(probe, ([entry]) => {
+      if (!entry) return;
+      setDimensions({
+        width: entry.contentRect.width,
+        gap: Number.parseFloat(getComputedStyle(grid).columnGap) || 0,
+      });
+    });
+  }, []);
+  const labeled =
+    (dimensions.width - dimensions.gap * (columns - 1)) / columns >= LABELED_SEGMENT_MIN_WIDTH;
   return (
-    <div className="@container/pool min-w-0">
+    <div className="min-w-0">
+      {/* A height-independent probe keeps legend changes from triggering resize feedback. */}
+      <div ref={probeRef} />
       <div
+        ref={gridRef}
         className="grid gap-x-1 gap-y-1"
-        style={{ gridTemplateColumns: `repeat(${pool.columns.length}, minmax(0, 1fr))` }}
+        style={{ gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))` }}
       >
         {pool.columns.map((member, position) =>
           member.window ? (
@@ -506,7 +544,8 @@ function PoolBar({
               color={color}
               now={now}
               index={position + 1}
-              showAccountName={pool.columns.length > 1}
+              labeled={labeled}
+              showAccountName={columns > 1}
             />
           ) : null,
         )}
diff --git a/apps/web/src/components/usage/UsagePage.tsx b/apps/web/src/components/usage/UsagePage.tsx
index 5728616edf8f2..e7db92cc37086 100644
--- a/apps/web/src/components/usage/UsagePage.tsx
+++ b/apps/web/src/components/usage/UsagePage.tsx
@@ -946,6 +946,7 @@ function UsageOverview({
                 breakdownModels.map((model, index) => {
                   const key = `${model.provider}:${model.model}`;
                   const value = metric === "tokens" ? model.totalTokens : model.costUsd;
+                  const hasBar = value > 0 && breakdownPeak > 0;
                   const share = modelShare(model, metric === "tokens" ? "tokens" : "cost");
                   const rowFigures = figureClass(loadingProviders.has(model.provider));
                   return (
@@ -958,23 +959,25 @@ function UsageOverview({
                         <button
                           type="button"
                           onClick={() => onSelectModel(key)}
-                          className="flex items-center gap-2 text-left text-foreground outline-none after:absolute after:inset-0"
+                          className={cn(
+                            "flex items-center gap-2 text-left text-foreground outline-none after:absolute after:inset-0",
+                            !hasBar && "py-1",
+                          )}
                         >
                           <ProviderMark provider={model.provider} className="size-3.5" />
                           {model.model}
                         </button>
-                        <div aria-hidden className={cn("mt-1.5 h-0.5 max-w-48", rowFigures)}>
-                          <div
-                            className="h-full rounded-full"
-                            style={{
-                              width:
-                                value > 0 && breakdownPeak > 0
-                                  ? `max(0.5rem, ${(value / breakdownPeak) * 100}%)`
-                                  : 0,
-                              backgroundColor: PROVIDER_PRESENTATION[model.provider].color,
-                            }}
-                          />
-                        </div>
+                        {hasBar ? (
+                          <div aria-hidden className={cn("mt-1.5 h-0.5 max-w-48", rowFigures)}>
+                            <div
+                              className="h-full rounded-full"
+                              style={{
+                                width: `max(0.5rem, ${(value / breakdownPeak) * 100}%)`,
+                                backgroundColor: PROVIDER_PRESENTATION[model.provider].color,
+                              }}
+                            />
+                          </div>
+                        ) : null}
                       </td>
                       <td className={cn("py-2.5 pl-6 text-foreground", rowFigures)}>
                         {isModelCostUnknown(model) ? (
diff --git a/apps/web/src/composer-list-continuation.test.ts b/apps/web/src/composer-list-continuation.test.ts
index aeab28a9b3601..d5d831fb4c251 100644
--- a/apps/web/src/composer-list-continuation.test.ts
+++ b/apps/web/src/composer-list-continuation.test.ts
@@ -43,6 +43,15 @@ describe("composer list continuation", () => {
   it("exits the list on an empty item", () => {
     expect(applyEdit("1. foo\n2. ", listContinuationForEnter("1. foo\n2. ", 10)!)).toBe("1. foo\n");
     expect(applyEdit("- ", listContinuationForEnter("- ", 2)!)).toBe("");
+    expect(applyEdit("1)\t", listContinuationForEnter("1)\t", 3)!)).toBe("");
+    expect(applyEdit("- [ ] ", listContinuationForEnter("- [ ] ", 6)!)).toBe("");
+  });
+
+  it("keeps a marker typed without a trailing space", () => {
+    expect(listContinuationForEnter("asd\n2.", 6)).toBeNull();
+    expect(listContinuationForEnter("1)", 2)).toBeNull();
+    expect(listContinuationForEnter("-", 1)).toBeNull();
+    expect(listContinuationForEnter("- [ ]", 5)).toBeNull();
   });
 
   it("ignores non-list lines and carets inside the marker", () => {
diff --git a/apps/web/src/composer-list-continuation.ts b/apps/web/src/composer-list-continuation.ts
index 4cbf52aab7ff6..1c2de5a482433 100644
--- a/apps/web/src/composer-list-continuation.ts
+++ b/apps/web/src/composer-list-continuation.ts
@@ -153,7 +153,7 @@ export function listContinuationForEnter(value: string, cursor: number): Compose
   if (!Number.isInteger(cursor) || cursor < 0 || cursor > value.length) return null;
   const line = currentLine(value, cursor);
   const parsed = parseListMarker(line.text);
-  if (!parsed) return null;
+  if (!parsed || parsed.marker.space === "") return null;
   const markerEnd = line.start + parsed.markerEnd;
   if (cursor < markerEnd) return null;
   const tokens = inlineTokenRanges(value);
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index 8fffe16573bd0..8f9d9bff5537c 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -11,7 +11,14 @@ import { Blockquote } from "@tiptap/extension-blockquote";
 import { CodeBlock } from "@tiptap/extension-code-block";
 import { Heading } from "@tiptap/extension-heading";
 import { HorizontalRule } from "@tiptap/extension-horizontal-rule";
-import { type Command, type Editor, mergeAttributes } from "@tiptap/core";
+import { Italic, starInputRegex, starPasteRegex } from "@tiptap/extension-italic";
+import {
+  type Command,
+  type Editor,
+  markInputRule,
+  markPasteRule,
+  mergeAttributes,
+} from "@tiptap/core";
 import { BulletList, ListItem, OrderedList } from "@tiptap/extension-list";
 import { TaskItem } from "@tiptap/extension-task-item";
 import { TaskList } from "@tiptap/extension-task-list";
@@ -127,6 +134,20 @@ export const ComposerCodeExtension = Code.extend({
   },
 });
 
+/**
+ * The composer writes italic as `*text*`, so it keeps only the `*` shortcuts.
+ * Tiptap's `_text_` rules fire on the `_` in names like `node_modules` and
+ * italicize back to an earlier `_build`, even one inside a code span.
+ */
+export const ComposerItalicExtension = Italic.extend({
+  addInputRules() {
+    return [markInputRule({ find: starInputRegex, type: this.type })];
+  },
+  addPasteRules() {
+    return [markPasteRule({ find: starPasteRegex, type: this.type })];
+  },
+});
+
 /**
  * Tiptap's block extensions each bind a chord that turns the current block into
  * their node (Mod-Shift-8 for a list, Mod-Alt-c for a fence, and so on). The
diff --git a/apps/web/src/hooks/useMediaQuery.ts b/apps/web/src/hooks/useMediaQuery.ts
index ec6ee4fa51160..f3df1b3a4b1de 100644
--- a/apps/web/src/hooks/useMediaQuery.ts
+++ b/apps/web/src/hooks/useMediaQuery.ts
@@ -77,7 +77,3 @@ export function useMediaQuery(query: BreakpointQuery | MediaQueryInput | (string
 
   return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
 }
-
-export function useIsMobile(): boolean {
-  return useMediaQuery("max-md");
-}
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index c88c04a327d9c..299fff4cbf35b 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -2118,7 +2118,7 @@ code {
 .chat-markdown th,
 .chat-markdown td {
   padding: 0.45rem 0.75rem;
-  text-align: left;
+  text-align: center;
 }
 
 .chat-markdown thead th {
diff --git a/apps/web/src/lib/t3ProjectFileDefaults.ts b/apps/web/src/lib/t3ProjectFileDefaults.ts
index e6210ae5c7674..b5000b4ddd92f 100644
--- a/apps/web/src/lib/t3ProjectFileDefaults.ts
+++ b/apps/web/src/lib/t3ProjectFileDefaults.ts
@@ -23,6 +23,6 @@ export async function readT3ProjectFile(
     T3_PROJECT_FILE_NAME,
     result._tag === "Success" ? result.value : null,
   );
-  if (data === null || data.truncated) return null;
+  if (data === null || data.exists === false || data.truncated) return null;
   return parseT3ProjectFile(data.contents);
 }
diff --git a/apps/web/src/pendingUserInput.test.ts b/apps/web/src/pendingUserInput.test.ts
index d6d14b0c4cacb..407b84be2af39 100644
--- a/apps/web/src/pendingUserInput.test.ts
+++ b/apps/web/src/pendingUserInput.test.ts
@@ -12,6 +12,7 @@ import {
   projectPendingUserInputAnswer,
   resolvePendingUserInputAnswer,
   setPendingUserInputCustomAnswer,
+  threadContextsReferencedByAnswer,
   togglePendingUserInputOptionSelection,
 } from "./pendingUserInput";
 
@@ -42,6 +43,22 @@ describe("projectPendingUserInputAnswer", () => {
   });
 });
 
+describe("threadContextsReferencedByAnswer", () => {
+  const kept = threadContextRecord(
+    { environmentId: EnvironmentId.make("env-answer"), threadId: ThreadId.make("kept-thread") },
+    "Kept work",
+  );
+  const deleted = threadContextRecord(
+    { environmentId: EnvironmentId.make("env-answer"), threadId: ThreadId.make("deleted-thread") },
+    "Deleted work",
+  );
+
+  it("preserves remaining chips without restoring deleted thread records", () => {
+    const answer = `Compare ${formatInlineContextReference(threadContextReference(kept))}`;
+    expect(threadContextsReferencedByAnswer(answer, [deleted, kept])).toEqual([kept]);
+  });
+});
+
 const singleSelectQuestion = {
   id: "scope",
   header: "Scope",
diff --git a/apps/web/src/pendingUserInput.ts b/apps/web/src/pendingUserInput.ts
index 2b37af07b3e35..7f14db16cc654 100644
--- a/apps/web/src/pendingUserInput.ts
+++ b/apps/web/src/pendingUserInput.ts
@@ -1,7 +1,10 @@
-import type { ThreadContextRecord, UserInputQuestion } from "@t3tools/contracts";
+import type { ThreadContextRecord } from "@t3tools/contracts";
+import type { ThreadUserInputQuestion as UserInputQuestion } from "@t3tools/client-runtime/state/thread-requests";
 import { replaceComposerContextReferences } from "@t3tools/shared/composerContextReferences";
 import { formatThreadLink } from "@t3tools/shared/threadLinks";
 
+import { collectInlineContextIds } from "./lib/composerContextReferences";
+
 export function projectPendingUserInputAnswer(
   answer: unknown,
   threadContexts: ReadonlyArray<ThreadContextRecord>,
@@ -14,6 +17,15 @@ export function projectPendingUserInputAnswer(
   });
 }
 
+// Question drafts retain deleted chip records for undo; only transfer referenced records.
+export function threadContextsReferencedByAnswer(
+  answer: string,
+  threadContexts: ReadonlyArray<ThreadContextRecord>,
+) {
+  const referencedIds = new Set(collectInlineContextIds(answer));
+  return threadContexts.filter((record) => referencedIds.has(record.contextId));
+}
+
 export interface PendingUserInputDraftAnswer {
   selectedOptionValues?: string[];
   customAnswer?: string;
diff --git a/apps/web/src/pierre-tree-theme.ts b/apps/web/src/pierre-tree-theme.ts
index 5d07b6c889ff8..f3d21a1c38f5f 100644
--- a/apps/web/src/pierre-tree-theme.ts
+++ b/apps/web/src/pierre-tree-theme.ts
@@ -9,6 +9,8 @@ export const PIERRE_TREE_UNSAFE_CSS = `
     --trees-font-family-override: var(--font-sans);
     --trees-font-size-override: 0.75rem;
   }
+  [data-truncate-content='visible'] { overflow: hidden; text-overflow: ellipsis; }
+  [data-truncate-marker] { display: none; }
   button[data-type='item'], button[data-type='item']::before { border-radius: var(--radius-md); }
   svg[data-icon-name='t3-tree-icon-loading'] { opacity: 0.6; }
   @media (prefers-reduced-motion: no-preference) {
diff --git a/apps/web/src/remoteOpen.test.ts b/apps/web/src/remoteOpen.test.ts
index d64161c66917b..339423a7da04a 100644
--- a/apps/web/src/remoteOpen.test.ts
+++ b/apps/web/src/remoteOpen.test.ts
@@ -177,6 +177,33 @@ describe("buildRemoteOpenUrl", () => {
     );
   });
 
+  it("adds a file position only for confirmed VS Code-family file targets", () => {
+    const targets = [
+      ["vscode", true, "vscode://vscode-remote/ssh-remote+sol/tmp/my%20file.md:1:1"],
+      ["cursor", true, "cursor://vscode-remote/ssh-remote+sol/tmp/my%20file.md:1:1"],
+      ["vscode", false, "vscode://vscode-remote/ssh-remote+sol/tmp/my%20file.md"],
+      ["vscode", undefined, "vscode://vscode-remote/ssh-remote+sol/tmp/my%20file.md"],
+      ["zed", true, "zed://ssh/sol/tmp/my%20file.md"],
+      [
+        "pycharm",
+        true,
+        "jetbrains://gateway/ssh/environment?h=sol&launchIde=true&ideHint=PY&projectHint=%2Ftmp%2Fmy+file.md",
+      ],
+    ] as const;
+
+    for (const [editor, isFile, expected] of targets) {
+      expect(
+        buildRemoteOpenUrl({
+          editor,
+          host: "sol",
+          absolutePath: "/tmp/my file.md",
+          ...(isFile === undefined ? {} : { isFile }),
+        }),
+        `${editor}, isFile=${isFile}`,
+      ).toBe(expected);
+    }
+  });
+
   it("returns undefined for editors without remote support", () => {
     expect(buildRemoteOpenUrl({ editor: "kiro", host: "sol", absolutePath: "/tmp/x" })).toBe(
       undefined,
diff --git a/apps/web/src/routes/_chat.index.tsx b/apps/web/src/routes/_chat.index.tsx
index b121de4837df8..ccb34b2458287 100644
--- a/apps/web/src/routes/_chat.index.tsx
+++ b/apps/web/src/routes/_chat.index.tsx
@@ -41,13 +41,11 @@ function IndexDraftLanding() {
   // Read at effect time: this page stays mounted while a navigation away from
   // "/" is still loading, but the router already points at the new location.
   const isStillOnIndex = useEffectEvent(() => router.state.location.pathname === "/");
-  // One start per attempt; a retry request opens the next attempt.
   const startedAttemptRef = useRef<number | null>(null);
   const [startState, setStartState] = useState({ failed: false, retryRequest: 0 });
 
-  const mostRecentProject = bootstrapped
-    ? (sortScopedProjectsForSidebar(projects, threads, "updated_at")[0] ?? null)
-    : null;
+  const mostRecentProject =
+    sortScopedProjectsForSidebar(projects, threads, "updated_at")[0] ?? null;
   const attempt = startState.retryRequest;
 
   useEffect(() => {
@@ -71,9 +69,6 @@ function IndexDraftLanding() {
       });
   }, [attempt, handleNewThread, mostRecentProject]);
 
-  if (!bootstrapped) {
-    return null;
-  }
   if (mostRecentProject !== null) {
     return startState.failed ? (
       <DraftStartError
@@ -86,7 +81,8 @@ function IndexDraftLanding() {
       />
     ) : null;
   }
-  return <NoProjectsHero />;
+  // A pending environment cannot prove the workspace is empty.
+  return bootstrapped ? <NoProjectsHero /> : null;
 }
 
 function DraftStartError({ onRetry }: { readonly onRetry: () => void }) {
diff --git a/apps/web/src/terminal-links.test.ts b/apps/web/src/terminal-links.test.ts
index a4e12cd122657..b7822a6d15315 100644
--- a/apps/web/src/terminal-links.test.ts
+++ b/apps/web/src/terminal-links.test.ts
@@ -58,6 +58,7 @@ describe("extractTerminalLinks", () => {
     ['"my file.ts":12:7', "my file.ts:12:7", 17],
     ["'my file.ts:12:7'", "my file.ts:12:7", 16],
     ["`my file.ts`", "my file.ts", 11],
+    ['"mój plik.ts":12', "mój plik.ts:12", 16],
   ])("finds a quoted basename in %s", (line, text, end) => {
     expect(extractTerminalLinks(line)).toEqual([{ kind: "path", text, start: 1, end }]);
   });
@@ -128,6 +129,18 @@ describe("extractTerminalLinks", () => {
     ]);
   });
 
+  it.each([
+    "src/żółć.ts:12:7",
+    "żółć/main.ts:12",
+    String.raw`żółć\main.ts:12`,
+    "src/cafe\u0301.ts:12",
+    "src/𐐀.ts:12",
+  ])("keeps the complete Unicode relative path %s", (text) => {
+    expect(extractTerminalLinks(`see ${text} for details`)).toEqual([
+      { kind: "path", text, start: 4, end: 4 + text.length },
+    ]);
+  });
+
   it("finds Windows absolute paths with forward slashes", () => {
     const line = "see C:/Users/someone/project/src/file.ts:42 for details";
     const path = "C:/Users/someone/project/src/file.ts:42";
diff --git a/apps/web/src/terminal-links.ts b/apps/web/src/terminal-links.ts
index dd46062ac7729..48a7c16edbc61 100644
--- a/apps/web/src/terminal-links.ts
+++ b/apps/web/src/terminal-links.ts
@@ -27,10 +27,12 @@ export interface WrappedTerminalLinkLine {
 }
 
 const URL_PATTERN = /https?:\/\/[^\s"'`<>]+/giu;
+// Bare paths start only at a segment boundary: hover detection runs this on
+// every frame, so separator-free output must not be rescanned at every suffix.
 const FILE_PATH_PATTERN =
-  /(?:~[\\/]|\.{1,2}[\\/]|\/|[A-Za-z]:[\\/]|\\\\)[^\s"'`<>]+|[A-Za-z0-9._-]+(?:[\\/][A-Za-z0-9._-]+)+(?::\d+){0,2}/g;
+  /(?:~[\\/]|\.{1,2}[\\/]|\/|[A-Za-z]:[\\/]|\\\\)[^\s"'`<>]+|(?<![\p{L}\p{M}\p{N}._-])[\p{L}\p{M}\p{N}._-]+(?:[\\/][\p{L}\p{M}\p{N}._-]+)+(?::\d+){0,2}/gu;
 const QUOTED_FILE_PATH_PATTERN =
-  /(["'`])(?<path>(?:~[\\/]|\.{1,2}[\\/]|\/|[A-Za-z]:[\\/]|\\\\|[A-Za-z0-9._ -]+[\\/])[^\r\n]*?|[A-Za-z0-9._ -]+\.[A-Za-z0-9_-]+(?::\d+){0,2})\1(?<position>(?::\d+){0,2})/g;
+  /(["'`])(?<path>(?:~[\\/]|\.{1,2}[\\/]|\/|[A-Za-z]:[\\/]|\\\\|[\p{L}\p{M}\p{N}._ -]+[\\/])[^\r\n]*?|[\p{L}\p{M}\p{N}._ -]+\.[\p{L}\p{M}\p{N}_-]+(?::\d+){0,2})\1(?<position>(?::\d+){0,2})/gu;
 const TRAILING_PUNCTUATION_PATTERN = /[.,;!?]+$/;
 // Paths also drop a trailing colon: compilers end `file:line:col:` with one.
 const TRAILING_PATH_PUNCTUATION_PATTERN = /[.,;:!?]+$/;
diff --git a/apps/web/src/workspaceTitlebar.ts b/apps/web/src/workspaceTitlebar.ts
index 729fdfa00dc6c..8813f9b81609d 100644
--- a/apps/web/src/workspaceTitlebar.ts
+++ b/apps/web/src/workspaceTitlebar.ts
@@ -1,2 +1,2 @@
 export const COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS =
-  "[[data-sidebar-state=collapsed]_&]:pl-[var(--workspace-titlebar-content-left)] max-md:[[data-sidebar-state=expanded]_&]:pl-[var(--workspace-titlebar-content-left)]";
+  "[[data-sidebar-state=collapsed]_&]:pl-[var(--workspace-titlebar-content-left)] [[data-sidebar-mobile=true][data-sidebar-state=expanded]_&]:pl-[var(--workspace-titlebar-content-left)]";
diff --git a/docs/internals/resource-telemetry.md b/docs/internals/resource-telemetry.md
index 736769f59b8ea..1b7dea3d6aaab 100644
--- a/docs/internals/resource-telemetry.md
+++ b/docs/internals/resource-telemetry.md
@@ -11,8 +11,13 @@ protocol. A missing or failed collector leaves the server running.
 The native child owns sampling and bounded in-memory history. It samples on a timer
 only while diagnostics has live subscribers. With none, the server sends a sample
 interval of 0 and the child samples only on request, so an idle server never walks
-the process table. History therefore covers only time with a live subscriber, plus
-on-demand samples. Consuming host power for background scheduling must not retain
+the process table. The exception is OTLP metrics export: a server exporting metrics
+requests one sample a minute and exports process totals by group
+([`ProcessGroupMetrics`](../../apps/server/src/resourceTelemetry/ProcessGroupMetrics.ts)),
+because the user asked for continuous telemetry. Groups are a fixed set named after
+the server's direct children, never process IDs or threads, so the series count
+stays bounded as agents come and go. History therefore covers only time with a live
+subscriber, plus on-demand and export samples. Consuming host power for background scheduling must not retain
 live diagnostics. There is no telemetry database or recurring shell-probe fallback.
 
 History has independent bounds for age, snapshot count, process rows, and retained
diff --git a/docs/user/composer.md b/docs/user/composer.md
index 66be9fe435712..39eb55a8c2848 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -149,7 +149,8 @@ into a normal draft.
 
 On web and desktop, choose **Edit from here** beneath a sent message to rewind
 the conversation to before that message. Choose **Revert and keep changes** to
-leave workspace files as they are, or **Revert files too** to restore them as well.
+leave workspace files as they are, or **Revert files too** to put the workspace back
+to its checkpoint from before that message. That also undoes edits you made yourself.
 File restore is only offered for threads running in a worktree, and it is
 refused when another thread or agent session also uses that directory, a folder
 inside it, or a folder that contains it, since
diff --git a/docs/user/cursor.md b/docs/user/cursor.md
index ad1a69ef956c2..5fc20811da60e 100644
--- a/docs/user/cursor.md
+++ b/docs/user/cursor.md
@@ -8,6 +8,7 @@ TypeScript package. It does not use Cursor's ACP transport for V2 execution.
 - Node.js 22.13 or newer. The repository's supported Node version satisfies this requirement.
 - Sign in with Cursor in **Settings > Providers > Cursor**, or provide a Cursor API key in
   `CURSOR_API_KEY`.
+- A paid Cursor plan on the account used for browser sign-in or `CURSOR_API_KEY`.
 - A model accepted by the Cursor SDK. `auto` is sent to the SDK as its `default` model selection.
 
 The adapter currently uses the SDK's local-agent runtime so runs operate in the selected T3 Code
diff --git a/docs/user/providers-acp.md b/docs/user/providers-acp.md
index 9f179e88da0f6..aef165d96eb4d 100644
--- a/docs/user/providers-acp.md
+++ b/docs/user/providers-acp.md
@@ -13,6 +13,10 @@ configuration, compaction, and agent-terminal updates when the agent supports th
 negotiates ACP v1 for Registry agents that have not migrated yet, so agents such as Pi continue to
 work through the same generic integration.
 
+Claude Agent uses the ACP v2 preview by default for Registry and local `claude-agent-acp`
+commands. If you encounter preview issues, set `CLAUDE_AGENT_ACP_EXPERIMENTAL_V2=0` in the
+provider instance's environment overrides to use ACP v1.
+
 ## Add an agent
 
 1. Open **Settings → Providers**.
diff --git a/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/migration.sql b/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/migration.sql
new file mode 100644
index 0000000000000..175f886bd3c16
--- /dev/null
+++ b/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/migration.sql
@@ -0,0 +1,4 @@
+CREATE TABLE "relay_upstream_api_pauses" (
+	"api" varchar(64) PRIMARY KEY,
+	"paused_until_ms" bigint NOT NULL
+);
diff --git a/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/snapshot.json b/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/snapshot.json
new file mode 100644
index 0000000000000..84acbfa6fd44e
--- /dev/null
+++ b/infra/relay/migrations/postgres/20261020013101_upstream_api_pauses/snapshot.json
@@ -0,0 +1,1634 @@
+{
+  "version": "8",
+  "dialect": "postgres",
+  "id": "f8594baa-6f4a-4a0d-a7f0-0aa717dfe785",
+  "prevIds": ["7b10c420-1566-4dfc-8e9c-c73efa561d3b"],
+  "ddl": [
+    {
+      "isRlsEnabled": false,
+      "name": "relay_agent_activity_rows",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_delivery_attempts",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_dpop_proofs",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_environment_credentials",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_environment_links",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_live_activities",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_managed_endpoint_allocations",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_managed_tunnel_limits",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_mobile_devices",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "isRlsEnabled": false,
+      "name": "relay_upstream_api_pauses",
+      "entityType": "tables",
+      "schema": "public"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_public_key",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "varchar(512)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "thread_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "state_json",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "type": "varchar(36)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(512)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "thread_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "device_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "kind",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "source_job_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(16)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "token_suffix",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "apns_status",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "apns_reason",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(128)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "apns_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "transport_error",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "type": "varchar(128)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "thumbprint",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "jti",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "iat",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "expires_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "credential_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_public_key",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "credential_hash",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "revoked_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "'T3 Environment'",
+      "generated": null,
+      "identity": null,
+      "name": "environment_label",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_public_key",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "endpoint_http_base_url",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "endpoint_ws_base_url",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(32)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "endpoint_provider_kind",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "true",
+      "generated": null,
+      "identity": null,
+      "name": "notifications_enabled",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "true",
+      "generated": null,
+      "identity": null,
+      "name": "live_activities_enabled",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "false",
+      "generated": null,
+      "identity": null,
+      "name": "managed_tunnels_enabled",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "boolean",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "false",
+      "generated": null,
+      "identity": null,
+      "name": "hold_webhooks_while_offline",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_by_device_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "revoked_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "device_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "activity_push_token",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "remote_start_queued_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "remote_started_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "ended_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "last_aggregate_json",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "last_live_activity_delivery_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "environment_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "hostname",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "tunnel_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "tunnel_name",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "dns_record_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "ready_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "recovery_enabled_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "recovery_environment_public_key",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "tunnel_released_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "origin",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "0",
+      "generated": null,
+      "identity": null,
+      "name": "generation",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "type": "varchar(191)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_tunnel_limits"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "max_tunnels",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_tunnel_limits"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_tunnel_limits"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_managed_tunnel_limits"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "user_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "device_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": "'iOS device'",
+      "generated": null,
+      "identity": null,
+      "name": "label",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(16)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "platform",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "ios_major_version",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "integer",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "android_api_level",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "app_version",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(255)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "bundle_id",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(16)",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "aps_environment",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "push_token",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "text",
+      "typeSchema": null,
+      "notNull": false,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "push_to_start_token",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "jsonb",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "preferences_json",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "created_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "updated_at",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "type": "varchar(64)",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "api",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_upstream_api_pauses"
+    },
+    {
+      "type": "bigint",
+      "typeSchema": null,
+      "notNull": true,
+      "dimensions": 0,
+      "default": null,
+      "generated": null,
+      "identity": null,
+      "name": "paused_until_ms",
+      "entityType": "columns",
+      "schema": "public",
+      "table": "relay_upstream_api_pauses"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "updated_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_agent_activity_rows_updated",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "environment_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "thread_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "created_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_delivery_attempts_environment",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "source_job_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_delivery_attempts_source_job",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_delivery_attempts"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "expires_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_dpop_proofs_expires_at",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "credential_hash",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_environment_credentials_hash",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "environment_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "revoked_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_environment_credentials_environment",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "environment_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "environment_public_key",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "revoked_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_environment_credentials_environment_key",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_environment_credentials"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "environment_id",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        },
+        {
+          "value": "revoked_at",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": false,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_environment_links_environment",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "activity_push_token",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_live_activities_activity_push_token",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "hostname",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_managed_endpoint_allocations_hostname",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "tunnel_name",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_managed_endpoint_allocations_tunnel_name",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "push_token",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_mobile_devices_push_token",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "nameExplicit": true,
+      "columns": [
+        {
+          "value": "push_to_start_token",
+          "isExpression": false,
+          "asc": true,
+          "nullsFirst": false,
+          "opclass": null
+        }
+      ],
+      "isUnique": true,
+      "where": null,
+      "with": "",
+      "method": "btree",
+      "concurrently": false,
+      "name": "idx_relay_mobile_devices_push_to_start_token",
+      "entityType": "indexes",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "columns": ["environment_id", "environment_public_key", "thread_id"],
+      "nameExplicit": false,
+      "name": "relay_agent_activity_rows_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_agent_activity_rows"
+    },
+    {
+      "columns": ["thumbprint", "jti"],
+      "nameExplicit": false,
+      "name": "relay_dpop_proofs_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_dpop_proofs"
+    },
+    {
+      "columns": ["user_id", "environment_id"],
+      "nameExplicit": false,
+      "name": "relay_environment_links_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_environment_links"
+    },
+    {
+      "columns": ["user_id", "device_id"],
+      "nameExplicit": false,
+      "name": "relay_live_activities_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_live_activities"
+    },
+    {
+      "columns": ["user_id", "environment_id"],
+      "nameExplicit": false,
+      "name": "relay_managed_endpoint_allocations_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_managed_endpoint_allocations"
+    },
+    {
+      "columns": ["user_id", "device_id"],
+      "nameExplicit": false,
+      "name": "relay_mobile_devices_pkey",
+      "entityType": "pks",
+      "schema": "public",
+      "table": "relay_mobile_devices"
+    },
+    {
+      "columns": ["id"],
+      "nameExplicit": false,
+      "name": "relay_delivery_attempts_pkey",
+      "schema": "public",
+      "table": "relay_delivery_attempts",
+      "entityType": "pks"
+    },
+    {
+      "columns": ["credential_id"],
+      "nameExplicit": false,
+      "name": "relay_environment_credentials_pkey",
+      "schema": "public",
+      "table": "relay_environment_credentials",
+      "entityType": "pks"
+    },
+    {
+      "columns": ["user_id"],
+      "nameExplicit": false,
+      "name": "relay_managed_tunnel_limits_pkey",
+      "schema": "public",
+      "table": "relay_managed_tunnel_limits",
+      "entityType": "pks"
+    },
+    {
+      "columns": ["api"],
+      "nameExplicit": false,
+      "name": "relay_upstream_api_pauses_pkey",
+      "schema": "public",
+      "table": "relay_upstream_api_pauses",
+      "entityType": "pks"
+    }
+  ],
+  "renames": []
+}
diff --git a/infra/relay/package.json b/infra/relay/package.json
index 2992bb56a12ad..dd2265aafb0d5 100644
--- a/infra/relay/package.json
+++ b/infra/relay/package.json
@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@clerk/backend": "catalog:",
+    "@distilled.cloud/cloudflare": "catalog:",
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
     "@noble/curves": "catalog:",
diff --git a/infra/relay/src/environments/CloudflareApiPause.test.ts b/infra/relay/src/environments/CloudflareApiPause.test.ts
new file mode 100644
index 0000000000000..c844a679c106a
--- /dev/null
+++ b/infra/relay/src/environments/CloudflareApiPause.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as SqlClient from "effect/sql/SqlClient";
+
+import * as RelayDb from "../db.ts";
+import * as CloudflareApiPause from "./CloudflareApiPause.ts";
+
+const TransactionConnection = SqlClient.TransactionConnection(7);
+
+// Like the Worker's alchemy database proxy: every property read returns
+// another proxy, never the client's real transaction key.
+const lazyProxy = (): unknown => new Proxy(() => {}, { get: () => lazyProxy() });
+
+// Records whether each statement would have joined the ambient transaction.
+function makeFakeDb(joinedTransaction: Array<boolean>) {
+  const statement = <A>(result: A) =>
+    Effect.serviceOption(TransactionConnection).pipe(
+      Effect.tap((connection) =>
+        Effect.sync(() => joinedTransaction.push(Option.isSome(connection))),
+      ),
+      Effect.as(result),
+    );
+  return {
+    $client: lazyProxy(),
+    select: () => ({
+      from: () => ({ where: () => ({ limit: () => statement([{ pausedUntilMs: 42 }]) }) }),
+    }),
+    insert: () => ({ values: () => ({ onConflictDoUpdate: () => statement([]) }) }),
+  } as unknown as RelayDb.RelayDb["Service"];
+}
+
+describe("CloudflareApiPause", () => {
+  it.effect("reads and records the pause outside a surrounding transaction", () => {
+    const joinedTransaction: Array<boolean> = [];
+    return Effect.gen(function* () {
+      const pause = yield* CloudflareApiPause.CloudflareApiPause;
+      const inTransaction = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        effect.pipe(
+          Effect.provideService(TransactionConnection, [
+            {} as never,
+            0,
+          ] as unknown as SqlClient.TransactionConnection.Service),
+        );
+
+      expect(yield* inTransaction(pause.pausedUntilMillis)).toBe(42);
+      yield* inTransaction(pause.pauseUntil(1_000));
+
+      expect(joinedTransaction).toEqual([false, false]);
+    }).pipe(
+      Effect.provide(
+        CloudflareApiPause.layer.pipe(
+          Layer.provide(Layer.succeed(RelayDb.RelayDb, makeFakeDb(joinedTransaction))),
+        ),
+      ),
+    );
+  });
+});
diff --git a/infra/relay/src/environments/CloudflareApiPause.ts b/infra/relay/src/environments/CloudflareApiPause.ts
new file mode 100644
index 0000000000000..00a076e4d6219
--- /dev/null
+++ b/infra/relay/src/environments/CloudflareApiPause.ts
@@ -0,0 +1,85 @@
+import { eq, sql } from "drizzle-orm";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import * as RelayDb from "../db.ts";
+import { relayUpstreamApiPauses } from "../persistence/schema.ts";
+
+const CLOUDFLARE_API = "cloudflare";
+
+// Every SqlClient's transaction connection lives under a key with this prefix.
+// Matching by key name instead of `db.$client.transactionService` because the
+// relay's database is an alchemy proxy, whose properties are proxies too, not
+// the real key.
+const SQL_TRANSACTION_KEY_PREFIX = "effect/sql/SqlClient/TransactionConnection/";
+
+const withoutSqlTransaction = (context: Context.Context<never>): Context.Context<never> =>
+  Context.makeUnsafe(
+    new Map(
+      Array.from(context.mapUnsafe).filter(([key]) => !key.startsWith(SQL_TRANSACTION_KEY_PREFIX)),
+    ),
+  );
+
+/**
+ * Cloudflare's API rate limit is per account, so a 429 seen by any isolate
+ * applies to all of them. Both operations fail open: a pause that cannot be
+ * read or recorded must not block provisioning.
+ *
+ * Both also run outside any ambient transaction. Provisioning calls Cloudflare
+ * while holding an allocation row lock, and a 429 there rolls that transaction
+ * back, which would drop the recorded pause; a failed read inside it would
+ * abort the provision's own statements.
+ */
+export class CloudflareApiPause extends Context.Service<
+  CloudflareApiPause,
+  {
+    /** Epoch milliseconds until which calls are paused, or 0. */
+    readonly pausedUntilMillis: Effect.Effect<number>;
+    readonly pauseUntil: (untilMillis: number) => Effect.Effect<void>;
+  }
+>()("t3code-relay/environments/CloudflareApiPause") {}
+
+export const make = Effect.gen(function* () {
+  const db = yield* RelayDb.RelayDb;
+  const outsideTransaction = <A, E>(effect: Effect.Effect<A, E>) =>
+    Effect.updateContext(effect, withoutSqlTransaction);
+
+  return CloudflareApiPause.of({
+    pausedUntilMillis: db
+      .select({ pausedUntilMs: relayUpstreamApiPauses.pausedUntilMs })
+      .from(relayUpstreamApiPauses)
+      .where(eq(relayUpstreamApiPauses.api, CLOUDFLARE_API))
+      .limit(1)
+      .pipe(
+        Effect.map((rows) => rows[0]?.pausedUntilMs ?? 0),
+        Effect.catch((cause) =>
+          Effect.logWarning("Could not read the shared Cloudflare API pause", { cause }).pipe(
+            Effect.as(0),
+          ),
+        ),
+        outsideTransaction,
+        Effect.withSpan("relay.cloudflare_api_pause.read"),
+      ),
+    pauseUntil: (untilMillis) =>
+      db
+        .insert(relayUpstreamApiPauses)
+        .values({ api: CLOUDFLARE_API, pausedUntilMs: untilMillis })
+        .onConflictDoUpdate({
+          target: relayUpstreamApiPauses.api,
+          set: {
+            pausedUntilMs: sql`greatest(${relayUpstreamApiPauses.pausedUntilMs}, excluded.paused_until_ms)`,
+          },
+        })
+        .pipe(
+          Effect.asVoid,
+          Effect.catch((cause) =>
+            Effect.logWarning("Could not record the shared Cloudflare API pause", { cause }),
+          ),
+          outsideTransaction,
+          Effect.withSpan("relay.cloudflare_api_pause.record"),
+        ),
+  });
+});
+
+export const layer = Layer.effect(CloudflareApiPause, make);
diff --git a/infra/relay/src/environments/ManagedEndpointProvider.test.ts b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
index 2e8c895d11005..9717382444fb8 100644
--- a/infra/relay/src/environments/ManagedEndpointProvider.test.ts
+++ b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
@@ -3,11 +3,15 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import { describe, expect, it } from "@effect/vitest";
 import * as Alchemy from "alchemy";
 import * as Cloudflare from "alchemy/Cloudflare";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
+import * as TestClock from "effect/testing/TestClock";
 
 import * as RelayConfiguration from "../Config.ts";
+import * as CloudflareApiPause from "./CloudflareApiPause.ts";
 import * as ManagedEndpointAllocations from "./ManagedEndpointAllocations.ts";
 import * as ManagedEndpointProvider from "./ManagedEndpointProvider.ts";
 import * as ManagedTunnelLimits from "./ManagedTunnelLimits.ts";
@@ -364,6 +368,17 @@ function layerProvider(
   );
 }
 
+function makeSharedCloudflareApiPause() {
+  let pausedUntilMillis = 0;
+  return CloudflareApiPause.CloudflareApiPause.of({
+    pausedUntilMillis: Effect.sync(() => pausedUntilMillis),
+    pauseUntil: (untilMillis) =>
+      Effect.sync(() => {
+        pausedUntilMillis = Math.max(pausedUntilMillis, untilMillis);
+      }),
+  });
+}
+
 const MANAGED_ENDPOINT_HASHES: Record<string, string> = {
   "user_ABC:env_ABC": "d101ac68108a423e",
   "user_ABC:env_shared": "d7e6356aaf8863aa",
@@ -413,6 +428,9 @@ describe("ManagedEndpointProvider", () => {
         Layer.succeed(ManagedEndpointAllocations.ManagedEndpointAllocations, makeAllocations()),
       ),
       Layer.provide(Layer.succeed(ManagedTunnelLimits.ManagedTunnelLimits, makeTunnelLimits())),
+      Layer.provide(
+        Layer.succeed(CloudflareApiPause.CloudflareApiPause, makeSharedCloudflareApiPause()),
+      ),
     );
 
     return Effect.gen(function* () {
@@ -754,6 +772,184 @@ describe("ManagedEndpointProvider", () => {
     }).pipe(Effect.provide(layer));
   });
 
+  it.effect("recovers a ready tunnel for the same origin with only reads", () => {
+    const tunnelCalls: TunnelCall[] = [];
+    const dnsCalls: DnsCall[] = [];
+    const allocationCalls: AllocationCall[] = [];
+    const layer = layerProvider(
+      makePersistentTunnelClient(tunnelCalls),
+      makeDnsClient(dnsCalls),
+      makeAllocations(allocationCalls),
+    );
+
+    return Effect.gen(function* () {
+      const provider = yield* ManagedEndpointProvider.ManagedEndpointProvider;
+      const request = {
+        userId: "user_ABC",
+        environmentId: "env_ABC",
+        origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
+      } as const;
+      const provisioned = yield* provider.provision(request);
+      tunnelCalls.length = 0;
+      dnsCalls.length = 0;
+      allocationCalls.length = 0;
+
+      const recovered = yield* provider.provision({ ...request, reuseReadyTunnel: true });
+
+      expect(recovered).toEqual(provisioned);
+      expect(tunnelCalls.map((call) => call.operation)).toEqual(["get", "getToken"]);
+      expect(dnsCalls).toEqual([]);
+      expect(allocationCalls.map((call) => call.operation)).toEqual(["reserve"]);
+    }).pipe(Effect.provide(layer));
+  });
+
+  it.effect("fully provisions a recovery when the ready tunnel cannot be reused", () => {
+    const tunnelCalls: TunnelCall[] = [];
+    const tunnelClient = makePersistentTunnelClient(tunnelCalls);
+    const layer = layerProvider(tunnelClient);
+
+    return Effect.gen(function* () {
+      const provider = yield* ManagedEndpointProvider.ManagedEndpointProvider;
+      const request = {
+        userId: "user_ABC",
+        environmentId: "env_ABC",
+        origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
+        reuseReadyTunnel: true,
+      } as const;
+      yield* provider.provision(request);
+
+      tunnelCalls.length = 0;
+      yield* provider.provision({
+        ...request,
+        origin: { localHttpHost: "127.0.0.1", localHttpPort: 3774 },
+      });
+      expect(tunnelCalls.map((call) => call.operation)).toEqual([
+        "list",
+        "putConfiguration",
+        "getToken",
+      ]);
+
+      yield* tunnelClient.delete("tunnel-id");
+      tunnelCalls.length = 0;
+      yield* provider.provision({
+        ...request,
+        origin: { localHttpHost: "127.0.0.1", localHttpPort: 3774 },
+      });
+      expect(tunnelCalls.map((call) => call.operation)).toEqual([
+        "get",
+        "list",
+        "create",
+        "putConfiguration",
+        "getToken",
+      ]);
+    }).pipe(Effect.provide(layer));
+  });
+
+  it.effect("keeps a pause recorded while a shared pause read was in flight", () => {
+    let listCalls = 0;
+    const tunnelClient = {
+      list: () =>
+        Effect.suspend(() => {
+          listCalls += 1;
+          return Effect.fail({ _tag: "TooManyRequests", message: "Rate limited" });
+        }),
+    } as unknown as Cloudflare.Tunnel.ReadWriteTunnelClient;
+
+    return Effect.gen(function* () {
+      const readStarted = yield* Deferred.make<void>();
+      const releaseRead = yield* Deferred.make<void>();
+      const layer = ManagedEndpointProvider.layerCloudflareBindings(
+        tunnelClient,
+        {} as Cloudflare.DNS.ReadWriteDnsClient,
+        {} as Alchemy.BaseRuntimeContext,
+      ).pipe(
+        Layer.provideMerge(NodeServices.layer),
+        Layer.provide(RelayConfiguration.layer(config)),
+        Layer.provide(
+          Layer.succeed(ManagedEndpointAllocations.ManagedEndpointAllocations, makeAllocations()),
+        ),
+        Layer.provide(Layer.succeed(ManagedTunnelLimits.ManagedTunnelLimits, makeTunnelLimits())),
+        Layer.provide(
+          Layer.succeed(
+            CloudflareApiPause.CloudflareApiPause,
+            CloudflareApiPause.CloudflareApiPause.of({
+              pausedUntilMillis: Deferred.succeed(readStarted, undefined).pipe(
+                Effect.andThen(Deferred.await(releaseRead)),
+                Effect.as(0),
+              ),
+              pauseUntil: () => Effect.void,
+            }),
+          ),
+        ),
+      );
+
+      yield* Effect.gen(function* () {
+        const tunnels = yield* ManagedEndpointProvider.ManagedEndpointTunnelClient;
+        const list = tunnels.list({ isDeleted: false }).pipe(Effect.flip);
+        // The first call starts the shared read; the second hits a 429 meanwhile.
+        const reading = yield* Effect.forkChild(list);
+        yield* Deferred.await(readStarted);
+        yield* list;
+        yield* Deferred.succeed(releaseRead, undefined);
+        yield* Fiber.join(reading);
+        yield* list;
+        expect(listCalls).toBe(1);
+      }).pipe(Effect.provide(layer));
+    });
+  });
+
+  it.effect("pauses Cloudflare calls in every isolate until a rate limit has passed", () => {
+    let listCalls = 0;
+    const tunnelClient = {
+      list: () =>
+        Effect.suspend(() => {
+          listCalls += 1;
+          return Effect.fail({ _tag: "TooManyRequests", message: "Rate limited" });
+        }),
+    } as unknown as Cloudflare.Tunnel.ReadWriteTunnelClient;
+    const sharedPause = makeSharedCloudflareApiPause();
+    const isolate = () =>
+      ManagedEndpointProvider.layerCloudflareBindings(
+        tunnelClient,
+        {} as Cloudflare.DNS.ReadWriteDnsClient,
+        {} as Alchemy.BaseRuntimeContext,
+      ).pipe(
+        Layer.provideMerge(NodeServices.layer),
+        Layer.provide(RelayConfiguration.layer(config)),
+        Layer.provide(
+          Layer.succeed(ManagedEndpointAllocations.ManagedEndpointAllocations, makeAllocations()),
+        ),
+        Layer.provide(Layer.succeed(ManagedTunnelLimits.ManagedTunnelLimits, makeTunnelLimits())),
+        Layer.provide(Layer.succeed(CloudflareApiPause.CloudflareApiPause, sharedPause)),
+      );
+    const provision = ManagedEndpointProvider.ManagedEndpointProvider.pipe(
+      Effect.flatMap((provider) =>
+        provider.provision({
+          userId: "user_ABC",
+          environmentId: "env_ABC",
+          origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
+        }),
+      ),
+      Effect.flip,
+    );
+
+    return Effect.gen(function* () {
+      const rateLimited = yield* provision.pipe(Effect.provide(isolate()));
+      const pausedElsewhere = yield* provision.pipe(Effect.provide(isolate()));
+      expect(listCalls).toBe(1);
+      expect(ManagedEndpointProvider.isCloudflareRateLimited(rateLimited)).toBe(true);
+      expect(pausedElsewhere).toMatchObject({
+        _tag: "ManagedEndpointProvisioningFailed",
+        stage: "ensure-tunnel",
+        cause: { cause: { _tag: "CloudflareApiPaused" } },
+      });
+
+      yield* TestClock.adjust("30 seconds");
+      yield* provision.pipe(Effect.provide(isolate()));
+      expect(listCalls).toBe(2);
+    });
+  });
+
   it.effect("recreates a checkpointed DNS record when it was removed externally", () => {
     const dnsCalls: DnsCall[] = [];
     const allocationCalls: AllocationCall[] = [];
diff --git a/infra/relay/src/environments/ManagedEndpointProvider.ts b/infra/relay/src/environments/ManagedEndpointProvider.ts
index bb906db16a8fa..6a5d1f8bc3c9a 100644
--- a/infra/relay/src/environments/ManagedEndpointProvider.ts
+++ b/infra/relay/src/environments/ManagedEndpointProvider.ts
@@ -1,9 +1,13 @@
+import * as CloudflareRetry from "@distilled.cloud/cloudflare/Retry";
 import * as Alchemy from "alchemy";
 import * as Cloudflare from "alchemy/Cloudflare";
 import * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
 import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Hex from "effect/encoding/Hex";
 import * as Layer from "effect/Layer";
@@ -23,6 +27,7 @@ import {
   managedEndpointHostname,
   managedEndpointTunnelName,
 } from "../deploymentConfig.ts";
+import * as CloudflareApiPause from "./CloudflareApiPause.ts";
 import * as ManagedEndpointAllocations from "./ManagedEndpointAllocations.ts";
 import * as ManagedTunnelLimits from "./ManagedTunnelLimits.ts";
 
@@ -148,6 +153,11 @@ export class ManagedEndpointProvider extends Context.Service<
       readonly userId: string;
       readonly environmentId: string;
       readonly origin: RelayManagedEndpointOrigin;
+      /**
+       * Return a ready tunnel that already serves this origin with only a
+       * liveness check and a fresh token, skipping ingress and DNS repair.
+       */
+      readonly reuseReadyTunnel?: boolean;
     }) => Effect.Effect<ManagedEndpointProvisioningResult, ManagedEndpointProviderError>;
     readonly reconcileOrigin: (input: {
       readonly userId: string;
@@ -389,6 +399,132 @@ export function isManagedEndpointNotFound(cause: unknown): boolean {
   return "cause" in cause && isManagedEndpointNotFound(cause.cause);
 }
 
+export class CloudflareApiPaused extends Schema.TaggedError<CloudflareApiPaused>()(
+  "CloudflareApiPaused",
+  { retryAfterMillis: Schema.Number },
+) {
+  override get message(): string {
+    return `Cloudflare API calls are paused for ${this.retryAfterMillis}ms after a rate limit`;
+  }
+}
+
+export function isCloudflareRateLimited(cause: unknown): boolean {
+  if (typeof cause !== "object" || cause === null) {
+    return false;
+  }
+  if (
+    "_tag" in cause &&
+    (cause._tag === "TooManyRequests" ||
+      cause._tag === "CloudflareRateLimited" ||
+      cause._tag === "CloudflareApiPaused")
+  ) {
+    return true;
+  }
+  if ("status" in cause && cause.status === 429) {
+    return true;
+  }
+  return "cause" in cause && isCloudflareRateLimited(cause.cause);
+}
+
+const CLOUDFLARE_DEFAULT_RATE_LIMIT_PAUSE = Duration.seconds(30);
+const CLOUDFLARE_MAX_RATE_LIMIT_PAUSE = Duration.minutes(2);
+
+function cloudflareRateLimitPauseMillis(cause: unknown): number {
+  const retryAfter =
+    typeof cause === "object" && cause !== null && "retryAfter" in cause
+      ? cause.retryAfter
+      : undefined;
+  const pause = Duration.isDuration(retryAfter) ? retryAfter : CLOUDFLARE_DEFAULT_RATE_LIMIT_PAUSE;
+  return Duration.toMillis(Duration.min(pause, CLOUDFLARE_MAX_RATE_LIMIT_PAUSE));
+}
+
+/**
+ * How long a caller should wait before retrying, when `cause` is a Cloudflare
+ * rate limit or a call refused during the pause that follows one.
+ */
+export function cloudflareRetryAfterMillis(cause: unknown): number | undefined {
+  for (let current = cause, depth = 0; depth < 8; depth++) {
+    if (typeof current !== "object" || current === null) return undefined;
+    if ("_tag" in current && current._tag === "CloudflareApiPaused") {
+      const retryAfterMillis: unknown = Reflect.get(current, "retryAfterMillis");
+      return typeof retryAfterMillis === "number" ? retryAfterMillis : undefined;
+    }
+    if (
+      ("_tag" in current &&
+        (current._tag === "TooManyRequests" || current._tag === "CloudflareRateLimited")) ||
+      ("status" in current && current.status === 429)
+    ) {
+      return cloudflareRateLimitPauseMillis(current);
+    }
+    if (!("cause" in current)) return undefined;
+    current = current.cause;
+  }
+  return undefined;
+}
+
+// The SDK's default policy sleeps through Retry-After inside the request, which
+// held every caller until its timeout and kept the account over its limit.
+// Rate limits surface at once instead; other transient failures still retry.
+const withoutRateLimitRetries: CloudflareRetry.Factory = (lastError) => {
+  const defaults = CloudflareRetry.makeDefault(lastError);
+  return {
+    ...defaults,
+    while: (error) => !isCloudflareRateLimited(error) && (defaults.while?.(error) ?? false),
+  };
+};
+
+// Every isolate rereads the shared pause at most this often, so a quiet
+// period costs one query per isolate rather than one per Cloudflare call.
+const CLOUDFLARE_PAUSE_REFRESH_MILLIS = 5_000;
+
+/**
+ * The rate limit is account-wide, so once one call is rejected every other
+ * call is too, from any isolate. Failing them without a request leaves the
+ * account room to recover instead of extending the limit.
+ */
+const makeCloudflareApiGate = (alchemyRuntimeContext: Alchemy.BaseRuntimeContext) => {
+  let pausedUntilMillis = 0;
+  let checkedAtMillis = Number.NEGATIVE_INFINITY;
+  return (pause: CloudflareApiPause.CloudflareApiPause["Service"]) => {
+    const recordRateLimit = Effect.fn("relay.cloudflare_api_pause.rate_limited")(function* (
+      cause: unknown,
+    ) {
+      const pauseMillis = cloudflareRateLimitPauseMillis(cause);
+      const until = (yield* Clock.currentTimeMillis) + pauseMillis;
+      pausedUntilMillis = Math.max(pausedUntilMillis, until);
+      yield* Effect.annotateCurrentSpan({ "relay.cloudflare.pause_ms": pauseMillis });
+      yield* pause.pauseUntil(until);
+    });
+    return <A, E>(
+      call: Effect.Effect<A, E, Alchemy.RuntimeContext>,
+    ): Effect.Effect<A, E | CloudflareApiPaused | Cause.TimeoutError> =>
+      Effect.gen(function* () {
+        const now = yield* Clock.currentTimeMillis;
+        if (now >= pausedUntilMillis && now - checkedAtMillis >= CLOUDFLARE_PAUSE_REFRESH_MILLIS) {
+          checkedAtMillis = now;
+          // Read first: a 429 recorded while the read is in flight must win.
+          const shared = yield* pause.pausedUntilMillis;
+          pausedUntilMillis = Math.max(pausedUntilMillis, shared);
+        }
+        // A paused call never reaches Cloudflare, so it leaves no 429 behind.
+        // Its own span keeps a storm visible to the rate-limit monitors.
+        if (now < pausedUntilMillis) {
+          return yield* new CloudflareApiPaused({ retryAfterMillis: pausedUntilMillis - now }).pipe(
+            Effect.withSpan("relay.cloudflare_api_pause.rejected"),
+          );
+        }
+        return yield* call.pipe(
+          Effect.provideService(CloudflareRetry.Retry, withoutRateLimitRetries),
+          Effect.timeout("8 seconds"),
+          Effect.tapError((cause) =>
+            isCloudflareRateLimited(cause) ? recordRateLimit(cause) : Effect.void,
+          ),
+          Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+        );
+      });
+  };
+};
+
 /**
  * Cloudflare refuses to delete a tunnel while a connector is still attached,
  * either one that has not finished draining or another runtime still serving
@@ -503,6 +639,65 @@ export const make = Effect.gen(function* () {
     );
   });
 
+  // Hosts ask for recovery whenever their connector cannot register, mostly
+  // for local reasons a fresh provision cannot fix. Those requests outnumber
+  // every other Cloudflare caller, so a tunnel that is ready for the same
+  // origin costs two reads instead of a full provision.
+  const reuseReadyTunnel = Effect.fnUntraced(function* (
+    allocation: ManagedEndpointAllocations.ManagedEndpointAllocation,
+    origin: RelayManagedEndpointOrigin,
+  ) {
+    const { tunnelId } = allocation;
+    if (
+      tunnelId === null ||
+      allocation.readyAt === null ||
+      allocation.dnsRecordId === null ||
+      allocation.tunnelReleasedAt !== null ||
+      allocation.origin?.localHttpHost !== origin.localHttpHost ||
+      allocation.origin.localHttpPort !== origin.localHttpPort
+    ) {
+      return Option.none<ManagedEndpointProvisioningResult>();
+    }
+    const failed = (
+      stage: "verify-tunnel" | "get-tunnel-token",
+      cause: ManagedEndpointTunnelClientError,
+    ) =>
+      new ManagedEndpointProvisioningFailed({
+        userId: allocation.userId,
+        environmentId: allocation.environmentId,
+        stage,
+        hostname: allocation.hostname,
+        tunnelName: allocation.tunnelName,
+        tunnelId,
+        cause,
+      });
+    const recorded = yield* tunnels.get(tunnelId).pipe(
+      Effect.asSome,
+      Effect.catchTags({
+        ManagedEndpointTunnelClientError: (cause) =>
+          isManagedEndpointNotFound(cause.cause)
+            ? Effect.succeedNone
+            : Effect.fail(failed("verify-tunnel", cause)),
+      }),
+    );
+    if (Option.isNone(recorded) || recorded.value.deletedAt) {
+      return Option.none<ManagedEndpointProvisioningResult>();
+    }
+    const connectorToken = yield* tunnels
+      .getToken(tunnelId)
+      .pipe(Effect.mapError((cause) => failed("get-tunnel-token", cause)));
+    yield* Effect.annotateCurrentSpan({ "relay.managed_endpoint.reused_ready_tunnel": true });
+    return Option.some<ManagedEndpointProvisioningResult>({
+      endpoint: managedEndpointForHostname(allocation.hostname),
+      runtime: {
+        providerKind: "cloudflare_tunnel",
+        connectorToken,
+        tunnelId,
+        tunnelName: allocation.tunnelName,
+      },
+    });
+  });
+
   const prepareDeprovision = Effect.fn("relay.managed_endpoint_provider.prepare_deprovision")(
     function* (input: { readonly userId: string; readonly environmentId: string }) {
       return yield* allocations.get(input).pipe(
@@ -1039,6 +1234,13 @@ export const make = Effect.gen(function* () {
         );
       const { hostname, tunnelName } = allocation;
 
+      if (input.reuseReadyTunnel === true) {
+        const reused = yield* reuseReadyTunnel(allocation, input.origin);
+        if (Option.isSome(reused)) {
+          return reused.value;
+        }
+      }
+
       const tunnelResponse = yield* tunnels.list({ name: tunnelName, isDeleted: false }).pipe(
         Effect.map((tunnels) => tunnels.result),
         Effect.map(Arr.findFirst((tunnel) => tunnel.name === tunnelName)),
@@ -1344,153 +1546,142 @@ export const layerCloudflareBindings = (
   tunnelClient: Cloudflare.Tunnel.ReadWriteTunnelClient,
   dnsClient: Cloudflare.DNS.ReadWriteDnsClient,
   alchemyRuntimeContext: Alchemy.BaseRuntimeContext,
-) =>
-  layer.pipe(
+) => {
+  // Created once per isolate so its cached pause survives layer rebuilds.
+  const cloudflare = makeCloudflareApiGate(alchemyRuntimeContext);
+  return layer.pipe(
     Layer.provideMerge(
-      Layer.mergeAll(
-        layerTunnelClient({
-          get: (tunnelId) =>
-            tunnelClient.get(tunnelId).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "get",
-                    tunnelId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          list: (request) =>
-            tunnelClient.list(request).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "list",
-                    ...(request.name === undefined ? {} : { tunnelName: request.name }),
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          create: (request) =>
-            tunnelClient.create(request).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "create",
-                    tunnelName: request.name,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          putConfiguration: (tunnelId, config) =>
-            tunnelClient.putConfiguration(tunnelId, config).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "put-configuration",
-                    tunnelId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          getToken: (tunnelId) =>
-            tunnelClient.getToken(tunnelId).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "get-token",
-                    tunnelId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          delete: (tunnelId) =>
-            tunnelClient.delete(tunnelId).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointTunnelClientError({
-                    operation: "delete",
-                    tunnelId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-        }),
-        layerDnsClient({
-          listRecords: (hostname) =>
-            dnsClient.listDnsRecords({ search: hostname }).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.map((response) =>
-                response.result.filter(
-                  (record): record is typeof record & { readonly id: string } =>
-                    typeof record.id === "string" &&
-                    normalizeHostname(record.name) === normalizeHostname(hostname),
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const pause = yield* CloudflareApiPause.CloudflareApiPause;
+          const gate = cloudflare(pause);
+          return Layer.mergeAll(
+            layerTunnelClient({
+              get: (tunnelId) =>
+                gate(tunnelClient.get(tunnelId)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "get",
+                        tunnelId,
+                        cause,
+                      }),
+                  ),
                 ),
-              ),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointDnsClientError({
-                    operation: "list-records",
-                    hostname,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          createRecord: (request) =>
-            dnsClient.createDnsRecord(request).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.map((response) => ({ id: response.id })),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointDnsClientError({
-                    operation: "create-record",
-                    hostname: request.name,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          updateRecord: (dnsRecordId, request) =>
-            dnsClient.updateDnsRecord(dnsRecordId, request).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointDnsClientError({
-                    operation: "update-record",
-                    hostname: request.name,
-                    dnsRecordId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
-          deleteRecord: (dnsRecordId) =>
-            dnsClient.deleteDnsRecord(dnsRecordId).pipe(
-              Effect.timeout("8 seconds"),
-              Effect.mapError(
-                (cause) =>
-                  new ManagedEndpointDnsClientError({
-                    operation: "delete-record",
-                    dnsRecordId,
-                    cause,
-                  }),
-              ),
-              Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
-            ),
+              list: (request) =>
+                gate(tunnelClient.list(request)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "list",
+                        ...(request.name === undefined ? {} : { tunnelName: request.name }),
+                        cause,
+                      }),
+                  ),
+                ),
+              create: (request) =>
+                gate(tunnelClient.create(request)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "create",
+                        tunnelName: request.name,
+                        cause,
+                      }),
+                  ),
+                ),
+              putConfiguration: (tunnelId, config) =>
+                gate(tunnelClient.putConfiguration(tunnelId, config)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "put-configuration",
+                        tunnelId,
+                        cause,
+                      }),
+                  ),
+                ),
+              getToken: (tunnelId) =>
+                gate(tunnelClient.getToken(tunnelId)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "get-token",
+                        tunnelId,
+                        cause,
+                      }),
+                  ),
+                ),
+              delete: (tunnelId) =>
+                gate(tunnelClient.delete(tunnelId)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointTunnelClientError({
+                        operation: "delete",
+                        tunnelId,
+                        cause,
+                      }),
+                  ),
+                ),
+            }),
+            layerDnsClient({
+              listRecords: (hostname) =>
+                gate(dnsClient.listDnsRecords({ search: hostname })).pipe(
+                  Effect.map((response) =>
+                    response.result.filter(
+                      (record): record is typeof record & { readonly id: string } =>
+                        typeof record.id === "string" &&
+                        normalizeHostname(record.name) === normalizeHostname(hostname),
+                    ),
+                  ),
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointDnsClientError({
+                        operation: "list-records",
+                        hostname,
+                        cause,
+                      }),
+                  ),
+                ),
+              createRecord: (request) =>
+                gate(dnsClient.createDnsRecord(request)).pipe(
+                  Effect.map((response) => ({ id: response.id })),
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointDnsClientError({
+                        operation: "create-record",
+                        hostname: request.name,
+                        cause,
+                      }),
+                  ),
+                ),
+              updateRecord: (dnsRecordId, request) =>
+                gate(dnsClient.updateDnsRecord(dnsRecordId, request)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointDnsClientError({
+                        operation: "update-record",
+                        hostname: request.name,
+                        dnsRecordId,
+                        cause,
+                      }),
+                  ),
+                ),
+              deleteRecord: (dnsRecordId) =>
+                gate(dnsClient.deleteDnsRecord(dnsRecordId)).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new ManagedEndpointDnsClientError({
+                        operation: "delete-record",
+                        dnsRecordId,
+                        cause,
+                      }),
+                  ),
+                ),
+            }),
+          );
         }),
       ),
     ),
   );
+};
diff --git a/infra/relay/src/environments/ManagedEndpointReaper.test.ts b/infra/relay/src/environments/ManagedEndpointReaper.test.ts
index 252b468e7cc79..26ce55a58a738 100644
--- a/infra/relay/src/environments/ManagedEndpointReaper.test.ts
+++ b/infra/relay/src/environments/ManagedEndpointReaper.test.ts
@@ -66,6 +66,7 @@ function harness(input?: {
   readonly namespace?: string;
   readonly failTunnelId?: string;
   readonly rateLimitedTunnelId?: string;
+  readonly rateLimitCause?: unknown;
   readonly failAllDeletes?: boolean;
   readonly failDeleteWhen?: (tunnelId: string) => boolean;
   readonly missingOnDeleteTunnelId?: string;
@@ -155,13 +156,13 @@ function harness(input?: {
                 tunnelId === input?.missingOnDeleteTunnelId
                   ? { _tag: "NotFound" }
                   : tunnelId === input?.rateLimitedTunnelId
-                    ? {
+                    ? (input.rateLimitCause ?? {
                         cause: {
                           _tag: "TooManyRequests",
                           message: "Cloudflare rate limit exceeded",
                           retryAfter: 60,
                         },
-                      }
+                      })
                     : "Cloudflare refused the deletion",
             }),
           )
@@ -653,7 +654,13 @@ describe("ManagedEndpointReaper", () => {
     }).pipe(Effect.provide(state.layer));
   });
 
-  it.effect("stops the sweep after a structured Cloudflare rate limit error", () => {
+  it.effect.each([
+    ["a structured Cloudflare rate limit error", undefined],
+    [
+      "a Cloudflare API pause recorded by another isolate",
+      new ManagedEndpointProvider.CloudflareApiPaused({ retryAfterMillis: 30_000 }),
+    ],
+  ] as const)("stops the sweep after %s", ([, rateLimitCause]) => {
     const state = harness({
       tunnels: [
         tunnel({
@@ -674,6 +681,7 @@ describe("ManagedEndpointReaper", () => {
         allocation({ tunnelId: "next", recoveryEnabled: true }),
       ],
       rateLimitedTunnelId: "limited",
+      rateLimitCause,
     });
 
     return Effect.gen(function* () {
diff --git a/infra/relay/src/environments/ManagedEndpointReaper.ts b/infra/relay/src/environments/ManagedEndpointReaper.ts
index 27c3574ff47a1..cbaf63577e739 100644
--- a/infra/relay/src/environments/ManagedEndpointReaper.ts
+++ b/infra/relay/src/environments/ManagedEndpointReaper.ts
@@ -110,19 +110,6 @@ function inactiveDaysAt(
   return (now.epochMilliseconds - timestamp.value.epochMilliseconds) / 86_400_000;
 }
 
-function isRateLimited(cause: unknown): boolean {
-  if (typeof cause !== "object" || cause === null) {
-    return false;
-  }
-  if ("_tag" in cause && cause._tag === "TooManyRequests") {
-    return true;
-  }
-  if ("status" in cause && cause.status === 429) {
-    return true;
-  }
-  return "cause" in cause && isRateLimited(cause.cause);
-}
-
 function rotatedPages(input: {
   readonly totalCount: number | undefined;
   readonly slot: number;
@@ -383,7 +370,7 @@ export const make = Effect.gen(function* () {
               legacy: candidate.legacy,
               cause: result.failure,
             });
-            if (isRateLimited(result.failure)) {
+            if (ManagedEndpointProvider.isCloudflareRateLimited(result.failure)) {
               stopDeleting = true;
               truncated = true;
             }
diff --git a/infra/relay/src/http/Api.test.ts b/infra/relay/src/http/Api.test.ts
index 81574b0392248..9455cf36ca4b4 100644
--- a/infra/relay/src/http/Api.test.ts
+++ b/infra/relay/src/http/Api.test.ts
@@ -187,6 +187,102 @@ describe("device listing compatibility", () => {
   });
 });
 
+describe("Cloudflare rate-limit retry hint", () => {
+  const provisioningFailed = (cause?: unknown) =>
+    new ManagedEndpointProvider.ManagedEndpointProvisioningFailed({
+      userId: "user-1",
+      environmentId: "env-1",
+      stage: "ensure-tunnel",
+      ...(cause === undefined
+        ? {}
+        : {
+            cause: new ManagedEndpointProvider.ManagedEndpointTunnelClientError({
+              operation: "list",
+              cause,
+            }),
+          }),
+    });
+
+  const linkResponse = (failure: ManagedEndpointProvider.ManagedEndpointProvisioningFailed) => {
+    const layerHandlers = RelayHttpApi.layerClientApi.pipe(
+      HttpRouter.provideRequest(
+        Layer.mergeAll(
+          Layer.mock(EnvironmentCredentials.EnvironmentCredentials, {}),
+          Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
+          Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
+          Layer.mock(RelayDb.RelayTransactions, {}),
+          Layer.mock(HookInbox.HookInbox, {}),
+        ),
+      ),
+      Layer.provide(
+        Layer.mergeAll(
+          Layer.succeed(RelayConfiguration.RelayConfiguration, relaySettings),
+          NodeCryptoLayer.layer,
+          Layer.mock(RelayTokens.RelayTokens, { resolveDpopAccessTokenScopes: () => null }),
+          Layer.mock(EnvironmentLinker.EnvironmentLinker, { link: () => Effect.fail(failure) }),
+          Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
+          Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
+          Layer.mock(Devices.Devices, {}),
+        ),
+      ),
+      Layer.provideMerge(
+        Layer.succeed(RelayClientAuth, {
+          clientBearer: (effect) =>
+            Effect.provideService(effect, RelayClientPrincipal, {
+              userId: "user-1",
+              token: "test-token",
+            }),
+        }),
+      ),
+    );
+    return Effect.acquireRelease(
+      Effect.sync(() =>
+        HttpRouter.toWebHandler(
+          HttpApiBuilder.layer(HttpApi.make("RelayApi").add(RelayApi.groups.client)).pipe(
+            Layer.provide(layerHandlers),
+            Layer.provide(HttpServer.layerServices),
+          ),
+          { disableLogger: true },
+        ),
+      ),
+      (app) => Effect.promise(() => app.dispose()),
+    ).pipe(
+      Effect.flatMap((app) =>
+        Effect.promise(() =>
+          app.handler(
+            new Request("https://relay.example.test/v1/client/environment-links", {
+              method: "POST",
+              headers: { authorization: "Bearer test-token", "content-type": "application/json" },
+              body: JSON.stringify({
+                proof: "signed-proof",
+                notificationsEnabled: true,
+                liveActivitiesEnabled: true,
+                managedTunnelsEnabled: true,
+              }),
+            }),
+          ),
+        ),
+      ),
+    );
+  };
+
+  it.effect("tells a link refused during a Cloudflare pause when to retry", () =>
+    Effect.gen(function* () {
+      const paused = yield* linkResponse(
+        provisioningFailed(
+          new ManagedEndpointProvider.CloudflareApiPaused({ retryAfterMillis: 24_100 }),
+        ),
+      );
+      expect(paused.status).toBe(503);
+      expect(paused.headers.get("retry-after")).toBe("25");
+
+      const other = yield* linkResponse(provisioningFailed());
+      expect(other.status).toBe(503);
+      expect(other.headers.get("retry-after")).toBeNull();
+    }).pipe(Effect.scoped),
+  );
+});
+
 describe("relay client authentication", () => {
   it.effect("preserves the existing Clerk session JWT path", () =>
     Effect.gen(function* () {
diff --git a/infra/relay/src/http/Api.ts b/infra/relay/src/http/Api.ts
index 8db3a4054d641..69925a3645311 100644
--- a/infra/relay/src/http/Api.ts
+++ b/infra/relay/src/http/Api.ts
@@ -102,6 +102,17 @@ const appendRelayCredentialResponseHeaders = HttpEffect.appendPreResponseHandler
     ),
 );
 
+// T3 Code hosts never retry sooner than Retry-After, so during a Cloudflare
+// rate limit they wait out the pause instead of retrying into it.
+const appendCloudflareRetryAfter = (error: unknown) => {
+  const retryAfterMillis = ManagedEndpointProvider.cloudflareRetryAfterMillis(error);
+  if (retryAfterMillis === undefined) return Effect.void;
+  const seconds = String(Math.max(1, Math.ceil(retryAfterMillis / 1000)));
+  return HttpEffect.appendPreResponseHandler((_request, response) =>
+    Effect.succeed(HttpServerResponse.setHeader(response, "retry-after", seconds)),
+  );
+};
+
 const appendRelayDpopChallengeHeader = HttpEffect.appendPreResponseHandler((_request, response) =>
   Effect.succeed(
     response.status === 401
@@ -693,6 +704,7 @@ export const recoverEnvironmentTunnelRecord = Effect.fn(
     userId: input.userId,
     environmentId: input.environmentId,
     origin: input.origin,
+    reuseReadyTunnel: true,
   });
   const recoveredTunnelId = recovered.runtime.tunnelId;
   if (
@@ -873,6 +885,7 @@ export const layerClientApi = HttpApiBuilder.group(
               cloudMintPublicKey: config.cloudMintPublicKey,
             };
           },
+          Effect.tapError(appendCloudflareRetryAfter),
           mapErrorTags({
             EnvironmentLinkProofExpired: (_error, traceId) =>
               new RelayEnvironmentLinkProofExpiredError({
@@ -1334,6 +1347,7 @@ export const layerServerApi = HttpApiBuilder.group(
               origin: payload.origin,
             });
           },
+          Effect.tapError(appendCloudflareRetryAfter),
           Effect.catchTags({
             ManagedEndpointOriginNotAllowed: () => Effect.fail(new HttpApiError.Unauthorized({})),
             ManagedEndpointProvisioningNotConfigured: () =>
@@ -1369,6 +1383,7 @@ export const layerServerApi = HttpApiBuilder.group(
               origin: payload.origin,
             });
           },
+          Effect.tapError(appendCloudflareRetryAfter),
           Effect.catchTags({
             ManagedEndpointOriginNotAllowed: () => Effect.fail(new HttpApiError.Unauthorized({})),
             ManagedEndpointProvisioningNotConfigured: () =>
diff --git a/infra/relay/src/monitoring.ts b/infra/relay/src/monitoring.ts
index 6577dab61cf95..3ed521de7e2de 100644
--- a/infra/relay/src/monitoring.ts
+++ b/infra/relay/src/monitoring.ts
@@ -119,9 +119,9 @@ const relayMonitors: ReadonlyArray<RelayMonitor> = [
     severity: "page",
     name: "T3 Connect relay: Cloudflare API rate limited",
     description:
-      "Cloudflare API 429s per 10 min from tunnel and DNS provisioning. Sustained at this level, links and recoveries stall. Peak before #16810: 1,286; during it: ~11k.",
+      "Cloudflare API 429s, plus calls the relay refused while paused after one, per 10 min. Sustained at this level, links and recoveries stall. Peak 429s before #16810: 1,286; during it: ~11k.",
     query: (dataset) =>
-      `['${dataset}']\n| where ${CLOUDFLARE_API} and ${STATUS} == 429\n| summarize rate_limited = count()`,
+      `['${dataset}']\n| where (${CLOUDFLARE_API} and ${STATUS} == 429) or name == "relay.cloudflare_api_pause.rejected"\n| summarize rate_limited = count()`,
     operator: "AboveOrEqual",
     threshold: 500,
     rangeMinutes: 10,
@@ -145,9 +145,9 @@ const relayMonitors: ReadonlyArray<RelayMonitor> = [
     severity: "warn",
     name: "T3 Connect relay: Cloudflare API near its limit",
     description:
-      "Any sustained Cloudflare API 429s. These bursts ran for days before #16810; raise the account limit or cut call volume before they grow.",
+      "Any sustained Cloudflare API 429s or paused calls. 429 bursts ran for days before #16810; raise the account limit or cut call volume before they grow.",
     query: (dataset) =>
-      `['${dataset}']\n| where ${CLOUDFLARE_API} and ${STATUS} == 429\n| summarize rate_limited = count()`,
+      `['${dataset}']\n| where (${CLOUDFLARE_API} and ${STATUS} == 429) or name == "relay.cloudflare_api_pause.rejected"\n| summarize rate_limited = count()`,
     operator: "AboveOrEqual",
     threshold: 20,
     rangeMinutes: 10,
@@ -250,7 +250,14 @@ const relayDashboardCharts = (dataset: string): ReadonlyArray<QueryChart> => {
     timeSeries(
       "cloudflare-api",
       "Cloudflare API calls by status",
-      `${source}\n| where ${CLOUDFLARE_API}\n| summarize count() by bin_auto(_time), status = ${STATUS}`,
+      // Calls refused during a rate-limit pause never reach Cloudflare, so
+      // they are their own series or a storm would look like a quiet period.
+      `${source}\n| where ${CLOUDFLARE_API} or name == "relay.cloudflare_api_pause.rejected"\n| summarize count() by bin_auto(_time), status = case(name == "relay.cloudflare_api_pause.rejected", "paused", isnull(${STATUS}), "no response", tostring(${STATUS}))`,
+    ),
+    timeSeries(
+      "provision-paths",
+      "Tunnel provisions by path",
+      `${source}\n| where name == "relay.managed_endpoint_provider.provision"\n| summarize reused_ready_tunnel = countif(error != true and tobool(['attributes.custom']['relay.managed_endpoint.reused_ready_tunnel']) == true), full_provision = countif(error != true and isnull(['attributes.custom']['relay.managed_endpoint.reused_ready_tunnel'])), failed = countif(error == true) by bin_auto(_time)`,
     ),
     timeSeries(
       "postgres",
diff --git a/infra/relay/src/persistence/schema.ts b/infra/relay/src/persistence/schema.ts
index 3ed6a75a5f6d6..132ceba16a900 100644
--- a/infra/relay/src/persistence/schema.ts
+++ b/infra/relay/src/persistence/schema.ts
@@ -5,6 +5,7 @@ import type {
   RelayManagedEndpointOrigin,
 } from "@t3tools/contracts/relay";
 import {
+  bigint,
   boolean,
   index,
   integer,
@@ -111,6 +112,13 @@ export const relayManagedEndpointAllocations = pgTable(
   ],
 );
 
+// One row per upstream API whose rate limit is shared by every Worker
+// isolate, so a 429 seen by one isolate pauses the rest.
+export const relayUpstreamApiPauses = pgTable("relay_upstream_api_pauses", {
+  api: varchar("api", { length: 64 }).primaryKey(),
+  pausedUntilMs: bigint("paused_until_ms", { mode: "number" }).notNull(),
+});
+
 export const relayManagedTunnelLimits = pgTable("relay_managed_tunnel_limits", {
   userId: varchar("user_id", { length: 191 }).primaryKey(),
   maxTunnels: integer("max_tunnels").notNull(),
diff --git a/infra/relay/src/worker.ts b/infra/relay/src/worker.ts
index 7e381b23f7d20..2d3e388ceb10b 100644
--- a/infra/relay/src/worker.ts
+++ b/infra/relay/src/worker.ts
@@ -57,6 +57,7 @@ import * as ApnsClient from "./agentActivity/ApnsClient.ts";
 import * as ApnsProviderTokens from "./agentActivity/ApnsProviderTokens.ts";
 import * as ApnsDeliveryQueue from "./agentActivity/ApnsDeliveryQueue.ts";
 import * as ApnsDeliveries from "./agentActivity/ApnsDeliveries.ts";
+import * as CloudflareApiPause from "./environments/CloudflareApiPause.ts";
 import * as EnvironmentConnector from "./environments/EnvironmentConnector.ts";
 import * as EnvironmentLinker from "./environments/EnvironmentLinker.ts";
 import * as EnvironmentPublishSignatures from "./environments/EnvironmentPublishSignatures.ts";
@@ -291,6 +292,7 @@ export const layer = Api.make(
       Layer.provideMerge(EnvironmentCredentials.layer),
       Layer.provideMerge(
         Layer.mergeAll(
+          CloudflareApiPause.layer,
           EnvironmentLinks.layer,
           ManagedEndpointAllocations.layer,
           ManagedTunnelLimits.layer,
diff --git a/native/resource-monitor/src/main.rs b/native/resource-monitor/src/main.rs
index 6137544ea0e2c..afb7028815592 100644
--- a/native/resource-monitor/src/main.rs
+++ b/native/resource-monitor/src/main.rs
@@ -21,6 +21,7 @@ const MAX_PROCESS_NAME_BYTES: usize = 1_024;
 const MAX_PROCESS_COMMAND_BYTES: usize = 16 * 1_024;
 const MAX_PROCESS_STATUS_BYTES: usize = 256;
 const HISTORY_CHUNK_SNAPSHOTS: usize = 32;
+const TWO_STAGE_PROCESS_REFRESH: bool = cfg!(any(target_os = "linux", target_os = "macos"));
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -455,7 +456,7 @@ impl Collector {
         roots.insert(config.root_pid);
         let tracked = select_tracked_pids(&rows, &roots);
         let tracked_process_count = tracked.len();
-        let process_details = if cfg!(target_os = "linux") && !tracked.is_empty() {
+        let process_details = if TWO_STAGE_PROCESS_REFRESH && !tracked.is_empty() {
             let monitor_pid = Pid::from_u32(std::process::id());
             let mut detail_pids = tracked
                 .iter()
@@ -562,7 +563,7 @@ impl Collector {
 
 // Keep CPU baselines separate. Even a metadata refresh resets Linux process times.
 fn process_discovery_refresh_kind() -> ProcessRefreshKind {
-    if cfg!(target_os = "linux") {
+    if TWO_STAGE_PROCESS_REFRESH {
         ProcessRefreshKind::nothing().with_cpu().without_tasks()
     } else {
         process_refresh_kind()
@@ -1035,6 +1036,43 @@ mod tests {
         assert!(process.cpu_percent.is_finite());
     }
 
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    #[test]
+    fn keeps_command_lines_and_memory_out_of_the_discovery_table() {
+        let mut collector = Collector::new();
+        let mut config = CollectorConfig {
+            root_pid: u32::MAX,
+            sample_interval: None,
+            external_processes: HashMap::new(),
+        };
+        assert!(collector.sample(&config, None).processes.is_empty());
+
+        let pid = Pid::from_u32(std::process::id());
+        let unselected = collector.system.process(pid).expect("discovered process");
+        assert!(unselected.cmd().is_empty());
+        assert_eq!(unselected.memory(), 0);
+        assert_eq!(unselected.virtual_memory(), 0);
+
+        config.external_processes.insert(pid.as_u32(), None);
+        let snapshot = collector.sample(&config, None);
+        let selected = snapshot
+            .processes
+            .iter()
+            .find(|process| process.pid == pid.as_u32())
+            .expect("external process details");
+        assert!(!selected.command.is_empty());
+        assert!(selected.resident_bytes > 0);
+        assert!(selected.start_time_ms > 0);
+
+        let retained = collector
+            .system
+            .process(pid)
+            .expect("retained CPU baseline");
+        assert!(retained.cmd().is_empty());
+        assert_eq!(retained.memory(), 0);
+        assert_eq!(retained.virtual_memory(), 0);
+    }
+
     #[test]
     fn accepts_clock_shifts_without_accepting_reused_process_starts() {
         assert!(matches_process_start_time(10_000, 13_600, 3_600));
diff --git a/packages/client-runtime/src/device/stream.test.ts b/packages/client-runtime/src/device/stream.test.ts
index 76dae57abd9c2..93b786cfed9bb 100644
--- a/packages/client-runtime/src/device/stream.test.ts
+++ b/packages/client-runtime/src/device/stream.test.ts
@@ -114,6 +114,8 @@ describe("native device stream transport", () => {
     socket.onopen?.();
     expect(socket.send).not.toHaveBeenCalled();
     socket.onmessage?.({ data: Uint8Array.of(0x83).buffer });
+    client.sendText("hello");
+    expect(socket.send).not.toHaveBeenCalled();
     client.setOrientation("landscape_right");
     client.pressButton("home");
     client.sendTouch("begin", 0.25, 0.75);
@@ -148,6 +150,8 @@ describe("native device stream transport", () => {
     client.setOrientation("landscape_right");
     client.pressButton("home");
     client.pressButton("appSwitcher");
+    const prefix = "a".repeat(299);
+    client.sendText(`${prefix}ä`);
     expect(
       socket.send.mock.calls.map(([message]) => JSON.parse(message as string) as unknown),
     ).toEqual([
@@ -156,6 +160,8 @@ describe("native device stream transport", () => {
       { type: "touch", action: "up", x: 0.2, y: 0.1 },
       { type: "home" },
       { type: "recents" },
+      { type: "text", text: prefix },
+      { type: "text", text: "ä" },
     ]);
     client.stop();
     expect(socket.close).toHaveBeenCalledTimes(1);
diff --git a/packages/client-runtime/src/device/stream.ts b/packages/client-runtime/src/device/stream.ts
index 6eeeb66cb9dc2..b9cdcb7a56bdd 100644
--- a/packages/client-runtime/src/device/stream.ts
+++ b/packages/client-runtime/src/device/stream.ts
@@ -100,6 +100,10 @@ const SEMU_MAGIC = 0x53454d55;
 const SEMU_HEADER_BYTES = 16;
 const SEMU_FLAG_KEY = 1;
 const SOFT_DECODE_QUEUE = 8;
+// expo-device-hub 0.15.3 serve-emu input.js MAX_TEXT_BYTES limits packets to 300 UTF-8 bytes.
+const ANDROID_MAX_TEXT_BYTES = 300;
+// The pinned hub queue depth is 128; the client does not read queue rejections.
+const ANDROID_MAX_TEXT_CHUNKS = 64;
 
 const IOS_MSG_TOUCH = 0x03;
 const IOS_MSG_BUTTON = 0x04;
@@ -116,6 +120,13 @@ const isWebCodecsSupported = (): boolean =>
   "VideoDecoder" in globalThis &&
   "EncodedVideoChunk" in globalThis;
 
+function utf8ByteLength(codePoint: number): number {
+  if (codePoint <= 0x7f) return 1;
+  if (codePoint <= 0x7ff) return 2;
+  if (codePoint <= 0xffff) return 3;
+  return 4;
+}
+
 function taggedJson(tag: number, payload: unknown): Uint8Array<ArrayBuffer> {
   const json = encoder.encode(JSON.stringify(payload));
   const out = new Uint8Array(1 + json.length);
@@ -245,6 +256,8 @@ export interface DeviceStreamClient {
   /** Normalized 0..1 coordinates in the displayed frame. */
   readonly sendTouch: (phase: "begin" | "move" | "end", x: number, y: number) => void;
   readonly sendKey: (event: KeyboardEvent, phase: "down" | "up") => void;
+  /** Android only: iOS input is HID key codes, which cannot carry arbitrary text. */
+  readonly sendText: (text: string) => void;
   readonly pressButton: (button: DeviceHardwareButton) => void;
   readonly rotate: () => void;
   readonly setOrientation: (orientation: DeviceScreenSize["orientation"]) => void;
@@ -1054,6 +1067,24 @@ export function createDeviceStreamClient(
         send(JSON.stringify({ type: "text", text: event.key }));
       }
     },
+    sendText: (text) => {
+      if (platform !== "android") return;
+      let chunk = "";
+      let chunkBytes = 0;
+      let sentChunks = 0;
+      for (const character of text) {
+        const characterBytes = utf8ByteLength(character.codePointAt(0)!);
+        if (chunkBytes + characterBytes > ANDROID_MAX_TEXT_BYTES) {
+          send(JSON.stringify({ type: "text", text: chunk }));
+          if (++sentChunks >= ANDROID_MAX_TEXT_CHUNKS) return;
+          chunk = "";
+          chunkBytes = 0;
+        }
+        chunk += character;
+        chunkBytes += characterBytes;
+      }
+      if (chunk.length > 0) send(JSON.stringify({ type: "text", text: chunk }));
+    },
     pressButton: (button) => {
       if (platform === "ios") {
         const name =
diff --git a/packages/client-runtime/src/errors/network.ts b/packages/client-runtime/src/errors/network.ts
index dce7935d94492..40816bc23f149 100644
--- a/packages/client-runtime/src/errors/network.ts
+++ b/packages/client-runtime/src/errors/network.ts
@@ -1,2 +1,2 @@
 export const NETWORK_BLOCKING_HINT =
-  "Your DNS or firewall may be blocking T3 Connect. Try another network, such as a phone hotspot.";
+  "Your DNS or firewall may be blocking T3 Connect. Try another network, such as a different Wi-Fi or mobile data.";
diff --git a/packages/client-runtime/src/pullRequestLinkInput.test.ts b/packages/client-runtime/src/pullRequestLinkInput.test.ts
index 47896c0d9ffdf..74cdad9f336ee 100644
--- a/packages/client-runtime/src/pullRequestLinkInput.test.ts
+++ b/packages/client-runtime/src/pullRequestLinkInput.test.ts
@@ -114,11 +114,17 @@ describe("resolveLinkPullRequestInput", () => {
     expect(result).toMatchObject({ error: expect.stringContaining("gitlab.com") });
   });
 
-  it("asks for a URL when a bare number has no project to resolve against", () => {
-    expect(
-      resolveLinkPullRequestInput({ reference: "12", project: null, hasProject: () => true }),
-    ).toMatchObject({ error: expect.stringContaining("full URL") });
-  });
+  it.each(["12", "#12"])(
+    "names the missing repository when resolving bare number %s",
+    (reference) => {
+      expect(
+        resolveLinkPullRequestInput({ reference, project: null, hasProject: () => true }),
+      ).toEqual({
+        error:
+          "Paste the full pull request URL; this thread has no repository to resolve the number against.",
+      });
+    },
+  );
 
   it("accepts a checkout command as a reference", () => {
     expect(
diff --git a/packages/client-runtime/src/pullRequestLinkInput.ts b/packages/client-runtime/src/pullRequestLinkInput.ts
index a6d4d4ce8d8b1..a72701adc903d 100644
--- a/packages/client-runtime/src/pullRequestLinkInput.ts
+++ b/packages/client-runtime/src/pullRequestLinkInput.ts
@@ -91,7 +91,10 @@ export function resolveLinkPullRequestInput(input: {
   const number = Number(parsed);
   if (!Number.isSafeInteger(number) || number < 1) return null;
   if (input.project === null) {
-    return { error: "Paste a full URL to link a pull request from another repository." };
+    return {
+      error:
+        "Paste the full pull request URL; this thread has no repository to resolve the number against.",
+    };
   }
   const webUrl = input.project.webUrl(number);
   const webReference = webUrl === null ? null : parseChangeRequestUrl(webUrl);
diff --git a/packages/client-runtime/src/state/commandPermissions.test.ts b/packages/client-runtime/src/state/commandPermissions.test.ts
index 265d41ff21f44..275b117253d92 100644
--- a/packages/client-runtime/src/state/commandPermissions.test.ts
+++ b/packages/client-runtime/src/state/commandPermissions.test.ts
@@ -8,6 +8,7 @@ import { describe, expect, it } from "@effect/vitest";
 import { vi } from "vite-plus/test";
 import {
   AuthOrchestrationOperateScope,
+  AuthPreviewOperateScope,
   AuthSettingsWriteScope,
   AuthSourceControlWriteScope,
   ThreadId,
@@ -59,6 +60,35 @@ const setup = Effect.gen(function* () {
 });
 
 describe("command permissions", () => {
+  it.effect("requires the destination preview grant to close a browser tab", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const registry = yield* setup;
+        const close = createCommandPermissions(runtime, WS_METHODS.previewClose);
+        registry.set(sessions(env), AsyncResult.success(grant(true)));
+        expect(registry.get(close.permissionAtom(env))).toBe(false);
+        expect((yield* close.authorize(registry, env).pipe(Effect.flip))._tag).toBe(
+          "EnvironmentAuthorizationError",
+        );
+        registry.set(
+          sessions(env),
+          AsyncResult.success({
+            ...grant(false),
+            scopes: [AuthPreviewOperateScope],
+            permissions: [AuthPreviewOperateScope],
+          }),
+        );
+        expect(registry.get(close.permissionAtom(env))).toBe(true);
+        yield* close.authorize(registry, env);
+        registry.set(sessions(other), AsyncResult.success(grant(false)));
+        expect(registry.get(close.permissionAtom(other))).toBe(false);
+        expect((yield* close.authorize(registry, other).pipe(Effect.flip))._tag).toBe(
+          "EnvironmentAuthorizationError",
+        );
+      }),
+    ),
+  );
+
   it.effect("requires the destination settings grant to run storage cleanup", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/packages/client-runtime/src/state/projectCommands.test.ts b/packages/client-runtime/src/state/projectCommands.test.ts
index 9d7d47ea9d835..a138bde04f7e1 100644
--- a/packages/client-runtime/src/state/projectCommands.test.ts
+++ b/packages/client-runtime/src/state/projectCommands.test.ts
@@ -3,6 +3,8 @@ import {
   AuthFilesystemWriteScope,
   EnvironmentId,
   ProjectId,
+  ProjectReadFileInput,
+  ProjectReadFileResult,
   ThreadId,
   type AuthSessionState,
   type ScopedProjectRef,
@@ -15,6 +17,7 @@ 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 Schema from "effect/Schema";
 import * as SubscriptionRef from "effect/SubscriptionRef";
 import * as Stream from "effect/Stream";
 import { Atom, AtomRegistry, AsyncResult } from "effect/reactivity";
@@ -26,6 +29,8 @@ import type { RpcSession } from "../rpc/session.ts";
 import type { EnvironmentProject } from "./models.ts";
 import { createProjectEnvironmentAtoms } from "./projectCommands.ts";
 
+const decodeReadFileInput = Schema.decodeUnknownSync(ProjectReadFileInput);
+const decodeReadFileResult = Schema.decodeUnknownSync(ProjectReadFileResult);
 const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
 vi.mock("./session.ts", () => ({
   createEnvironmentSessionAtoms: () => ({ sessionStateAtom: sessions }),
@@ -43,7 +48,10 @@ const PROJECT = {
 const makeHarness = Effect.fn("TestProjectCommands.makeHarness")(function* () {
   const metadataRequests: string[][] = [];
   const file = { byteLength: 5 };
-  const readResponse = { wait: Effect.void as Effect.Effect<void> };
+  const readResponse = {
+    wait: Effect.void as Effect.Effect<void>,
+    missing: false,
+  };
   const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
     target: { environmentId: ENVIRONMENT_ID },
     session: yield* SubscriptionRef.make(
@@ -54,7 +62,17 @@ const makeHarness = Effect.fn("TestProjectCommands.makeHarness")(function* () {
             Effect.gen(function* () {
               const byteLength = file.byteLength;
               yield* readResponse.wait;
-              return { relativePath: "foo", byteLength, contents: "old", truncated: false };
+              return decodeReadFileResult(
+                readResponse.missing
+                  ? {
+                      relativePath: "foo",
+                      byteLength: 0,
+                      contents: "",
+                      truncated: false,
+                      exists: false,
+                    }
+                  : { relativePath: "foo", byteLength, contents: "old", truncated: false },
+              );
             }),
           [WS_METHODS.projectsWriteFile]: () =>
             Effect.sync(() => {
@@ -65,10 +83,11 @@ const makeHarness = Effect.fn("TestProjectCommands.makeHarness")(function* () {
             Effect.sync(() => {
               metadataRequests.push(input.paths);
               return {
-                entries: input.paths.map(() => ({
-                  kind: "file" as const,
-                  byteLength: file.byteLength,
-                })),
+                entries: input.paths.map(() =>
+                  readResponse.missing
+                    ? null
+                    : { kind: "file" as const, byteLength: file.byteLength },
+                ),
               };
             }),
         },
@@ -126,6 +145,35 @@ const makeHarness = Effect.fn("TestProjectCommands.makeHarness")(function* () {
 });
 
 describe("writeFile metadata", () => {
+  it.effect("preserves optional read results without seeding metadata for an absent file", () =>
+    Effect.gen(function* () {
+      const h = yield* makeHarness();
+      h.readResponse.missing = true;
+      const input = { cwd: "/repo", relativePath: "foo", allowMissing: true };
+      expect.soft(decodeReadFileInput(input)).toEqual(input);
+      const result = yield* AtomRegistry.getResult(
+        h.registry,
+        h.commands.readFile({ environmentId: ENVIRONMENT_ID, input }),
+        { suspendOnWaiting: true },
+      );
+      expect.soft(result).toEqual({
+        relativePath: "foo",
+        byteLength: 0,
+        contents: "",
+        truncated: false,
+        exists: false,
+      });
+      const metadata = h.commands.fileMetadata({
+        environmentId: ENVIRONMENT_ID,
+        input: { path: "/repo/foo" },
+      });
+      expect(
+        yield* AtomRegistry.getResult(h.registry, metadata, { suspendOnWaiting: true }),
+      ).toBeNull();
+      expect(h.metadataRequests).toEqual([["/repo/foo"]]);
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("reuses a current file read without another metadata request", () =>
     Effect.gen(function* () {
       const h = yield* makeHarness();
diff --git a/packages/client-runtime/src/state/projectCommands.ts b/packages/client-runtime/src/state/projectCommands.ts
index 12b57e48a46bc..ca9b8c7d02481 100644
--- a/packages/client-runtime/src/state/projectCommands.ts
+++ b/packages/client-runtime/src/state/projectCommands.ts
@@ -143,7 +143,10 @@ export function createProjectEnvironmentAtoms<R, E>(
       execute: (input) =>
         fileMetadata.seedAfterRead(
           request(WS_METHODS.projectsReadFile, input),
-          (result, isCurrent) => fileMetadata.rememberFile(input.cwd, result, isCurrent),
+          (result, isCurrent) =>
+            result.exists === false
+              ? Effect.void
+              : fileMetadata.rememberFile(input.cwd, result, isCurrent),
         ),
     }),
     optimisticFile: (target: OptimisticProjectFileTarget) =>
diff --git a/packages/client-runtime/src/state/subagentRuntime.test.ts b/packages/client-runtime/src/state/subagentRuntime.test.ts
index 5cf96fc937d22..45dfe610dad31 100644
--- a/packages/client-runtime/src/state/subagentRuntime.test.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.test.ts
@@ -87,9 +87,11 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
     expect(rows[2]?.startedAt).toBeNull();
   });
 
-  it("derives a settled member's end from its reported duration", () => {
+  it("uses a settled member's wall-clock completion separately from its execution duration", () => {
     const [, settled] = projectedSubagentsToRuntime([
       subagent({
+        status: "completed",
+        completedAt: at("2026-08-01T10:00:09.000Z"),
         workflow: {
           phases: [],
           agents: [
@@ -97,6 +99,7 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
               state: "completed",
               startedAt: Date.UTC(2026, 7, 1, 10, 0, 0),
               durationMs: 1500,
+              completedAt: Date.UTC(2026, 7, 1, 10, 0, 4, 432),
               totalTokens: 71_141,
               toolCalls: 3,
               prompt: "Reply with exactly: A1",
@@ -107,7 +110,7 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
       }),
     ]);
     expect(settled?.status).toBe("completed");
-    expect(settled?.completedAt).toBe("2026-08-01T10:00:01.500Z");
+    expect(settled?.completedAt).toBe("2026-08-01T10:00:04.432Z");
     expect(settled?.result).toBe("A1");
     expect(settled?.progress).toBe("Reply with exactly: A1");
     expect(settled?.usage).toEqual({ totalTokens: 71_141, toolUses: 3, durationMs: 1500 });
@@ -125,7 +128,12 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
             agents: [
               member(),
               member({ index: 2, state: "queued" }),
-              member({ index: 3, state: "completed" }),
+              member({
+                index: 3,
+                state: "completed",
+                startedAt: Date.UTC(2026, 7, 1, 10, 0, 0),
+                durationMs: 1500,
+              }),
             ],
           },
         }),
@@ -133,7 +141,11 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
       expect(groups[0]?.workflow.status).toBe(status);
       const members = groups[0]?.phases.flatMap((phase) => phase.members);
       expect(members?.map((agent) => agent.status)).toEqual([status, status, "completed"]);
-      expect(members?.[0]?.completedAt).toBe("2026-08-01T10:00:09.000Z");
+      expect(members?.map((agent) => agent.completedAt)).toEqual([
+        "2026-08-01T10:00:09.000Z",
+        "2026-08-01T10:00:09.000Z",
+        "2026-08-01T10:00:01.500Z",
+      ]);
     },
   );
 
diff --git a/packages/client-runtime/src/state/subagentRuntime.ts b/packages/client-runtime/src/state/subagentRuntime.ts
index cba84900ea099..c007bc56b9743 100644
--- a/packages/client-runtime/src/state/subagentRuntime.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.ts
@@ -139,9 +139,10 @@ function workflowMembersToRuntime(
     const failed = status === "failed";
     const startedAt = isoFromEpochMillis(agent.startedAt);
     const completedAt = isTerminalSubagentStatus(status)
-      ? agent.startedAt !== undefined && agent.durationMs !== undefined
-        ? isoFromEpochMillis(agent.startedAt + agent.durationMs)
-        : coordinator.completedAt
+      ? (isoFromEpochMillis(agent.completedAt) ??
+        (agent.startedAt !== undefined && agent.durationMs !== undefined
+          ? isoFromEpochMillis(agent.startedAt + agent.durationMs)
+          : coordinator.completedAt))
       : null;
     return {
       ...coordinator,
diff --git a/packages/client-runtime/src/state/threadExecution.test.ts b/packages/client-runtime/src/state/threadExecution.test.ts
index 86a0986256b74..4af529df8e4eb 100644
--- a/packages/client-runtime/src/state/threadExecution.test.ts
+++ b/packages/client-runtime/src/state/threadExecution.test.ts
@@ -441,7 +441,7 @@ describe("formatModelSelectionEffort", () => {
     model: "claude-sonnet-5",
     ...(options === undefined ? {} : { options }),
   });
-  const catalog = (descriptor: { currentValue?: string }) => [
+  const catalog = (descriptor: { id?: string; currentValue?: string }) => [
     {
       slug: "claude-sonnet-5",
       name: "Claude Sonnet 5",
@@ -464,27 +464,26 @@ describe("formatModelSelectionEffort", () => {
     },
   ];
 
-  it("names stored and matching reported effort, preferring the stored choice", () => {
-    expect(
-      formatModelSelectionEffort(selection([{ id: "effort", value: "xhigh" }]), catalog({})),
-    ).toBe("Extra High");
-    const reported = selection([{ id: "effort", value: "xhigh" }]);
-    expect(formatModelSelectionEffort(selection(), catalog({}), reported)).toBe("Extra High");
-    expect(
-      formatModelSelectionEffort(
-        selection([{ id: "effort", value: "medium" }]),
-        catalog({}),
-        reported,
-      ),
-    ).toBe("Medium");
-    expect(
-      formatModelSelectionEffort(
-        selection([{ id: "effort", value: "retired-effort" }]),
-        catalog({ currentValue: "medium" }),
-        reported,
-      ),
-    ).toBeNull();
-  });
+  it.each(["effort", "reasoning_effort"])(
+    "names stored and matching reported %s, preferring the stored choice",
+    (id) => {
+      expect(formatModelSelectionEffort(selection([{ id, value: "xhigh" }]), catalog({ id }))).toBe(
+        "Extra High",
+      );
+      const reported = selection([{ id, value: "xhigh" }]);
+      expect(formatModelSelectionEffort(selection(), catalog({ id }), reported)).toBe("Extra High");
+      expect(
+        formatModelSelectionEffort(selection([{ id, value: "medium" }]), catalog({ id }), reported),
+      ).toBe("Medium");
+      expect(
+        formatModelSelectionEffort(
+          selection([{ id, value: "retired-effort" }]),
+          catalog({ id, currentValue: "medium" }),
+          reported,
+        ),
+      ).toBeNull();
+    },
+  );
 
   it("shows nothing when neither the selection nor the provider states an effort", () => {
     expect(formatModelSelectionEffort(selection(), catalog({}))).toBeNull();
diff --git a/packages/client-runtime/src/state/threadExecution.ts b/packages/client-runtime/src/state/threadExecution.ts
index 2f85fb6ed792e..8c27b2373c037 100644
--- a/packages/client-runtime/src/state/threadExecution.ts
+++ b/packages/client-runtime/src/state/threadExecution.ts
@@ -151,7 +151,13 @@ export function deriveReportedModelSelection(
   return providerThread?.nativeMetadata?.modelSelection ?? null;
 }
 
-const REASONING_EFFORT_OPTION_IDS = ["reasoningEffort", "effort", "reasoning", "variant"] as const;
+export const REASONING_EFFORT_OPTION_IDS: ReadonlyArray<string> = [
+  "reasoningEffort",
+  "effort",
+  "reasoning",
+  "variant",
+  "reasoning_effort",
+];
 
 export function formatModelSelectionEffort(
   selection: ModelSelection,
diff --git a/packages/client-runtime/src/t3ToolSummary.ts b/packages/client-runtime/src/t3ToolSummary.ts
index 25878d4ff5bc7..668078191c40e 100644
--- a/packages/client-runtime/src/t3ToolSummary.ts
+++ b/packages/client-runtime/src/t3ToolSummary.ts
@@ -405,15 +405,19 @@ export function summarizeT3ToolCalls(
       const started = outcomes.filter((outcome) => outcome !== "failed").length;
       const failed = outcomes.length - started;
       failedCount += failed;
-      if (outcomes.length > 0 && started === 0) {
+      if (outcomes.length === 0) {
+        label = phrase(
+          "Started writing",
+          "start writing",
+          `review guides${selected.length === 1 ? "" : ` ${times}`}`,
+        );
+      } else if (started === 0) {
         label = `Could not start ${quantity(failed, "review guide")}`;
       } else {
         label = phrase(
           "Started",
           "start",
-          outcomes.length === 0
-            ? `review guides ${times}`
-            : `${quantity(started, "review guide")}${failed > 0 ? `, ${failed} failed` : ""}`,
+          `${quantity(started, "review guide")}${failed > 0 ? `, ${failed} failed` : ""}`,
         );
       }
       break;
diff --git a/packages/client-runtime/src/work-log/presentation.test.ts b/packages/client-runtime/src/work-log/presentation.test.ts
index e5f0acd9d9e37..11c4cb78fdf37 100644
--- a/packages/client-runtime/src/work-log/presentation.test.ts
+++ b/packages/client-runtime/src/work-log/presentation.test.ts
@@ -375,6 +375,49 @@ describe("resolveWorkEntryToolPresentation", () => {
     ).toBe(completed);
   });
 
+  it("distinguishes an interrupted unwatch from a completed unwatch", () => {
+    const entry = { label: "T3-code.unwatch_pull_request" };
+    expect(
+      (["inProgress", "stopped", "completed"] as const).map(
+        (toolLifecycleStatus) =>
+          resolveWorkEntryToolPresentation({ ...entry, toolLifecycleStatus })?.displayName,
+      ),
+    ).toEqual([
+      "Unwatching a pull request",
+      "Stopped unwatching a pull request",
+      "Stopped watching a pull request",
+    ]);
+  });
+
+  it("describes starting review-guide writing in rows and groups without outcomes", () => {
+    const entry = {
+      id: "guides",
+      createdAt: "2026-10-07T00:00:00.000Z",
+      tone: "tool",
+      label: "T3-code.write_pull_request_guides",
+      toolLifecycleStatus: "completed",
+    } satisfies WorkLogPresentationEntry;
+    expect({
+      row: resolveWorkEntryToolPresentation(entry)?.displayName,
+      single: summarizeToolGroup([entry]).summary,
+      repeated: summarizeToolGroup([entry, { ...entry, id: "guides-2" }]).summary,
+    }).toEqual({
+      row: "Started writing review guides",
+      single: "Started writing review guides",
+      repeated: "Started writing review guides 2 times",
+    });
+  });
+
+  it("describes delegated-task cancellation as an ongoing action then a request", () => {
+    const entry = { label: "T3-code.task_cancel" };
+    expect(
+      (["inProgress", "completed"] as const).map(
+        (toolLifecycleStatus) =>
+          resolveWorkEntryToolPresentation({ ...entry, toolLifecycleStatus })?.displayName,
+      ),
+    ).toEqual(["Canceling a delegated task", "Requested cancellation of a delegated task"]);
+  });
+
   it("summarizes workflow stop targets separately from their parent thread", () => {
     const entry = {
       id: "workflow-stop",
diff --git a/packages/contracts/src/acpRegistry.test.ts b/packages/contracts/src/acpRegistry.test.ts
index 8f87d41a9b06e..3859f53a6b75c 100644
--- a/packages/contracts/src/acpRegistry.test.ts
+++ b/packages/contracts/src/acpRegistry.test.ts
@@ -50,6 +50,7 @@ describe("ACP Registry contracts", () => {
     expect(decodeSearchInput({ query: "  codex  " })).toEqual({
       query: "codex",
     });
+    expect(decodeSearchInput({ query: "", limit: 512 })).toEqual({ query: "", limit: 512 });
     expect(
       decodePrepareResult({
         agentId: "codex-acp",
@@ -62,6 +63,8 @@ describe("ACP Registry contracts", () => {
 
   it("rejects oversized queries and result metadata", () => {
     expect(() => decodeSearchInput({ query: "x".repeat(121) })).toThrow();
+    expect(() => decodeSearchInput({ query: "", limit: 0 })).toThrow();
+    expect(() => decodeSearchInput({ query: "", limit: 513 })).toThrow();
     expect(() =>
       decodeSearchAgent({
         id: "agent",
diff --git a/packages/contracts/src/acpRegistry.ts b/packages/contracts/src/acpRegistry.ts
index 559ac6e47761c..3962cf4a995ff 100644
--- a/packages/contracts/src/acpRegistry.ts
+++ b/packages/contracts/src/acpRegistry.ts
@@ -47,8 +47,13 @@ export type AcpRegistryDistribution = typeof AcpRegistryDistribution.Type;
 export const AcpRegistryIntegrity = Schema.Literals(["sha256", "registry"]);
 export type AcpRegistryIntegrity = typeof AcpRegistryIntegrity.Type;
 
+export const ACP_REGISTRY_MAX_AGENTS = 512;
+
 export const AcpRegistrySearchInput = Schema.Struct({
   query: TrimmedString.check(Schema.isMaxLength(120)),
+  limit: Schema.optional(
+    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: ACP_REGISTRY_MAX_AGENTS })),
+  ),
 });
 export type AcpRegistrySearchInput = typeof AcpRegistrySearchInput.Type;
 
@@ -70,7 +75,7 @@ export const AcpRegistrySearchAgent = Schema.Struct({
 export type AcpRegistrySearchAgent = typeof AcpRegistrySearchAgent.Type;
 
 export const AcpRegistrySearchResult = Schema.Struct({
-  agents: Schema.Array(AcpRegistrySearchAgent).check(Schema.isMaxLength(20)),
+  agents: Schema.Array(AcpRegistrySearchAgent).check(Schema.isMaxLength(ACP_REGISTRY_MAX_AGENTS)),
 });
 export type AcpRegistrySearchResult = typeof AcpRegistrySearchResult.Type;
 
diff --git a/packages/contracts/src/clientRpcPermissions.ts b/packages/contracts/src/clientRpcPermissions.ts
index 7d758fafa464d..60f2ef2b7fec0 100644
--- a/packages/contracts/src/clientRpcPermissions.ts
+++ b/packages/contracts/src/clientRpcPermissions.ts
@@ -2,6 +2,7 @@ import * as Schema from "effect/Schema";
 import { GitPreparePullRequestThreadInput } from "./git.ts";
 import {
   AuthOrchestrationOperateScope,
+  AuthPreviewOperateScope,
   AuthSettingsWriteScope,
   AuthSourceControlWriteScope,
   type AuthEnvironmentScope,
@@ -11,6 +12,7 @@ import { WS_METHODS } from "./rpc.ts";
 
 /** Incremental client enforcement; the server still authorizes every request. */
 export const CLIENT_GUARDED_RPC_SCOPES = {
+  [WS_METHODS.previewClose]: AuthPreviewOperateScope,
   [WS_METHODS.serverRunStorageCleanup]: AuthSettingsWriteScope,
   [WS_METHODS.serverCheckOtlpEndpoint]: AuthSettingsWriteScope,
   [WS_METHODS.serverCheckSecretSource]: AuthSettingsWriteScope,
diff --git a/packages/contracts/src/editor.ts b/packages/contracts/src/editor.ts
index f40d1823b9ad3..afdb04dd59fd8 100644
--- a/packages/contracts/src/editor.ts
+++ b/packages/contracts/src/editor.ts
@@ -181,6 +181,7 @@ export const buildRemoteOpenUrl = (input: {
   readonly editor: EditorId;
   readonly host: string;
   readonly absolutePath: string;
+  readonly isFile?: boolean;
 }): string | undefined => {
   const scheme = remoteSchemeForEditor(input.editor);
   if (scheme === undefined) {
@@ -210,7 +211,8 @@ export const buildRemoteOpenUrl = (input: {
     return `${scheme}://ssh/${encodedHost}${encodedZedPath}`;
   }
   const encodedPath = rootedPath.split("/").map(encodeURIComponent).join("/");
-  return `${scheme}://vscode-remote/ssh-remote+${encodedHost}${encodedPath}`;
+  // VS Code opens a bare vscode-remote path as a folder; a trailing position makes it open the file.
+  return `${scheme}://vscode-remote/ssh-remote+${encodedHost}${encodedPath}${input.isFile ? ":1:1" : ""}`;
 };
 
 export const RemoteOpenTargetKind = Schema.Literals(["tailscale", "mdns"]);
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index d5364ea2fa8f4..1dc4880358116 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -669,6 +669,7 @@ export const OrchestrationV2WorkflowAgent = Schema.Struct({
   durationMs: Schema.optional(NonNegativeInt),
   queuedAt: Schema.optional(NonNegativeInt),
   startedAt: Schema.optional(NonNegativeInt),
+  completedAt: Schema.optional(NonNegativeInt),
   prompt: Schema.optional(Schema.NonEmptyString),
   result: Schema.optional(Schema.NonEmptyString),
 });
@@ -1132,6 +1133,7 @@ export const OrchestrationV2UserInputQuestion = Schema.Struct({
       label: TrimmedNonEmptyString,
       description: TrimmedNonEmptyString,
       value: Schema.optional(Schema.String),
+      preview: Schema.optional(Schema.String),
     }),
   ),
   multiSelect: Schema.optional(Schema.Boolean),
@@ -1825,6 +1827,7 @@ export const OrchestrationV2ThreadShell = Schema.Struct({
   activityRunStatus: Schema.optional(
     Schema.NullOr(Schema.Literals(["preparing", "starting", "running", "waiting"])),
   ),
+  blockedOnThreadWait: Schema.optional(Schema.Boolean),
   status: OrchestrationV2ShellThreadStatus,
   lastError: Schema.optional(Schema.NullOr(Schema.String)),
   lastErrorClass: Schema.optional(Schema.NullOr(OrchestrationV2ProviderFailureClass)),
diff --git a/packages/contracts/src/project.ts b/packages/contracts/src/project.ts
index d377311620a86..ef4477575fff5 100644
--- a/packages/contracts/src/project.ts
+++ b/packages/contracts/src/project.ts
@@ -418,6 +418,8 @@ export const ProjectReadFileInput = Schema.Struct({
   // Workspace-relative, or an absolute host path for a file outside the
   // workspace. Only workspace-relative paths can be written back.
   relativePath: TrimmedNonEmptyString.check(Schema.isMaxLength(PROJECT_READ_FILE_PATH_MAX_LENGTH)),
+  // Optional files can be absent without failing the read.
+  allowMissing: Schema.optional(Schema.Boolean),
 });
 export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;
 
@@ -426,6 +428,8 @@ export const ProjectReadFileResult = Schema.Struct({
   contents: Schema.String,
   byteLength: NonNegativeInt,
   truncated: Schema.Boolean,
+  // Omitted by older servers; false only for an absent optional file.
+  exists: Schema.optional(Schema.Boolean),
 });
 export type ProjectReadFileResult = typeof ProjectReadFileResult.Type;
 
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 4749395cc75d3..d4fb764ca31bf 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -1035,6 +1035,7 @@ export const StorageCleanupReportEntry = Schema.Struct({
   outcome: Schema.Literals(["removed", "kept", "failed"]),
   reason: Schema.String,
   path: Schema.NullOr(Schema.String),
+  projectPath: Schema.NullOr(Schema.String).pipe(Schema.withDecodingDefault(Effect.succeed(null))),
   threadId: Schema.NullOr(ThreadId),
   threadTitle: Schema.NullOr(Schema.String),
   bytes: Schema.NullOr(Schema.Number).pipe(Schema.withDecodingDefault(Effect.succeed(null))),
diff --git a/packages/effect-codex-app-server/src/protocol.test.ts b/packages/effect-codex-app-server/src/protocol.test.ts
index 7249afff10713..0b17a7b603cba 100644
--- a/packages/effect-codex-app-server/src/protocol.test.ts
+++ b/packages/effect-codex-app-server/src/protocol.test.ts
@@ -371,6 +371,80 @@ it.layer(NodeServices.layer)("effect-codex-app-server protocol", (it) => {
       }),
   );
 
+  it.effect.each(["newline-terminated", "unfinished"])(
+    "rejects an oversized %s message using UTF-8 bytes before logging or parsing",
+    (framing) =>
+      Effect.gen(function* () {
+        const { stdio, input, output } = yield* makeInMemoryStdio();
+        const notifications: Array<CodexProtocol.CodexAppServerIncomingNotification> = [];
+        const logged: Array<unknown> = [];
+        const termination = yield* Deferred.make<CodexError.CodexAppServerError>();
+        let reachedEnd = false;
+        const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
+          stdio: Stdio.make({
+            ...stdio,
+            stdin: stdio.stdin.pipe(
+              Stream.concat(
+                Stream.suspend(() => {
+                  reachedEnd = true;
+                  return Stream.empty;
+                }),
+              ),
+            ),
+          }),
+          maxIncomingMessageBytes: 16,
+          logIncoming: true,
+          logger: (event) =>
+            Effect.sync(() => {
+              logged.push(event.payload);
+            }),
+          onNotification: (notification) =>
+            Effect.sync(() => {
+              notifications.push(notification);
+            }),
+          onTermination: (error) => Deferred.succeed(termination, error).pipe(Effect.asVoid),
+        });
+        const pending = yield* Effect.forEach(["thread/read", "thread/list"], (method) =>
+          transport.request(method, {}).pipe(Effect.forkScoped),
+        );
+        yield* Effect.forEach(pending, () => Queue.take(output));
+
+        // Two 16-byte lines must survive; the 17-byte line is only 15 UTF-16 code units.
+        const firstLine = '{"method":"xé"}';
+        const secondLine = '{"method":"x/a"}';
+        const bytes = encoder.encode(
+          `${firstLine}\n${secondLine}\n{"method":"éé"}${framing === "unfinished" ? "" : "\n"}`,
+        );
+        // Split a UTF-8 sequence on both sides of the byte limit.
+        const firstSplit = bytes.indexOf(0xc3) + 1;
+        yield* Queue.offer(input, bytes.subarray(0, firstSplit));
+        if (framing === "unfinished") {
+          const lastSplit = bytes.lastIndexOf(0xc3) + 1;
+          yield* Queue.offer(input, bytes.subarray(firstSplit, lastSplit));
+          yield* Queue.offer(input, bytes.subarray(lastSplit));
+        } else {
+          yield* Queue.offer(input, bytes.subarray(firstSplit));
+        }
+        yield* Queue.end(input);
+
+        const error = yield* Deferred.await(termination);
+        assert.instanceOf(error, CodexError.CodexAppServerTransportError);
+        assert.equal(error.operation, "read-input-stream");
+        assert.isFalse(reachedEnd, "Must reject the unfinished line before reading EOF");
+        for (const response of pending) {
+          const failure = yield* Fiber.join(response).pipe(
+            Effect.match({
+              onFailure: (error) => error,
+              onSuccess: () => assert.fail("Expected the oversized message to fail the request"),
+            }),
+          );
+          assert.strictEqual(failure, error);
+        }
+        assert.deepEqual(notifications, [{ method: "xé" }, { method: "x/a" }]);
+        assert.deepEqual(logged, [firstLine, { method: "xé" }, secondLine, { method: "x/a" }]);
+      }),
+  );
+
   it.effect("reports a malformed fragmented final line before input stream termination", () =>
     Effect.gen(function* () {
       const { stdio, input, output } = yield* makeInMemoryStdio();
diff --git a/packages/effect-codex-app-server/src/protocol.ts b/packages/effect-codex-app-server/src/protocol.ts
index c1f6cb1f1b6b5..bf67174033f4d 100644
--- a/packages/effect-codex-app-server/src/protocol.ts
+++ b/packages/effect-codex-app-server/src/protocol.ts
@@ -16,6 +16,8 @@ const isJsonRpcId = Schema.is(JsonRpcId);
 const isJsonRpcResponseEnvelope = Schema.is(JsonRpcResponseEnvelope);
 const isCodexAppServerError = Schema.is(CodexError.CodexAppServerError);
 const MAX_BUFFERED_RAW_MESSAGES = 32;
+// Bound JSONL lines before joining and parsing; the LF delimiter is excluded.
+const MAX_INCOMING_MESSAGE_BYTES = 128 * 1024 * 1024;
 
 export interface CodexAppServerProtocolLogEvent {
   readonly direction: "incoming" | "outgoing";
@@ -39,6 +41,8 @@ export interface CodexAppServerPatchedProtocolOptions {
   readonly terminationError?: Effect.Effect<CodexError.CodexAppServerError>;
   readonly logIncoming?: boolean;
   readonly logOutgoing?: boolean;
+  // Test override; production uses MAX_INCOMING_MESSAGE_BYTES.
+  readonly maxIncomingMessageBytes?: number;
   readonly logger?: (event: CodexAppServerProtocolLogEvent) => Effect.Effect<void, never>;
   readonly onNotification?: (
     notification: CodexAppServerIncomingNotification,
@@ -164,7 +168,9 @@ export const makeCodexAppServerPatchedProtocol = Effect.fn("makeCodexAppServerPa
       yield* Queue.sliding<CodexAppServerIncomingRequest>(MAX_BUFFERED_RAW_MESSAGES);
     const pending = yield* Ref.make(new Map<string, CodexAppServerPendingRequest>());
     const nextRequestId = yield* Ref.make(1);
+    const maxIncomingMessageBytes = options.maxIncomingMessageBytes ?? MAX_INCOMING_MESSAGE_BYTES;
     const remainder: Array<string> = [];
+    let remainderBytes = 0;
     const terminationHandled = yield* Ref.make(false);
     const terminationFailure = yield* Ref.make(Option.none<CodexError.CodexAppServerError>());
     const terminationSignal = yield* Deferred.make<void>();
@@ -399,26 +405,30 @@ export const makeCodexAppServerPatchedProtocol = Effect.fn("makeCodexAppServerPa
     yield* options.stdio.stdin.pipe(
       Stream.interruptWhen(Deferred.await(terminationSignal)),
       Stream.decodeText(),
-      Stream.runForEach((chunk) =>
-        Effect.sync(() => {
-          const lines: Array<string> = [];
+      Stream.runForEach(
+        Effect.fnUntraced(function* (chunk) {
           let start = 0;
-          for (
-            let newline = chunk.indexOf("\n");
-            newline !== -1;
-            newline = chunk.indexOf("\n", start)
-          ) {
-            remainder.push(chunk.slice(start, newline));
-            lines.push(remainder.join("").replace(/\r$/, ""));
+          while (start < chunk.length) {
+            const newline = chunk.indexOf("\n", start);
+            const fragment = chunk.slice(start, newline === -1 ? chunk.length : newline);
+            // decodeText holds back split UTF-8 sequences, so fragment byte sums are exact.
+            remainderBytes += Buffer.byteLength(fragment, "utf8");
+            if (remainderBytes > maxIncomingMessageBytes) {
+              remainder.length = 0;
+              return yield* new CodexError.CodexAppServerTransportError({
+                operation: "read-input-stream",
+                cause: new Error(`Incoming message exceeded ${maxIncomingMessageBytes} bytes.`),
+              });
+            }
+            remainder.push(fragment);
+            if (newline === -1) break;
+            const line = remainder.join("").replace(/\r$/, "");
             remainder.length = 0;
+            remainderBytes = 0;
+            yield* handleLine(line);
             start = newline + 1;
           }
-          // Keep unfinished lines in fragments so each chunk is scanned only once.
-          if (start < chunk.length) {
-            remainder.push(chunk.slice(start));
-          }
-          return lines;
-        }).pipe(Effect.flatMap((lines) => Effect.forEach(lines, handleLine, { discard: true }))),
+        }),
       ),
       Effect.matchEffect({
         onFailure: (error) =>
diff --git a/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts b/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
index dafad5460f1a9..f362500ab3216 100644
--- a/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
+++ b/packages/provider-acp-registry/src/server/AcpRegistrySupport.test.ts
@@ -1,6 +1,8 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { describe, expect, it } from "@effect/vitest";
 import {
+  AcpRegistrySearchInput,
+  AcpRegistrySearchResult,
   DEFAULT_SERVER_SETTINGS,
   ProviderDriverKind,
   ProviderInstanceId,
@@ -29,6 +31,8 @@ import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
 const registryUrl = "https://registry.test/registry.json";
 const archiveUrl = "https://registry.test/example-agent.bin";
 const decodeAcpRegistrySettings = Schema.decodeSync(AcpRegistrySettings);
+const decodeSearchInput = Schema.decodeEffect(AcpRegistrySearchInput);
+const decodeSearchResult = Schema.decodeEffect(AcpRegistrySearchResult);
 const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
 
 function makeAgent(
@@ -1050,6 +1054,51 @@ describe("AcpRegistrySupport", () => {
     );
   });
 
+  it.effect("keeps default searches at 20 and honors larger catalog limits", () => {
+    const base = makeAgent({
+      binary: {
+        "linux-x86_64": { archive: archiveUrl, cmd: "example-agent" },
+      },
+    });
+    const agents = Array.from({ length: 26 }, (_, index) => {
+      const suffix = String(index).padStart(2, "0");
+      return { ...base, id: `example-agent-${suffix}`, name: `Example Agent ${suffix}` };
+    });
+    return Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const cacheDir = yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-acp-registry-limit-",
+      });
+      const resolver = yield* AcpRegistrySupport.makeAcpRegistryCatalog({
+        cacheDir,
+        toolsDir: `${cacheDir}/tools`,
+        registryUrl,
+      });
+      const input = yield* decodeSearchInput({ query: "", limit: 512 });
+      const catalog = yield* resolver.search(input).pipe(Effect.flatMap(decodeSearchResult));
+      const limited = yield* resolver.search({ query: "", limit: 25 });
+      const defaultCatalog = yield* resolver.search({ query: "" });
+      const matches = yield* resolver.search({ query: "example" });
+
+      expect(catalog.agents).toHaveLength(26);
+      expect(limited.agents).toHaveLength(25);
+      expect(defaultCatalog.agents).toHaveLength(20);
+      expect(matches.agents).toHaveLength(20);
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(
+        layerResolver((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(JSON.stringify({ version: "1.0.0", agents })),
+            ),
+          ),
+        ),
+      ),
+    );
+  });
+
   it.effect("discards registry agents with blank names or unsafe versions", () => {
     const distribution = {
       binary: {
diff --git a/packages/provider-acp-registry/src/server/AcpRegistrySupport.ts b/packages/provider-acp-registry/src/server/AcpRegistrySupport.ts
index 28e05da3f55fe..049e0121a594b 100644
--- a/packages/provider-acp-registry/src/server/AcpRegistrySupport.ts
+++ b/packages/provider-acp-registry/src/server/AcpRegistrySupport.ts
@@ -1,4 +1,5 @@
 import {
+  ACP_REGISTRY_MAX_AGENTS,
   AcpRegistryOperationError,
   AcpRegistryOperationErrorReason,
   TrimmedNonEmptyString,
@@ -51,7 +52,8 @@ const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest
 const MAX_REGISTRY_BYTES = 1024 * 1024;
 const MAX_ARCHIVE_BYTES = 1024 * 1024 * 1024;
 const MAX_PACKAGE_MANIFEST_BYTES = 1024 * 1024;
-const MAX_SEARCH_RESULTS = 20;
+// Older clients omit the limit and validate responses against a 20-agent cap.
+const DEFAULT_SEARCH_LIMIT = 20;
 const REGISTRY_REQUEST_TIMEOUT = "30 seconds";
 const ARCHIVE_REQUEST_TIMEOUT = "20 minutes";
 const PACKAGE_INSTALL_TIMEOUT = "20 minutes";
@@ -170,7 +172,7 @@ type AcpRegistryPackageInstallReceipt = typeof AcpRegistryPackageInstallReceipt.
 
 const AcpRegistryIndexEnvelope = Schema.Struct({
   version: BoundedVersion,
-  agents: Schema.Array(Schema.Unknown).check(Schema.isMaxLength(512)),
+  agents: Schema.Array(Schema.Unknown).check(Schema.isMaxLength(ACP_REGISTRY_MAX_AGENTS)),
 });
 export interface AcpRegistryIndex {
   readonly version: string;
@@ -1614,8 +1616,9 @@ export const makeAcpRegistryCatalog = Effect.fn("AcpRegistryCatalog.make")(funct
           compareText(left.agent.name.toLowerCase(), right.agent.name.toLowerCase()) ||
           compareText(left.agent.id, right.agent.id),
       );
+      const limit = input.limit ?? DEFAULT_SEARCH_LIMIT;
       return {
-        agents: ranked.slice(0, MAX_SEARCH_RESULTS).map(({ agent, distribution }) => ({
+        agents: ranked.slice(0, limit).map(({ agent, distribution }) => ({
           id: agent.id,
           name: agent.name,
           version: agent.version,
diff --git a/packages/provider-acp-registry/src/server/adapter.ts b/packages/provider-acp-registry/src/server/adapter.ts
index 6de4e773ee1cd..f6f407394d92e 100644
--- a/packages/provider-acp-registry/src/server/adapter.ts
+++ b/packages/provider-acp-registry/src/server/adapter.ts
@@ -1,3 +1,8 @@
+import {
+  extractClaudeSubagentUpdate,
+  extractClaudeSubagentSessionEvent,
+  isClaudeProvisionalSubagentTool,
+} from "./claudeAcp.ts";
 import {
   normalizeDevinSessionUpdate,
   normalizeDevinToolCall,
@@ -25,6 +30,7 @@ import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 import * as EffectAcpErrors from "effect-acp/errors";
 
 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
+import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
 import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
 import {
   normalizeAcpRegistryCommands,
@@ -71,6 +77,7 @@ export interface AcpRegistryAdapterV2Options {
     EffectAcpErrors.AcpError,
     ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto | Scope.Scope
   >;
+  readonly continuationRequests?: Parameters<typeof makeAcpAdapterV2>[0]["continuationRequests"];
   readonly assertComplete?: Effect.Effect<void, EffectAcpErrors.AcpError>;
 }
 
@@ -183,6 +190,22 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
     registryAgentId === "github-copilot-cli" ||
     (options.settings.source === "local" &&
       /^copilot(\.exe|\.cmd)?$/i.test(options.settings.commandPath.split(/[\\/]/).pop() ?? ""));
+  const isClaude =
+    registryAgentId === "claude-acp" ||
+    (options.settings.source === "local" &&
+      /^claude-agent-acp(\.exe|\.cmd)?$/i.test(
+        options.settings.commandPath.split(/[\\/]/).pop() ?? "",
+      ));
+  const runtimeOptions = isClaude
+    ? {
+        ...options,
+        environment: {
+          ...options.environment,
+          CLAUDE_AGENT_ACP_EXPERIMENTAL_V2:
+            options.environment.CLAUDE_AGENT_ACP_EXPERIMENTAL_V2 ?? "1",
+        },
+      }
+    : options;
   const copilotRouting = isCopilot ? makeCopilotSubagentRouting() : undefined;
   const flavor: AcpAdapterV2Flavor = {
     driver: ACP_REGISTRY_PROVIDER,
@@ -192,6 +215,14 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
     ...(registryAgentId === "mistral-vibe"
       ? { registerExtensions: registerMistralVibeAcpExtensions }
       : {}),
+    ...(isClaude
+      ? {
+          followAgentWorkState: true,
+          extractSubagentUpdate: extractClaudeSubagentUpdate,
+          isProvisionalSubagentTool: isClaudeProvisionalSubagentTool,
+          extractSubagentSessionEvent: extractClaudeSubagentSessionEvent,
+        }
+      : {}),
     ...(isDevin
       ? {
           clientCapabilitiesMeta: {
@@ -211,7 +242,7 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
           normalizeSessionUpdate: copilotRouting.normalizeSessionUpdate,
           extractSubagentUpdate: extractCopilotSubagentUpdate,
         }),
-    makeRuntime: options.makeRuntime ?? makeAcpRegistryRuntime(options, catalog),
+    makeRuntime: options.makeRuntime ?? makeAcpRegistryRuntime(runtimeOptions, catalog),
     ...(runtimeCoordinator === undefined
       ? {}
       : {
@@ -245,6 +276,9 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu
     instanceId: options.instanceId,
     flavor,
     selfInvocation: options.selfInvocation,
+    ...(options.continuationRequests === undefined
+      ? {}
+      : { continuationRequests: options.continuationRequests }),
     // Devin runs commands through client terminals and has no ask mode over ACP to fall back on.
     ...(isDevin
       ? {
@@ -287,6 +321,7 @@ export const AcpRegistryAdapterV2Driver: ProviderAdapterDriver<
         settings: { ...input.config, enabled: input.enabled },
         environment: yield* mergeProviderInstanceEnvironment(input.environment, hostEnvironment),
         selfInvocation,
+        continuationRequests: yield* ProviderContinuationRequests.ProviderContinuationRequests,
         nativeLogging: (threadId) =>
           makeNativeLogger({
             nativeEventLogger: providerEventLoggers.native,
diff --git a/packages/provider-acp-registry/src/server/claudeAcp.ts b/packages/provider-acp-registry/src/server/claudeAcp.ts
new file mode 100644
index 0000000000000..4c875ce597f57
--- /dev/null
+++ b/packages/provider-acp-registry/src/server/claudeAcp.ts
@@ -0,0 +1,117 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import type * as AcpSchema from "effect-acp/compat";
+import type { AcpToolCallState } from "@t3tools/provider-acp/server/runtimeModel";
+import type {
+  AcpAdapterV2SubagentUpdate,
+  AcpSubagentSessionEvent,
+} from "@t3tools/provider-acp/server/adapter";
+
+const decodeAgentInput = Schema.decodeUnknownOption(
+  Schema.Struct({
+    prompt: Schema.String,
+    description: Schema.optionalKey(Schema.String),
+    model: Schema.optionalKey(Schema.String),
+    run_in_background: Schema.optionalKey(Schema.Boolean),
+  }),
+);
+const decodeAsyncResponse = Schema.decodeUnknownOption(
+  Schema.Struct({
+    claudeCode: Schema.Struct({ toolResponse: Schema.Struct({ isAsync: Schema.Boolean }) }),
+  }),
+);
+
+export function isClaudeProvisionalSubagentTool(tool: AcpToolCallState): boolean {
+  return (
+    (tool.data.name === "Agent" || tool.data.name === "Task") &&
+    tool.status !== "failed" &&
+    tool.status !== "completed" &&
+    Option.isNone(decodeAgentInput(tool.data.rawInput))
+  );
+}
+
+export function extractClaudeSubagentUpdate(
+  tool: AcpToolCallState,
+): AcpAdapterV2SubagentUpdate | undefined {
+  if (tool.data.name !== "Agent" && tool.data.name !== "Task") return;
+  const input = decodeAgentInput(tool.data.rawInput);
+  if (Option.isNone(input)) return;
+  const response = decodeAsyncResponse(tool.data.meta);
+  const background =
+    input.value.run_in_background === true ||
+    (Option.isSome(response) && response.value.claudeCode.toolResponse.isAsync);
+  return {
+    nativeTaskId: tool.toolCallId,
+    childSessionId: null,
+    prompt: input.value.prompt,
+    title: input.value.description ?? null,
+    model: input.value.model ?? null,
+    status:
+      tool.status === "failed"
+        ? "failed"
+        : tool.status === "completed" && !background
+          ? "completed"
+          : "running",
+    result: null,
+  };
+}
+
+const decodeChildState = Schema.decodeUnknownOption(
+  Schema.Struct({
+    sessionId: Schema.String,
+    state: Schema.Struct({
+      state: Schema.String,
+      stopReason: Schema.optionalKey(Schema.NullOr(Schema.String)),
+      error: Schema.optionalKey(Schema.NullOr(Schema.Struct({ message: Schema.String }))),
+    }),
+  }),
+);
+const decodeDelegation = Schema.decodeUnknownOption(
+  Schema.Struct({
+    messageId: Schema.String,
+    senderSessionId: Schema.optionalKey(Schema.String),
+    content: Schema.Array(
+      Schema.Struct({ type: Schema.String, text: Schema.optionalKey(Schema.String) }),
+    ),
+  }),
+);
+
+// Claude's session_message id is the Agent/Task or SendMessage tool-use id.
+export function extractClaudeSubagentSessionEvent(
+  notification: AcpSchema.SessionNotification,
+): AcpSubagentSessionEvent | undefined {
+  const update = notification.update;
+  if (update.sessionUpdate !== "_t3_unknown") return;
+  if (update.originalSessionUpdate === "subagent_update") {
+    const child = decodeChildState(update.raw);
+    if (Option.isNone(child)) return;
+    const { sessionId, state } = child.value;
+    return {
+      type: "state",
+      childSessionId: sessionId,
+      parentSessionId: notification.sessionId,
+      status:
+        state.state === "running" || state.state === "requires_action"
+          ? "running"
+          : state.stopReason === "error"
+            ? "failed"
+            : state.stopReason === "cancelled" || state.state === "unknown"
+              ? "cancelled"
+              : "completed",
+      result: state.error?.message ?? null,
+    };
+  }
+  if (update.originalSessionUpdate === "session_message") {
+    const delegation = decodeDelegation(update.raw);
+    if (Option.isNone(delegation)) return;
+    return {
+      type: "delegation",
+      childSessionId: notification.sessionId,
+      parentSessionId: delegation.value.senderSessionId ?? null,
+      delegationId: delegation.value.messageId,
+      prompt: delegation.value.content
+        .flatMap((block) => (block.type === "text" && block.text !== undefined ? [block.text] : []))
+        .join("\n"),
+    };
+  }
+}
diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts
index 5aaac47c943bb..3c145c3ac96ec 100644
--- a/packages/provider-acp/src/server/adapter.ts
+++ b/packages/provider-acp/src/server/adapter.ts
@@ -289,9 +289,13 @@ export interface AcpAdapterV2Flavor {
   readonly registerExtensions?: (
     context: AcpAdapterV2ExtensionContext,
   ) => Effect.Effect<void, EffectAcpErrors.AcpError>;
+  readonly extractSubagentSessionEvent?: (
+    notification: EffectAcpSchema.SessionNotification,
+  ) => AcpSubagentSessionEvent | undefined;
   readonly extractSubagentUpdate?: (
     toolCall: AcpToolCallState,
   ) => AcpAdapterV2SubagentUpdate | undefined;
+  readonly isProvisionalSubagentTool?: (toolCall: AcpToolCallState) => boolean;
   readonly normalizeToolCall?: (toolCall: AcpToolCallState) => AcpToolCallState;
   readonly extractProposedPlanMarkdown?: (toolCall: AcpToolCallState) => string | undefined;
   readonly extractBackgroundTaskId?: (toolCall: AcpToolCallState) => string | undefined;
@@ -327,6 +331,8 @@ export interface AcpAdapterV2Flavor {
   readonly terminateRuntimeProcessGroupOnInterrupt?: boolean;
   readonly preserveRuntimeOnSettledInterrupt?: boolean;
   readonly enablePostSettleContinuation?: boolean;
+  /** Settle on native idle after the accepted user echo, only on negotiated ACP v2. */
+  readonly followAgentWorkState?: boolean;
   /**
    * Grok CLI currently accepts and vision-processes image blocks while still
    * reporting the capability as false; without this override, screenshot turns
@@ -356,6 +362,22 @@ export function acpProviderItemNativeId(input: {
     : input.nativeId;
 }
 
+export type AcpSubagentSessionEvent =
+  | {
+      readonly type: "state";
+      readonly childSessionId: string;
+      readonly parentSessionId: string;
+      readonly status: "running" | "completed" | "failed" | "cancelled";
+      readonly result: string | null;
+    }
+  | {
+      readonly type: "delegation";
+      readonly childSessionId: string;
+      readonly parentSessionId: string | null;
+      readonly delegationId: string;
+      readonly prompt: string;
+    };
+
 export interface AcpAdapterV2SubagentUpdate {
   readonly nativeTaskId: string;
   readonly prompt: string;
@@ -1039,6 +1061,7 @@ interface ActiveAcpTurn {
   finalizedStatus: "completed" | "interrupted" | "failed" | "cancelled" | null;
   promptSettled: boolean;
   promptSettledStatus: "completed" | "interrupted" | "failed" | "cancelled" | null;
+  workAccepted: boolean;
   readonly promptWireSettled: Deferred.Deferred<void, never>;
   backgroundFinalizeGeneration: number;
 }
@@ -1200,8 +1223,8 @@ interface ActiveAcpSubagent {
   readonly childThreadId: ThreadId;
   readonly childRootNodeId: OrchestrationV2ExecutionNode["id"];
   readonly turnItemId: OrchestrationV2TurnItem["id"];
-  readonly turnItemOrdinal: number;
-  readonly providerTurnId: OrchestrationV2ProviderTurn["id"];
+  turnItemOrdinal: number;
+  providerTurnId: OrchestrationV2ProviderTurn["id"];
   readonly parentProviderThreadId: ProviderThreadId;
   childSessionId: string | null;
   assistantText: string;
@@ -1209,6 +1232,19 @@ interface ActiveAcpSubagent {
   readonly childItemOrdinals: Map<string, number>;
   nextChildOrdinal: number;
   terminalStatusProjected: boolean;
+  readonly toolState: Pick<ActiveAcpTurn, "tools" | "toolUpdatesSkipped" | "toolStartedAt">;
+  readonly toolSessionIds: Map<string, string>;
+}
+
+interface AcpNativeChildSession {
+  parentSessionId: string | null;
+  status: "running" | "completed" | "failed" | "cancelled";
+  result: string | null;
+  delegationId: string | null;
+  prompt: string;
+  subagent: ActiveAcpSubagent | undefined;
+  owner: ActiveAcpTurn | undefined;
+  readonly pending: Array<EffectAcpSchema.SessionNotification>;
 }
 
 function acpSubagentStatusIsTerminal(status: OrchestrationV2Subagent["status"]): boolean {
@@ -1273,7 +1309,7 @@ const TOOL_UPDATE_PERSIST_EVERY = 10;
  * resend the whole call each time.
  */
 function shouldPersistToolUpdate(
-  context: ActiveAcpTurn,
+  context: Pick<ActiveAcpTurn, "toolUpdatesSkipped">,
   key: string,
   previous: AcpToolCallState | undefined,
   next: AcpToolCallState,
@@ -1493,6 +1529,19 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           input.runtimePolicy;
         const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
         const activeTurn = yield* Ref.make<ActiveAcpTurn | null>(null);
+        let pendingStopCloseTurn: ActiveAcpTurn | null = null;
+        let followsAgentWorkState = false;
+        let agentWork: Extract<
+          EffectAcpSchema.SessionUpdate,
+          { sessionUpdate: "state_update" }
+        > | null = null;
+        const agentRequests = new Set<object>();
+        const nativeChildren = new Map<string, AcpNativeChildSession>();
+        const extractSubagentUpdate = (tool: AcpToolCallState) =>
+          flavor.extractSubagentSessionEvent !== undefined && !followsAgentWorkState
+            ? undefined
+            : flavor.extractSubagentUpdate?.(tool);
+        let turnAttached = yield* Deferred.make<boolean>();
         const activeSessionId = yield* Ref.make<string | null>(null);
         const contextUsageBySessionId = yield* Ref.make(
           new Map<string, ThreadTokenUsageSnapshot>(),
@@ -1510,6 +1559,18 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
         } | null>(null);
         const activeSessionSetup =
           yield* Ref.make<AcpSessionRuntime.AcpSessionRuntimeStartResult | null>(null);
+        const setActiveSessionSetup = Effect.fnUntraced(function* (
+          setup: AcpSessionRuntime.AcpSessionRuntimeStartResult,
+        ) {
+          followsAgentWorkState =
+            flavor.followAgentWorkState === true &&
+            continuationRequests !== undefined &&
+            setup.initializeResult.protocolVersion === 2;
+          agentWork = null;
+          agentRequests.clear();
+          nativeChildren.clear();
+          yield* Ref.set(activeSessionSetup, setup);
+        });
         const activeSelection = yield* Ref.make<ModelSelection | null>(null);
         const activeInteractionMode = yield* Ref.make<ProviderInteractionMode | null>(null);
         const promptInstructionStates = yield* Ref.make(new Map<string, T3AcpInstructionState>());
@@ -1879,7 +1940,36 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
         const handleRuntimeTerminationAtGeneration = (runtimeGeneration: number) =>
           runRuntimeCallbackAtGeneration(
             runtimeGeneration,
-            Ref.set(runtimeRestartRequired, true),
+            Effect.gen(function* () {
+              yield* Ref.set(runtimeRestartRequired, true);
+              if (!followsAgentWorkState) return;
+              agentWork = { sessionUpdate: "state_update", state: "idle", stopReason: "error" };
+              for (const child of nativeChildren.values()) {
+                if (child.status !== "running") continue;
+                child.status = "failed";
+                child.result = null;
+              }
+              for (const child of nativeChildren.values()) {
+                if (
+                  child.subagent === undefined ||
+                  acpSubagentStatusIsTerminal(child.subagent.task.status)
+                )
+                  continue;
+                child.result = null;
+                yield* publishNativeChildStatus(child, "failed");
+              }
+              agentRequests.clear();
+              yield* Ref.set(wakeBuffer, []);
+              yield* Ref.set(continuationRequested, false);
+              yield* cancelPendingRuntimeRequests();
+              const context = yield* Ref.get(activeTurn);
+              if (context !== null)
+                yield* finalizeTurn(
+                  context,
+                  "failed",
+                  makeProviderFailure({ class: "transport_error" }),
+                );
+            }),
           ).pipe(Effect.asVoid);
         const makeRuntimeInput = (
           runtimeGeneration: number,
@@ -2510,6 +2600,101 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           }
         });
 
+        const projectSubagentTool = Effect.fnUntraced(function* (
+          subagent: ActiveAcpSubagent,
+          sessionId: string,
+          toolCall: AcpToolCallState,
+          projectedStatus?: ProjectedToolStatus,
+        ) {
+          const nativeTaskId = subagent.task.nativeTaskRef?.nativeId ?? String(subagent.task.id);
+          const key =
+            sessionId === subagent.childSessionId
+              ? `${nativeTaskId}:tool:${toolCall.toolCallId}`
+              : `${nativeTaskId}:session:${sessionId}:tool:${toolCall.toolCallId}`;
+          const context = subagent.toolState;
+          const rootSessionId = yield* Ref.get(activeSessionId);
+          subagent.toolSessionIds.set(key, sessionId);
+          const previous = context.tools.get(key);
+          const merged = mergeToolCallState(previous, toolCall);
+          context.tools.set(key, merged);
+          if (
+            projectedStatus === undefined &&
+            !shouldPersistToolUpdate(context, key, previous, merged, merged.status)
+          )
+            return;
+          const mcpIdentity = extractMcpToolCallIdentity(merged, {
+            embeddedTerminalCommands: [
+              ...embeddedTerminalCommands(sessionId, toolCall.toolCallId),
+              ...(rootSessionId === null
+                ? []
+                : embeddedTerminalCommands(rootSessionId, toolCall.toolCallId)),
+            ],
+          });
+          const now = yield* DateTime.now;
+          const status = projectedStatus ?? toolStatus(merged.status);
+          const startedAt = context.toolStartedAt.get(key) ?? now;
+          context.toolStartedAt.set(key, startedAt);
+          const ordinal = resolveSubagentChildOrdinal(subagent, key);
+          yield* emitProviderEvent({
+            type: "turn_item.updated",
+            driver,
+            turnItem: {
+              id: providerTurnItemId(key),
+              threadId: subagent.childThreadId,
+              runId: null,
+              nodeId: subagent.childRootNodeId,
+              providerThreadId: subagent.task.providerThreadId,
+              providerTurnId: null,
+              nativeItemRef: { driver, nativeId: key, strength: "strong" },
+              parentItemId: null,
+              ordinal,
+              status,
+              title: merged.title ?? merged.kind ?? "Tool",
+              startedAt,
+              completedAt: completedAtForStatus(status, now),
+              updatedAt: now,
+              type: "dynamic_tool",
+              ...(mcpIdentity === undefined
+                ? {}
+                : mcpToolPresentation({
+                    serverName: mcpIdentity.server,
+                    toolName: mcpIdentity.tool,
+                    source: unknownRecord(
+                      (
+                        unknownRecord(unknownRecord(merged.data.rawOutput)?.result) ??
+                        unknownRecord(merged.data.rawOutput)
+                      )?._meta,
+                    )?.source,
+                  })),
+              toolName:
+                mcpIdentity === undefined
+                  ? (merged.title ?? merged.kind ?? "Tool")
+                  : `${mcpIdentity.server}.${mcpIdentity.tool}`,
+              input: merged.data.rawInput ?? null,
+              output: merged.data.rawOutput ?? merged.data.content ?? null,
+            },
+          });
+        });
+
+        const terminalizeSubagentTools = Effect.fnUntraced(function* (subagent: ActiveAcpSubagent) {
+          for (const [key, tool] of subagent.toolState.tools) {
+            if (
+              toolStatus(tool.status) !== "running" &&
+              toolStatus(tool.status) !== "pending" &&
+              toolStatus(tool.status) !== "waiting"
+            )
+              continue;
+            const sessionId = subagent.toolSessionIds.get(key);
+            if (sessionId !== undefined)
+              yield* projectSubagentTool(
+                subagent,
+                sessionId,
+                { ...tool, status: "failed" },
+                "interrupted",
+              );
+          }
+        });
+
         const emitSubagent = Effect.fnUntraced(function* (
           context: ActiveAcpTurn,
           update: AcpAdapterV2SubagentUpdate,
@@ -2606,6 +2791,12 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             childItemOrdinals: new Map(),
             nextChildOrdinal: 101,
             terminalStatusProjected: false,
+            toolState: {
+              tools: new Map(),
+              toolUpdatesSkipped: new Map(),
+              toolStartedAt: new Map(),
+            },
+            toolSessionIds: new Map(),
           };
           subagent.task = task;
           context.subagents.set(nativeTaskId, subagent);
@@ -2790,6 +2981,301 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           }
         });
 
+        const nativeChild = (sessionId: string) => {
+          let child = nativeChildren.get(sessionId);
+          if (child === undefined) {
+            child = {
+              parentSessionId: null,
+              status: "running",
+              result: null,
+              delegationId: null,
+              prompt: "",
+              subagent: undefined,
+              owner: undefined,
+              pending: [],
+            };
+            nativeChildren.set(sessionId, child);
+          }
+          return child;
+        };
+
+        const setNativeChildState = (
+          child: AcpNativeChildSession,
+          status: AcpNativeChildSession["status"],
+          result: string | null,
+        ) => {
+          if (child.status !== "running" && status === "running" && child.subagent !== undefined) {
+            // A new execution replaces its result; live ownership transfers keep their progress.
+            child.subagent.task = { ...child.subagent.task, result: null };
+            child.subagent.assistantText = "";
+            child.subagent.assistantMessages.clear();
+          }
+          child.status = status;
+          child.result = result;
+        };
+
+        const nativeChildOwner = (sessionId: string): AcpNativeChildSession | undefined => {
+          const visited = new Set<string>();
+          let child = nativeChildren.get(sessionId);
+          while (child !== undefined && !visited.has(sessionId)) {
+            if (child.subagent !== undefined) return child;
+            visited.add(sessionId);
+            if (child.parentSessionId === null) return;
+            sessionId = child.parentSessionId;
+            child = nativeChildren.get(sessionId);
+          }
+        };
+
+        const hasWorkingDescendant = (sessionId: string) => {
+          for (const [id, child] of nativeChildren) {
+            if (id === sessionId || child.status !== "running") continue;
+            const visited = new Set<string>();
+            let parent = child.parentSessionId;
+            while (parent !== null && !visited.has(parent)) {
+              if (parent === sessionId) return true;
+              visited.add(parent);
+              parent = nativeChildren.get(parent)?.parentSessionId ?? null;
+            }
+          }
+          return false;
+        };
+
+        const publishNativeChildStatus = Effect.fnUntraced(function* (
+          child: AcpNativeChildSession,
+          status: AcpAdapterV2SubagentUpdate["status"],
+        ) {
+          const { subagent, owner } = child;
+          if (subagent === undefined || owner === undefined) return;
+          if (acpSubagentStatusIsTerminal(status)) yield* terminalizeSubagentTools(subagent);
+          yield* emitSubagent(owner, {
+            nativeTaskId: subagent.task.nativeTaskRef?.nativeId ?? subagent.task.id,
+            childSessionId: subagent.childSessionId,
+            prompt: subagent.task.prompt,
+            title: subagent.task.title,
+            model: subagent.task.model,
+            status,
+            result: child.result,
+          });
+        });
+
+        const syncNativeChildren = Effect.fnUntraced(function* (
+          context: ActiveAcpTurn,
+        ): Effect.fn.Return<void> {
+          const rootSessionId = yield* Ref.get(activeSessionId);
+          for (const [sessionId, child] of nativeChildren) {
+            if (child.parentSessionId !== rootSessionId) continue;
+            if (child.subagent === undefined && child.delegationId !== null) {
+              const subagent = context.subagents.get(child.delegationId);
+              if (subagent !== undefined) {
+                child.subagent = subagent;
+                child.owner = context;
+                yield* emitSubagent(context, {
+                  nativeTaskId: child.delegationId,
+                  childSessionId: sessionId,
+                  prompt: subagent.task.prompt,
+                  title: subagent.task.title,
+                  model: subagent.task.model,
+                  status: "running",
+                  result: child.result,
+                });
+              }
+            }
+            const subagent = child.subagent;
+            if (subagent === undefined) continue;
+            const newDelegation =
+              child.delegationId !== null &&
+              child.delegationId !== subagent.task.nativeTaskRef?.nativeId &&
+              !subagent.childItemOrdinals.has(`${sessionId}:prompt:${child.delegationId}`);
+            if (newDelegation && child.status !== "running")
+              setNativeChildState(child, "running", null);
+            const hasNativeWork = child.status === "running" || hasWorkingDescendant(sessionId);
+            if (
+              (hasNativeWork && acpSubagentStatusIsTerminal(subagent.task.status)) ||
+              (child.owner !== context &&
+                (child.owner?.finalizedStatus !== "completed" || newDelegation) &&
+                (hasNativeWork || child.pending.length > 0))
+            ) {
+              // The ownership event precedes child tools so the old run can detach first.
+              child.owner = context;
+              subagent.task = {
+                ...subagent.task,
+                runId: context.input.runId,
+                parentNodeId: context.input.rootNodeId,
+                status: "running",
+                completedAt: null,
+              };
+              subagent.providerTurnId = context.providerTurnId;
+              subagent.turnItemOrdinal = yield* resolveItemOrdinal(
+                context,
+                subagent.task.nativeTaskRef?.nativeId ?? subagent.task.id,
+              );
+              subagent.terminalStatusProjected = false;
+              context.subagents.set(
+                subagent.task.nativeTaskRef?.nativeId ?? subagent.task.id,
+                subagent,
+              );
+              context.subagentsBySessionId.set(sessionId, subagent);
+              yield* publishNativeChildStatus(child, "running");
+              for (const [key, tool] of subagent.toolState.tools) {
+                const toolSessionId = subagent.toolSessionIds.get(key);
+                if (
+                  toolSessionId === undefined ||
+                  (toolStatus(tool.status) !== "running" && toolStatus(tool.status) !== "pending")
+                )
+                  continue;
+                subagent.toolState.toolUpdatesSkipped.delete(key);
+                yield* projectSubagentTool(subagent, toolSessionId, tool, toolStatus(tool.status));
+              }
+            }
+            if (
+              child.delegationId !== null &&
+              child.delegationId !== subagent.task.nativeTaskRef?.nativeId
+            ) {
+              const nativeItemId = `${sessionId}:prompt:${child.delegationId}`;
+              if (!subagent.childItemOrdinals.has(nativeItemId)) {
+                const now = yield* DateTime.now;
+                const artifacts = makeSubagentConversationArtifacts({
+                  senderThreadId: subagent.task.threadId,
+                  messageId: providerMessageId(nativeItemId),
+                  turnItemId: providerTurnItemId(nativeItemId),
+                  threadId: subagent.childThreadId,
+                  rootNodeId: subagent.childRootNodeId,
+                  providerThreadId: subagent.task.providerThreadId,
+                  providerTurnId: null,
+                  nativeItemRef: { driver, nativeId: nativeItemId, strength: "weak" },
+                  role: "user",
+                  text: child.prompt,
+                  ordinal: resolveSubagentChildOrdinal(subagent, nativeItemId),
+                  now,
+                });
+                yield* emitProviderEvent({
+                  type: "message.updated",
+                  driver,
+                  message: artifacts.message,
+                });
+                yield* emitProviderEvent({
+                  type: "turn_item.updated",
+                  driver,
+                  turnItem: artifacts.turnItem,
+                });
+              }
+            }
+          }
+          for (const [sessionId, child] of nativeChildren) {
+            const owner = nativeChildOwner(sessionId);
+            if (owner?.owner !== context && owner?.owner?.finalizedStatus !== "completed") continue;
+            for (const notification of child.pending.splice(0))
+              yield* projectNativeChildFrame(notification);
+            if (
+              child.subagent?.childSessionId != null &&
+              child.status !== "running" &&
+              !hasWorkingDescendant(child.subagent.childSessionId)
+            ) {
+              yield* publishNativeChildStatus(child, child.status);
+            }
+          }
+        });
+
+        const projectNativeChildFrame = Effect.fnUntraced(function* (
+          notification: EffectAcpSchema.SessionNotification,
+        ): Effect.fn.Return<void> {
+          const child = nativeChild(notification.sessionId);
+          const owner = nativeChildOwner(notification.sessionId);
+          const subagent = owner?.subagent;
+          if (
+            subagent === undefined ||
+            owner?.owner === undefined ||
+            (owner.owner.finalized && owner.owner.finalizedStatus !== "completed") ||
+            (acpSubagentStatusIsTerminal(subagent.task.status) && child.status === "running")
+          ) {
+            if (child.pending.length < 256) child.pending.push(notification);
+            if (subagent !== undefined) {
+              const root = yield* Ref.get(activeSessionId);
+              if (root !== null) yield* offerContinuationRun(root);
+            }
+            return;
+          }
+          const update = notification.update;
+          if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+            for (const event of parseSessionUpdateEvent(notification).events) {
+              if (event._tag === "ToolCallUpdated") {
+                yield* projectSubagentTool(
+                  subagent,
+                  notification.sessionId,
+                  flavor.normalizeToolCall?.(event.toolCall) ?? event.toolCall,
+                );
+              }
+            }
+          } else {
+            yield* projectSubagentNotification(subagent, notification);
+          }
+        });
+
+        const followNativeChild = Effect.fnUntraced(function* (
+          notification: EffectAcpSchema.SessionNotification,
+          context: ActiveAcpTurn | null,
+        ): Effect.fn.Return<boolean> {
+          if (!followsAgentWorkState || flavor.extractSubagentSessionEvent === undefined)
+            return false;
+          const root = yield* Ref.get(activeSessionId);
+          const event = flavor.extractSubagentSessionEvent(notification);
+          if (event !== undefined) {
+            if (yield* Ref.get(stoppedRunQuarantine)) return true;
+            const child = nativeChild(event.childSessionId);
+            child.parentSessionId = event.parentSessionId ?? child.parentSessionId;
+            if (event.type === "state") {
+              setNativeChildState(child, event.status, event.result);
+            } else {
+              child.delegationId = event.delegationId;
+              child.prompt = event.prompt;
+            }
+            if (context !== null) yield* syncNativeChildren(context);
+            const owner = nativeChildOwner(event.childSessionId);
+            if (owner?.subagent !== undefined && owner.owner !== undefined) {
+              const sessionId = owner.subagent.childSessionId;
+              if (
+                owner.status !== "running" &&
+                sessionId !== null &&
+                !hasWorkingDescendant(sessionId)
+              ) {
+                yield* publishNativeChildStatus(owner, owner.status);
+              } else if (acpSubagentStatusIsTerminal(owner.subagent.task.status)) {
+                if (context !== null) yield* syncNativeChildren(context);
+                else if (root !== null) yield* offerContinuationRun(root);
+              }
+            }
+            return true;
+          }
+          if (notification.sessionId === root) return false;
+          if (yield* Ref.get(stoppedRunQuarantine)) return true;
+          const update = notification.update;
+          if (update.sessionUpdate === "state_update") {
+            const child = nativeChild(notification.sessionId);
+            setNativeChildState(
+              child,
+              update.state !== "idle"
+                ? "running"
+                : update.stopReason === "error"
+                  ? "failed"
+                  : update.stopReason === "cancelled"
+                    ? "cancelled"
+                    : "completed",
+              update.state === "idle" ? (update.error?.message ?? null) : null,
+            );
+          }
+          if (context !== null) yield* syncNativeChildren(context);
+          yield* projectNativeChildFrame(notification);
+          const owner = nativeChildOwner(notification.sessionId);
+          if (
+            owner?.subagent?.childSessionId != null &&
+            owner.status !== "running" &&
+            !hasWorkingDescendant(owner.subagent.childSessionId)
+          ) {
+            yield* publishNativeChildStatus(owner, owner.status);
+          }
+          return true;
+        });
+
         const toolOutputText = (toolCall: AcpToolCallState): string => {
           if (typeof toolCall.data.rawOutput === "string") {
             return toolCall.data.rawOutput;
@@ -2918,6 +3404,14 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           const merged = mergeToolCallState(previous, incoming);
           const toolCall = flavor.normalizeToolCall?.(merged) ?? merged;
           context.tools.set(toolCall.toolCallId, toolCall);
+          if (
+            followsAgentWorkState &&
+            projectedStatus === undefined &&
+            flavor.isProvisionalSubagentTool?.(toolCall)
+          ) {
+            yield* rearmDeferredFinalize(context);
+            return;
+          }
           const backgroundTaskId = flavor.extractBackgroundTaskId?.(toolCall);
           if (backgroundTaskId !== undefined) {
             context.toolCallIdsByBackgroundTaskId.set(backgroundTaskId, toolCall.toolCallId);
@@ -3003,9 +3497,10 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           // hydration; do not spawn a phantom subagent for a registered monitor.
           const subagentUpdate = hydratedRegisteredMonitor
             ? undefined
-            : flavor.extractSubagentUpdate?.(toolCall);
+            : extractSubagentUpdate(toolCall);
           if (subagentUpdate !== undefined) {
             yield* emitSubagent(context, subagentUpdate);
+            if (followsAgentWorkState) yield* syncNativeChildren(context);
             if (subagentUpdate.suppressNormalTool !== false) {
               yield* rearmDeferredFinalize(context);
               return;
@@ -3816,11 +4311,103 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           return true;
         });
 
+        const settleIdleWork = Effect.fnUntraced(function* (
+          context: ActiveAcpTurn,
+        ): Effect.fn.Return<void> {
+          if (
+            !followsAgentWorkState ||
+            context.finalized ||
+            (!context.workAccepted && !context.interrupted) ||
+            agentWork?.state !== "idle" ||
+            agentRequests.size > 0
+          )
+            return;
+          const work = agentWork;
+          // Native close sends cancelled idle before acknowledging the user's Stop.
+          if (work.stopReason === "cancelled" && pendingStopCloseTurn === context) {
+            context.interrupted = true;
+          }
+          const failure =
+            work.stopReason === "error"
+              ? (flavor.promptFailure?.(
+                  new EffectAcpErrors.AcpRequestError({
+                    code: work.error?.code ?? -32603,
+                    errorMessage: work.error?.message ?? "Provider turn failed.",
+                    ...(work.error?.data === undefined ? {} : { data: work.error.data }),
+                  }),
+                ) ?? makeProviderFailure({ message: work.error?.message, class: "provider_error" }))
+              : undefined;
+          yield* finalizeTurn(
+            context,
+            failure !== undefined
+              ? "failed"
+              : work.stopReason === "cancelled"
+                ? "cancelled"
+                : "completed",
+            failure,
+          );
+        });
+
+        const awaitRequestTurn = Effect.fnUntraced(function* (generation: number) {
+          if (!followsAgentWorkState) return true;
+          while (true) {
+            const waiting = yield* runRuntimeCallbackAtGeneration(
+              generation,
+              Effect.gen(function* () {
+                if (yield* Ref.get(stoppedRunQuarantine)) return false;
+                if ((yield* Ref.get(activeTurn)) !== null) return null;
+                const sessionId = yield* Ref.get(activeSessionId);
+                if (sessionId !== null) yield* offerContinuationRun(sessionId);
+                return turnAttached;
+              }),
+            );
+            if (Option.isNone(waiting)) return yield* Effect.never;
+            if (waiting.value === false) return false;
+            if (waiting.value === null) return true;
+            if (!(yield* Deferred.await(waiting.value))) return false;
+          }
+        });
+
+        const holdingAgentRequest =
+          (generation: number) =>
+          <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+            Effect.suspend(() =>
+              !followsAgentWorkState
+                ? effect
+                : Effect.acquireUseRelease(
+                    runRuntimeCallbackAtGeneration(
+                      generation,
+                      Effect.sync(() => {
+                        const token = {};
+                        agentRequests.add(token);
+                        return token;
+                      }),
+                    ),
+                    (token) => (Option.isNone(token) ? Effect.never : effect),
+                    (token) =>
+                      runRuntimeCallbackAtGeneration(
+                        generation,
+                        Effect.gen(function* () {
+                          if (Option.isSome(token)) agentRequests.delete(token.value);
+                          const context = yield* Ref.get(activeTurn);
+                          if (context !== null) yield* settleIdleWork(context);
+                        }),
+                      ).pipe(Effect.asVoid),
+                  ),
+            );
+
         const handleSessionUpdate = Effect.fnUntraced(function* (
           notification: EffectAcpSchema.SessionNotification,
         ) {
           const context = yield* Ref.get(activeTurn);
           const update = notification.update;
+          if (
+            followsAgentWorkState &&
+            flavor.extractSubagentSessionEvent !== undefined &&
+            notification.sessionId !== (yield* Ref.get(activeSessionId)) &&
+            (yield* Ref.get(stoppedRunQuarantine))
+          )
+            return;
           if (yield* projectAgentTerminalUpdate(notification, context)) return;
           if (
             update.sessionUpdate === "usage_update" ||
@@ -3878,7 +4465,43 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                 providerThread,
               });
             }
-            return;
+            if (update.sessionUpdate !== "state_update") return;
+          }
+          if (yield* followNativeChild(notification, context)) return;
+          if (
+            followsAgentWorkState &&
+            !(yield* Ref.get(stoppedRunQuarantine)) &&
+            notification.sessionId === (yield* Ref.get(activeSessionId))
+          ) {
+            if (update.sessionUpdate === "state_update") agentWork = update;
+            if (
+              update.sessionUpdate === "user_message" ||
+              update.sessionUpdate === "user_message_chunk"
+            ) {
+              agentWork = { sessionUpdate: "state_update", state: "running" };
+              if (context !== null) {
+                context.workAccepted = true;
+                if (!context.finalized) return;
+              }
+            }
+            if (
+              context !== null &&
+              update.sessionUpdate === "state_update" &&
+              update.state === "idle"
+            ) {
+              yield* settleIdleWork(context);
+            } else if (
+              context === null &&
+              !(yield* Ref.get(stoppedRunQuarantine)) &&
+              (acpRootSessionUpdateIngestsOutput(notification) ||
+                update.sessionUpdate === "user_message" ||
+                update.sessionUpdate === "user_message_chunk" ||
+                (update.sessionUpdate === "state_update" && update.state === "running"))
+            ) {
+              yield* Ref.update(wakeBuffer, (current) => [...current, notification]);
+              yield* offerContinuationRun(notification.sessionId);
+              return;
+            }
           }
           if (
             context?.finalized === true &&
@@ -3939,7 +4562,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               for (const event of parseSessionUpdateEvent(notification).events) {
                 if (event._tag !== "ToolCallUpdated") continue;
                 const toolCall = flavor.normalizeToolCall?.(event.toolCall) ?? event.toolCall;
-                const subagentUpdate = flavor.extractSubagentUpdate(toolCall);
+                const subagentUpdate = extractSubagentUpdate(toolCall);
                 if (subagentUpdate === undefined) continue;
                 if (!acpSubagentStatusIsTerminal(subagentUpdate.status)) {
                   continue;
@@ -4090,7 +4713,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               for (const event of parseSessionUpdateEvent(notification).events) {
                 if (event._tag !== "ToolCallUpdated") continue;
                 const toolCall = flavor.normalizeToolCall?.(event.toolCall) ?? event.toolCall;
-                const subagentUpdate = flavor.extractSubagentUpdate(toolCall);
+                const subagentUpdate = extractSubagentUpdate(toolCall);
                 if (subagentUpdate !== undefined) {
                   if (
                     subagentUpdate.nativeTaskId === nativeTaskId ||
@@ -4100,64 +4723,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                   }
                   continue;
                 }
-                const key = `${nativeTaskId}:tool:${toolCall.toolCallId}`;
-                const previous = context.tools.get(key);
-                const merged = mergeToolCallState(previous, toolCall);
-                context.tools.set(key, merged);
-                if (!shouldPersistToolUpdate(context, key, previous, merged, merged.status))
-                  continue;
-                const mcpIdentity = extractMcpToolCallIdentity(merged, {
-                  embeddedTerminalCommands: [
-                    ...embeddedTerminalCommands(notification.sessionId, toolCall.toolCallId),
-                    ...(rootSessionId === null
-                      ? []
-                      : embeddedTerminalCommands(rootSessionId, toolCall.toolCallId)),
-                  ],
-                });
-                const now = yield* DateTime.now;
-                const status = toolStatus(merged.status);
-                const startedAt = context.toolStartedAt.get(key) ?? now;
-                context.toolStartedAt.set(key, startedAt);
-                const ordinal = resolveSubagentChildOrdinal(subagent, key);
-                yield* emitProviderEvent({
-                  type: "turn_item.updated",
-                  driver,
-                  turnItem: {
-                    id: providerTurnItemId(key),
-                    threadId: subagent.childThreadId,
-                    runId: null,
-                    nodeId: subagent.childRootNodeId,
-                    providerThreadId: subagent.task.providerThreadId,
-                    providerTurnId: null,
-                    nativeItemRef: { driver, nativeId: key, strength: "strong" },
-                    parentItemId: null,
-                    ordinal,
-                    status,
-                    title: merged.title ?? merged.kind ?? "Tool",
-                    startedAt,
-                    completedAt: completedAtForStatus(status, now),
-                    updatedAt: now,
-                    type: "dynamic_tool",
-                    ...(mcpIdentity === undefined
-                      ? {}
-                      : mcpToolPresentation({
-                          serverName: mcpIdentity.server,
-                          toolName: mcpIdentity.tool,
-                          source: unknownRecord(
-                            (
-                              unknownRecord(unknownRecord(merged.data.rawOutput)?.result) ??
-                              unknownRecord(merged.data.rawOutput)
-                            )?._meta,
-                          )?.source,
-                        })),
-                    toolName:
-                      mcpIdentity === undefined
-                        ? (merged.title ?? merged.kind ?? "Tool")
-                        : `${mcpIdentity.server}.${mcpIdentity.tool}`,
-                    input: merged.data.rawInput ?? null,
-                    output: merged.data.rawOutput ?? merged.data.content ?? null,
-                  },
-                });
+                yield* projectSubagentTool(subagent, notification.sessionId, toolCall);
               }
               return;
             }
@@ -4664,62 +5230,73 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           } as const;
         });
 
-        const requestUserInputWithAdmission = (
-          generation: number,
-          request: Effect.Effect<AcpAdapterV2UserInputRequest>,
-          transportRequestId: string,
-        ) =>
-          runRuntimeCallbackAtGeneration(
-            generation,
-            request.pipe(
-              Effect.flatMap((value) =>
-                beginUserInputRequest(value, generation, transportRequestId),
+        const requestUserInputWithAdmission = Effect.fn(
+          "AcpAdapterV2.requestUserInputWithAdmission",
+        )(
+          function* (
+            generation: number,
+            request: Effect.Effect<AcpAdapterV2UserInputRequest>,
+            transportRequestId: string,
+          ) {
+            if (!(yield* awaitRequestTurn(generation))) {
+              return { answers: null, acknowledgeNativeResponse: Effect.void };
+            }
+            return yield* runRuntimeCallbackAtGeneration(
+              generation,
+              request.pipe(
+                Effect.flatMap((value) =>
+                  beginUserInputRequest(value, generation, transportRequestId),
+                ),
               ),
-            ),
-          ).pipe(
-            Effect.flatMap((pending) => {
-              if (Option.isNone(pending)) return Effect.never;
-              const { answers, requestId, transportRequestId } = pending.value;
-              return Deferred.await(answers).pipe(
-                Effect.flatMap((result) =>
-                  runRuntimeCallbackAtGeneration(generation, Effect.succeed(result)).pipe(
-                    Effect.flatMap((checked) =>
-                      Option.isSome(checked)
-                        ? Effect.succeed({
-                            acknowledgeNativeResponse: acknowledgeNativeResponse(
-                              generation,
-                              transportRequestId,
-                            ),
-                            answers: checked.value,
-                          })
-                        : Effect.never,
+            ).pipe(
+              Effect.flatMap((pending) => {
+                if (Option.isNone(pending)) return Effect.never;
+                const { answers, requestId, transportRequestId } = pending.value;
+                return Deferred.await(answers).pipe(
+                  Effect.flatMap((result) =>
+                    runRuntimeCallbackAtGeneration(generation, Effect.succeed(result)).pipe(
+                      Effect.flatMap((checked) =>
+                        Option.isSome(checked)
+                          ? Effect.succeed({
+                              acknowledgeNativeResponse: acknowledgeNativeResponse(
+                                generation,
+                                transportRequestId,
+                              ),
+                              answers: checked.value,
+                            })
+                          : Effect.never,
+                      ),
                     ),
                   ),
-                ),
-                Effect.ensuring(
-                  runRuntimeCallbackAtGeneration(
-                    generation,
-                    Effect.gen(function* () {
-                      yield* Ref.update(pendingRuntimeRequests, (current) => {
-                        const updated = new Map(current);
-                        updated.delete(String(requestId));
-                        return updated;
-                      });
-                    }),
-                  ).pipe(Effect.asVoid),
-                ),
-              );
-            }),
-            Effect.mapError(
-              (cause) =>
-                new EffectAcpErrors.AcpTransportError({
-                  detail: "Failed to handle ACP user input request",
-                  cause,
-                }),
-            ),
-          );
+                  Effect.ensuring(
+                    runRuntimeCallbackAtGeneration(
+                      generation,
+                      Effect.gen(function* () {
+                        yield* Ref.update(pendingRuntimeRequests, (current) => {
+                          const updated = new Map(current);
+                          updated.delete(String(requestId));
+                          return updated;
+                        });
+                      }),
+                    ).pipe(Effect.asVoid),
+                  ),
+                );
+              }),
+            );
+          },
+          Effect.mapError(
+            (cause) =>
+              new EffectAcpErrors.AcpTransportError({
+                detail: "Failed to handle ACP user input request",
+                cause,
+              }),
+          ),
+        );
 
         const cancelPendingRuntimeRequests = Effect.fnUntraced(function* () {
+          const waiting = turnAttached;
+          turnAttached = yield* Deferred.make<boolean>();
+          yield* Deferred.succeed(waiting, false);
           const requests = yield* Ref.modify(pendingRuntimeRequests, (current) => [
             [...current.values()],
             new Map<string, PendingRuntimeRequest>(),
@@ -5005,7 +5582,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             for (const event of parseSessionUpdateEvent(notification).events) {
               if (event._tag !== "ToolCallUpdated") continue;
               const toolCall = flavor.normalizeToolCall?.(event.toolCall) ?? event.toolCall;
-              const subagentUpdate = flavor.extractSubagentUpdate(toolCall);
+              const subagentUpdate = extractSubagentUpdate(toolCall);
               if (
                 subagentUpdate === undefined ||
                 !acpSubagentStatusIsTerminal(subagentUpdate.status)
@@ -5084,6 +5661,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
         ) {
           if (carryover === null) return;
           for (const subagent of carryover.subagents) {
+            yield* terminalizeSubagentTools(subagent);
             if (acpSubagentStatusIsTerminal(subagent.task.status)) {
               if (!subagent.terminalStatusProjected) {
                 yield* projectCarryoverSubagentStatus(
@@ -5102,14 +5680,12 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           /* Provider events include streaming deltas; avoid a span for each update. */
           Effect.fnUntraced(
             function* (rawNotification: EffectAcpSchema.SessionNotification) {
-              if (clientTerminals !== undefined) {
-                const embedded = embeddedTerminalIdsFromSessionUpdate(rawNotification);
-                if (embedded !== undefined) {
-                  rememberEmbeddedTerminals({
-                    ...embedded,
-                    sessionId: rawNotification.sessionId,
-                  });
-                }
+              const embedded = embeddedTerminalIdsFromSessionUpdate(rawNotification);
+              if (embedded !== undefined) {
+                rememberEmbeddedTerminals({
+                  ...embedded,
+                  sessionId: rawNotification.sessionId,
+                });
               }
               const notification =
                 clientTerminals === undefined
@@ -5310,13 +5886,20 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                 yield* userInput.acknowledgeNativeResponse;
                 return response ?? ({ outcome: { outcome: "cancelled" } } as const);
               }
+              const dispositionFor = (policy: ProviderAdapter.ProviderAdapterV2RuntimePolicy) =>
+                (flavor.permissionDisposition ?? acpPermissionDisposition)(policy, params);
+              if (followsAgentWorkState && dispositionFor(latestRuntimePolicy) === "ask") {
+                if (!(yield* awaitRequestTurn(handlerGeneration)))
+                  return { outcome: { outcome: "cancelled" } } as const;
+              }
               const admitted = yield* runRuntimeCallbackAtGeneration(
                 handlerGeneration,
                 Effect.gen(function* () {
-                  const context = yield* activeContext;
-                  const disposition = (flavor.permissionDisposition ?? acpPermissionDisposition)(
-                    context.input.runtimePolicy,
-                    params,
+                  const context = followsAgentWorkState
+                    ? yield* Ref.get(activeTurn)
+                    : yield* activeContext;
+                  const disposition = dispositionFor(
+                    context?.input.runtimePolicy ?? latestRuntimePolicy,
                   );
                   if (disposition === "allow") {
                     const optionId = selectAutoApprovedPermissionOption(params);
@@ -5341,7 +5924,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                   return {
                     _tag: "Pending" as const,
                     pending: yield* beginApprovalRequest(
-                      context,
+                      yield* activeContext,
                       params,
                       handlerGeneration,
                       transportRequestId,
@@ -5426,6 +6009,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                     cause,
                   }),
               ),
+              holdingAgentRequest(handlerGeneration),
             ),
           );
           yield* targetRuntime.handleElicitation((params, requestContext) =>
@@ -5561,7 +6145,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                     } as const);
               yield* userInput.acknowledgeNativeResponse;
               return response;
-            }),
+            }).pipe(holdingAgentRequest(handlerGeneration)),
           );
           if (flavor.registerExtensions !== undefined) {
             yield* flavor.registerExtensions({
@@ -5857,7 +6441,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               return yield* startAcpRuntime(input.threadId);
             });
         yield* Ref.set(activeSessionId, started.sessionId);
-        yield* Ref.set(activeSessionSetup, started);
+        yield* setActiveSessionSetup(started);
         rememberTerminalEnvironment(started.sessionId, yield* readMcpContext(input.threadId));
         const capabilities = negotiatedCapabilities(flavor.capabilities, started);
         const canLoadSession = started.initializeResult.agentCapabilities?.loadSession === true;
@@ -6156,6 +6740,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           }
           if (!options.terminalizeSubagents) return;
           for (const subagent of context.subagents.values()) {
+            yield* terminalizeSubagentTools(subagent);
             if (subagent.task.status !== "running" && subagent.task.status !== "pending") {
               continue;
             }
@@ -6176,7 +6761,8 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           context: ActiveAcpTurn,
         ) {
           for (const tool of context.tools.values()) {
-            if (!acpCompletedTurnShouldTerminalizeTool(tool, flavor)) continue;
+            if (!acpCompletedTurnShouldTerminalizeTool(tool, { ...flavor, extractSubagentUpdate }))
+              continue;
             yield* emitTool(context, tool, "completed");
           }
         });
@@ -6201,7 +6787,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
           context: ActiveAcpTurn,
           status: "completed" | "interrupted" | "failed" | "cancelled",
           failure?: OrchestrationV2ProviderFailure,
-        ) {
+        ): Effect.fn.Return<void> {
           if (context.finalized) return;
           const settledStatus = context.interrupted ? "interrupted" : status;
           context.finalizedStatus = settledStatus;
@@ -6294,6 +6880,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             driver,
             providerThread: updatedProviderThread,
           });
+          const rootSessionId = yield* Ref.get(activeSessionId);
           yield* emitProviderEvent(
             settledStatus === "failed"
               ? {
@@ -6307,6 +6894,11 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                     `terminal-failure:${context.providerTurnId}`,
                   ),
                   status: settledStatus,
+                  ...(followsAgentWorkState &&
+                  rootSessionId !== null &&
+                  hasWorkingDescendant(rootSessionId)
+                    ? { childTurnsContinue: true }
+                    : {}),
                   failure: failure ?? makeProviderFailure({ class: "provider_error" }),
                   ...(context.providerRetry === undefined
                     ? {}
@@ -6513,7 +7105,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             if (needsSessionActivation) {
               const activated = yield* activateSession(requestedSessionId, turnInput.threadId);
               yield* Ref.set(activeSessionId, activated.sessionId);
-              yield* Ref.set(activeSessionSetup, activated);
+              yield* setActiveSessionSetup(activated);
               yield* configureSession(activated, turnInput.modelSelection, turnInput.runtimePolicy);
               yield* Ref.set(activeSelection, turnInput.modelSelection);
               yield* Ref.set(activeInteractionMode, turnInput.runtimePolicy.interactionMode);
@@ -6550,7 +7142,8 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
             // Continuation turns attach to wake traffic the agent already produced
             // after the prior root turn settled; do not re-prompt the ACP session.
             const isContinuationTurn =
-              postSettleContinuationEnabled && acpIsProviderContinuationMessage(turnInput.message);
+              (postSettleContinuationEnabled || followsAgentWorkState) &&
+              acpIsProviderContinuationMessage(turnInput.message);
             const isAppOwnedWakeTurn = acpIsAppOwnedWakeTurn(turnInput.message);
             if (!isAppOwnedWakeTurn) {
               yield* Ref.set(midTurnUnreportedCompletedTaskIds, new Set());
@@ -6629,6 +7222,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               finalizedStatus: null,
               promptSettled: false,
               promptSettledStatus: null,
+              workAccepted: false,
               promptWireSettled,
               backgroundFinalizeGeneration: 0,
             };
@@ -6696,6 +7290,11 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
               createdAt: startedAt,
               updatedAt: startedAt,
             });
+            if (followsAgentWorkState)
+              yield* runtimeCallbackPermit.withPermit(syncNativeChildren(context));
+            const attached = turnAttached;
+            turnAttached = yield* Deferred.make<boolean>();
+            yield* Deferred.succeed(attached, true);
             // Every attach ends the deferred-terminal contract, but only the
             // queued provider continuation owns wake traffic. A user turn may
             // start before that continuation and must leave its buffer intact.
@@ -6708,13 +7307,28 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                 reports: new Map([...reports].filter(([key]) => !offered.has(key))),
                 offered: noWakeReports.offered,
               }));
-              const drainedWakeCount = yield* Ref.modify(wakeBuffer, (current) => {
+              const takeWakeBuffer = Ref.modify(wakeBuffer, (current) => {
                 const next: Array<EffectAcpSchema.SessionNotification> = [];
                 return [
                   current.filter((notification) => notification.sessionId === requestedSessionId),
                   next,
                 ] as const;
-              }).pipe(
+              });
+              if (followsAgentWorkState) {
+                yield* runtimeCallbackPermit.withPermit(
+                  Effect.gen(function* () {
+                    const liveWork = agentWork;
+                    yield* Effect.forEach(yield* takeWakeBuffer, handleSessionUpdate, {
+                      discard: true,
+                    });
+                    agentWork = liveWork;
+                    context.workAccepted = true;
+                    yield* settleIdleWork(context);
+                  }),
+                );
+                return;
+              }
+              const drainedWakeCount = yield* takeWakeBuffer.pipe(
                 Effect.tap((drained) =>
                   Effect.forEach(drained, handleSessionUpdate, {
                     concurrency: 1,
@@ -6766,7 +7380,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                 runRuntimeCallbackAtGeneration(
                   promptGeneration,
                   Effect.gen(function* () {
-                    if (context.finalized) return;
+                    if (context.finalized || followsAgentWorkState) return;
                     const status =
                       result.stopReason === "cancelled"
                         ? context.interrupted
@@ -6795,9 +7409,17 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                   promptGeneration,
                   Effect.gen(function* () {
                     if (context.finalized) return;
+                    const error = Cause.findError(cause);
+                    // Native close rejects prompts cancelled before insertion with -32800.
+                    const interrupted =
+                      context.interrupted ||
+                      (pendingStopCloseTurn === context &&
+                        Result.isSuccess(error) &&
+                        error.success._tag === "AcpRequestError" &&
+                        error.success.code === -32800);
                     yield* finalizeTurn(
                       context,
-                      context.interrupted ? "interrupted" : "failed",
+                      interrupted ? "interrupted" : "failed",
                       flavor.promptFailure?.(Cause.squash(cause)) ??
                         makeProviderFailure({
                           cause: Cause.squash(cause),
@@ -6911,9 +7533,23 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                     : flavor.getModelContextWindow?.(selection, session);
                 },
               }),
-          ...(postSettleContinuationEnabled
+          ...(postSettleContinuationEnabled || followsAgentWorkState
             ? {
                 hasPendingBackgroundWork: Effect.gen(function* () {
+                  const rootSessionId = yield* Ref.get(activeSessionId);
+                  if (
+                    followsAgentWorkState &&
+                    rootSessionId !== null &&
+                    hasWorkingDescendant(rootSessionId)
+                  )
+                    return true;
+                  if (
+                    followsAgentWorkState &&
+                    (agentWork?.state === "running" ||
+                      agentWork?.state === "requires_action" ||
+                      agentRequests.size > 0)
+                  )
+                    return true;
                   if ((yield* Ref.get(wakeBuffer)).length > 0) return true;
                   if (yield* Ref.get(continuationRequested)) return true;
                   if ((yield* Ref.get(runningBackgroundTaskIds)).size > 0) return true;
@@ -7003,7 +7639,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                       threadInput.providerThread.appThreadId,
                     ).pipe(Effect.tapError(() => restorePreviousItemIdentity));
                     yield* Ref.set(activeSessionId, activated.sessionId);
-                    yield* Ref.set(activeSessionSetup, activated);
+                    yield* setActiveSessionSetup(activated);
                     const nextSelection = threadInput.modelSelection ?? input.modelSelection;
                     const nextRuntimePolicy = threadInput.runtimePolicy ?? input.runtimePolicy;
                     yield* configureSession(activated, nextSelection, nextRuntimePolicy);
@@ -7058,6 +7694,54 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                   return yield* Effect.gen(function* () {
                     const transition = yield* Effect.gen(function* () {
                       const interruptContext = yield* Ref.get(activeTurn);
+                      if (
+                        followsAgentWorkState &&
+                        turnInput.requestRuntimeRestart === true &&
+                        (interruptContext === null ||
+                          interruptContext.providerTurnId === turnInput.providerTurnId)
+                      ) {
+                        // ACP cancel leaves native children alive; close confirms session-wide Stop.
+                        pendingStopCloseTurn = interruptContext;
+                        const closed = yield* runtime.closeSession().pipe(
+                          Effect.timeoutOption("10 seconds"),
+                          Effect.mapError(
+                            (cause) =>
+                              new ProviderAdapter.ProviderAdapterProtocolError({
+                                driver,
+                                detail:
+                                  "The agent refused to close its session; background work may still run",
+                                cause,
+                              }),
+                          ),
+                        );
+                        if (Option.isNone(closed)) {
+                          return yield* new ProviderAdapter.ProviderAdapterProtocolError({
+                            driver,
+                            detail:
+                              "The agent did not confirm session close; background work may still run",
+                          });
+                        }
+                        yield* runtimeCallbackPermit.withPermit(
+                          Effect.gen(function* () {
+                            // Callbacks can settle the turn while close is awaiting confirmation.
+                            const context = yield* Ref.get(activeTurn);
+                            const carryover = yield* Ref.get(carryoverSubagents);
+                            yield* Ref.set(stoppedRunQuarantine, true);
+                            yield* Ref.set(runtimeRestartRequired, true);
+                            agentWork = null;
+                            agentRequests.clear();
+                            nativeChildren.clear();
+                            yield* quarantineStoppedRun();
+                            if (context !== null) context.interrupted = true;
+                            yield* cancelPendingRuntimeRequests();
+                            yield* terminalizeCarryoverSubagents(carryover);
+                            if (context !== null) {
+                              yield* finalizeTurn(context, "interrupted");
+                            }
+                          }),
+                        );
+                        return undefined;
+                      }
                       const softSteerCandidate =
                         flavor.preserveRuntimeOnSettledInterrupt === true &&
                         turnInput.requestRuntimeRestart !== true &&
@@ -7209,7 +7893,13 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                         teardownBarrier,
                         settledSoftInterrupt,
                       };
-                    });
+                    }).pipe(
+                      Effect.ensuring(
+                        Effect.sync(() => {
+                          pendingStopCloseTurn = null;
+                        }),
+                      ),
+                    );
                     if (transition === undefined) return;
                     const {
                       context,
@@ -7407,7 +8097,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                       yield* readMcpContext(snapshotInput.providerThread.appThreadId),
                     );
                     yield* Ref.set(activeSessionId, activated.sessionId);
-                    yield* Ref.set(activeSessionSetup, activated);
+                    yield* setActiveSessionSetup(activated);
                     yield* Ref.set(activeSelection, null);
                     yield* Ref.set(activeInteractionMode, null);
                   }
@@ -7469,7 +8159,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                         );
                         yield* Ref.set(runtimeRestartRequired, false);
                         yield* Ref.set(activeSessionId, candidate.sessionId);
-                        yield* Ref.set(activeSessionSetup, candidate);
+                        yield* setActiveSessionSetup(candidate);
                         yield* Ref.set(activeSelection, null);
                         yield* Ref.set(activeInteractionMode, null);
                         yield* Ref.set(promptInstructionStates, new Map());
@@ -7569,7 +8259,7 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
                     yield* readMcpContext(forkInput.targetThreadId),
                   );
                   yield* Ref.set(activeSessionId, forked.sessionId);
-                  yield* Ref.set(activeSessionSetup, forked);
+                  yield* setActiveSessionSetup(forked);
                   yield* Ref.set(activeSelection, null);
                   yield* Ref.set(activeInteractionMode, null);
                   itemIdentityVersion = 2;
diff --git a/packages/provider-acp/src/server/runtimeModel.ts b/packages/provider-acp/src/server/runtimeModel.ts
index bad434e938e0c..f7c10bdf3ad9c 100644
--- a/packages/provider-acp/src/server/runtimeModel.ts
+++ b/packages/provider-acp/src/server/runtimeModel.ts
@@ -814,6 +814,7 @@ export function canonicalItemTypeFromAcpToolKind(kind: string | undefined): Tool
 function makeToolCallState(
   input: {
     readonly toolCallId: string;
+    readonly name?: string | null | undefined;
     readonly title?: string | null | undefined;
     readonly kind?: EffectAcpSchema.ToolKind | null | undefined;
     readonly status?: EffectAcpSchema.ToolCallStatus | null | undefined;
@@ -841,6 +842,7 @@ function makeToolCallState(
       ? title
       : undefined;
   const data: Record<string, unknown> = { toolCallId };
+  if (input.name != null) data.name = input.name;
   if (kind) {
     data.kind = kind;
   }
@@ -911,6 +913,7 @@ function parseTypedToolCallState(
   return makeToolCallState(
     {
       toolCallId: event.toolCallId,
+      name: event.name,
       title: event.title,
       kind: event.kind,
       status: event.status,
diff --git a/packages/provider-core/src/server/maintenanceResolver.test.ts b/packages/provider-core/src/server/maintenanceResolver.test.ts
index 66b9ded4f32eb..aeba8b9187c9d 100644
--- a/packages/provider-core/src/server/maintenanceResolver.test.ts
+++ b/packages/provider-core/src/server/maintenanceResolver.test.ts
@@ -544,6 +544,49 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
     }),
   );
 
+  it.effect.each([
+    {
+      name: "the default home",
+      resolved: "/Users/theo/.vite-plus/bin/claude",
+      real: "/Users/theo/.vite-plus/current/bin/vp",
+      platform: "darwin",
+    },
+    {
+      name: "the XDG home",
+      resolved: "/home/theo/.local/share/vite-plus/bin/claude",
+      real: "/home/theo/.local/share/vite-plus/current/bin/vp",
+      platform: "linux",
+    },
+    {
+      name: "the Windows home",
+      resolved: "C:\\Users\\Theo\\AppData\\Local\\vite-plus\\bin\\claude.cmd",
+      real: "C:\\Users\\Theo\\AppData\\Local\\vite-plus\\packages\\@anthropic-ai\\claude-code\\lib\\node_modules\\@anthropic-ai\\claude-code\\cli.js",
+      platform: "win32",
+    },
+  ] as const)("updates a Vite+ global install in $name with vp", (fixture) =>
+    Effect.gen(function* () {
+      const capabilities = yield* resolveInstall({ definition: claudeUpdate, ...fixture });
+
+      expect(capabilities.update).toMatchObject({
+        command: "vp i -g @anthropic-ai/claude-code",
+        lockKey: "vite-plus-global",
+      });
+    }),
+  );
+
+  it.effect("keeps a project folder named vite-plus manual-only", () =>
+    Effect.gen(function* () {
+      const capabilities = yield* resolveInstall({
+        definition: claudeUpdate,
+        resolved: "/work/vite-plus/bin/claude",
+        real: "/work/vite-plus/node_modules/@anthropic-ai/claude-code/cli.js",
+        platform: "linux",
+      });
+
+      expect(capabilities.update).toBeNull();
+    }),
+  );
+
   it.effect("proves Windows npm ownership from the package manifest beside the shim", () =>
     Effect.gen(function* () {
       const tempDir = yield* makeTempDir("t3-npm-windows-capabilities");
@@ -759,6 +802,43 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
     }),
   );
 
+  it.effect.each(["wrapper", "symlink"])(
+    "keeps a mise-owned %s in a native install location manual-only",
+    (launcher, { skip }) => {
+      if (windowsHost || (launcher === "symlink" && !symlinksSupported)) skip();
+      return Effect.gen(function* () {
+        const tempDir = yield* makeTempDir("t3-native-mise");
+        const nativePath = NodePath.join(tempDir, ".local", "bin", "native-package-tool");
+        if (launcher === "wrapper") {
+          writeExecutable(nativePath);
+          NodeFS.writeFileSync(
+            nativePath,
+            '#!/bin/sh\nexec mise x native-package-tool -- native-package-tool "$@"\n',
+          );
+        } else {
+          const target = NodePath.join(
+            tempDir,
+            "mise",
+            "installs",
+            "native-package-tool",
+            "1.0.0",
+            "native-package-tool",
+          );
+          writeExecutable(target);
+          NodeFS.mkdirSync(NodePath.dirname(nativePath), { recursive: true });
+          NodeFS.symlinkSync(target, nativePath);
+        }
+
+        const capabilities = yield* resolveProviderMaintenanceCapabilitiesEffect(
+          nativePackageToolUpdate,
+          { binaryPath: nativePath, env: { PATH: "" } },
+        ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, noSpawn));
+
+        expect(capabilities.update).toBeNull();
+      });
+    },
+  );
+
   it.effect.skipIf(windowsHost)("runs an explicit native updater outside PATH", () =>
     Effect.gen(function* () {
       const tempDir = yield* makeTempDir("t3-native-update");
diff --git a/packages/provider-core/src/server/maintenanceResolver.ts b/packages/provider-core/src/server/maintenanceResolver.ts
index a27fab2084f76..efd618041394b 100644
--- a/packages/provider-core/src/server/maintenanceResolver.ts
+++ b/packages/provider-core/src/server/maintenanceResolver.ts
@@ -211,8 +211,15 @@ export function normalizeCommandPath(commandPath: string): string {
   return commandPath.replaceAll("\\", "/").toLowerCase();
 }
 
+/**
+ * Vite+ shims live in `<VP_HOME>/bin`: `~/.vite-plus` by default,
+ * `~/.local/share/vite-plus` with the XDG layout, and `%LOCALAPPDATA%\vite-plus`
+ * on Windows.
+ */
 function isVitePlusGlobalCommandPath(commandPath: string): boolean {
-  return normalizeCommandPath(commandPath).includes("/.vite-plus/bin/");
+  return /\/(?:\.vite-plus|\.local\/share\/vite-plus|appdata\/local\/vite-plus)\/bin\//.test(
+    normalizeCommandPath(commandPath),
+  );
 }
 
 function isBunGlobalCommandPath(commandPath: string): boolean {
@@ -456,7 +463,13 @@ export const resolvePackageManagedProviderMaintenance = Effect.fn(
         ...(nativeUpdate.env ? { env: nativeUpdate.env } : {}),
       })
     : manual;
-  if (nativeUpdate?.isCommandPath && commandPaths.some(nativeUpdate.isCommandPath)) {
+  // A native-looking launcher can still delegate to a mise-owned install.
+  if (
+    nativeUpdate?.isCommandPath &&
+    commandPaths.some(nativeUpdate.isCommandPath) &&
+    !commandPaths.some(isMiseCommandPath) &&
+    !(yield* isMiseWrapperScript(context))
+  ) {
     return native;
   }
   // A `node_modules` path not proven below belongs to another package or a
diff --git a/packages/provider-core/src/server/managedProvider.test.ts b/packages/provider-core/src/server/managedProvider.test.ts
index b69c41a342219..8732964dac601 100644
--- a/packages/provider-core/src/server/managedProvider.test.ts
+++ b/packages/provider-core/src/server/managedProvider.test.ts
@@ -293,6 +293,59 @@ describe("makeManagedServerProvider", () => {
     ).pipe(Effect.provide(Layer.mergeAll(layerNeverRunTest, TestClock.layer()))),
   );
 
+  it.effect("skips periodic checks while disabled and resumes them once enabled", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const settingsRef = yield* Ref.make<TestSettings>({ enabled: false });
+        const settingsChanges = yield* PubSub.unbounded<TestSettings>();
+        const checkCalls = yield* Ref.make(0);
+        const releaseInitialCheck = yield* Deferred.make<void>();
+        const updates = yield* Queue.unbounded<ServerProvider>();
+        const provider = yield* makeManagedServerProvider<TestSettings>({
+          resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
+          getSettings: Ref.get(settingsRef),
+          streamSettings: Stream.fromPubSub(settingsChanges),
+          haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
+          initialSnapshot: () => Effect.succeed({ ...initialSnapshot, enabled: false }),
+          checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
+            Effect.tap((count) =>
+              count === 1 ? Deferred.await(releaseInitialCheck) : Effect.void,
+            ),
+            Effect.andThen(Ref.get(settingsRef)),
+            Effect.map(({ enabled }) => ({ ...refreshedSnapshot, enabled })),
+          ),
+          refreshInterval: "5 minutes",
+        });
+        yield* provider.streamChanges.pipe(
+          Stream.runForEach((snapshot) => Queue.offer(updates, snapshot)),
+          Effect.forkScoped,
+        );
+        yield* Effect.yieldNow;
+        yield* Deferred.succeed(releaseInitialCheck, undefined);
+        yield* Queue.take(updates);
+
+        yield* TestClock.adjust("5 minutes");
+        yield* TestClock.adjust("5 minutes");
+        yield* Effect.yieldNow;
+        assert.strictEqual(yield* Ref.get(checkCalls), 1);
+        assert.strictEqual(yield* Queue.size(updates), 0);
+
+        yield* provider.refresh;
+        yield* Queue.take(updates);
+        assert.strictEqual(yield* Ref.get(checkCalls), 2);
+
+        yield* Ref.set(settingsRef, { enabled: true });
+        yield* PubSub.publish(settingsChanges, { enabled: true });
+        assert.strictEqual((yield* Queue.take(updates)).enabled, true);
+        assert.strictEqual(yield* Ref.get(checkCalls), 3);
+
+        yield* TestClock.adjust("5 minutes");
+        yield* Queue.take(updates);
+        assert.strictEqual(yield* Ref.get(checkCalls), 4);
+      }),
+    ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
+  );
+
   it.effect("disables periodic provider refreshes when the explicit interval is zero", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/packages/provider-core/src/server/managedProvider.ts b/packages/provider-core/src/server/managedProvider.ts
index 98ff340ddda54..e069bf3af0047 100644
--- a/packages/provider-core/src/server/managedProvider.ts
+++ b/packages/provider-core/src/server/managedProvider.ts
@@ -220,6 +220,11 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
 
   const hasProviderStatusDemand = Effect.gen(function* () {
     const state = yield* Ref.get(snapshotStateRef);
+    // A disabled instance has nothing to probe; a periodic check would only
+    // republish a snapshot that differs in checkedAt.
+    if (!state.snapshot.enabled) {
+      return false;
+    }
     const instanceId = state.snapshot.instanceId;
     const [genericDemand, instanceDemand] = yield* Effect.all([
       host.shouldRunBackgroundWork({ type: "provider-status" }),
diff --git a/packages/provider-core/src/server/runtimeInstructions.ts b/packages/provider-core/src/server/runtimeInstructions.ts
index ca31b32cd9bf7..b1aadb5e0d446 100644
--- a/packages/provider-core/src/server/runtimeInstructions.ts
+++ b/packages/provider-core/src/server/runtimeInstructions.ts
@@ -1,5 +1,5 @@
 const PULL_REQUEST_LINKING_INSTRUCTIONS = `<pull_request_linking>
-When the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. When asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.
+When the t3-code MCP server exposes link_pull_request, you must use it to register every pull request you create or work on for this thread. Call link_pull_request with the full PR URL immediately after creating a PR or starting work on an existing PR. For a stack, call it for every layer, not just the current branch or the top PR. This applies when creating or updating PRs through gh, gh stack, another CLI, or the host API: those operations do not register the PRs with this thread. Linking an already-linked PR is safe. Before finishing PR work, call list_thread_pull_requests and link any PR from your work that is missing. Do not link unrelated PRs mentioned only as background. If a linking call fails, report that failure instead of claiming the PR is linked. As a delegated child task, do not watch or poll PRs; return PR URLs, head SHA, and pending review/check state to your parent. Otherwise, when asked to monitor, watch, or babysit a PR and watch_pull_request is available, call it and end your turn: T3 Code wakes you when checks finish, someone else comments, or the branch conflicts, so do not poll or run your own watcher. When monitoring is done and you hand the work back to the user, call unwatch_pull_request first so the thread returns to their inbox.
 </pull_request_linking>`;
 
 /**
diff --git a/packages/provider-core/src/server/snapshotProbe.ts b/packages/provider-core/src/server/snapshotProbe.ts
index 75ca132579d9b..98d8acf1cf379 100644
--- a/packages/provider-core/src/server/snapshotProbe.ts
+++ b/packages/provider-core/src/server/snapshotProbe.ts
@@ -265,6 +265,8 @@ export function buildServerProvider(input: {
     version: input.probe.version,
     status: input.enabled ? input.probe.status : "disabled",
     auth: input.probe.auth,
+    // Drivers with in-app setup replace these CLI-owned defaults.
+    setup: { canAuthenticate: false, canInstall: false },
     checkedAt: input.checkedAt,
     ...(input.probe.message ? { message: input.probe.message } : {}),
     models: input.models,
diff --git a/packages/provider-core/src/server/usage.ts b/packages/provider-core/src/server/usage.ts
index 68cd6571307c9..89c627e5fa162 100644
--- a/packages/provider-core/src/server/usage.ts
+++ b/packages/provider-core/src/server/usage.ts
@@ -62,6 +62,8 @@ export interface TranscriptUsageFormat<State> {
   readonly usageMarkers: readonly [string, ...string[]];
   parseLine(line: string, state: State): readonly UsageRecord[];
   parseProjected(projected: unknown, state: State): readonly UsageRecord[];
+  /** Cumulative malformed or inconsistent usage records, including skipped records. */
+  readMalformedRecords?(state: State): number;
   /**
    * Present for formats whose records depend on earlier lines. The state at a
    * resume point is persisted in the scan cache through `schema`, so a grown
diff --git a/packages/provider-cursor/src/server/CursorSdkCatalog.ts b/packages/provider-cursor/src/server/CursorSdkCatalog.ts
index 7f317cc0978fd..fae053fe535c9 100644
--- a/packages/provider-cursor/src/server/CursorSdkCatalog.ts
+++ b/packages/provider-cursor/src/server/CursorSdkCatalog.ts
@@ -26,6 +26,10 @@ export class CursorSdkCatalogError extends Schema.TaggedError<CursorSdkCatalogEr
       ? "Cursor SDK authentication failed."
       : "Cursor SDK catalog request failed.";
   }
+
+  get planRequired(): boolean {
+    return this.cause instanceof CursorSdkError && this.cause.code === "plan_required";
+  }
 }
 
 export class CursorSdkCatalog extends Context.Service<
diff --git a/packages/provider-cursor/src/server/adapter.test.ts b/packages/provider-cursor/src/server/adapter.test.ts
index be87e4a481968..8aecb9f92dfe4 100644
--- a/packages/provider-cursor/src/server/adapter.test.ts
+++ b/packages/provider-cursor/src/server/adapter.test.ts
@@ -830,11 +830,7 @@ describe("CursorAdapterV2", () => {
           name: "weather",
           kind: "integration",
         });
-        assert.deepEqual(item.input, {
-          providerIdentifier: "weather",
-          toolName: "get_weather",
-          args: { city: "Berlin" },
-        });
+        assert.deepEqual(item.input, { city: "Berlin" });
       }
       const fileSearchItems = events.flatMap((event) =>
         event.type === "turn_item.updated" &&
diff --git a/packages/provider-cursor/src/server/adapter.ts b/packages/provider-cursor/src/server/adapter.ts
index b69ba4449b82d..765ec16fdec57 100644
--- a/packages/provider-cursor/src/server/adapter.ts
+++ b/packages/provider-cursor/src/server/adapter.ts
@@ -1321,7 +1321,7 @@ export const makeCursorAdapterV2 = Effect.fn("makeCursorAdapterV2")(function* (
                     })
                   : {}),
                 toolName: cursorToolName(toolCall),
-                input: toolCall.args,
+                input: toolCall.type === "mcp" ? (toolCall.args.args ?? {}) : toolCall.args,
                 ...(cursorToolOutput(toolCall) === undefined
                   ? {}
                   : { output: cursorToolOutput(toolCall) }),
diff --git a/packages/provider-cursor/src/server/auth.test.ts b/packages/provider-cursor/src/server/auth.test.ts
index 3d31211ac5aef..8219f1aa202fc 100644
--- a/packages/provider-cursor/src/server/auth.test.ts
+++ b/packages/provider-cursor/src/server/auth.test.ts
@@ -234,6 +234,8 @@ it.layer(NodeServices.layer)("CursorAuth", (it) => {
 
   it.effect("discards a credential rejected by verification and permits a fresh login", () =>
     Effect.gen(function* () {
+      const rejectionMessage =
+        "Cursor needs a paid plan to run in T3 Code. Upgrade this account or sign in with a different one.";
       let rejected = true;
       const harness = yield* makeHarness({
         onChanged: (signedIn) =>
@@ -242,7 +244,7 @@ it.layer(NodeServices.layer)("CursorAuth", (it) => {
                 new ProviderSetupError({
                   instanceId,
                   operation: "start",
-                  detail: "Could not verify the Cursor sign-in.",
+                  detail: rejectionMessage,
                 }),
               )
             : Effect.void,
@@ -250,7 +252,8 @@ it.layer(NodeServices.layer)("CursorAuth", (it) => {
       yield* harness.auth.controller.start(owner);
       yield* phase(harness.auth, "waiting");
       yield* Effect.sync(() => harness.complete.resolve());
-      yield* phase(harness.auth, "failed");
+      const failed = yield* phase(harness.auth, "failed");
+      expect(failed.message).toBe(rejectionMessage);
       expect(yield* Effect.promise(() => harness.store.load())).toBeUndefined();
       expect(yield* harness.auth.readApiKey).toBeUndefined();
       expect(Exit.isFailure(yield* Effect.exit(harness.auth.requireApiKey))).toBe(true);
diff --git a/packages/provider-cursor/src/server/auth.ts b/packages/provider-cursor/src/server/auth.ts
index 2122731a9d76e..6b7d43fd38c37 100644
--- a/packages/provider-cursor/src/server/auth.ts
+++ b/packages/provider-cursor/src/server/auth.ts
@@ -4,12 +4,14 @@ import {
   type ProviderAuthState,
   type ProviderInstanceId,
 } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
 import * as Clock from "effect/Clock";
 import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
+import * as Option from "effect/Option";
 import * as Queue from "effect/Queue";
 import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
@@ -271,7 +273,10 @@ export const makeCursorAuth = Effect.fn("makeCursorAuth")(function* (options: Cu
                 expiresAt: null,
                 message: Exit.isSuccess(result)
                   ? "Signed in with Cursor."
-                  : "Cursor sign-in failed or expired. Start sign-in again.",
+                  : Option.match(Cause.findErrorOption(result.cause), {
+                      onNone: () => "Cursor sign-in failed or expired. Start sign-in again.",
+                      onSome: (error) => error.detail,
+                    }),
               });
             }),
           ),
diff --git a/packages/provider-cursor/src/server/status.test.ts b/packages/provider-cursor/src/server/status.test.ts
index 32eedf9e3a9cd..1aed62d535466 100644
--- a/packages/provider-cursor/src/server/status.test.ts
+++ b/packages/provider-cursor/src/server/status.test.ts
@@ -14,6 +14,7 @@ import {
   checkCursorProviderStatus,
 } from "./status.ts";
 import * as CursorSdkCatalog from "./CursorSdkCatalog.ts";
+import { CursorSdkError } from "./sdk.ts";
 
 const decodeCursorSettings = Schema.decodeSync(CursorSettingsSchema);
 
@@ -231,6 +232,49 @@ describe("checkCursorProviderStatus", () => {
     }),
   );
 
+  it.effect.each([
+    {
+      authenticationType: "browser" as const,
+      message:
+        "Cursor needs a paid plan to run in T3 Code. Upgrade this account or sign in with a different one.",
+    },
+    {
+      authenticationType: "api-key" as const,
+      message:
+        "Cursor needs a paid plan to run in T3 Code. Upgrade the account that owns CURSOR_API_KEY or use a key from a paid account.",
+    },
+  ])(
+    "explains a rejected plan for $authenticationType authentication",
+    ({ authenticationType, message }) =>
+      Effect.gen(function* () {
+        const provider = yield* checkCursorProviderStatus(
+          baseCursorSettings,
+          { CURSOR_API_KEY: "free-plan-key" },
+          authenticationType,
+        ).pipe(
+          Effect.provide(
+            CursorSdkCatalog.layerTest(() =>
+              Effect.fail(
+                new CursorSdkCatalog.CursorSdkCatalogError({
+                  authenticationFailure: false,
+                  cause: new CursorSdkError(
+                    "[plan_required] Cloud Agent is not available for free users. Please upgrade to Pro.",
+                    { code: "plan_required", status: 403 },
+                  ),
+                }),
+              ),
+            ),
+          ),
+        );
+
+        expect(provider).toMatchObject({
+          status: "error",
+          auth: { status: "unknown" },
+          message,
+        });
+      }),
+  );
+
   it.effect("requires a Cursor API key without probing any external Cursor binary", () =>
     Effect.gen(function* () {
       const provider = yield* checkCursorProviderStatus(baseCursorSettings).pipe(
diff --git a/packages/provider-cursor/src/server/status.ts b/packages/provider-cursor/src/server/status.ts
index 2c21a01459b0f..9722ddbcfd23a 100644
--- a/packages/provider-cursor/src/server/status.ts
+++ b/packages/provider-cursor/src/server/status.ts
@@ -294,7 +294,19 @@ export const checkCursorProviderStatus = Effect.fn("checkCursorProviderStatus")(
     yield* Effect.logWarning("Cursor SDK catalog probe failed", {
       cause: catalogResult.failure.cause,
     });
-    const authenticationFailure = catalogResult.failure.authenticationFailure;
+    const failure = catalogResult.failure;
+    let message = "Cursor SDK catalog request failed. Check server logs for details.";
+    if (failure.authenticationFailure) {
+      message =
+        authenticationType === "browser"
+          ? "Cursor sign-in expired or was rejected. Sign in again in provider settings."
+          : "Cursor SDK authentication failed. Check CURSOR_API_KEY.";
+    } else if (failure.planRequired) {
+      message =
+        authenticationType === "browser"
+          ? "Cursor needs a paid plan to run in T3 Code. Upgrade this account or sign in with a different one."
+          : "Cursor needs a paid plan to run in T3 Code. Upgrade the account that owns CURSOR_API_KEY or use a key from a paid account.";
+    }
     return buildServerProvider({
       presentation: CURSOR_PRESENTATION,
       enabled: cursorSettings.enabled,
@@ -304,12 +316,8 @@ export const checkCursorProviderStatus = Effect.fn("checkCursorProviderStatus")(
         installed: true,
         version: null,
         status: "error",
-        auth: { status: authenticationFailure ? "unauthenticated" : "unknown" },
-        message: authenticationFailure
-          ? authenticationType === "browser"
-            ? "Cursor sign-in expired or was rejected. Sign in again in provider settings."
-            : "Cursor SDK authentication failed. Check CURSOR_API_KEY."
-          : "Cursor SDK catalog request failed. Check server logs for details.",
+        auth: { status: failure.authenticationFailure ? "unauthenticated" : "unknown" },
+        message,
       },
     });
   }
diff --git a/packages/provider-grok/src/server/status.ts b/packages/provider-grok/src/server/status.ts
index 825f8080599a6..dfa9163ec3670 100644
--- a/packages/provider-grok/src/server/status.ts
+++ b/packages/provider-grok/src/server/status.ts
@@ -59,7 +59,10 @@ const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({
 });
 
 const VERSION_PROBE_TIMEOUT_MS = 4_000;
-const GROK_ACP_INITIALIZE_TIMEOUT_MS = 8_000;
+// Grok writes the initialize result only after startup work (settings,
+// skill discovery, file watching). From a home directory that work measured
+// 9-14s on CLI 1.0.52, so an 8s cap records a healthy CLI as a failed probe.
+const GROK_ACP_INITIALIZE_TIMEOUT_MS = 20_000;
 const GROK_API_KEY_ENV = "XAI_API_KEY";
 
 const GROK_BUILT_IN_MODELS: ReadonlyArray<ServerProviderModel> = [
@@ -301,6 +304,37 @@ const runGrokCliCommand = Effect.fn("GrokProviderStatus.runGrokCliCommand")(func
   );
 });
 
+const probeGrokModels = Effect.fn("GrokProviderStatus.probeGrokModels")(function* (
+  grokSettings: GrokSettings,
+  environment: NodeJS.ProcessEnv,
+) {
+  const modelsResult = yield* runGrokCliCommand(grokSettings, ["models"], environment).pipe(
+    Effect.timeoutOption(AUTH_PROBE_TIMEOUT_MS),
+    Effect.result,
+  );
+  // Only a clean exit is parsed. Failed invocations print help or error text that
+  // must not be read as model slugs or as a login verdict.
+  const modelsOutput =
+    Result.isSuccess(modelsResult) &&
+    Option.isSome(modelsResult.success) &&
+    modelsResult.success.value.code === 0
+      ? modelsResult.success.value
+      : undefined;
+  const cliModels: GrokModelsCliOutput = modelsOutput
+    ? parseGrokModelsCliOutput(`${modelsOutput.stdout}\n${modelsOutput.stderr}`)
+    : { authenticated: null, models: [] };
+  if (!modelsOutput) {
+    yield* Effect.logWarning("Grok CLI model listing failed or timed out.", {
+      errorTag: Result.isFailure(modelsResult)
+        ? modelsResult.failure._tag
+        : Option.isNone(modelsResult.success)
+          ? "Timeout"
+          : `ExitCode${modelsResult.success.value.code}`,
+    });
+  }
+  return cliModels;
+});
+
 const decodeAvailableCommands = Schema.decodeUnknownOption(Schema.Array(Schema.Unknown));
 const decodeAvailableCommand = Schema.decodeUnknownOption(
   Schema.Struct({
@@ -385,6 +419,7 @@ export const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(func
   }
 
   const probeEnvironment = grokProbeEnvironment(environment);
+  const apiKey = environment[GROK_API_KEY_ENV]?.trim();
 
   const versionResult = yield* runGrokCliCommand(
     grokSettings,
@@ -454,32 +489,17 @@ export const checkGrokProviderStatus = Effect.fn("checkGrokProviderStatus")(func
   }
 
   // `grok models` reports login state and model slugs without starting the agent.
-  const modelsResult = yield* runGrokCliCommand(grokSettings, ["models"], probeEnvironment).pipe(
-    Effect.timeoutOption(AUTH_PROBE_TIMEOUT_MS),
-    Effect.result,
-  );
-  // Only a clean exit is parsed. Failed invocations print help or error text that
-  // must not be read as model slugs or as a login verdict.
-  const modelsOutput =
-    Result.isSuccess(modelsResult) &&
-    Option.isSome(modelsResult.success) &&
-    modelsResult.success.value.code === 0
-      ? modelsResult.success.value
-      : undefined;
-  const cliModels: GrokModelsCliOutput = modelsOutput
-    ? parseGrokModelsCliOutput(`${modelsOutput.stdout}\n${modelsOutput.stderr}`)
-    : { authenticated: null, models: [] };
-  if (!modelsOutput) {
-    yield* Effect.logWarning("Grok CLI model listing failed or timed out.", {
-      errorTag: Result.isFailure(modelsResult)
-        ? modelsResult.failure._tag
-        : Option.isNone(modelsResult.success)
-          ? "Timeout"
-          : `ExitCode${modelsResult.success.value.code}`,
-    });
+  let cliModels = yield* probeGrokModels(grokSettings, probeEnvironment);
+  // An expired access token prints the logged-out line, then the CLI refreshes it in the same
+  // process. Probing again after that process exited tells a refresh from a real logout.
+  if (cliModels.authenticated === false && !apiKey) {
+    const recheck = yield* probeGrokModels(grokSettings, probeEnvironment);
+    if (recheck.authenticated !== null) {
+      cliModels = recheck;
+    }
   }
 
-  const auth: ServerProviderAuth = environment[GROK_API_KEY_ENV]?.trim()
+  const auth: ServerProviderAuth = apiKey
     ? { status: "authenticated", type: "api_key", label: "xAI API key" }
     : cliModels.authenticated === true
       ? { status: "authenticated", type: "cached_token", label: "Grok account" }
diff --git a/packages/provider-opencode/src/server/OpenCodeRuntime.ts b/packages/provider-opencode/src/server/OpenCodeRuntime.ts
index bd17cb81bcb96..8cac4a2c5e0e2 100644
--- a/packages/provider-opencode/src/server/OpenCodeRuntime.ts
+++ b/packages/provider-opencode/src/server/OpenCodeRuntime.ts
@@ -701,6 +701,7 @@ const makeOpenCodeRuntime = Effect.gen(function* () {
       args,
       name: "opencode",
       env: input.environment,
+      shared: true,
     });
     const spawnCommand = yield* resolveCommand(launch.command, launch.args, input.environment);
     const serverPassword = resolveOpenCodeServerPassword({
diff --git a/packages/provider-opencode/src/server/toolItems.ts b/packages/provider-opencode/src/server/toolItems.ts
index c222c223bf892..a0f7e2c6bfe37 100644
--- a/packages/provider-opencode/src/server/toolItems.ts
+++ b/packages/provider-opencode/src/server/toolItems.ts
@@ -1,4 +1,5 @@
 import type { OrchestrationV2TurnItem } from "@t3tools/contracts";
+import { resolveT3McpToolId } from "@t3tools/shared/t3McpToolPresentation";
 import { formatReadToolLabel, formatSearchToolLabel } from "@t3tools/shared/toolActivity";
 
 // Search results stay on the timeline wire, so keep their text a preview.
@@ -12,6 +13,7 @@ type ToolItemBase = Omit<
 export function openCodeToolProjectionKind(
   toolName: string,
 ): "command_execution" | "file_change" | "file_search" | "web_search" | "dynamic_tool" {
+  if (resolveT3McpToolId(toolName) !== null) return "dynamic_tool";
   const normalized = toolName.toLowerCase();
   if (normalized === "todowrite") {
     return "dynamic_tool";
diff --git a/packages/provider-pi/src/server/textGeneration.test.ts b/packages/provider-pi/src/server/textGeneration.test.ts
index 30e178d71c535..99965b8c5dcfd 100644
--- a/packages/provider-pi/src/server/textGeneration.test.ts
+++ b/packages/provider-pi/src/server/textGeneration.test.ts
@@ -14,7 +14,7 @@ import { makePiTextGeneration } from "./textGeneration.ts";
 const decodeJsonLine = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
 const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
 
-const makeFakePi = (reply: string) =>
+const makeFakePi = (reply: string, setModelError?: string) =>
   Effect.gen(function* () {
     const stdout = yield* Queue.unbounded<Uint8Array, Cause.Done>();
     const received: Array<Record<string, unknown>> = [];
@@ -35,6 +35,8 @@ const makeFakePi = (reply: string) =>
             yield* emit({ type: "agent_settled" });
           } else if (record["type"] === "get_last_assistant_text") {
             yield* emit({ ...response, success: true, data: { text: reply } });
+          } else if (record["type"] === "set_model" && setModelError !== undefined) {
+            yield* emit({ ...response, success: false, error: setModelError });
           } else {
             yield* emit({ ...response, success: true });
           }
@@ -83,3 +85,29 @@ it.effect("puts linked source control context in the Pi thread title prompt", ()
     assert.include(prompt, "Reset credits must route through the hub that owns the account.");
   }),
 );
+
+it.effect("names the model and the disabled extensions when Pi cannot load it", () =>
+  Effect.gen(function* () {
+    const pi = yield* makeFakePi("", "Model not found: demo/demo-model");
+    const textGeneration = yield* makePiTextGeneration(
+      { enabled: true, binaryPath: "pi", launchArgs: "", customModels: [] },
+      {},
+    ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, pi.spawner));
+
+    const error = yield* textGeneration
+      .generateCommitMessage({
+        cwd: process.cwd(),
+        branch: "main",
+        stagedSummary: "M README.md",
+        stagedPatch: "diff --git a/README.md b/README.md",
+        modelSelection: createModelSelection(ProviderInstanceId.make("pi"), "demo/demo-model"),
+      })
+      .pipe(Effect.flip);
+
+    assert.equal(error._tag, "TextGenerationError");
+    assert.include(error.detail, "Pi rejected model 'demo/demo-model'");
+    assert.include(error.detail, "Model not found: demo/demo-model");
+    assert.include(error.detail, "--no-extensions");
+    assert.isUndefined(pi.received.find((record) => record["type"] === "prompt"));
+  }),
+);
diff --git a/packages/provider-pi/src/server/textGeneration.ts b/packages/provider-pi/src/server/textGeneration.ts
index 29bf67c3d592b..a0137f3716680 100644
--- a/packages/provider-pi/src/server/textGeneration.ts
+++ b/packages/provider-pi/src/server/textGeneration.ts
@@ -60,11 +60,24 @@ export const makePiTextGeneration = Effect.fn("makePiTextGeneration")(function*
             detail: `Pi model '${modelSelection.model}' must use provider/model format.`,
           });
         }
-        yield* connection.request({
-          type: "set_model",
-          provider: parsed.provider,
-          modelId: parsed.modelId,
-        });
+        yield* connection
+          .request({ type: "set_model", provider: parsed.provider, modelId: parsed.modelId })
+          .pipe(
+            // Model discovery loads extensions that this background helper disables.
+            Effect.mapError((error) =>
+              error._tag === "PiRpcError" && error.operation === "set_model"
+                ? new TextGenerationError({
+                    operation,
+                    detail:
+                      `Pi rejected model '${modelSelection.model}': ${error.detail ?? "unknown error"}. ` +
+                      "If the model comes from a Pi extension or package, text generation cannot use it " +
+                      "because it runs Pi with --no-extensions. Pick a built-in Pi model or one defined " +
+                      "in Pi's models.json.",
+                    cause: error,
+                  })
+                : error,
+            ),
+          );
       }
 
       yield* connection.request({ type: "prompt", message: prompt });
diff --git a/packages/shared/src/nodeSqliteClient.test.ts b/packages/shared/src/nodeSqliteClient.test.ts
index a50fda417eb88..1ad763de4bf36 100644
--- a/packages/shared/src/nodeSqliteClient.test.ts
+++ b/packages/shared/src/nodeSqliteClient.test.ts
@@ -707,6 +707,43 @@ it.effect("lets a read be cancelled while its worker is still starting", () =>
   ),
 );
 
+it.effect.each(["cold", "warm", "stalled"])(
+  "completes an interrupted shutdown finalizer's read with a %s reader",
+  (state) => {
+    const { warnings, layer: logs } = captureWarnings();
+    return withReaderClient((sql) => {
+      const shutdown = Effect.gen(function* () {
+        const read = sql.withTransaction(countEntries(sql)).pipe(SqliteClient.readOnly);
+        if (state === "warm") yield* read;
+        const registered = yield* Deferred.make<void>();
+        const finalizing = yield* Deferred.make<void>();
+        let observed: number | undefined;
+        const fiber = yield* Effect.scoped(
+          Effect.gen(function* () {
+            yield* Effect.addFinalizer(() =>
+              Effect.gen(function* () {
+                yield* Deferred.succeed(finalizing, undefined);
+                observed = yield* read;
+              }).pipe(Effect.orDie),
+            );
+            yield* Deferred.succeed(registered, undefined);
+            return yield* Effect.never;
+          }),
+        ).pipe(Effect.forkChild);
+        yield* Deferred.await(registered);
+        const interrupted = yield* Effect.forkChild(Fiber.interrupt(fiber));
+        yield* Deferred.await(finalizing);
+        if (state === "stalled") yield* TestClock.adjust("10 seconds");
+        yield* Fiber.join(interrupted);
+
+        assert.equal(observed, 1);
+        assert.lengthOf(warnings, state === "stalled" ? 1 : 0);
+      });
+      return state === "stalled" ? silently(shutdown) : shutdown;
+    }).pipe(Effect.provide(logs));
+  },
+);
+
 it.effect("logs one warning when concurrent first reads find the reader unavailable", () => {
   const { warnings, layer: logs } = captureWarnings();
   return withFileClient((sql, filename) =>
diff --git a/packages/shared/src/nodeSqliteClient.ts b/packages/shared/src/nodeSqliteClient.ts
index 7ee8292cb71b2..03283a614ee62 100644
--- a/packages/shared/src/nodeSqliteClient.ts
+++ b/packages/shared/src/nodeSqliteClient.ts
@@ -48,9 +48,11 @@ export interface SqliteClientConfig {
   readonly checkpointWorker?: boolean | undefined;
 }
 
-const ReadOnly = Context.Reference<boolean>("@t3tools/shared/nodeSqliteClient/ReadOnly", {
-  defaultValue: () => false,
-});
+// SqlClient masks transaction acquisition, so readOnly carries the caller's interruption policy.
+const ReadOnly = Context.Reference<typeof Effect.interruptible | undefined>(
+  "@t3tools/shared/nodeSqliteClient/ReadOnly",
+  { defaultValue: () => undefined },
+);
 
 /**
  * Wrap the whole transaction, as in
@@ -59,7 +61,9 @@ const ReadOnly = Context.Reference<boolean>("@t3tools/shared/nodeSqliteClient/Re
  * with "attempt to write a readonly database".
  */
 export const readOnly = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  Effect.provideService(effect, ReadOnly, true);
+  Effect.uninterruptibleMask((restore) =>
+    restore(Effect.provideService(effect, ReadOnly, restore)),
+  );
 
 interface Acquired {
   readonly connection: "writer" | "reader";
@@ -441,15 +445,16 @@ const makeReader = Effect.fnUntraced(function* (options: SqliteClientConfig) {
     } catch (cause) {
       return turnOff(undefined, String(cause));
     }
-    // SqlClient acquires transaction connections uninterruptibly. Waiting for the
-    // worker happens before any lock is taken, so let a cancelled request leave.
     return Effect.flatMap(
-      Effect.interruptible(
-        Effect.timeoutOption(
-          Effect.promise(() => reader.started),
-          startupTimeout,
-        ),
-      ),
+      Effect.withFiber((fiber) => {
+        const restore = Context.get(fiber.context, ReadOnly) ?? identity;
+        return restore(
+          Effect.timeoutOption(
+            Effect.promise(() => reader.started),
+            startupTimeout,
+          ),
+        );
+      }),
       (startup): Effect.Effect<Connection | undefined> =>
         // Another acquire may have timed out and retired this worker while this one
         // waited; a late "ready" must not hand out a worker that is being terminated.
diff --git a/packages/shared/src/orchestrationV2PendingBackgroundWork.ts b/packages/shared/src/orchestrationV2PendingBackgroundWork.ts
index 15453ae01850c..8073bcccd0bb5 100644
--- a/packages/shared/src/orchestrationV2PendingBackgroundWork.ts
+++ b/packages/shared/src/orchestrationV2PendingBackgroundWork.ts
@@ -7,7 +7,9 @@ import type {
   ThreadPullRequestLink,
 } from "@t3tools/contracts";
 import { isOrchestrationV2WorkActive } from "@t3tools/contracts";
+import * as Predicate from "effect/Predicate";
 
+import { resolveT3McpToolId } from "./t3McpToolPresentation.ts";
 import { threadPullRequestKeyOf } from "./threadPullRequests.ts";
 
 const BACKGROUND_TURN_ITEM_TYPES = new Set<OrchestrationV2TurnItem["type"]>([
@@ -16,6 +18,15 @@ const BACKGROUND_TURN_ITEM_TYPES = new Set<OrchestrationV2TurnItem["type"]>([
   "subagent",
 ]);
 
+// Plans and text streams can stay open across tool calls without executing work.
+const EXECUTION_TURN_ITEM_TYPES = new Set<OrchestrationV2TurnItem["type"]>([
+  ...BACKGROUND_TURN_ITEM_TYPES,
+  "file_change",
+  "file_search",
+  "web_search",
+  "compaction",
+]);
+
 const TERMINAL_RUN_STATUSES = new Set<OrchestrationV2Run["status"]>([
   "cancelled",
   "completed",
@@ -48,6 +59,39 @@ export function turnItemUpdateCanEndBackgroundWork(
   return BACKGROUND_TURN_ITEM_TYPES.has(item.type) && !isOrchestrationV2WorkActive(item.status);
 }
 
+export function deriveBlockedOnThreadWait(input: {
+  readonly activeRun: Pick<OrchestrationV2Run, "id" | "status"> | null;
+  readonly turnItems: ReadonlyArray<OrchestrationV2TurnItem>;
+}): boolean {
+  if (input.activeRun?.status !== "running") return false;
+  let hasWait = false;
+  for (const item of input.turnItems) {
+    if (
+      item.runId !== input.activeRun.id ||
+      !EXECUTION_TURN_ITEM_TYPES.has(item.type) ||
+      (item.status !== "running" && item.status !== "waiting") ||
+      // App-owned rows track the child, including the child a blocking delegate is waiting for.
+      (item.type === "subagent" && item.origin === "app_owned")
+    ) {
+      continue;
+    }
+    if (item.type !== "dynamic_tool") return false;
+    const tool = resolveT3McpToolId(item.toolName);
+    if (
+      tool !== "t3_thread_wait" &&
+      !(
+        tool === "delegate_task" &&
+        Predicate.isObject(item.input) &&
+        Reflect.get(item.input, "mode") === "wait"
+      )
+    ) {
+      return false;
+    }
+    hasWait = true;
+  }
+  return hasWait;
+}
+
 export function backgroundWorkHoldsCompletion(
   tasks: ReadonlyArray<Pick<PendingBackgroundWorkTask, "kind">>,
 ): boolean {
diff --git a/packages/shared/src/t3McpToolPresentation.ts b/packages/shared/src/t3McpToolPresentation.ts
index b18351cdd2c49..8541958758db3 100644
--- a/packages/shared/src/t3McpToolPresentation.ts
+++ b/packages/shared/src/t3McpToolPresentation.ts
@@ -106,12 +106,12 @@ const T3_MCP_TOOLS: Readonly<Record<string, T3McpToolDefinition>> = {
     "pull-request",
   ),
   unwatch_pull_request: tool(
-    ["Stop watching", "Stopping watching", "Stopped watching", "a pull request"],
+    ["Stop watching", "Unwatching", "Stopped watching", "a pull request"],
     "unwatch-pr",
     "pull-request",
   ),
   write_pull_request_guides: tool(
-    ["Write", "Writing", "Started", "review guides"],
+    ["Write", "Writing", "Started writing", "review guides"],
     "write-pr-guides",
     "pull-request",
   ),
@@ -127,7 +127,7 @@ const T3_MCP_TOOLS: Readonly<Record<string, T3McpToolDefinition>> = {
   delegate_task: tool(["Delegate", "Delegating", "Delegated", "a child task"], "delegate"),
   task_status: tool(["Get", "Getting", "Got", "delegated task status"], "task-status"),
   task_cancel: tool(
-    ["Cancel", "Canceling", "Requested cancellation of", "delegated task"],
+    ["Cancel", "Canceling", "Requested cancellation of", "a delegated task"],
     "task-cancel",
   ),
   schedule_task: tool(
diff --git a/packages/shared/src/threadPullRequests.test.ts b/packages/shared/src/threadPullRequests.test.ts
index dc97cbfa7dd95..53e4a407449fa 100644
--- a/packages/shared/src/threadPullRequests.test.ts
+++ b/packages/shared/src/threadPullRequests.test.ts
@@ -315,6 +315,63 @@ describe("resolveThreadPullRequestChains", () => {
     });
   });
 
+  it("uses a later complete native snapshot for layer order and the current pull request", () => {
+    const links = [18, 20, 83, 84].map((number) =>
+      link(number, {
+        linkedAt: "2026-01-01T00:00:00.000Z",
+        snapshot: snapshot(),
+        stack: {
+          kind: "native",
+          id: "80",
+          number: 80,
+          url: "https://github.com/pingdotgg/t3code/stacks/80",
+          base: "main",
+          layers: (number < 83
+            ? [79, 37, 38, 39, 76, 18, 20]
+            : [79, 37, 38, 39, 76, 18, 20, 83, 84]
+          ).map((number) => ({ number, headBranch: `pr-${number}`, state: "open" })),
+        },
+      }),
+    );
+    expect
+      .soft(
+        resolveThreadPullRequestChains(links).map((chain) =>
+          chain.layers.map((layer) => layer.number),
+        ),
+      )
+      .toEqual([[18, 20, 83, 84]]);
+    expect(resolveThreadCurrentPullRequest(links)).toMatchObject({
+      kind: "stack",
+      top: { number: 84 },
+      open: [{ number: 84 }, { number: 83 }, { number: 20 }, { number: 18 }],
+    });
+  });
+
+  it("uses the earliest longest partial snapshot and appends missing members in stored order", () => {
+    const links = [
+      [3, 2],
+      [9, 2, 3],
+      [9, 3, 2],
+      [9, 3, 2],
+    ].map((numbers, index) =>
+      link(index + 1, {
+        stack: {
+          kind: "native",
+          id: "s1",
+          number: 1,
+          url: "https://github.com/pingdotgg/t3code/stacks/1",
+          base: "main",
+          layers: numbers.map((number) => ({ number, headBranch: `pr-${number}`, state: "open" })),
+        },
+      }),
+    );
+    expect(
+      resolveThreadPullRequestChains(links).map((chain) =>
+        chain.layers.map((layer) => layer.number),
+      ),
+    ).toEqual([[2, 3, 1, 4]]);
+  });
+
   it("uses the native stack order when the host provides one", () => {
     const stack = {
       kind: "native" as const,
diff --git a/packages/shared/src/threadPullRequests.ts b/packages/shared/src/threadPullRequests.ts
index 4e593fa358fc9..cfda147bba701 100644
--- a/packages/shared/src/threadPullRequests.ts
+++ b/packages/shared/src/threadPullRequests.ts
@@ -230,8 +230,26 @@ export function resolveThreadPullRequestChains(
     nativeStacks.set(stackKey, members);
   }
   for (const members of nativeStacks.values()) {
-    const order = new Map(members[0]!.stack!.layers.map((layer, index) => [layer.number, index]));
-    members.sort((left, right) => (order.get(left.number) ?? 0) - (order.get(right.number) ?? 0));
+    // Saved snapshots can lag behind newer members of the same stack.
+    const memberNumbers = new Set(members.map((member) => member.number));
+    let layers = members[0]!.stack!.layers;
+    let coverage = layers.filter((layer) => memberNumbers.has(layer.number)).length;
+    for (const member of members.slice(1)) {
+      const candidate = member.stack!.layers;
+      const candidateCoverage = candidate.filter((layer) => memberNumbers.has(layer.number)).length;
+      if (
+        candidateCoverage > coverage ||
+        (candidateCoverage === coverage && candidate.length > layers.length)
+      ) {
+        layers = candidate;
+        coverage = candidateCoverage;
+      }
+    }
+    const order = new Map(layers.map((layer, index) => [layer.number, index]));
+    members.sort(
+      (left, right) =>
+        (order.get(left.number) ?? layers.length) - (order.get(right.number) ?? layers.length),
+    );
     for (const member of members) placed.add(threadPullRequestKeyOf(member));
     chains.push({ kind: "native", layers: members, depths: members.map((_, index) => index) });
   }
diff --git a/packages/ssh/src/command.test.ts b/packages/ssh/src/command.test.ts
index 28efc3c9487a6..d47af297fe5ba 100644
--- a/packages/ssh/src/command.test.ts
+++ b/packages/ssh/src/command.test.ts
@@ -187,6 +187,54 @@ describe("ssh command", () => {
     }).pipe(Effect.provide(layerProcess));
   });
 
+  it.live.each([
+    { name: "default head", keepErrorOutputTail: undefined, exitCode: 1, stderr: "" },
+    {
+      name: "opt-in tail",
+      keepErrorOutputTail: true,
+      exitCode: 1,
+      stderr: "stderr failure ".repeat(400),
+    },
+    { name: "successful output", keepErrorOutputTail: true, exitCode: 0, stderr: "" },
+  ])("preserves process output: $name", ({ keepErrorOutputTail, exitCode, stderr }) =>
+    Effect.gen(function* () {
+      const prefix = `HEAD\n${"verbose-prefix ".repeat(400)}`;
+      const secret = "synthetic-secret".repeat(400);
+      const diagnostic = "\nPANIC: emulator SDK is broken\n";
+      const stdout = `${prefix}{"credential":"${secret}"}${diagnostic}`;
+      const nativeSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+      // Replace only the SSH endpoint with a real, deterministic process.
+      const spawner = ChildProcessSpawner.make(() =>
+        nativeSpawner.spawn(
+          ChildProcess.make(process.execPath, [
+            "-e",
+            `process.stdout.write(${JSON.stringify(stdout)}); process.stderr.write(${JSON.stringify(stderr)}); process.exitCode = ${exitCode};`,
+          ]),
+        ),
+      );
+      const command = runSshCommand(
+        { alias: "synthetic-fixture", hostname: "synthetic-fixture", username: null, port: null },
+        keepErrorOutputTail === undefined ? {} : { keepErrorOutputTail },
+      ).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+      if (exitCode === 0) {
+        assert.deepEqual(yield* command, { stdout, stderr });
+        return;
+      }
+      const failure = yield* Effect.flip(command);
+      assert.instanceOf(failure, SshCommandError);
+      assert.equal(failure.exitCode, 1);
+      assert.equal(failure.stderr, stderr);
+      assert.equal(failure.message, stderr.trim() || failure.stdout?.trim());
+      const redacted = `${prefix}{"credential":"[redacted]"}${diagnostic}`;
+      assert.equal(
+        failure.stdout,
+        keepErrorOutputTail
+          ? `[truncated]\n${redacted.slice(-4_000)}`
+          : `${redacted.slice(0, 4_000)}\n[truncated]`,
+      );
+    }).pipe(Effect.provide(NodeServices.layer)),
+  );
+
   it.effect("redacts credentials from stdout in non-zero command failures", () => {
     const spawner = ChildProcessSpawner.make(() =>
       Effect.succeed(makeFailedProcess({ stdout: '{"credential":"pairing-secret"}\n' })),
diff --git a/packages/ssh/src/command.ts b/packages/ssh/src/command.ts
index 3b62676ecec60..1b295bf68546a 100644
--- a/packages/ssh/src/command.ts
+++ b/packages/ssh/src/command.ts
@@ -39,6 +39,8 @@ export interface RunSshCommandOptions extends SshAuthOptions {
   readonly remoteCommandArgs?: ReadonlyArray<string>;
   readonly stdin?: string;
   readonly timeoutMs?: number;
+  /** Keep the end of long failed-command stdout, where the final cause usually is. */
+  readonly keepErrorOutputTail?: boolean;
 }
 
 export function parseSshResolveOutput(alias: string, stdout: string): DesktopSshEnvironmentTarget {
@@ -133,14 +135,15 @@ const collectProcessOutput = <E>(stream: Stream.Stream<Uint8Array, E>): Effect.E
     ),
   );
 
-function redactSshErrorOutput(output: string): string {
+function redactSshErrorOutput(output: string, keepTail = false): string {
   const redacted = output.replace(
     /("(?:access_token|bearerToken|credential|pairingToken|token)"\s*:\s*")[^"]+(")/giu,
     "$1[redacted]$2",
   );
-  return redacted.length > MAX_SSH_ERROR_OUTPUT_LENGTH
-    ? `${redacted.slice(0, MAX_SSH_ERROR_OUTPUT_LENGTH)}\n[truncated]`
-    : redacted;
+  if (redacted.length <= MAX_SSH_ERROR_OUTPUT_LENGTH) return redacted;
+  return keepTail
+    ? `[truncated]\n${redacted.slice(-MAX_SSH_ERROR_OUTPUT_LENGTH)}`
+    : `${redacted.slice(0, MAX_SSH_ERROR_OUTPUT_LENGTH)}\n[truncated]`;
 }
 
 function normalizeSshErrorMessage(input: {
@@ -262,7 +265,7 @@ const runSshCommandInScope = Effect.fn("ssh/command.runSshCommand.inScope")(func
   );
 
   if (exitCode !== 0) {
-    const diagnosticStdout = redactSshErrorOutput(stdout);
+    const diagnosticStdout = redactSshErrorOutput(stdout, input.keepErrorOutputTail);
     yield* Effect.logWarning("ssh.command.failed", {
       ...sshTargetLogFields(target),
       command: ["ssh", ...args],
diff --git a/packages/ssh/src/tunnel.ts b/packages/ssh/src/tunnel.ts
index c7be29a9dedb2..069a522f17519 100644
--- a/packages/ssh/src/tunnel.ts
+++ b/packages/ssh/src/tunnel.ts
@@ -1429,7 +1429,7 @@ const makeSshEnvironmentManager = Effect.fn("ssh/tunnel.SshEnvironmentManager.ma
       attempt,
       destination: target.alias.trim() || target.hostname.trim(),
       username: target.username,
-      prompt: `Enter the SSH password for ${hostSpec}.`,
+      prompt: `Enter the SSH password or verification code for ${hostSpec}.`,
     });
     if (password === null) {
       yield* Effect.logWarning("ssh.auth.passwordPrompt.cancelled", {
diff --git a/patches/@legendapp__list@3.3.5.patch b/patches/@legendapp__list@3.3.5.patch
index 36474d27a0c64..499e3466f27fa 100644
--- a/patches/@legendapp__list@3.3.5.patch
+++ b/patches/@legendapp__list@3.3.5.patch
@@ -1619,7 +1619,7 @@ index 95465f2..ddfc467 100644
    useValueListener$("scrollAdjustUserOffset", callback);
    return null;
 diff --git a/react.js b/react.js
-index 914d2da..0c2917d 100644
+index 914d2da..86dbd9a 100644
 --- a/react.js
 +++ b/react.js
 @@ -4702,7 +4702,8 @@ function maybeUpdateAnchoredEndSpace(ctx) {
@@ -1645,7 +1645,17 @@ index 914d2da..0c2917d 100644
    }
    return nextSize;
  }
-@@ -5651,6 +5658,18 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
+@@ -4956,7 +4963,8 @@ function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
+     const itemKey = peek$(ctx, `containerItemKey${containerId}`);
+     const element = viewRef == null ? void 0 : viewRef.current;
+     if (itemKey !== void 0 && element) {
+-      const rect = element.getBoundingClientRect();
++      // Unlike getBoundingClientRect, offset sizes ignore ancestor transforms (e.g. a popup's zoom-in), like ResizeObserver.
++      const rect = { height: element.offsetHeight, width: element.offsetWidth };
+       setContainerLayoutBaseline(element, rect);
+       measurements.push({
+         containerId,
+@@ -5651,6 +5659,18 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
  });
  
  // src/utils/reordering.ts
@@ -1664,7 +1674,7 @@ index 914d2da..0c2917d 100644
  function sortDOMElements(container, indexByElement) {
    const elements = Array.from(container.children);
    if (elements.length <= 1) return elements;
-@@ -5690,9 +5709,9 @@ function sortDOMElements(container, indexByElement) {
+@@ -5690,9 +5710,9 @@ function sortDOMElements(container, indexByElement) {
          }
        }
        if (nextStableElement) {
@@ -1676,7 +1686,7 @@ index 914d2da..0c2917d 100644
        }
      }
    }
-@@ -6446,8 +6465,8 @@ function ScrollAdjust() {
+@@ -6446,8 +6466,8 @@ function ScrollAdjust() {
                window.getComputedStyle(contentNode)[axis.paddingEndProp]
              );
              const temporaryPaddingEnd = `${(currentPaddingEnd || 0) + pad}px`;
@@ -1687,7 +1697,7 @@ index 914d2da..0c2917d 100644
              scrollBy();
              if (resetPaddingRafRef.current !== void 0) {
 diff --git a/react.mjs b/react.mjs
-index 95465f2..b73bfdf 100644
+index 95465f2..cff49dc 100644
 --- a/react.mjs
 +++ b/react.mjs
 @@ -4681,7 +4681,8 @@ function maybeUpdateAnchoredEndSpace(ctx) {
@@ -1713,7 +1723,17 @@ index 95465f2..b73bfdf 100644
    }
    return nextSize;
  }
-@@ -5630,6 +5637,18 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
+@@ -4935,7 +4942,8 @@ function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
+     const itemKey = peek$(ctx, `containerItemKey${containerId}`);
+     const element = viewRef == null ? void 0 : viewRef.current;
+     if (itemKey !== void 0 && element) {
+-      const rect = element.getBoundingClientRect();
++      // Unlike getBoundingClientRect, offset sizes ignore ancestor transforms (e.g. a popup's zoom-in), like ResizeObserver.
++      const rect = { height: element.offsetHeight, width: element.offsetWidth };
+       setContainerLayoutBaseline(element, rect);
+       measurements.push({
+         containerId,
+@@ -5630,6 +5638,18 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
  });
  
  // src/utils/reordering.ts
@@ -1732,7 +1752,7 @@ index 95465f2..b73bfdf 100644
  function sortDOMElements(container, indexByElement) {
    const elements = Array.from(container.children);
    if (elements.length <= 1) return elements;
-@@ -5669,9 +5688,9 @@ function sortDOMElements(container, indexByElement) {
+@@ -5669,9 +5689,9 @@ function sortDOMElements(container, indexByElement) {
          }
        }
        if (nextStableElement) {
@@ -1744,7 +1764,7 @@ index 95465f2..b73bfdf 100644
        }
      }
    }
-@@ -6425,8 +6444,8 @@ function ScrollAdjust() {
+@@ -6425,8 +6445,8 @@ function ScrollAdjust() {
                window.getComputedStyle(contentNode)[axis.paddingEndProp]
              );
              const temporaryPaddingEnd = `${(currentPaddingEnd || 0) + pad}px`;
diff --git a/patches/expo-sharing@58.0.19.patch b/patches/expo-sharing@58.0.19.patch
index d4aa7c4bf4bb0..a5ce4559f52cc 100644
--- a/patches/expo-sharing@58.0.19.patch
+++ b/patches/expo-sharing@58.0.19.patch
@@ -108,6 +108,72 @@ index 74544e0..92bd2f5 100644
  };
  export type BaseResolvedSharePayload = SharePayload & {
      /**
+diff --git a/plugin/build/ios/xcode/addPbxGroup.js b/plugin/build/ios/xcode/addPbxGroup.js
+index 0867938bdc6df7aeba560cb84dc9c9156c842d95..6ff5be15de702c79cc932def1af68e4c801db48e 100644
+--- a/plugin/build/ios/xcode/addPbxGroup.js
++++ b/plugin/build/ios/xcode/addPbxGroup.js
+@@ -29,9 +29,23 @@ function addPbxGroup(xcodeProject, targetName, shareExtensionFiles, platformProj
+     }).flat();
+     // Add generated files
+     targetFiles.push(`${targetName}.entitlements`);
+-    targetFiles.push(`Info.plist`);
+     const sharedFiles = Object.values(shareExtensionFiles.sharedFiles ?? []).flat().map((file)=>_path().default.join(sharedFilesPath, file)).map((file)=>_path().default.relative(_path().default.join(platformProjectRoot, targetName, 'shared'), file));
+-    const { uuid: mainGroupUuid } = xcodeProject.addPbxGroup(targetFiles, targetName, targetName);
++    const { uuid: mainGroupUuid, pbxGroup: mainGroup } = xcodeProject.addPbxGroup(targetFiles, targetName, targetName);
++    // Xcode 27.2 rejects file references shared between groups. Bypass
++    // addPbxGroup's path deduplication so the widget keeps its own Info.plist.
++    const infoPlistReference = xcodeProject.generateUuid();
++    const fileReferences = xcodeProject.pbxFileReferenceSection();
++    fileReferences[infoPlistReference] = {
++        isa: 'PBXFileReference',
++        lastKnownFileType: 'text.plist.xml',
++        path: 'Info.plist',
++        sourceTree: '"<group>"'
++    };
++    fileReferences[`${infoPlistReference}_comment`] = 'Info.plist';
++    mainGroup.children.push({
++        value: infoPlistReference,
++        comment: 'Info.plist'
++    });
+     const { uuid: sharedGroupUuid } = xcodeProject.addPbxGroup(sharedFiles, 'shared', 'shared');
+     if (mainGroupUuid && sharedGroupUuid) {
+         // @ts-expect-error: TODO(@kitten): This used to be untyped, and is failing now
+diff --git a/plugin/src/ios/xcode/addPbxGroup.ts b/plugin/src/ios/xcode/addPbxGroup.ts
+index 943c263c0cf58be595bfc9745c91827da81befec..3a99a1822beb25fea3835123b9a4ad7ac3b4f8d5 100644
+--- a/plugin/src/ios/xcode/addPbxGroup.ts
++++ b/plugin/src/ios/xcode/addPbxGroup.ts
+@@ -19,14 +19,29 @@ export function addPbxGroup(
+ 
+   // Add generated files
+   targetFiles.push(`${targetName}.entitlements`);
+-  targetFiles.push(`Info.plist`);
+ 
+   const sharedFiles = Object.values(shareExtensionFiles.sharedFiles ?? [])
+     .flat()
+     .map((file) => path.join(sharedFilesPath, file))
+     .map((file) => path.relative(path.join(platformProjectRoot, targetName, 'shared'), file));
+ 
+-  const { uuid: mainGroupUuid } = xcodeProject.addPbxGroup(targetFiles, targetName, targetName);
++  const { uuid: mainGroupUuid, pbxGroup: mainGroup } = xcodeProject.addPbxGroup(
++    targetFiles,
++    targetName,
++    targetName
++  );
++  // Xcode 27.2 rejects file references shared between groups. Bypass
++  // addPbxGroup's path deduplication so the widget keeps its own Info.plist.
++  const infoPlistReference = xcodeProject.generateUuid();
++  const fileReferences = xcodeProject.pbxFileReferenceSection();
++  fileReferences[infoPlistReference] = {
++    isa: 'PBXFileReference',
++    lastKnownFileType: 'text.plist.xml',
++    path: 'Info.plist',
++    sourceTree: '"<group>"',
++  };
++  fileReferences[`${infoPlistReference}_comment`] = 'Info.plist';
++  mainGroup.children.push({ value: infoPlistReference, comment: 'Info.plist' });
+   const { uuid: sharedGroupUuid } = xcodeProject.addPbxGroup(sharedFiles, 'shared', 'shared');
+ 
+   if (mainGroupUuid && sharedGroupUuid) {
 diff --git a/src/Sharing.types.ts b/src/Sharing.types.ts
 index 18af320..3a52b70 100644
 --- a/src/Sharing.types.ts
diff --git a/patches/react-native-image-viewing@0.2.2.patch b/patches/react-native-image-viewing@0.2.2.patch
index 6e2b719704e17..f85cb5fea135b 100644
--- a/patches/react-native-image-viewing@0.2.2.patch
+++ b/patches/react-native-image-viewing@0.2.2.patch
@@ -89,12 +89,16 @@ index 5fcaa9f9a7d893817fee89b85186ee3936118e69..3effe838fa54495d165b81cc7501e72d
      const imageContainer = useRef(null);
      const imageDimensions = useImageDimensions(imageSrc);
      const [translate, scale] = getImageTransform(imageDimensions, SCREEN);
-@@ -31,7 +31,7 @@ const ImageItem = ({ imageSrc, onZoom, onRequestClose, onLongPress, delayLongPre
-                 scrollEnabled: !isZoomed,
+@@ -28,10 +28,10 @@ const ImageItem = ({ imageSrc, onZoom, onRequestClose, onLongPress, delayLongPre
+         onZoom(isZoomed);
+         if ((_a = imageContainer) === null || _a === void 0 ? void 0 : _a.current) {
+             imageContainer.current.setNativeProps({
+-                scrollEnabled: !isZoomed,
++                scrollEnabled: swipeToCloseEnabled && !isZoomed,
              });
          }
 -    }, [imageContainer]);
-+    }, [imageContainer, onZoom]);
++    }, [imageContainer, onZoom, swipeToCloseEnabled]);
      const onLongPressHandler = useCallback(() => {
          onLongPress(imageSrc);
      }, [imageSrc, onLongPress]);
@@ -272,3 +276,13 @@ index 99dcbc7efea4eba86a8bc2bad71dde73c8ebf1b4..3a374c0923879548ec3826a78be16f79
      let numberInitialTouches = 1;
      let initialTouches = [];
      let currentScale = initialScale;
+@@ -266,6 +266,9 @@ const usePanResponder = ({ initialScale, initialTranslate, onZoom, doubleTapToZo
+                 tmpTranslate = null;
+             }
+         },
++        // A gesture taken over mid-pinch must commit like a release, or pans stay
++        // gated on the pre-pinch scale while the image still shows zoomed.
++        onTerminate: () => handlers.onRelease(),
+     };
+     const panResponder = useMemo(() => createPanResponder(handlers), [handlers]);
+     return [panResponder.panHandlers, scaleValue, translateValue];
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 427fb33de38c7..d05277f7c17d2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,6 +6,9 @@ settings:
 
 catalogs:
   default:
+    '@distilled.cloud/cloudflare':
+      specifier: 1.0.0-rc.13
+      version: 1.0.0-rc.13
     '@effect/graphql-generator':
       specifier: 4.0.5
       version: 4.0.5
@@ -169,7 +172,7 @@ patchedDependencies:
   '@expo/metro-config@58.0.14': 90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760
   '@expo/ui@58.0.20': 5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e
   '@ff-labs/fff-node@0.11.0': cc71fcec015f4d39bc96ae2e2bf6b0ca678124c722c66a7841efce9d34b5983c
-  '@legendapp/list@3.3.5': 50016a0e88f22b96cd8a947ac875700163b4aa05595981075f6049ed573bc6f8
+  '@legendapp/list@3.3.5': f42a6bbed14ee061220f2fac9f74eb1cae201e16c9a759626e4cce61eed501f3
   '@pierre/diffs@1.5.2': 2ec81ba1e8ce4681095a3473c2bf78e630417740c622720ef624febb467c25fc
   '@react-native-ai/apple@0.12.0': 2d09870c2848d185cb05b53ed823a46e12dba519324d8dd8e584e28731990f9d
   '@react-native-menu/menu@2.0.0': a4866ecfcd44f318043de839d20110c17e14909004900f002ffe12050376f2ba
@@ -179,14 +182,14 @@ patchedDependencies:
   expo-audio@58.0.9: 2c2f8c73a23d48804c8b537b8cd73c25eb331aa47d82eaa481c6766cb81e5add
   expo-modules-core@58.0.22: f0b0fd100550ed76e5c25b4d13eb7c9ff62825f8f197c53edf7bf447c50c9fb7
   expo-network@58.0.3: cd09b6d1744dde4efa081b5619ebcff38877d98f7502a51cab121629dece8237
-  expo-sharing@58.0.19: ad248759641ddd71b8331c09dbb3b18c8a551785f2df507533805babd3c0c124
+  expo-sharing@58.0.19: 61a9741dc6166fdbb5baa2e489275a65dd21aa11d2c915f490a1b337a4468e76
   expo-widgets@58.0.20: 8623cb034b720c5ef2da8012c765805a7298909bd92eaf8381f64dbde41b77dd
   mdast-util-math@3.0.0: afe6b2c89e1eaddfd3c90cf2723f12c9a17d513e65beff51653781486013251c
   micromark-extension-gfm-table@2.1.1: 9ad23a530e45d9f83cba1da8654fe16d5af8b59d5c73d5c7a7c91fd25b9be1d8
   micromark-extension-llm-math@3.1.0: 49ab4815c18b003f6af998dcc6c258c17a21b50b2cc87745f12d4bd8b6d591f9
   node-pty@1.2.0-beta.15: f1e680afec85f650699ea756f91f469844ec4c976f4f168492a45c6b3f67d651
   react-native-gesture-handler@3.3.0: abe20e1d1c23549297cbbc818e14fe479b41455930d9663135d6b40fe359b626
-  react-native-image-viewing@0.2.2: a479085493f2404ecdefea18f46c6be3ad49cfb54da8e78dc7746651263cb5a0
+  react-native-image-viewing@0.2.2: 419f35ee91eac88ced9438058281db5eb09d9c799d8974c1172926068c9448cf
   react-native-keyboard-controller@1.22.7: f28d08f1233e3cce8b9324b4357d2b10f1ee040b8051bc87235b0fb95069b9bb
   react-native-pdf-jsi@5.0.0: 6f52854210f61bef499850ebd498229a111bc34ec5b2a4925e644f2f48f42760
   react-native-webview@14.0.1: 81caa279ec3dc1f81209062133b66e8f824e13f106cca57f1fa732a72c2ab378
@@ -349,7 +352,7 @@ importers:
         version: 58.0.20(patch_hash=5a26480373850c1a7943919aa21f904151b335a0cb01042109e0746def37923e)(@babel/core@7.29.7)(expo@58.0.14)(react-dom@19.3.0(react@19.3.0))(react-native-worklets@0.13.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
       '@legendapp/list':
         specifier: 'catalog:'
-        version: 3.3.5(patch_hash=50016a0e88f22b96cd8a947ac875700163b4aa05595981075f6049ed573bc6f8)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
+        version: 3.3.5(patch_hash=f42a6bbed14ee061220f2fac9f74eb1cae201e16c9a759626e4cce61eed501f3)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
       '@material/material-color-utilities':
         specifier: 0.3.0
         version: 0.3.0
@@ -529,7 +532,7 @@ importers:
         version: 58.0.4(expo@58.0.14)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))
       expo-sharing:
         specifier: 58.0.19
-        version: 58.0.19(patch_hash=ad248759641ddd71b8331c09dbb3b18c8a551785f2df507533805babd3c0c124)(expo@58.0.14)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)(typescript@7.0.2)
+        version: 58.0.19(patch_hash=61a9741dc6166fdbb5baa2e489275a65dd21aa11d2c915f490a1b337a4468e76)(expo@58.0.14)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)(typescript@7.0.2)
       expo-splash-screen:
         specifier: ~58.0.10
         version: 58.0.10(expo@58.0.14)(typescript@7.0.2)
@@ -571,7 +574,7 @@ importers:
         version: 3.3.0(patch_hash=abe20e1d1c23549297cbbc818e14fe479b41455930d9663135d6b40fe359b626)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
       react-native-image-viewing:
         specifier: ^0.2.2
-        version: 0.2.2(patch_hash=a479085493f2404ecdefea18f46c6be3ad49cfb54da8e78dc7746651263cb5a0)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
+        version: 0.2.2(patch_hash=419f35ee91eac88ced9438058281db5eb09d9c799d8974c1172926068c9448cf)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
       react-native-keyboard-controller:
         specifier: 1.22.7
         version: 1.22.7(patch_hash=f28d08f1233e3cce8b9324b4357d2b10f1ee040b8051bc87235b0fb95069b9bb)(react-native-reanimated@4.7.1(react-native-worklets@0.13.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
@@ -840,7 +843,7 @@ importers:
         version: 0.9.0
       '@legendapp/list':
         specifier: 'catalog:'
-        version: 3.3.5(patch_hash=50016a0e88f22b96cd8a947ac875700163b4aa05595981075f6049ed573bc6f8)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
+        version: 3.3.5(patch_hash=f42a6bbed14ee061220f2fac9f74eb1cae201e16c9a759626e4cce61eed501f3)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)
       '@noble/hashes':
         specifier: 'catalog:'
         version: 1.8.0
@@ -904,6 +907,9 @@ importers:
       '@tiptap/extension-horizontal-rule':
         specifier: ^3.31.3
         version: 3.31.3(@tiptap/core@3.31.3(@tiptap/pm@3.31.3))(@tiptap/pm@3.31.3)
+      '@tiptap/extension-italic':
+        specifier: ^3.31.3
+        version: 3.31.3(@tiptap/core@3.31.3(@tiptap/pm@3.31.3))
       '@tiptap/extension-list':
         specifier: ^3.31.3
         version: 3.31.3(@tiptap/core@3.31.3(@tiptap/pm@3.31.3))(@tiptap/pm@3.31.3)
@@ -1064,6 +1070,9 @@ importers:
       '@clerk/backend':
         specifier: 3.25.0
         version: 3.25.0(react-dom@19.3.0(react@19.3.0))(react@19.3.0)
+      '@distilled.cloud/cloudflare':
+        specifier: 'catalog:'
+        version: 1.0.0-rc.13(effect@4.0.5)
       '@effect/sql-pg':
         specifier: 4.0.5
         version: 4.0.5(effect@4.0.5)
@@ -15371,7 +15380,7 @@ snapshots:
     dependencies:
       jsbi: 4.3.2
 
-  '@legendapp/list@3.3.5(patch_hash=50016a0e88f22b96cd8a947ac875700163b4aa05595981075f6049ed573bc6f8)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)':
+  '@legendapp/list@3.3.5(patch_hash=f42a6bbed14ee061220f2fac9f74eb1cae201e16c9a759626e4cce61eed501f3)(react-dom@19.3.0(react@19.3.0))(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)':
     dependencies:
       react: 19.3.0
       use-sync-external-store: 1.6.0(react@19.3.0)
@@ -19828,7 +19837,7 @@ snapshots:
 
   expo-server@58.0.5: {}
 
-  expo-sharing@58.0.19(patch_hash=ad248759641ddd71b8331c09dbb3b18c8a551785f2df507533805babd3c0c124)(expo@58.0.14)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)(typescript@7.0.2):
+  expo-sharing@58.0.19(patch_hash=61a9741dc6166fdbb5baa2e489275a65dd21aa11d2c915f490a1b337a4468e76)(expo@58.0.14)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0)(typescript@7.0.2):
     dependencies:
       '@expo/config-plugins': 58.0.9(typescript@7.0.2)
       '@expo/config-types': 58.0.3
@@ -22595,7 +22604,7 @@ snapshots:
       react: 19.3.0
       react-native: 0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6)
 
-  react-native-image-viewing@0.2.2(patch_hash=a479085493f2404ecdefea18f46c6be3ad49cfb54da8e78dc7746651263cb5a0)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0):
+  react-native-image-viewing@0.2.2(patch_hash=419f35ee91eac88ced9438058281db5eb09d9c799d8974c1172926068c9448cf)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6))(react@19.3.0):
     dependencies:
       react: 19.3.0
       react-native: 0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7)(bufferutil@4.1.0)(utf-8-validate@6.0.6))(@types/react@19.3.0)(bufferutil@4.1.0)(react@19.3.0)(utf-8-validate@6.0.6)
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index ac0a089fb9504..12ec4bc1b6e1c 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -34,6 +34,9 @@ catalog:
   "@clerk/expo": 4.13.0
   "@clerk/react": 6.17.8
   "@clerk/shared": 4.40.0
+  # Must match the version alchemy depends on: the relay overrides its
+  # Cloudflare retry policy through this package's Retry service.
+  "@distilled.cloud/cloudflare": 1.0.0-rc.13
   "@effect/atom-react": 4.0.5
   "@effect/graphql-generator": 4.0.5
   "@effect/openapi-generator": 4.0.5