diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index ee12b02b4d47..f7d0c106593e 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1348,6 +1348,24 @@ jobs:
             args:
               - --filter=@t3tools/scripts...
 
+      - name: Read published release notes
+        if: needs.preflight.outputs.is_prerelease == 'true'
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          RELEASE_TAG: ${{ needs.preflight.outputs.tag }}
+          RELEASE_CHANNEL: ${{ needs.preflight.outputs.release_channel }}
+        run: |
+          if [ "$RELEASE_CHANNEL" = 'nightly' ]; then
+            if ! gh release view "$RELEASE_TAG" --json body --jq '.body // ""' > "$RUNNER_TEMP/discord-release-notes.md"; then
+              : > "$RUNNER_TEMP/discord-release-notes.md"
+              echo '::warning::Could not read published release notes; announcing without a changelog.'
+            fi
+          else
+            : > "$RUNNER_TEMP/discord-release-notes.md"
+          fi
+
       - name: Announce prerelease on Discord
         if: needs.preflight.outputs.is_prerelease == 'true'
         continue-on-error: true
@@ -1360,7 +1378,8 @@ jobs:
             --release-name "${{ needs.preflight.outputs.release_name }}" \
             --release-version "${{ needs.preflight.outputs.version }}" \
             --tag "${{ needs.preflight.outputs.tag }}" \
-            --release-url "https://github.com/${{ github.repository }}/releases/tag/${{ needs.preflight.outputs.tag }}"
+            --release-url "https://github.com/${{ github.repository }}/releases/tag/${{ needs.preflight.outputs.tag }}" \
+            --release-notes-file "$RUNNER_TEMP/discord-release-notes.md"
 
       - name: Announce latest release on Discord
         if: needs.preflight.outputs.make_latest == 'true'
diff --git a/apps/desktop/src/app/DesktopApp.ts b/apps/desktop/src/app/DesktopApp.ts
index 365363881f5b..d98f61d6fc00 100644
--- a/apps/desktop/src/app/DesktopApp.ts
+++ b/apps/desktop/src/app/DesktopApp.ts
@@ -19,6 +19,7 @@ import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
 import * as DesktopWindow from "../window/DesktopWindow.ts";
 import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+import * as DesktopLegacyLocalStorage from "./DesktopLegacyLocalStorage.ts";
 import * as DesktopLifecycle from "./DesktopLifecycle.ts";
 import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts";
 import * as DesktopObservability from "./DesktopObservability.ts";
@@ -179,6 +180,10 @@ const bootstrap = Effect.gen(function* () {
   });
   yield* installDesktopIpcHandlers();
   yield* logBootstrapInfo("bootstrap ipc handlers registered");
+  // Before any window: the preload merges these items before the app reads storage.
+  yield* (yield* DesktopLegacyLocalStorage.DesktopLegacyLocalStorage).load(
+    yield* (yield* DesktopAppIdentity.DesktopAppIdentity).resolveUserDataPath,
+  );
 
   yield* snapShot.initialize;
 
diff --git a/apps/desktop/src/app/DesktopLegacyLocalStorage.ts b/apps/desktop/src/app/DesktopLegacyLocalStorage.ts
new file mode 100644
index 000000000000..b29cfb3b7c63
--- /dev/null
+++ b/apps/desktop/src/app/DesktopLegacyLocalStorage.ts
@@ -0,0 +1,117 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+
+import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
+import { readChromiumLocalStorage } from "./chromiumLocalStorage.ts";
+import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+
+/**
+ * Carries the renderer's localStorage (prompt stash, unsent drafts, layout,
+ * theme) over from the V1 desktop profile, which V2 replaced with its own
+ * `t3code-v2` profile. The V1 profile is only read, never opened by Chromium,
+ * so this works while V1 is still running.
+ *
+ * `load` runs before the window opens; the preload takes the items once,
+ * merges them into the new profile, and calls `complete`, which writes a
+ * marker so later launches skip the read. A failed read or merge, or a window
+ * that never completes, leaves no marker and retries next launch.
+ */
+export class DesktopLegacyLocalStorage extends Context.Service<
+  DesktopLegacyLocalStorage,
+  {
+    readonly load: (userDataPath: string) => Effect.Effect<void>;
+    readonly take: Effect.Effect<Option.Option<Readonly<Record<string, string>>>>;
+    readonly complete: Effect.Effect<void>;
+  }
+>()("@t3tools/desktop/app/DesktopLegacyLocalStorage") {}
+
+const MARKER_FILE_NAME = "v1-local-storage-imported";
+// V1 used "T3 Code (Alpha)" when that folder existed and "t3code" otherwise.
+const V1_PROFILE_NAMES = ["T3 Code (Alpha)", "t3code"];
+
+const make = Effect.gen(function* () {
+  const environment = yield* DesktopEnvironment.DesktopEnvironment;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const items = yield* Ref.make(Option.none<Readonly<Record<string, string>>>());
+  const markerPath = yield* Ref.make(Option.none<string>());
+
+  /** Newest file mtime in a directory; appending to a log leaves the directory's own mtime alone. */
+  const newestFileMtime = (directory: string) =>
+    Effect.gen(function* () {
+      let newest = 0;
+      for (const name of yield* fs.readDirectory(directory)) {
+        const info = yield* fs.stat(path.join(directory, name)).pipe(Effect.option);
+        if (Option.isNone(info)) continue;
+        const mtime = Option.match(info.value.mtime, {
+          onNone: () => 0,
+          onSome: (date) => date.getTime(),
+        });
+        newest = Math.max(newest, mtime);
+      }
+      return newest;
+    }).pipe(Effect.option);
+
+  /** The V1 profile whose Local Storage was written most recently, if any. */
+  const findV1LocalStorage = Effect.gen(function* () {
+    let newest: { readonly directory: string; readonly mtime: number } | null = null;
+    for (const name of V1_PROFILE_NAMES) {
+      const directory = path.join(environment.appDataDirectory, name, "Local Storage", "leveldb");
+      const mtime = yield* newestFileMtime(directory);
+      if (Option.isNone(mtime)) continue;
+      if (newest === null || mtime.value > newest.mtime) newest = { directory, mtime: mtime.value };
+    }
+    return newest?.directory ?? null;
+  });
+
+  const writeMarker = Effect.gen(function* () {
+    const marker = yield* Ref.get(markerPath);
+    if (Option.isNone(marker)) return;
+    yield* fs
+      .writeFileString(marker.value, "")
+      .pipe(
+        Effect.catch((error) =>
+          Effect.logWarning("Could not record the V1 Local Storage import", error),
+        ),
+      );
+  });
+
+  const load = Effect.fn("desktop.legacyLocalStorage.load")(function* (userDataPath: string) {
+    // Development already shares its profile between versions.
+    if (environment.isDevelopment) return;
+    const marker = path.join(userDataPath, MARKER_FILE_NAME);
+    if (yield* fs.exists(marker).pipe(Effect.orElseSucceed(() => true))) return;
+    yield* Ref.set(markerPath, Option.some(marker));
+    const directory = yield* findV1LocalStorage;
+    if (directory === null) return yield* writeMarker;
+    const origin = ElectronProtocol.getDesktopUrl(false).replace(/\/$/, "");
+    const read = yield* readChromiumLocalStorage(directory, origin).pipe(
+      Effect.provideService(FileSystem.FileSystem, fs),
+      Effect.provideService(Path.Path, path),
+      Effect.tapError((error) =>
+        Effect.logWarning("Could not read V1 Local Storage; will retry next launch", error),
+      ),
+      Effect.option,
+    );
+    if (Option.isNone(read)) return;
+    yield* Effect.logInfo("V1 Local Storage ready to import", {
+      directory,
+      keys: read.value.size,
+    });
+    yield* Ref.set(items, Option.some(Object.fromEntries(read.value)));
+  });
+
+  return DesktopLegacyLocalStorage.of({
+    load,
+    // Taking clears the items, so a reload before `complete` cannot merge twice.
+    take: Ref.getAndSet(items, Option.none()),
+    complete: writeMarker,
+  });
+});
+
+export const layer = Layer.effect(DesktopLegacyLocalStorage, make);
diff --git a/apps/desktop/src/app/chromiumLocalStorage.ts b/apps/desktop/src/app/chromiumLocalStorage.ts
new file mode 100644
index 000000000000..d5847b814db6
--- /dev/null
+++ b/apps/desktop/src/app/chromiumLocalStorage.ts
@@ -0,0 +1,460 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as PlatformError from "effect/PlatformError";
+import * as Schema from "effect/Schema";
+
+/**
+ * Read-only decoder for a Chromium profile's `Local Storage/leveldb`.
+ *
+ * It reads the database files directly and never takes LevelDB's lock, so it
+ * works while another app version has the profile open. Live files come from
+ * the MANIFEST that CURRENT names, and the newest sequence number wins, which
+ * is how LevelDB itself resolves overwrites and deletions.
+ */
+
+const LOG_BLOCK_SIZE = 32 * 1024;
+const LOG_HEADER_SIZE = 7;
+const TABLE_FOOTER_SIZE = 48;
+const BLOCK_TRAILER_SIZE = 5;
+
+class LevelDbFormatError extends Schema.TaggedError<LevelDbFormatError>()("LevelDbFormatError", {
+  detail: Schema.String,
+}) {}
+
+const isLevelDbFormatError = Schema.is(LevelDbFormatError);
+
+const fail = (detail: string): never => {
+  throw new LevelDbFormatError({ detail });
+};
+
+// ignoreBOM keeps a leading U+FEFF that is part of the stored string.
+const textDecoderUtf16 = new TextDecoder("utf-16le", { ignoreBOM: true });
+const textDecoderUtf8 = new TextDecoder();
+
+/** True ISO-8859-1. WHATWG's "latin1" label is windows-1252, which remaps 0x80-0x9F. */
+function decodeLatin1(bytes: Uint8Array): string {
+  let result = "";
+  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+    result += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+  }
+  return result;
+}
+
+class Reader {
+  readonly bytes: Uint8Array;
+  offset: number;
+  constructor(bytes: Uint8Array, offset = 0) {
+    this.bytes = bytes;
+    this.offset = offset;
+  }
+  get done() {
+    return this.offset >= this.bytes.length;
+  }
+  byte(): number {
+    if (this.offset >= this.bytes.length) fail("unexpected end of data");
+    return this.bytes[this.offset++]!;
+  }
+  varint(): number {
+    let result = 0;
+    let multiplier = 1;
+    for (let shift = 0; shift < 64; shift += 7) {
+      const byte = this.byte();
+      result += (byte & 0x7f) * multiplier;
+      if ((byte & 0x80) === 0) return result;
+      multiplier *= 128;
+    }
+    return fail("varint too long");
+  }
+  take(length: number): Uint8Array {
+    if (length < 0 || this.offset + length > this.bytes.length) fail("length out of range");
+    const slice = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  lengthPrefixed(): Uint8Array {
+    return this.take(this.varint());
+  }
+}
+
+const readUint32 = (bytes: Uint8Array, offset: number) =>
+  (bytes[offset]! | (bytes[offset + 1]! << 8) | (bytes[offset + 2]! << 16)) +
+  bytes[offset + 3]! * 0x1000000;
+
+const CRC32C_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index++) {
+    let crc = index;
+    for (let bit = 0; bit < 8; bit++) crc = crc & 1 ? (crc >>> 1) ^ 0x82f63b78 : crc >>> 1;
+    table[index] = crc >>> 0;
+  }
+  return table;
+})();
+
+function crc32c(bytes: Uint8Array): number {
+  let crc = 0xffffffff;
+  for (const byte of bytes) crc = CRC32C_TABLE[(crc ^ byte) & 0xff]! ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+/** LevelDB stores CRCs masked so a CRC of data containing CRCs stays well distributed. */
+const unmaskCrc = (masked: number) => {
+  const rotated = (masked - 0xa282ead8) >>> 0;
+  return ((rotated >>> 17) | (rotated << 15)) >>> 0;
+};
+
+function decompressSnappy(input: Uint8Array): Uint8Array {
+  const reader = new Reader(input);
+  const output = new Uint8Array(reader.varint());
+  let written = 0;
+  while (!reader.done) {
+    const tag = reader.byte();
+    const kind = tag & 3;
+    if (kind === 0) {
+      let length = tag >>> 2;
+      if (length >= 60) {
+        const extraBytes = length - 59;
+        length = 0;
+        for (let index = 0; index < extraBytes; index++) length += reader.byte() * 256 ** index;
+      }
+      length += 1;
+      if (written + length > output.length) fail("snappy literal overflows output");
+      output.set(reader.take(length), written);
+      written += length;
+      continue;
+    }
+    let length: number;
+    let offset: number;
+    if (kind === 1) {
+      length = 4 + ((tag >>> 2) & 7);
+      offset = ((tag >>> 5) << 8) | reader.byte();
+    } else if (kind === 2) {
+      length = (tag >>> 2) + 1;
+      offset = reader.byte() | (reader.byte() << 8);
+    } else {
+      length = (tag >>> 2) + 1;
+      offset = readUint32(reader.take(4), 0);
+    }
+    if (offset === 0 || offset > written || written + length > output.length) {
+      fail("snappy copy out of range");
+    }
+    // Copies may overlap their own output, so they go byte by byte.
+    for (let index = 0; index < length; index++) {
+      output[written] = output[written - offset]!;
+      written++;
+    }
+  }
+  if (written !== output.length) fail("snappy output length mismatch");
+  return output;
+}
+
+/**
+ * Splits a LevelDB log (write-ahead log or MANIFEST) into its records. Like
+ * LevelDB's own reader, a corrupt record or zero padding skips the rest of its
+ * block, since a reused log keeps appending after a torn write, and a record
+ * cut off by the end of the file ends the log.
+ */
+function readLogRecords(bytes: Uint8Array): Uint8Array[] {
+  const records: Uint8Array[] = [];
+  let pending: Uint8Array[] | null = null;
+  let offset = 0;
+  while (offset + LOG_HEADER_SIZE <= bytes.length) {
+    const blockRemaining = LOG_BLOCK_SIZE - (offset % LOG_BLOCK_SIZE);
+    if (blockRemaining < LOG_HEADER_SIZE) {
+      offset += blockRemaining;
+      continue;
+    }
+    const length = bytes[offset + 4]! | (bytes[offset + 5]! << 8);
+    const type = bytes[offset + 6]!;
+    const end = offset + LOG_HEADER_SIZE + length;
+    const fitsBlock = LOG_HEADER_SIZE + length <= blockRemaining;
+    if (fitsBlock && end > bytes.length) break;
+    const typeAndPayload = bytes.subarray(offset + 6, end);
+    if (
+      type === 0 ||
+      !fitsBlock ||
+      crc32c(typeAndPayload) !== unmaskCrc(readUint32(bytes, offset))
+    ) {
+      offset += blockRemaining;
+      pending = null;
+      continue;
+    }
+    const payload = typeAndPayload.subarray(1);
+    offset = end;
+    if (type === 1) {
+      records.push(payload);
+      pending = null;
+    } else if (type === 2) {
+      pending = [payload];
+    } else if (type === 3 && pending) {
+      pending.push(payload);
+    } else if (type === 4 && pending) {
+      pending.push(payload);
+      const total = pending.reduce((sum, part) => sum + part.length, 0);
+      const record = new Uint8Array(total);
+      let position = 0;
+      for (const part of pending) {
+        record.set(part, position);
+        position += part.length;
+      }
+      records.push(record);
+      pending = null;
+    } else {
+      pending = null;
+    }
+  }
+  return records;
+}
+
+interface LiveFiles {
+  readonly tables: ReadonlyArray<number>;
+  readonly logNumber: number;
+  readonly previousLogNumber: number;
+}
+
+/** Replays MANIFEST version edits to find the live table files and log. */
+function readManifest(bytes: Uint8Array): LiveFiles {
+  const tables = new Set<number>();
+  let logNumber = 0;
+  let previousLogNumber = 0;
+  // LevelDB refuses to open a MANIFEST missing any of these, and so do we.
+  const required = new Set([2, 3, 4]);
+  for (const record of readLogRecords(bytes)) {
+    const reader = new Reader(record);
+    while (!reader.done) {
+      const tag = reader.varint();
+      required.delete(tag);
+      switch (tag) {
+        case 1: // comparator
+          reader.lengthPrefixed();
+          break;
+        case 2:
+          logNumber = reader.varint();
+          break;
+        case 3: // next file number
+        case 4: // last sequence
+          reader.varint();
+          break;
+        case 5: // compaction pointer
+          reader.varint();
+          reader.lengthPrefixed();
+          break;
+        case 6: // deleted file
+          reader.varint();
+          tables.delete(reader.varint());
+          break;
+        case 7: {
+          reader.varint();
+          tables.add(reader.varint());
+          reader.varint();
+          reader.lengthPrefixed();
+          reader.lengthPrefixed();
+          break;
+        }
+        case 9:
+          previousLogNumber = reader.varint();
+          break;
+        default:
+          fail(`unknown manifest tag ${tag}`);
+      }
+    }
+  }
+  if (required.size > 0) fail("incomplete manifest");
+  return { tables: [...tables], logNumber, previousLogNumber };
+}
+
+interface VersionedEntry {
+  readonly sequence: number;
+  /** `null` marks a deletion. */
+  readonly value: Uint8Array | null;
+}
+
+type EntryMap = Map<string, { readonly key: Uint8Array; readonly entry: VersionedEntry }>;
+
+const keyId = decodeLatin1;
+
+function record(entries: EntryMap, key: Uint8Array, entry: VersionedEntry) {
+  const id = keyId(key);
+  const existing = entries.get(id);
+  if (!existing || existing.entry.sequence < entry.sequence) entries.set(id, { key, entry });
+}
+
+/** Applies one write-ahead log record (a WriteBatch). */
+function readWriteBatch(entries: EntryMap, batch: Uint8Array) {
+  if (batch.length < 12) fail("write batch too short");
+  // The sequence is a little-endian uint64; real values stay far below 2^53.
+  const sequence = readUint32(batch, 0) + readUint32(batch, 4) * 0x100000000;
+  const count = readUint32(batch, 8);
+  const reader = new Reader(batch, 12);
+  for (let index = 0; index < count; index++) {
+    const type = reader.byte();
+    const key = reader.lengthPrefixed();
+    if (type === 1) {
+      record(entries, key, { sequence: sequence + index, value: reader.lengthPrefixed() });
+    } else if (type === 0) {
+      record(entries, key, { sequence: sequence + index, value: null });
+    } else {
+      fail(`unknown write batch record type ${type}`);
+    }
+  }
+}
+
+function readBlock(table: Uint8Array, reader: Reader): Uint8Array {
+  const offset = reader.varint();
+  const size = reader.varint();
+  if (offset + size + BLOCK_TRAILER_SIZE > table.length) fail("block handle out of range");
+  const contents = table.subarray(offset, offset + size);
+  const compression = table[offset + size]!;
+  const checksum = unmaskCrc(readUint32(table, offset + size + 1));
+  if (crc32c(table.subarray(offset, offset + size + 1)) !== checksum) fail("block checksum");
+  if (compression === 0) return contents;
+  if (compression === 1) return decompressSnappy(contents);
+  return fail(`unsupported block compression ${compression}`);
+}
+
+function* blockEntries(block: Uint8Array): Generator<[Uint8Array, Uint8Array]> {
+  if (block.length < 4) fail("block too short");
+  const restartCount = readUint32(block, block.length - 4);
+  const limit = block.length - 4 - restartCount * 4;
+  if (limit < 0) fail("restart array out of range");
+  const reader = new Reader(block.subarray(0, limit));
+  let key = new Uint8Array(0);
+  while (!reader.done) {
+    const shared = reader.varint();
+    const unshared = reader.varint();
+    const valueLength = reader.varint();
+    if (shared > key.length) fail("block key prefix out of range");
+    const nextKey = new Uint8Array(shared + unshared);
+    nextKey.set(key.subarray(0, shared));
+    nextKey.set(reader.take(unshared), shared);
+    key = nextKey;
+    yield [key, reader.take(valueLength)];
+  }
+}
+
+/** Applies every entry in one sorted table (`.ldb`/`.sst`) file. */
+function readTable(entries: EntryMap, table: Uint8Array) {
+  if (table.length < TABLE_FOOTER_SIZE) fail("table too short");
+  const footer = new Reader(table, table.length - TABLE_FOOTER_SIZE);
+  footer.varint();
+  footer.varint();
+  const index = readBlock(table, footer);
+  for (const [, handle] of blockEntries(index)) {
+    const block = readBlock(table, new Reader(handle));
+    for (const [internalKey, value] of blockEntries(block)) {
+      if (internalKey.length < 8) fail("internal key too short");
+      const trailerOffset = internalKey.length - 8;
+      const trailer =
+        readUint32(internalKey, trailerOffset) +
+        readUint32(internalKey, trailerOffset + 4) * 0x100000000;
+      const type = trailer % 256;
+      const sequence = Math.floor(trailer / 256);
+      const key = internalKey.subarray(0, trailerOffset);
+      record(entries, key, { sequence, value: type === 1 ? value : null });
+    }
+  }
+}
+
+/** Chromium prefixes each stored string with 0 (UTF-16LE) or 1 (Latin-1). */
+function decodeChromiumString(bytes: Uint8Array): string | null {
+  if (bytes.length === 0) return null;
+  const body = bytes.subarray(1);
+  if (bytes[0] === 1) return decodeLatin1(body);
+  if (bytes[0] === 0 && body.length % 2 === 0) return textDecoderUtf16.decode(body);
+  return null;
+}
+
+export class ChromiumLocalStorageReadError extends Schema.TaggedError<ChromiumLocalStorageReadError>()(
+  "ChromiumLocalStorageReadError",
+  {
+    directory: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  override get message() {
+    return `Could not read Chromium Local Storage at ${this.directory}.`;
+  }
+}
+
+/**
+ * Returns the localStorage items one origin (for example `t3code://app`) had
+ * in the profile, or an empty map when the profile never stored any.
+ */
+export const readChromiumLocalStorage = Effect.fn("desktop.chromiumLocalStorage.read")(function* (
+  directory: string,
+  origin: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const readFile = (name: string) => fs.readFile(path.join(directory, name));
+  const wrap = Effect.mapError(
+    (cause: PlatformError.PlatformError | LevelDbFormatError) =>
+      new ChromiumLocalStorageReadError({ directory, cause }),
+  );
+  const decode = <A>(run: () => A) =>
+    Effect.try({
+      try: run,
+      catch: (cause) =>
+        isLevelDbFormatError(cause) ? cause : new LevelDbFormatError({ detail: String(cause) }),
+    });
+
+  const current = textDecoderUtf8.decode(yield* readFile("CURRENT").pipe(wrap)).trim();
+  if (!/^MANIFEST-\d+$/.test(current)) {
+    return yield* new ChromiumLocalStorageReadError({
+      directory,
+      cause: new LevelDbFormatError({ detail: "bad CURRENT" }),
+    });
+  }
+  const manifest = yield* readFile(current).pipe(wrap);
+  const live = yield* decode(() => readManifest(manifest)).pipe(wrap);
+  const logs = (yield* fs.readDirectory(directory).pipe(wrap))
+    .map((name) => /^(\d+)\.log$/.exec(name))
+    // The logs LevelDB's own recovery replays.
+    .filter((match) => {
+      const number = Number(match?.[1]);
+      return number >= live.logNumber || number === live.previousLogNumber;
+    })
+    .map((match) => match![0]);
+
+  const entries: EntryMap = new Map();
+  for (const number of live.tables) {
+    const name = String(number).padStart(6, "0");
+    // Newer LevelDB names tables .ldb; older databases may still hold .sst files.
+    const bytes = yield* readFile(`${name}.ldb`).pipe(
+      Effect.catchIf(
+        (error) => error.reason._tag === "NotFound",
+        () => readFile(`${name}.sst`),
+      ),
+      wrap,
+    );
+    yield* decode(() => readTable(entries, bytes)).pipe(wrap);
+  }
+  for (const name of logs) {
+    const bytes = yield* readFile(name).pipe(wrap);
+    yield* decode(() => {
+      for (const batch of readLogRecords(bytes)) readWriteBatch(entries, batch);
+    }).pipe(wrap);
+  }
+
+  // A flush while another process has the database open can move entries
+  // from a log we read into a table our MANIFEST copy predates. Fail so the
+  // caller retries rather than import a snapshot missing those entries.
+  const currentAfter = textDecoderUtf8.decode(yield* readFile("CURRENT").pipe(wrap)).trim();
+  const manifestAfter = yield* fs.stat(path.join(directory, current)).pipe(wrap);
+  if (currentAfter !== current || Number(manifestAfter.size) !== manifest.length) {
+    return yield* new ChromiumLocalStorageReadError({
+      directory,
+      cause: new LevelDbFormatError({ detail: "database changed while reading" }),
+    });
+  }
+
+  const prefix = `_${origin}\u0000`;
+  const items = new Map<string, string>();
+  for (const [id, { key: rawKey, entry }] of entries) {
+    if (!id.startsWith(prefix) || entry.value === null) continue;
+    const key = decodeChromiumString(rawKey.subarray(prefix.length));
+    const value = decodeChromiumString(entry.value);
+    if (key !== null && value !== null) items.set(key, value);
+  }
+  return items;
+});
diff --git a/apps/desktop/src/ipc/DesktopIpcHandlers.ts b/apps/desktop/src/ipc/DesktopIpcHandlers.ts
index 4b43cd0eee96..a16535c4a5eb 100644
--- a/apps/desktop/src/ipc/DesktopIpcHandlers.ts
+++ b/apps/desktop/src/ipc/DesktopIpcHandlers.ts
@@ -70,6 +70,10 @@ import {
 } from "./methods/snapShot.ts";
 import * as PreviewIpc from "./methods/preview.ts";
 import * as AppActivationIpc from "./methods/appActivation.ts";
+import {
+  completeLegacyLocalStorage,
+  takeLegacyLocalStorage,
+} from "./methods/legacyLocalStorage.ts";
 import { getWslState, setWslBackendEnabled, setWslDistro, setWslOnly } from "./methods/wsl.ts";
 
 export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers")(function* () {
@@ -80,6 +84,8 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers"
   yield* ipc.handle(AppActivationIpc.setReady);
   yield* ipc.handle(AppActivationIpc.complete);
 
+  yield* ipc.handleSync(takeLegacyLocalStorage);
+  yield* ipc.handle(completeLegacyLocalStorage);
   yield* ipc.handleSync(getAppBranding);
   yield* ipc.handleSync(getSystemLocale);
   yield* ipc.handleSync(getWindowFullscreenState);
diff --git a/apps/desktop/src/ipc/channels.ts b/apps/desktop/src/ipc/channels.ts
index 151cd633d04e..098748dff124 100644
--- a/apps/desktop/src/ipc/channels.ts
+++ b/apps/desktop/src/ipc/channels.ts
@@ -119,3 +119,5 @@ export const PREVIEW_RECORDING_INPUT_CHANNEL = "desktop:preview-recording-input"
 
 export const RECEIVE_PROVIDER_AUTH_CALLBACK_CHANNEL = "desktop:receive-provider-auth-callback";
 export const CANCEL_PROVIDER_AUTH_CALLBACK_CHANNEL = "desktop:cancel-provider-auth-callback";
+export const TAKE_LEGACY_LOCAL_STORAGE_CHANNEL = "desktop:take-legacy-local-storage";
+export const COMPLETE_LEGACY_LOCAL_STORAGE_CHANNEL = "desktop:complete-legacy-local-storage";
diff --git a/apps/desktop/src/ipc/methods/legacyLocalStorage.ts b/apps/desktop/src/ipc/methods/legacyLocalStorage.ts
new file mode 100644
index 000000000000..13f657e7812f
--- /dev/null
+++ b/apps/desktop/src/ipc/methods/legacyLocalStorage.ts
@@ -0,0 +1,30 @@
+import * as Electron from "electron";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+import * as DesktopLegacyLocalStorage from "../../app/DesktopLegacyLocalStorage.ts";
+import * as IpcChannels from "../channels.ts";
+import { makeIpcMethod, makeSyncIpcMethod } from "../DesktopIpc.ts";
+
+export const takeLegacyLocalStorage = makeSyncIpcMethod({
+  channel: IpcChannels.TAKE_LEGACY_LOCAL_STORAGE_CHANNEL,
+  result: Schema.NullOr(Schema.Record(Schema.String, Schema.String)),
+  handler: Effect.fn("desktop.ipc.legacyLocalStorage.take")(function* () {
+    const legacy = yield* DesktopLegacyLocalStorage.DesktopLegacyLocalStorage;
+    return Option.getOrNull(yield* legacy.take);
+  }),
+});
+
+export const completeLegacyLocalStorage = makeIpcMethod({
+  channel: IpcChannels.COMPLETE_LEGACY_LOCAL_STORAGE_CHANNEL,
+  payload: Schema.Void,
+  result: Schema.Void,
+  handler: Effect.fn("desktop.ipc.legacyLocalStorage.complete")(function* (_, event) {
+    const legacy = yield* DesktopLegacyLocalStorage.DesktopLegacyLocalStorage;
+    // Chromium writes localStorage to disk lazily; persist the merge before
+    // the marker stops later launches from retrying it.
+    if (event) Electron.webContents.fromId(event.sender.id)?.session.flushStorageData();
+    yield* legacy.complete;
+  }),
+});
diff --git a/apps/desktop/src/legacyLocalStorageMerge.test.ts b/apps/desktop/src/legacyLocalStorageMerge.test.ts
new file mode 100644
index 000000000000..fd10c1d02019
--- /dev/null
+++ b/apps/desktop/src/legacyLocalStorageMerge.test.ts
@@ -0,0 +1,102 @@
+import { assert, describe, it } from "@effect/vitest";
+
+import { mergeLegacyLocalStorage } from "./legacyLocalStorageMerge.ts";
+
+const memoryStorage = (initial: Record<string, string> = {}) => {
+  const items = new Map(Object.entries(initial));
+  return {
+    items,
+    getItem: (key: string) => items.get(key) ?? null,
+    setItem: (key: string, value: string) => void items.set(key, value),
+  };
+};
+
+const stash = (...ids: string[]) =>
+  JSON.stringify({
+    version: 2,
+    state: { entries: ids.map((id) => ({ id, prompt: `prompt ${id}` })) },
+  });
+
+const drafts = (version: number, threadKey: string, prompt: string) =>
+  JSON.stringify({
+    version,
+    state: {
+      draftsByThreadKey: { [threadKey]: { prompt } },
+      draftThreadsByThreadKey: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
+    },
+  });
+
+describe("mergeLegacyLocalStorage", () => {
+  it("copies V1 keys into an empty profile, except the per-install client id", () => {
+    const storage = memoryStorage();
+    mergeLegacyLocalStorage(storage, {
+      "t3code:theme": "dark",
+      "t3code:prompt-stash:v2": stash("a"),
+      "t3.backgroundActivity.clientId": "v1-client",
+    });
+    assert.equal(storage.getItem("t3code:theme"), "dark");
+    assert.equal(storage.getItem("t3code:prompt-stash:v2"), stash("a"));
+    assert.equal(storage.getItem("t3.backgroundActivity.clientId"), null);
+  });
+
+  it("keeps V2 values for plain keys", () => {
+    const storage = memoryStorage({ "t3code:theme": "light" });
+    mergeLegacyLocalStorage(storage, { "t3code:theme": "dark" });
+    assert.equal(storage.getItem("t3code:theme"), "light");
+  });
+
+  it("appends V1 stash entries after V2's without duplicating ids", () => {
+    const storage = memoryStorage({ "t3code:prompt-stash:v2": stash("new", "shared") });
+    mergeLegacyLocalStorage(storage, { "t3code:prompt-stash:v2": stash("shared", "old") });
+    const ids = JSON.parse(storage.getItem("t3code:prompt-stash:v2")!).state.entries.map(
+      (entry: { id: string }) => entry.id,
+    );
+    assert.deepStrictEqual(ids, ["new", "shared", "old"]);
+  });
+
+  it("adds V1 drafts for other threads and keeps V2's draft for the same thread", () => {
+    const storage = memoryStorage({
+      "t3code:composer-drafts:v1": drafts(9, "env:shared", "v2 text"),
+    });
+    const legacy = JSON.parse(drafts(9, "env:shared", "v1 text"));
+    legacy.state.draftsByThreadKey["env:old"] = { prompt: "v1 only" };
+    mergeLegacyLocalStorage(storage, { "t3code:composer-drafts:v1": JSON.stringify(legacy) });
+    const merged = JSON.parse(storage.getItem("t3code:composer-drafts:v1")!);
+    assert.equal(merged.state.draftsByThreadKey["env:shared"].prompt, "v2 text");
+    assert.equal(merged.state.draftsByThreadKey["env:old"].prompt, "v1 only");
+  });
+
+  it("leaves V2 drafts alone when the stored shapes differ in version", () => {
+    const current = drafts(10, "env:a", "v2");
+    const storage = memoryStorage({ "t3code:composer-drafts:v1": current });
+    mergeLegacyLocalStorage(storage, { "t3code:composer-drafts:v1": drafts(9, "env:b", "v1") });
+    assert.equal(storage.getItem("t3code:composer-drafts:v1"), current);
+  });
+
+  it("caps the merged stash at the store's entry limit, dropping the oldest V1 entries", () => {
+    const v2Ids = Array.from({ length: 15 }, (_, index) => `v2-${index}`);
+    const v1Ids = Array.from({ length: 10 }, (_, index) => `v1-${index}`);
+    const storage = memoryStorage({ "t3code:prompt-stash:v2": stash(...v2Ids) });
+    mergeLegacyLocalStorage(storage, { "t3code:prompt-stash:v2": stash(...v1Ids) });
+    const ids = JSON.parse(storage.getItem("t3code:prompt-stash:v2")!).state.entries.map(
+      (entry: { id: string }) => entry.id,
+    );
+    assert.deepStrictEqual(ids, [...v2Ids, ...v1Ids.slice(0, 5)]);
+  });
+
+  it("keeps importing other keys after one write fails, and reports the failure", () => {
+    const storage = memoryStorage();
+    const setItem = storage.setItem;
+    storage.setItem = (key, value) => {
+      if (key === "t3code:theme") throw new DOMException("full", "QuotaExceededError");
+      setItem(key, value);
+    };
+    const complete = mergeLegacyLocalStorage(storage, {
+      "t3code:theme": "dark",
+      "t3code:last-editor": "zed",
+    });
+    assert.equal(storage.getItem("t3code:last-editor"), "zed");
+    assert.isFalse(complete);
+  });
+});
diff --git a/apps/desktop/src/legacyLocalStorageMerge.ts b/apps/desktop/src/legacyLocalStorageMerge.ts
new file mode 100644
index 000000000000..5a048e2edd18
--- /dev/null
+++ b/apps/desktop/src/legacyLocalStorageMerge.ts
@@ -0,0 +1,113 @@
+/**
+ * Merges V1 profile localStorage items into the V2 profile. Runs in the preload
+ * before the app reads storage, and never overwrites what V2 already holds: a
+ * key V2 has written keeps V2's value, except that stashed prompts and unsent
+ * drafts are merged entry by entry so neither side's are lost.
+ */
+
+interface MergeStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+const PROMPT_STASH_KEY = "t3code:prompt-stash:v2";
+const COMPOSER_DRAFTS_KEY = "t3code:composer-drafts:v1";
+const NOT_IMPORTED_KEYS = new Set([
+  // Identifies one running install to the server; two apps must not share it.
+  "t3.backgroundActivity.clientId",
+  // Resumes a permission setup V1 left mid-flow; V2 would redirect to it on boot.
+  "t3code:snap-shot-setup-resume:v1",
+]);
+/** Matches MAX_STASH_ENTRIES in apps/web/src/promptStashStore.ts. */
+const MAX_STASH_ENTRIES = 20;
+const DRAFT_RECORD_FIELDS = [
+  "draftsByThreadKey",
+  "draftThreadsByThreadKey",
+  "logicalProjectDraftThreadKeyByLogicalProjectKey",
+] as const;
+
+type JsonObject = Record<string, unknown>;
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+function parseObject(raw: string): JsonObject | null {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    return isObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** V2 entries first, then V1 entries V2 does not already have, up to the stash cap. */
+function mergePromptStash(current: JsonObject, legacy: JsonObject): JsonObject | null {
+  const currentEntries = isObject(current.state) ? current.state.entries : null;
+  const legacyEntries = isObject(legacy.state) ? legacy.state.entries : null;
+  if (!Array.isArray(currentEntries) || !Array.isArray(legacyEntries)) return null;
+  if (current.version !== legacy.version) return null;
+  const ids = new Set(currentEntries.map((entry) => (isObject(entry) ? entry.id : undefined)));
+  const added = legacyEntries.filter((entry) => isObject(entry) && !ids.has(entry.id));
+  const state = isObject(current.state) ? current.state : {};
+  return {
+    ...current,
+    state: { ...state, entries: [...currentEntries, ...added].slice(0, MAX_STASH_ENTRIES) },
+  };
+}
+
+/** Adds V1 drafts for threads V2 has no draft for. Shapes must share a version. */
+function mergeComposerDrafts(current: JsonObject, legacy: JsonObject): JsonObject | null {
+  if (current.version !== legacy.version) return null;
+  if (!isObject(current.state) || !isObject(legacy.state)) return null;
+  const state: JsonObject = { ...current.state };
+  for (const field of DRAFT_RECORD_FIELDS) {
+    const currentRecord = state[field];
+    const legacyRecord = legacy.state[field];
+    if (!isObject(currentRecord) || !isObject(legacyRecord)) return null;
+    state[field] = { ...legacyRecord, ...currentRecord };
+  }
+  return { ...current, state };
+}
+
+const isMergedKey = (key: string) => key === PROMPT_STASH_KEY || key === COMPOSER_DRAFTS_KEY;
+
+function mergeValue(key: string, current: string, legacy: string): string | null {
+  const merge =
+    key === PROMPT_STASH_KEY
+      ? mergePromptStash
+      : key === COMPOSER_DRAFTS_KEY
+        ? mergeComposerDrafts
+        : null;
+  if (merge === null) return null;
+  const currentObject = parseObject(current);
+  const legacyObject = parseObject(legacy);
+  if (currentObject === null || legacyObject === null) return null;
+  const merged = merge(currentObject, legacyObject);
+  return merged === null ? null : JSON.stringify(merged);
+}
+
+/** Returns false when a write failed, so the caller can retry on a later launch. */
+export function mergeLegacyLocalStorage(
+  storage: MergeStorage,
+  legacyItems: Readonly<Record<string, string>>,
+): boolean {
+  let complete = true;
+  // Stash and drafts first, so a full quota costs layout state rather than prompts.
+  const keys = Object.keys(legacyItems).sort(
+    (left, right) => Number(isMergedKey(right)) - Number(isMergedKey(left)),
+  );
+  for (const key of keys) {
+    if (NOT_IMPORTED_KEYS.has(key)) continue;
+    const legacy = legacyItems[key]!;
+    const current = storage.getItem(key);
+    const next = current === null ? legacy : mergeValue(key, current, legacy);
+    if (next === null || next === current) continue;
+    try {
+      storage.setItem(key, next);
+    } catch {
+      // Over quota: skip this key rather than abandon the rest.
+      complete = false;
+    }
+  }
+  return complete;
+}
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index d1c32d5ae7cd..42a557bc84c8 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -8,6 +8,8 @@ for (const stream of [process.stdout, process.stderr]) {
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeServices from "@effect/platform-node/NodeServices";
+// @effect-diagnostics-next-line nodeBuiltinImport:off - Version output must flush before Electron exits, without acquiring the runtime.
+import * as NodeFS from "node:fs";
 import * as NodeOS from "node:os";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -58,6 +60,7 @@ import * as DesktopShellEnvironment from "./shell/DesktopShellEnvironment.ts";
 import * as DesktopSshEnvironment from "./ssh/DesktopSshEnvironment.ts";
 import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts";
 import * as DesktopState from "./app/DesktopState.ts";
+import * as DesktopLegacyLocalStorage from "./app/DesktopLegacyLocalStorage.ts";
 import * as DesktopTelemetryPublisher from "./telemetry/DesktopTelemetryPublisher.ts";
 import * as DesktopUpdates from "./updates/DesktopUpdates.ts";
 import * as BrowserImport from "./preview/BrowserImport/BrowserImport.ts";
@@ -69,6 +72,15 @@ import * as DesktopWslBackend from "./wsl/DesktopWslBackend.ts";
 import * as DesktopWslEnvironment from "./wsl/DesktopWslEnvironment.ts";
 import * as DesktopWslServerTree from "./wsl/DesktopWslServerTree.ts";
 
+if (process.argv.includes("--version")) {
+  try {
+    NodeFS.writeSync(process.stdout.fd, `${Electron.app.getVersion()}\n`);
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "EPIPE") throw error;
+  }
+  Electron.app.exit(0);
+}
+
 const desktopEnvironmentLayer = Layer.unwrap(
   Effect.gen(function* () {
     const metadata = yield* Effect.service(ElectronApp.ElectronApp).pipe(
@@ -129,6 +141,7 @@ const desktopFoundationLayer = Layer.mergeAll(
   MacPermissions.layer,
   DesktopState.layer,
   DesktopShutdown.layer,
+  DesktopLegacyLocalStorage.layer,
   DesktopAppSettings.layer,
   DesktopClientSettings.layer,
   DesktopConnectionCatalogStore.layer.pipe(Layer.provideMerge(DesktopSavedEnvironments.layer)),
diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts
index e84a5821e9ff..7d7269974bcd 100644
--- a/apps/desktop/src/preload.ts
+++ b/apps/desktop/src/preload.ts
@@ -10,6 +10,7 @@ import { exposeClerkBridge } from "@clerk/electron/preload";
 import { contextBridge, ipcRenderer, webFrame, webUtils } from "electron";
 
 import * as IpcChannels from "./ipc/channels.ts";
+import { mergeLegacyLocalStorage } from "./legacyLocalStorageMerge.ts";
 
 const SNAP_SHOT_EVENT_TYPES = new Set([
   "requested",
@@ -30,6 +31,18 @@ function isSnapShotEvent(value: unknown): value is DesktopSnapShotEvent {
 
 exposeClerkBridge({ passkeys: true });
 
+// Runs before any app script reads localStorage. See DesktopLegacyLocalStorage.
+try {
+  const legacyItems: unknown = ipcRenderer.sendSync(IpcChannels.TAKE_LEGACY_LOCAL_STORAGE_CHANNEL);
+  if (typeof legacyItems === "object" && legacyItems !== null) {
+    if (mergeLegacyLocalStorage(window.localStorage, legacyItems as Record<string, string>)) {
+      void ipcRenderer.invoke(IpcChannels.COMPLETE_LEGACY_LOCAL_STORAGE_CHANNEL);
+    }
+  }
+} catch {
+  // Best effort: the app still starts on the V2 profile's own storage.
+}
+
 // oxlint-disable-next-line t3code/no-global-process-runtime -- Electron exposes the client platform in its sandboxed preload process.
 const clientPlatform = process.platform;
 
diff --git a/apps/mobile/modules/t3-markdown-text/ios/T3MarkdownText.mm b/apps/mobile/modules/t3-markdown-text/ios/T3MarkdownText.mm
index 8fa5abfe2a8e..c0db129ee8c8 100644
--- a/apps/mobile/modules/t3-markdown-text/ios/T3MarkdownText.mm
+++ b/apps/mobile/modules/t3-markdown-text/ios/T3MarkdownText.mm
@@ -311,6 +311,12 @@ - (instancetype)initWithFrame:(CGRect)frame
     _textView.editable = false;
     _textView.textContainerInset = UIEdgeInsetsZero;
     _textView.textContainer.lineFragmentPadding = 0;
+    // The shadow node already sized this view to fit every line. A container
+    // that tracks the frame can come out a fraction of a point shorter after
+    // pixel rounding, and TextKit then drops the last line. Size it by hand
+    // with unbounded height and let the view's bounds clip.
+    _textView.textContainer.widthTracksTextView = NO;
+    _textView.textContainer.heightTracksTextView = NO;
     _textView.delegate = self;
     // Chat text supports selection and contextual actions, but not drag-and-drop.
     _textView.textDragInteraction.enabled = NO;
@@ -477,6 +483,7 @@ - (void)drawRect:(CGRect)rect
   }
   if (frameChanged) {
     _textView.frame = _view.frame;
+    _textView.textContainer.size = CGSizeMake(CGRectGetWidth(_view.frame), CGFLOAT_MAX);
   }
 
   // Text attachments have no native link element. Expose their existing runs
diff --git a/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts b/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
index 75d1e852acf8..6ae50075093f 100644
--- a/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
+++ b/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
@@ -1,4 +1,5 @@
 import type { MarkdownNode } from "react-native-nitro-markdown/headless";
+import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
 import { collectComposerInlineTokens } from "@t3tools/shared/composerInlineTokens";
 import { imageMimeType } from "@t3tools/shared/image";
 import { isWindowsAbsolutePath } from "@t3tools/shared/path";
@@ -109,7 +110,8 @@ export function nativeMarkdownContextCopyRanges(
   }>,
 ) {
   let offset = 0;
-  return runs.flatMap(({ run, text, inlineImageLength }) => {
+  const ranges: Array<{ start: number; end: number; text: string }> = [];
+  for (const [index, { run, text, inlineImageLength }] of runs.entries()) {
     const start = offset;
     offset += text.length + inlineImageLength;
     const reference = parseComposerContextHref(run.href ?? "");
@@ -117,11 +119,25 @@ export function nativeMarkdownContextCopyRanges(
       ? formatComposerContextReference({ ...reference, label: run.text })
       : run.skillName
         ? `$${run.skillName}`
-        : run.fileIcon && run.href
-          ? (run.sourceText ?? `[${run.text}](<${run.href}>)`)
-          : null;
-    return source === null ? [] : [{ start, end: offset, text: source }];
-  });
+        : run.sourceText !== undefined
+          ? run.sourceText
+          : run.fileIcon && run.href
+            ? `[${run.text}](<${run.href}>)`
+            : null;
+    if (source === null) continue;
+    const previous = ranges.at(-1);
+    if (
+      run.sourceText !== undefined &&
+      !runs[index - 1]?.run.fileIcon &&
+      previous?.end === start &&
+      previous.text === source
+    ) {
+      previous.end = offset;
+    } else {
+      ranges.push({ start, end: offset, text: source });
+    }
+  }
+  return ranges;
 }
 
 import type { SelectableMarkdownSkill } from "./SelectableMarkdownText.types";
@@ -181,6 +197,7 @@ interface RunContext {
   readonly href?: string;
   readonly externalHost?: string;
   readonly fileIcon?: MarkdownFileIcon;
+  readonly sourceText?: string;
   readonly role?: NativeMarkdownTextRun["role"];
   readonly headingLevel?: number;
   readonly depth?: number;
@@ -268,6 +285,7 @@ function sameRunStyle(left: NativeMarkdownTextRun, right: NativeMarkdownTextRun)
     left.href === right.href &&
     left.externalHost === right.externalHost &&
     left.fileIcon === right.fileIcon &&
+    left.sourceText === right.sourceText &&
     left.skillName === right.skillName &&
     left.skillLabel === right.skillLabel &&
     left.role === right.role &&
@@ -298,6 +316,7 @@ function appendRun(
     ...(context.href ? { href: context.href } : {}),
     ...(context.externalHost ? { externalHost: context.externalHost } : {}),
     ...(context.fileIcon ? { fileIcon: context.fileIcon } : {}),
+    ...(context.sourceText !== undefined ? { sourceText: context.sourceText } : {}),
     ...(context.role ? { role: context.role } : {}),
     ...(context.headingLevel ? { headingLevel: context.headingLevel } : {}),
     ...(context.depth ? { depth: context.depth } : {}),
@@ -432,6 +451,36 @@ function nodeTextContent(node: MarkdownNode): string {
   return (node.children ?? []).map(nodeTextContent).join("");
 }
 
+function fileLinkLabelMarkdown(node: MarkdownNode): string {
+  const children = (node.children ?? []).map(fileLinkLabelMarkdown).join("");
+  switch (node.type) {
+    case "bold":
+      return `**${children}**`;
+    case "italic":
+      return `*${children}*`;
+    case "strikethrough":
+      return `~~${children}~~`;
+    case "code_inline": {
+      const content = nodeTextContent(node);
+      const fence = "`".repeat(
+        Math.max(0, ...(content.match(/`+/g) ?? []).map((run) => run.length)) + 1,
+      );
+      const padding = /^`|`$|^ .* $/.test(content) && content.trim().length > 0 ? " " : "";
+      return `${fence}${padding}${content}${padding}${fence}`;
+    }
+    case "soft_break":
+      return "\n";
+    case "line_break":
+      return "  \n";
+    case "text":
+      return textNodeContent(nodeTextContent(node)).replace(/[\\[\]*_`~]/g, "\\$&");
+    case "image":
+      return `![${(node.alt ?? "").replace(/[\\[\]]/g, "\\$&")}](<${node.href ?? ""}>)`;
+    default:
+      return node.content ?? children;
+  }
+}
+
 function appendNode(
   runs: NativeMarkdownTextRun[],
   node: MarkdownNode,
@@ -482,6 +531,23 @@ function appendNode(
       }
       const presentation = resolveMarkdownLinkPresentation(node.href ?? "");
       if (presentation.kind === "file") {
+        const label = textNodeContent(nodeTextContent(node));
+        if (!isMarkdownFileLinkLabel(label, presentation.href)) {
+          const fileRuns: NativeMarkdownTextRun[] = [];
+          const fileContext = {
+            ...context,
+            href: presentation.href,
+            sourceText: `[${fileLinkLabelMarkdown(node)}](<${presentation.href}>)`,
+          };
+          appendChildren(fileRuns, node, fileContext);
+          appendRun(fileRuns, " ", fileContext);
+          appendRun(fileRuns, presentation.label, {
+            ...fileContext,
+            fileIcon: presentation.icon,
+          });
+          runs.push(...fileRuns);
+          return runs;
+        }
         return appendRun(runs, presentation.label, {
           ...context,
           href: presentation.href,
diff --git a/apps/mobile/package.json b/apps/mobile/package.json
index df0d8aea4c52..602ffb66bace 100644
--- a/apps/mobile/package.json
+++ b/apps/mobile/package.json
@@ -127,7 +127,7 @@
     "react-native-worklets": "0.13.0",
     "shiki": "4.2.0",
     "tailwind-merge": "^3.5.0",
-    "uniwind": "1.11.0"
+    "uniwind": "1.12.1"
   },
   "devDependencies": {
     "@effect/vitest": "catalog:",
diff --git a/apps/mobile/src/components/SourceControlIcon.tsx b/apps/mobile/src/components/SourceControlIcon.tsx
index 873f3729a8a1..4c7fd9e05baa 100644
--- a/apps/mobile/src/components/SourceControlIcon.tsx
+++ b/apps/mobile/src/components/SourceControlIcon.tsx
@@ -67,29 +67,162 @@ export function SourceControlIcon(props: {
         </Svg>
       );
     case "azure-devops":
+      // Microsoft Azure DevOps mark via selfhst/icons (CC BY 4.0): https://github.com/selfhst/icons/blob/main/svg/azure-devops.svg
       return (
-        <Svg width={size} height={size} viewBox="0 0 96 96">
+        <Svg width={size} height={size} viewBox="0 0 512 512">
           <Defs>
-            <LinearGradient id="azure-a" x1="42.83" x2="15.79" y1="12.69" y2="92.57">
-              <Stop offset="0" stopColor="#114A8B" />
-              <Stop offset="1" stopColor="#0669BC" />
+            <LinearGradient
+              id="azure-a"
+              x1="58.027"
+              x2="58.027"
+              y1="356.668"
+              y2="100.668"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset="0" stopColor="#163697" />
+              <Stop offset=".276" stopColor="#2052cb" />
+              <Stop offset=".518" stopColor="#2764e7" />
+              <Stop offset=".879" stopColor="#367af2" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-b"
+              x1="58.027"
+              x2="58.027"
+              y1="351.334"
+              y2="292.668"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset="0" stopColor="#102784" />
+              <Stop offset="1" stopColor="#2052cb" stopOpacity="0" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-c"
+              x1="389.98"
+              x2="107.314"
+              y1="57.935"
+              y2="193.935"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset="0" stopColor="#163697" />
+              <Stop offset=".301" stopColor="#2052cb" />
+              <Stop offset=".626" stopColor="#2764e7" />
+              <Stop offset=".926" stopColor="#367af2" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-d"
+              x1="391.996"
+              x2="341.385"
+              y1="76.552"
+              y2="78.224"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset="0" stopColor="#102784" />
+              <Stop offset="1" stopColor="#2052cb" stopOpacity="0" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-e"
+              x1="442.24"
+              x2="442.24"
+              y1="54.769"
+              y2="419.38"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset=".043" stopColor="#2052cb" />
+              <Stop offset=".489" stopColor="#367af2" />
+              <Stop offset=".943" stopColor="#16bbda" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-f"
+              x1="435.596"
+              x2="425.732"
+              y1="270.413"
+              y2="385.266"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset=".134" stopColor="#16bbda" stopOpacity="0" />
+              <Stop offset=".932" stopColor="#6be7a0" stopOpacity=".8629" />
             </LinearGradient>
-            <LinearGradient id="azure-b" x1="47.84" x2="77.52" y1="10.36" y2="89.44">
-              <Stop offset="0" stopColor="#3CCBF4" />
-              <Stop offset="1" stopColor="#2892DF" />
+            <LinearGradient
+              id="azure-g"
+              x1="437.081"
+              x2="507.893"
+              y1="204.362"
+              y2="119.081"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset="0" stopColor="#2c68e0" stopOpacity="0" />
+              <Stop offset=".898" stopColor="#66c0ff" stopOpacity=".5" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-h"
+              x1="99.399"
+              x2="352.75"
+              y1="279.26"
+              y2="498.676"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset=".005" stopColor="#367af2" />
+              <Stop offset=".507" stopColor="#0fafff" />
+              <Stop offset="1" stopColor="#26cfe8" />
+            </LinearGradient>
+            <LinearGradient
+              id="azure-i"
+              x1="184.342"
+              x2="338.581"
+              y1="356.795"
+              y2="480.642"
+              gradientTransform="matrix(1 0 0 -1 0 514)"
+              gradientUnits="userSpaceOnUse"
+            >
+              <Stop offset=".443" stopColor="#26cfe8" stopOpacity="0" />
+              <Stop offset=".897" stopColor="#6be7a0" stopOpacity=".8629" />
             </LinearGradient>
           </Defs>
           <Path
+            d="M116.1 73.4c-5.8 5.8-13.7 13.8-13.7 22.6v216.4c0 8.9-3.3 17.3-9 23.4s-13.3 9.2-21.1 8.5l-42.7-3.1c-7.9-.5-15-3.9-20.3-9.3-5.7-5.7-9.3-13.7-9.3-22.6V202.7c0-8.9 3.6-16.9 9.4-22.6l2-1.9z"
             fill="url(#azure-a)"
-            d="M33.34 6.54h26.04l-27.03 80.1a4.15 4.15 0 0 1-3.94 2.81H8.15a4.14 4.14 0 0 1-3.93-5.47L29.4 9.38a4.15 4.15 0 0 1 3.94-2.83z"
           />
           <Path
-            fill="#0078D4"
-            d="M71.17 60.26H29.88a1.91 1.91 0 0 0-1.3 3.31l26.53 24.76a4.17 4.17 0 0 0 2.85 1.13h23.38z"
+            d="M116.1 73.4c-5.8 5.8-13.7 13.8-13.7 22.6v216.4c0 8.9-3.3 17.3-9 23.4s-13.3 9.2-21.1 8.5l-42.7-3.1c-7.9-.5-15-3.9-20.3-9.3-5.7-5.7-9.3-13.7-9.3-22.6V202.7c0-8.9 3.6-16.9 9.4-22.6l2-1.9z"
+            fill="url(#azure-b)"
           />
           <Path
-            fill="url(#azure-b)"
-            d="M66.6 9.36a4.14 4.14 0 0 0-3.93-2.82H33.65a4.15 4.15 0 0 1 3.93 2.82l25.18 74.62a4.15 4.15 0 0 1-3.93 5.48h29.02a4.15 4.15 0 0 0 3.93-5.48z"
+            d="m500.5 366-128 106.7c-5.5 4.6-12.7 7.4-20.5 7.4q-2.4 0-4.8-.3l-112.5-16.9v27.8c0 11.7-9.6 21.3-21.3 21.3-7.3 0-13.5-3.6-17.5-9.1l-36.2-51.4-5.4-7.6-36.6-51.9-7-10c-2.6-3.5-3.9-7.8-3.9-12.3 0-6 2.5-11.6 6.8-15.7 3.8-3.7 9.1-5.8 14.5-5.8.4 0 1 .1 1.5.1l105.2 7.5L384 366.5l93.7 6.7c.7.1 1.6.1 2.3.1 7.8 0 14.9-2.7 20.5-7.3"
+            fill="url(#azure-c)"
+          />
+          <Path
+            d="m500.5 366-128 106.7c-5.5 4.6-12.7 7.4-20.5 7.4q-2.4 0-4.8-.3l-112.5-16.9v27.8c0 11.7-9.6 21.3-21.3 21.3-7.3 0-13.5-3.6-17.5-9.1l-36.2-51.4-5.4-7.6-36.6-51.9-7-10c-2.6-3.5-3.9-7.8-3.9-12.3 0-6 2.5-11.6 6.8-15.7 3.8-3.7 9.1-5.8 14.5-5.8.4 0 1 .1 1.5.1l105.2 7.5L384 366.5l93.7 6.7c.7.1 1.6.1 2.3.1 7.8 0 14.9-2.7 20.5-7.3"
+            fill="url(#azure-d)"
+          />
+          <Path
+            d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+            fill="url(#azure-e)"
+          />
+          <Path
+            d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+            fill="url(#azure-f)"
+            fillOpacity=".7"
+          />
+          <Path
+            d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+            fill="url(#azure-g)"
+          />
+          <Path
+            d="M384 125.5c0 11.2-8.6 20.5-19.8 21.3-.5 0-1.1.1-1.6.1l-127.9 9.2-132.3 9.1-72.7 5.5c-6.9.4-13.2 3.1-18.2 7.4L116.1 73.4c4.7-4.7 10.9-8 17.8-9.1l100.8-15.1V21.3C234.7 9.6 244.3 0 256 0c5.8 0 11.1 2.3 14.9 6.1l33.4 32.6 16.9 16.5 40.3 39.3 16.1 15.8c4.1 3.9 6.4 9.4 6.4 15.2"
+            fill="url(#azure-h)"
+          />
+          <Path
+            d="M384 125.5c0 11.2-8.6 20.5-19.8 21.3-.5 0-1.1.1-1.6.1l-127.9 9.2-132.3 9.1-72.7 5.5c-6.9.4-13.2 3.1-18.2 7.4L116.1 73.4c4.7-4.7 10.9-8 17.8-9.1l100.8-15.1V21.3C234.7 9.6 244.3 0 256 0c5.8 0 11.1 2.3 14.9 6.1l33.4 32.6 16.9 16.5 40.3 39.3 16.1 15.8c4.1 3.9 6.4 9.4 6.4 15.2"
+            fill="url(#azure-i)"
+            fillOpacity=".5"
           />
         </Svg>
       );
diff --git a/apps/mobile/src/connection/onboarding.ts b/apps/mobile/src/connection/onboarding.ts
index fdf1f527feb7..5e443dfac82d 100644
--- a/apps/mobile/src/connection/onboarding.ts
+++ b/apps/mobile/src/connection/onboarding.ts
@@ -13,10 +13,20 @@ const onboardingScheduler = createAtomCommandScheduler();
 export const connectPairingUrl = createRuntimeCommand(connectionAtomRuntime, {
   label: "mobile:connection:connect-pairing-url",
   scheduler: onboardingScheduler,
-  concurrency: { mode: "singleFlight", key: (pairingUrl: string) => pairingUrl },
-  execute: (pairingUrl: string) =>
+  concurrency: {
+    mode: "singleFlight",
+    // Adding a route to a different machine with the same link is its own
+    // operation: it must check its own expected machine.
+    key: (input: { readonly pairingUrl: string; readonly expectedEnvironmentId?: EnvironmentId }) =>
+      JSON.stringify([input.pairingUrl, input.expectedEnvironmentId ?? null]),
+  },
+  execute: (input: {
+    readonly pairingUrl: string;
+    /** Set when adding a route to this saved machine. */
+    readonly expectedEnvironmentId?: EnvironmentId;
+  }) =>
     ConnectionOnboarding.ConnectionOnboarding.pipe(
-      Effect.flatMap((onboarding) => onboarding.registerPairing({ pairingUrl })),
+      Effect.flatMap((onboarding) => onboarding.registerPairing(input)),
     ),
 });
 
diff --git a/apps/mobile/src/connection/platform.ts b/apps/mobile/src/connection/platform.ts
index 5fd5665a0a64..96c0a08e43ee 100644
--- a/apps/mobile/src/connection/platform.ts
+++ b/apps/mobile/src/connection/platform.ts
@@ -27,6 +27,7 @@ import * as MobileStorage from "../persistence/mobile-storage";
 import { appAtomRegistry } from "../state/atom-registry";
 import { clearThreadOutboxEnvironment } from "../state/thread-outbox-removal";
 import { clearComposerDraftsEnvironment } from "../state/use-composer-drafts";
+import { clearThreadComposerErrorsForEnvironment } from "../state/thread-composer-error";
 import { mobileApplicationActiveWakeup } from "./app-state-wakeups";
 import { connectionStorageLayer } from "./storage";
 import { presenceLayer } from "./user-input";
@@ -83,29 +84,75 @@ const connectivityLayer = Connectivity.layer({
   ),
 });
 
+/**
+ * Wakes connections when the device moves between networks while staying
+ * online, such as Wi-Fi to cellular. Connectivity only reports online or
+ * offline, so leaving home on cellular would otherwise go unnoticed until the
+ * LAN socket times out.
+ */
+const networkPathChanges = Stream.callback<"network-changed">((queue) =>
+  Effect.acquireRelease(
+    Effect.sync(() => {
+      let active = true;
+      let previous: Network.NetworkStateType | undefined;
+      const record = (state: Network.NetworkState) => {
+        const type = state.isConnected === true ? state.type : undefined;
+        if (previous !== undefined && type !== undefined && type !== previous) {
+          Queue.offerUnsafe(queue, "network-changed");
+        }
+        previous = type ?? previous;
+      };
+      // The listener reports changes only, so seed the current type; without
+      // it the first Wi-Fi to cellular move would go unnoticed.
+      void Network.getNetworkStateAsync()
+        .then((state) => {
+          if (active && previous === undefined && state.isConnected === true) {
+            previous = state.type;
+          }
+        })
+        .catch(() => undefined);
+      const subscription = Network.addNetworkStateListener(record);
+      return {
+        remove: () => {
+          active = false;
+          subscription.remove();
+        },
+      };
+    }),
+    (subscription) => Effect.sync(() => subscription.remove()),
+  ).pipe(Effect.asVoid),
+);
+
 const wakeupsLayer = Wakeups.layer({
-  changes: Stream.merge(
-    Stream.callback<"application-active-probe" | "application-active-reconnect">((queue) =>
-      Effect.acquireRelease(
-        Effect.sync(() => {
-          let backgroundedAtMs = AppState.currentState === "background" ? Date.now() : null;
-          return AppState.addEventListener("change", (state) => {
-            if (state === "background") {
-              backgroundedAtMs = Date.now();
-              return;
-            }
-            if (state === "active") {
-              Queue.offerUnsafe(queue, mobileApplicationActiveWakeup(backgroundedAtMs, Date.now()));
-              backgroundedAtMs = null;
-            }
-          });
-        }),
-        (subscription) => Effect.sync(() => subscription.remove()),
-      ).pipe(Effect.asVoid),
-    ),
-    managedRelayAccountChanges(appAtomRegistry).pipe(
-      Stream.map(() => "credentials-changed" as const),
-    ),
+  changes: Stream.mergeAll(
+    [
+      Stream.callback<"application-active-probe" | "application-active-reconnect">((queue) =>
+        Effect.acquireRelease(
+          Effect.sync(() => {
+            let backgroundedAtMs = AppState.currentState === "background" ? Date.now() : null;
+            return AppState.addEventListener("change", (state) => {
+              if (state === "background") {
+                backgroundedAtMs = Date.now();
+                return;
+              }
+              if (state === "active") {
+                Queue.offerUnsafe(
+                  queue,
+                  mobileApplicationActiveWakeup(backgroundedAtMs, Date.now()),
+                );
+                backgroundedAtMs = null;
+              }
+            });
+          }),
+          (subscription) => Effect.sync(() => subscription.remove()),
+        ).pipe(Effect.asVoid),
+      ),
+      managedRelayAccountChanges(appAtomRegistry).pipe(
+        Stream.map(() => "credentials-changed" as const),
+      ),
+      networkPathChanges,
+    ],
+    { concurrency: "unbounded" },
   ),
 });
 
@@ -219,6 +266,7 @@ const environmentOwnedDataCleanupLayer = Layer.succeed(
         [
           Effect.promise(() => clearThreadOutboxEnvironment(environmentId)),
           Effect.promise(() => clearComposerDraftsEnvironment(environmentId)),
+          Effect.sync(() => clearThreadComposerErrorsForEnvironment(environmentId)),
         ],
         { concurrency: "unbounded", discard: true },
       ).pipe(
diff --git a/apps/mobile/src/connection/storage.ts b/apps/mobile/src/connection/storage.ts
index d2fbdd8cd9a9..6c1fd326a7b6 100644
--- a/apps/mobile/src/connection/storage.ts
+++ b/apps/mobile/src/connection/storage.ts
@@ -3,6 +3,7 @@ import {
   registerConnectionInCatalog,
   removeConnectionFromCatalog,
   setConnectionEnabledInCatalog,
+  setRoutesInCatalog,
   removeCatalogValue,
   replaceCatalogValue,
   Persistence,
@@ -27,6 +28,7 @@ function targetPersistenceError(
     | "list-targets"
     | "list-disabled-targets"
     | "register-connection"
+    | "set-connection-routes"
     | "remove-connection"
     | "set-connection-enabled",
   error: ConnectionTransientError,
@@ -57,13 +59,17 @@ export const connectionStorageLayer = Layer.effectContext(
       ),
     });
     const registrationStore = Persistence.ConnectionRegistrationStore.of({
-      register: (registration) =>
+      register: (registration, routes) =>
         catalog
-          .update((document) => registerConnectionInCatalog(document, registration))
+          .update((document) => registerConnectionInCatalog(document, registration, routes))
           .pipe(Effect.mapError((error) => targetPersistenceError("register-connection", error))),
-      remove: (target) =>
+      setRoutes: (environmentId, routes) =>
         catalog
-          .update((document) => removeConnectionFromCatalog(document, target))
+          .update((document) => setRoutesInCatalog(document, environmentId, routes))
+          .pipe(Effect.mapError((error) => targetPersistenceError("set-connection-routes", error))),
+      remove: (environmentId) =>
+        catalog
+          .update((document) => removeConnectionFromCatalog(document, environmentId))
           .pipe(Effect.mapError((error) => targetPersistenceError("remove-connection", error))),
       setEnabled: (environmentId, enabled) =>
         catalog
diff --git a/apps/mobile/src/features/cloud/cloud-drafts.ts b/apps/mobile/src/features/cloud/cloud-drafts.ts
index 1cc94da52bb3..124aef277485 100644
--- a/apps/mobile/src/features/cloud/cloud-drafts.ts
+++ b/apps/mobile/src/features/cloud/cloud-drafts.ts
@@ -1,4 +1,4 @@
-import { EnvironmentRegistry } from "@t3tools/client-runtime/connection";
+import { EnvironmentRegistry, removedWithRelay } from "@t3tools/client-runtime/connection";
 import { createRuntimeCommand } from "@t3tools/client-runtime/state/runtime";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
@@ -27,7 +27,8 @@ export const removeCloudEnvironments = createRuntimeCommand(connectionAtomRuntim
     const entries = yield* SubscriptionRef.get(registry.entries);
     const environmentIds = new Set(
       [...entries.values()]
-        .filter((entry) => entry.target._tag === "RelayConnectionTarget")
+        // Only environments that sign-out removes entirely lose their drafts.
+        .filter(removedWithRelay)
         .map((entry) => entry.target.environmentId),
     );
     // Credentials are already revoked. A failed backup must leave the local
diff --git a/apps/mobile/src/features/connection/ConnectionsNewRouteScreen.tsx b/apps/mobile/src/features/connection/ConnectionsNewRouteScreen.tsx
index 1cf2dfd6b69b..b46f5433ff60 100644
--- a/apps/mobile/src/features/connection/ConnectionsNewRouteScreen.tsx
+++ b/apps/mobile/src/features/connection/ConnectionsNewRouteScreen.tsx
@@ -6,6 +6,7 @@ import {
   useRoute,
   type StaticScreenProps,
 } from "@react-navigation/native";
+import type { EnvironmentId } from "@t3tools/contracts";
 import { AsyncResult } from "effect/unstable/reactivity";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { Alert, Linking, Platform, View } from "react-native";
@@ -23,6 +24,8 @@ type ConnectionsNewRouteParams = {
   readonly mode?: string;
   readonly pairingUrl?: string;
   readonly autoConnect?: string;
+  /** Adds a route to this saved machine instead of a new environment. */
+  readonly routeFor?: EnvironmentId;
 };
 
 export function ConnectionsNewRouteScreen({
@@ -158,7 +161,7 @@ export function ConnectionsNewRouteScreen({
       setIsSubmitting(true);
       onChangeConnectionPairingUrl(pairingUrl);
       try {
-        const result = await onConnectPress(pairingUrl);
+        const result = await onConnectPress(pairingUrl, params.routeFor);
         if (AsyncResult.isSuccess(result)) {
           if (replaceWithHome || !navigation.canGoBack()) {
             navigation.dispatch(StackActions.replace("Home"));
@@ -170,7 +173,7 @@ export function ConnectionsNewRouteScreen({
         setIsSubmitting(false);
       }
     },
-    [navigation, onChangeConnectionPairingUrl, onConnectPress],
+    [navigation, onChangeConnectionPairingUrl, onConnectPress, params.routeFor],
   );
 
   const handleSubmit = useCallback(async () => {
diff --git a/apps/mobile/src/features/connection/environmentSections.test.ts b/apps/mobile/src/features/connection/environmentSections.test.ts
index 3eff54259a03..1293e7893235 100644
--- a/apps/mobile/src/features/connection/environmentSections.test.ts
+++ b/apps/mobile/src/features/connection/environmentSections.test.ts
@@ -157,4 +157,21 @@ describe("mobile environment settings sections", () => {
     expect(sections.connectedCloudEnvironments).toEqual([cloud]);
     expect(sections.availableCloudEnvironments).toEqual([]);
   });
+
+  it("offers T3 Connect for a machine saved only over the LAN, as an added route", () => {
+    const local = connectedEnvironment({
+      environmentId: "environment-desk",
+      isRelayManaged: false,
+    });
+
+    const sections = splitEnvironmentSections({
+      connectedEnvironments: [local],
+      cloudEnvironments: [cloudEnvironment("environment-desk")],
+    });
+
+    expect(sections.localEnvironments).toEqual([local]);
+    expect(
+      sections.availableCloudEnvironments.map((environment) => environment.environmentId),
+    ).toEqual([EnvironmentId.make("environment-desk")]);
+  });
 });
diff --git a/apps/mobile/src/features/connection/useConnectionController.ts b/apps/mobile/src/features/connection/useConnectionController.ts
index 78bf8a5a4702..6445a6ff71cb 100644
--- a/apps/mobile/src/features/connection/useConnectionController.ts
+++ b/apps/mobile/src/features/connection/useConnectionController.ts
@@ -69,7 +69,11 @@ export function useConnectionController() {
   );
 
   const connectPairingUrl = useCallback(
-    (pairingUrl: string) => connectPairingUrlMutation(pairingUrl),
+    (pairingUrl: string, expectedEnvironmentId?: EnvironmentId) =>
+      connectPairingUrlMutation({
+        pairingUrl,
+        ...(expectedEnvironmentId === undefined ? {} : { expectedEnvironmentId }),
+      }),
     [connectPairingUrlMutation],
   );
   const connectRelayEnvironment = useCallback(
diff --git a/apps/mobile/src/features/settings/EnvironmentRoutesSection.tsx b/apps/mobile/src/features/settings/EnvironmentRoutesSection.tsx
new file mode 100644
index 000000000000..c95306c90132
--- /dev/null
+++ b/apps/mobile/src/features/settings/EnvironmentRoutesSection.tsx
@@ -0,0 +1,310 @@
+import { useAtomValue } from "@effect/atom-react";
+import {
+  type ConnectionRoute,
+  connectionRouteAddress,
+  connectionRouteId,
+  connectionRouteLabel,
+  connectionRoutes,
+  isLearned,
+} from "@t3tools/client-runtime/connection";
+import type { EnvironmentId } from "@t3tools/contracts";
+import * as Option from "effect/Option";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Alert, Pressable, View } from "react-native";
+import { Gesture, GestureDetector } from "react-native-gesture-handler";
+import Reanimated, { ReduceMotion, useAnimatedStyle, withTiming } from "react-native-reanimated";
+
+import { SymbolView } from "../../components/AppSymbol";
+import { AppText as Text } from "../../components/AppText";
+import { environmentCatalog } from "../../connection/catalog";
+import { environmentSession } from "../../state/session";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { SettingsSection } from "./components/SettingsSection";
+
+const ROW_HEIGHT = 64;
+
+/**
+ * The ways this device reaches an environment, preferred first. The first
+ * route that answers is used, and the connection moves back up the list when
+ * a better route is reachable again. Edit shows drag handles and remove
+ * buttons; Add route pairs this machine over another address.
+ */
+export function EnvironmentRoutesSection({
+  environmentId,
+  connected,
+  onAddRoute,
+}: {
+  readonly environmentId: EnvironmentId;
+  readonly connected: boolean;
+  readonly onAddRoute: () => void;
+}) {
+  const entry = useAtomValue(environmentCatalog.catalogValueAtom).entries.get(environmentId);
+  const prepared = useAtomValue(environmentSession.preparedConnectionValueAtom(environmentId));
+  const reorder = useAtomCommand(environmentCatalog.reorderRoutes, "route reorder");
+  const removeRoute = useAtomCommand(environmentCatalog.removeRoute, "route removal");
+  const [editing, setEditing] = useState(false);
+  const saved = entry === undefined ? [] : connectionRoutes(entry);
+  const savedIds = saved.map((route) => connectionRouteId(route.target));
+  // A dropped order shows until the catalog matches it.
+  const [pending, setPending] = useState<ReadonlyArray<string> | null>(null);
+  const order =
+    pending !== null &&
+    pending.length === savedIds.length &&
+    pending.some((id, index) => id !== savedIds[index])
+      ? pending
+      : savedIds;
+  const [drag, setDrag] = useState<{ readonly id: string; readonly translation: number } | null>(
+    null,
+  );
+  if (entry === undefined) return null;
+
+  const byId = new Map(saved.map((route) => [connectionRouteId(route.target), route]));
+  const routes = order.flatMap((id) => byId.get(id) ?? []);
+  const activeRouteId =
+    connected && Option.isSome(prepared) ? connectionRouteId(prepared.value.target) : null;
+
+  const commit = (next: ReadonlyArray<string>) => {
+    setPending(next);
+    void reorder({ environmentId, routeIds: next }).then((result) => {
+      if (result._tag === "Failure") setPending(null);
+    });
+  };
+  const move = (from: number, to: number) => {
+    if (to < 0 || to >= order.length || from === to) return;
+    const next = [...order];
+    const [moved] = next.splice(from, 1);
+    next.splice(to, 0, moved!);
+    commit(next);
+  };
+  const dropIndex = (from: number, translation: number) =>
+    Math.max(0, Math.min(order.length - 1, from + Math.round(translation / ROW_HEIGHT)));
+  const confirmRemove = (route: ConnectionRoute) =>
+    Alert.alert(
+      `Remove ${connectionRouteLabel(route)}?`,
+      connectionRouteAddress(route) ?? undefined,
+      [
+        { text: "Cancel", style: "cancel" },
+        {
+          text: "Remove",
+          style: "destructive",
+          onPress: () =>
+            void removeRoute({ environmentId, routeId: connectionRouteId(route.target) }),
+        },
+      ],
+    );
+
+  const dragFrom = drag === null ? -1 : order.indexOf(drag.id);
+  const dragTo = drag === null ? -1 : dropIndex(dragFrom, drag.translation);
+
+  return (
+    <SettingsSection
+      title="Routes"
+      trailing={
+        routes.length > 1 ? (
+          <Pressable
+            accessibilityRole="button"
+            onPress={() => setEditing((value) => !value)}
+            className="px-2 py-1 active:opacity-70"
+          >
+            <Text className="text-sm font-t3-medium text-primary-text">
+              {editing ? "Done" : "Edit"}
+            </Text>
+          </Pressable>
+        ) : undefined
+      }
+    >
+      {routes.map((route, index) => {
+        const id = connectionRouteId(route.target);
+        // Rows between the lifted row and its drop slot shift to make room.
+        const shift =
+          dragFrom === -1 || index === dragFrom
+            ? 0
+            : dragFrom < dragTo && index > dragFrom && index <= dragTo
+              ? -ROW_HEIGHT
+              : dragFrom > dragTo && index < dragFrom && index >= dragTo
+                ? ROW_HEIGHT
+                : 0;
+        return (
+          <RouteRow
+            key={id}
+            route={route}
+            position={index + 1}
+            count={routes.length}
+            inUse={id === activeRouteId}
+            editing={editing}
+            offset={index === dragFrom ? (drag?.translation ?? 0) : shift}
+            lifted={index === dragFrom}
+            onDragStart={() => setDrag({ id, translation: 0 })}
+            onDragMove={(translation) => setDrag({ id, translation })}
+            onDragEnd={(translation, cancelled) => {
+              setDrag(null);
+              if (!cancelled) move(index, dropIndex(index, translation));
+            }}
+            onStep={(direction) => move(index, direction === "up" ? index - 1 : index + 1)}
+            // The last route goes with the machine, which is "Remove" on the row.
+            // A learned route would be learned again, so it is only reordered.
+            onRemove={
+              routes.length > 1 && !isLearned(route) ? () => confirmRemove(route) : undefined
+            }
+          />
+        );
+      })}
+      <Pressable
+        accessibilityRole="button"
+        onPress={onAddRoute}
+        className="flex-row items-center gap-3 px-4 py-3.5 active:opacity-70"
+      >
+        <SymbolView name="plus" size={16} tintColorClassName="accent-icon" type="monochrome" />
+        <Text className="text-base text-primary-text">Add route</Text>
+      </Pressable>
+    </SettingsSection>
+  );
+}
+
+function RouteRow(props: {
+  readonly route: ConnectionRoute;
+  readonly position: number;
+  readonly count: number;
+  readonly inUse: boolean;
+  readonly editing: boolean;
+  readonly offset: number;
+  readonly lifted: boolean;
+  readonly onDragStart: () => void;
+  readonly onDragMove: (translation: number) => void;
+  readonly onDragEnd: (translation: number, cancelled: boolean) => void;
+  readonly onStep: (direction: "up" | "down") => void;
+  readonly onRemove: (() => void) | undefined;
+}) {
+  const { route, lifted, offset } = props;
+  const label = connectionRouteLabel(route);
+  const address = connectionRouteAddress(route);
+  const style = useAnimatedStyle(() => ({
+    transform: [
+      {
+        translateY: lifted
+          ? offset
+          : withTiming(offset, { duration: 160, reduceMotion: ReduceMotion.System }),
+      },
+    ],
+    zIndex: lifted ? 1 : 0,
+  }));
+  return (
+    <Reanimated.View
+      style={[{ height: ROW_HEIGHT }, style]}
+      className={
+        lifted ? "flex-row items-center bg-grouped-card shadow-md" : "flex-row items-center"
+      }
+    >
+      {props.editing && props.onRemove ? (
+        <Pressable
+          accessibilityRole="button"
+          accessibilityLabel={`Remove ${label} route`}
+          onPress={props.onRemove}
+          className="h-full items-center justify-center pl-4 active:opacity-70"
+        >
+          <SymbolView
+            name="xmark.circle.fill"
+            size={20}
+            tintColorClassName="accent-danger-foreground"
+            type="monochrome"
+          />
+        </Pressable>
+      ) : null}
+      <View
+        accessible
+        accessibilityLabel={[
+          label,
+          address,
+          isLearned(route) ? "Found automatically" : null,
+          props.inUse ? "In use" : null,
+          `Route ${props.position} of ${props.count}`,
+        ]
+          .filter((part) => part !== null)
+          .join(", ")}
+        className="min-w-0 flex-1 gap-0.5 px-4"
+      >
+        <View className="flex-row items-center gap-2">
+          <Text className="text-base text-foreground">{label}</Text>
+          {props.inUse ? (
+            <Text className="text-xs font-t3-medium text-success-foreground">In use</Text>
+          ) : null}
+        </View>
+        {address !== null ? (
+          <Text numberOfLines={1} className="text-sm text-foreground-muted">
+            {isLearned(route) ? `${address} · found automatically` : address}
+          </Text>
+        ) : null}
+      </View>
+      {props.editing ? (
+        <DragHandle
+          title={label}
+          canMoveUp={props.position > 1}
+          canMoveDown={props.position < props.count}
+          onStart={props.onDragStart}
+          onMove={props.onDragMove}
+          onEnd={props.onDragEnd}
+          onStep={props.onStep}
+        />
+      ) : null}
+    </Reanimated.View>
+  );
+}
+
+/** Pan recognition wins over the settings scroll view only inside the handle. */
+function DragHandle(props: {
+  readonly title: string;
+  readonly canMoveUp: boolean;
+  readonly canMoveDown: boolean;
+  readonly onStart: () => void;
+  readonly onMove: (translation: number) => void;
+  readonly onEnd: (translation: number, cancelled: boolean) => void;
+  readonly onStep: (direction: "up" | "down") => void;
+}) {
+  const latest = useRef(props);
+  useEffect(() => {
+    latest.current = props;
+  });
+  const translation = useRef(0);
+  const gesture = useMemo(
+    () =>
+      Gesture.Pan()
+        .minDistance(0)
+        .shouldCancelWhenOutside(false)
+        .runOnJS(true)
+        .onStart(() => {
+          translation.current = 0;
+          latest.current.onStart();
+        })
+        .onUpdate((event) => {
+          translation.current = event.translationY;
+          latest.current.onMove(event.translationY);
+        })
+        .onFinalize((_, success) => latest.current.onEnd(translation.current, !success)),
+    [],
+  );
+  return (
+    <GestureDetector gesture={gesture}>
+      <View
+        collapsable={false}
+        accessible
+        accessibilityRole="adjustable"
+        accessibilityLabel={`Reorder ${props.title}`}
+        accessibilityActions={[
+          ...(props.canMoveUp ? [{ name: "decrement", label: "Move up" }] : []),
+          ...(props.canMoveDown ? [{ name: "increment", label: "Move down" }] : []),
+        ]}
+        onAccessibilityAction={({ nativeEvent }) => {
+          if (nativeEvent.actionName === "decrement" && props.canMoveUp) props.onStep("up");
+          if (nativeEvent.actionName === "increment" && props.canMoveDown) props.onStep("down");
+        }}
+        style={{ width: 48, height: ROW_HEIGHT, alignItems: "center", justifyContent: "center" }}
+      >
+        <SymbolView
+          name="line.3.horizontal"
+          size={20}
+          tintColorClassName="accent-foreground-muted"
+        />
+      </View>
+    </GestureDetector>
+  );
+}
diff --git a/apps/mobile/src/features/settings/SettingsEnvironmentDetailRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsEnvironmentDetailRouteScreen.tsx
index be334da900ab..1e8e6c73ff0f 100644
--- a/apps/mobile/src/features/settings/SettingsEnvironmentDetailRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsEnvironmentDetailRouteScreen.tsx
@@ -1,5 +1,5 @@
 import { useAtomValue } from "@effect/atom-react";
-import type { StaticScreenProps } from "@react-navigation/native";
+import { useNavigation, type StaticScreenProps } from "@react-navigation/native";
 import type { EnvironmentId, ServerProvider } from "@t3tools/contracts";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import { AsyncResult } from "effect/unstable/reactivity";
@@ -15,6 +15,7 @@ import { environmentSession } from "../../state/session";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { useRemoteConnections } from "../../state/use-remote-environment-registry";
 import { ConnectionEnvironmentRow } from "../connection/ConnectionEnvironmentRow";
+import { EnvironmentRoutesSection } from "./EnvironmentRoutesSection";
 import { SettingsActionRow } from "./components/SettingsActionRow";
 import { SettingsScreen } from "./components/SettingsScreen";
 import { SettingsSection } from "./components/SettingsSection";
@@ -41,6 +42,7 @@ export function SettingsEnvironmentDetailRouteScreen({
 
 function EnvironmentDetail({ environmentId }: { readonly environmentId: EnvironmentId }) {
   const insets = useSafeAreaInsets();
+  const navigation = useNavigation();
   const connections = useRemoteConnections();
   const environment = connections.connectedEnvironments.find(
     (entry) => entry.environmentId === environmentId,
@@ -167,6 +169,19 @@ function EnvironmentDetail({ environmentId }: { readonly environmentId: Environm
                 onUpdate={connections.onUpdateEnvironment}
               />
             </SettingsSection>
+            <EnvironmentRoutesSection
+              environmentId={environmentId}
+              connected={connected}
+              onAddRoute={() =>
+                navigation.navigate("SettingsSheet", {
+                  screen: "SettingsContent",
+                  params: {
+                    screen: "SettingsEnvironmentNew",
+                    params: { routeFor: environmentId },
+                  },
+                })
+              }
+            />
             {!connected ? (
               <Text className="px-2 text-sm text-foreground-muted">
                 Connect this environment to manage it.
diff --git a/apps/mobile/src/features/threads/ComposerErrorNotice.tsx b/apps/mobile/src/features/threads/ComposerErrorNotice.tsx
new file mode 100644
index 000000000000..37ea6078f2ab
--- /dev/null
+++ b/apps/mobile/src/features/threads/ComposerErrorNotice.tsx
@@ -0,0 +1,55 @@
+import { useEffect } from "react";
+import { AccessibilityInfo, Platform, Pressable, View } from "react-native";
+
+import { AppText as Text } from "../../components/AppText";
+import { SymbolView } from "../../components/AppSymbol";
+
+/** Why the thread's last message did not send, above the composer until dismissed. */
+export function ComposerErrorNotice({
+  message,
+  onDismiss,
+}: {
+  readonly message: string;
+  readonly onDismiss: () => void;
+}) {
+  // accessibilityLiveRegion below only reaches TalkBack; VoiceOver needs an
+  // explicit announcement.
+  useEffect(() => {
+    if (Platform.OS === "ios") {
+      AccessibilityInfo.announceForAccessibility(message);
+    }
+  }, [message]);
+  return (
+    <View className="px-4 pb-3">
+      <View className="flex-row items-start gap-3 rounded-[20px] border-continuous bg-card p-4">
+        <SymbolView
+          name="exclamationmark.circle"
+          size={16}
+          tintColorClassName="accent-danger-foreground"
+          type="monochrome"
+        />
+        <Text
+          selectable
+          accessibilityLiveRegion="polite"
+          className="min-w-0 flex-1 text-sm text-foreground"
+        >
+          {message}
+        </Text>
+        <Pressable
+          accessibilityLabel="Dismiss error"
+          accessibilityRole="button"
+          hitSlop={12}
+          onPress={onDismiss}
+          className="p-1 active:opacity-60"
+        >
+          <SymbolView
+            name="xmark"
+            size={14}
+            tintColorClassName="accent-icon-muted"
+            type="monochrome"
+          />
+        </Pressable>
+      </View>
+    </View>
+  );
+}
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index 0e5ddf41e48a..0294726131d2 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -1,3 +1,4 @@
+import { useAtomValue } from "@effect/atom-react";
 import { useThreadReportedModelSelection } from "../../state/entities";
 import { UsageLimitRecoveryCard } from "./UsageLimitRecoveryCard";
 import { useNavigation } from "@react-navigation/native";
@@ -93,6 +94,10 @@ import { useEnvironmentQuery } from "../../state/query";
 import { threadDevicePreviews } from "../devices/threadDevicePreviews";
 import type { QueuedThreadMessage } from "../../state/thread-outbox-model";
 import { scopedThreadKey } from "../../lib/scopedEntities";
+import {
+  clearThreadComposerError,
+  threadComposerErrorsAtom,
+} from "../../state/thread-composer-error";
 import { threadEnvironment } from "../../state/threads";
 import { useAtomCommand } from "../../state/use-atom-command";
 import { useDelayedStatus } from "../../lib/useDelayedStatus";
@@ -104,6 +109,7 @@ import type {
   ThreadFeedLatestRun,
 } from "../../lib/threadActivity";
 import { PendingApprovalCard } from "./PendingApprovalCard";
+import { ComposerErrorNotice } from "./ComposerErrorNotice";
 import { ComposerFeedback } from "./ComposerFeedback";
 import { ComposerUsageLimits } from "./ComposerUsageLimits";
 import { PendingUserInputCard } from "./PendingUserInputCard";
@@ -364,6 +370,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
   const navigationHeaderHeight = useContext(HeaderHeightContext) || insets.top + 44;
   const agentLabel = `${props.selectedThread.modelSelection.instanceId} agent`;
   const selectedThreadKey = scopedThreadKey(props.environmentId, props.selectedThread.id);
+  const composerError = useAtomValue(threadComposerErrorsAtom)[selectedThreadKey]?.message ?? null;
   const queuedCount = useThreadQueuedCount({
     environmentId: props.environmentId,
     threadId: props.selectedThread.id,
@@ -1196,6 +1203,18 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                     onDismiss={() => props.onDismissFeedback(submission.id)}
                   />
                 ))}
+                {composerError !== null ? (
+                  <Animated.View
+                    className="shrink-0"
+                    entering={FadeInDown.duration(180)}
+                    exiting={FadeOut.duration(120)}
+                  >
+                    <ComposerErrorNotice
+                      message={composerError}
+                      onDismiss={() => clearThreadComposerError(selectedThreadKey)}
+                    />
+                  </Animated.View>
+                ) : null}
                 {usageLimitsReport && activeUserInputRequestId === null ? (
                   <Animated.View
                     className="shrink-0 px-4 pb-3"
diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx
index 7d591d59e8c5..0f55d36c0110 100644
--- a/apps/mobile/src/features/threads/ThreadFeed.tsx
+++ b/apps/mobile/src/features/threads/ThreadFeed.tsx
@@ -36,6 +36,8 @@ import {
   type CodexArtifactTemplate,
 } from "@t3tools/client-runtime/codex-artifact-templates";
 import { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";
+import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
+import { getTextContent, type MarkdownNode } from "react-native-nitro-markdown/headless";
 import { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import {
@@ -721,7 +723,7 @@ interface MarkdownStyleSet {
 }
 
 const failedMarkdownFaviconHosts = new Set<string>();
-const MarkdownLinkLabelContext = createContext(false);
+const MarkdownLinkLabelContext = createContext<"file" | "other" | null>(null);
 const markdownLinkStyles = StyleSheet.create({
   inlineIcon: {
     width: 14,
@@ -813,6 +815,22 @@ function MarkdownInlineCode(props: {
   );
 }
 
+function MarkdownImage(props: {
+  readonly node: MarkdownNode;
+  readonly renderImage: MarkdownImageRenderer;
+}) {
+  const insideLink = useContext(MarkdownLinkLabelContext);
+  if (insideLink === "file")
+    return <NativeText>{props.node.alt ?? props.node.title ?? ""}</NativeText>;
+  return props.node.href
+    ? props.renderImage({
+        href: props.node.href,
+        alt: props.node.alt ?? null,
+        title: props.node.title ?? null,
+      })
+    : null;
+}
+
 const ARTIFACT_TEMPLATE_SYMBOL_BY_KIND: Record<
   CodexArtifactTemplate["artifactKind"],
   AppSymbolName
@@ -1183,26 +1201,31 @@ function useMarkdownStyles(
       preserveSoftBreaks: boolean,
       highlightCode: boolean,
     ): CustomRenderers => ({
-      link: ({ children, href = "" }) => {
+      link: ({ children, node, href = "" }) => {
         const presentation = resolveMarkdownLinkPresentation(href);
         if (presentation.kind === "file") {
           return (
-            <NativeText
-              className="font-t3-bold"
-              onPress={() => onLinkPress(href)}
-              style={{ color: inlineTextColor }}
-            >
-              <Image
-                source={markdownFileIconSource(presentation.icon)}
-                style={markdownLinkStyles.inlineIcon}
-              />
-              {presentation.label}
-            </NativeText>
+            <MarkdownLinkLabelContext.Provider value="file">
+              <NativeText onPress={() => onLinkPress(href)} style={{ color: inlineTextColor }}>
+                {!isMarkdownFileLinkLabel(getTextContent(node), href) && <>{children} </>}
+                <NativeText
+                  className="font-t3-bold"
+                  onPress={() => onLinkPress(href)}
+                  style={{ color: inlineTextColor }}
+                >
+                  <Image
+                    source={markdownFileIconSource(presentation.icon)}
+                    style={markdownLinkStyles.inlineIcon}
+                  />
+                  {presentation.label}
+                </NativeText>
+              </NativeText>
+            </MarkdownLinkLabelContext.Provider>
           );
         }
         if (presentation.kind === "external") {
           return (
-            <MarkdownLinkLabelContext.Provider value>
+            <MarkdownLinkLabelContext.Provider value="other">
               <MarkdownExternalLink
                 href={presentation.href}
                 host={presentation.host}
@@ -1216,7 +1239,7 @@ function useMarkdownStyles(
         }
         const linkHref = presentation.href;
         return (
-          <MarkdownLinkLabelContext.Provider value>
+          <MarkdownLinkLabelContext.Provider value="other">
             <NativeText
               className="underline"
               onPress={
@@ -1265,14 +1288,7 @@ function useMarkdownStyles(
           })}
         </View>
       ),
-      image: ({ node }) =>
-        node.href
-          ? (renderImage({
-              href: node.href,
-              alt: node.alt ?? null,
-              title: node.title ?? null,
-            }) ?? undefined)
-          : undefined,
+      image: ({ node }) => <MarkdownImage node={node} renderImage={renderImage} />,
       code_inline: ({ content }) => (
         <MarkdownInlineCode
           content={content ?? ""}
diff --git a/apps/mobile/src/features/threads/thread-subagent-group.tsx b/apps/mobile/src/features/threads/thread-subagent-group.tsx
index c0f1adf4736e..aacc2c07353f 100644
--- a/apps/mobile/src/features/threads/thread-subagent-group.tsx
+++ b/apps/mobile/src/features/threads/thread-subagent-group.tsx
@@ -1,5 +1,5 @@
 import { useAtomValue } from "@effect/atom-react";
-import { useIsFocused, useNavigation } from "@react-navigation/native";
+import { StackActions, useIsFocused, useNavigation } from "@react-navigation/native";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { summarizeSubagentStatuses } from "@t3tools/client-runtime/state/subagent-display";
 import { isActiveSubagentStatus } from "@t3tools/client-runtime/state/subagentRuntime";
@@ -158,11 +158,15 @@ export function ThreadSubagentGroup(props: {
                 }
                 disabled={threadId === null}
                 onPress={() => {
+                  // Push, not navigate: navigate reuses this Thread route, so back
+                  // would skip the parent thread.
                   if (threadId !== null)
-                    navigation.navigate("Thread", {
-                      environmentId: String(props.environmentId),
-                      threadId: String(threadId),
-                    });
+                    navigation.dispatch(
+                      StackActions.push("Thread", {
+                        environmentId: String(props.environmentId),
+                        threadId: String(threadId),
+                      }),
+                    );
                 }}
                 className="rounded-lg px-3 py-3 active:bg-subtle"
               >
diff --git a/apps/mobile/src/features/threads/thread-work-log.tsx b/apps/mobile/src/features/threads/thread-work-log.tsx
index 57287c81eda1..dd2ebeb76ff6 100644
--- a/apps/mobile/src/features/threads/thread-work-log.tsx
+++ b/apps/mobile/src/features/threads/thread-work-log.tsx
@@ -60,9 +60,12 @@ import { cn } from "../../lib/cn";
 import { THREAD_WORK_ROW_MIN_HEIGHT, type deriveThreadWorkLogSizing } from "../../lib/layout";
 import {
   type AgentSpawnSummary,
+  formatItemFullDetail,
   type ThreadFeedActivity,
   workEntryRowLabel,
 } from "../../lib/threadActivity";
+import { toolCallLines, turnItemOutputText } from "@t3tools/client-runtime/work-log/item-detail";
+import { useTurnItemDetail } from "../../state/queries";
 import {
   resolveThreadWorkGroupInitialScroll,
   shouldFollowThreadWorkGroupAppend,
@@ -70,6 +73,7 @@ import {
 } from "./thread-feed-live-follow";
 import {
   resolveWorkEntryToolPresentation,
+  toolGroupAction,
   type ToolGroupSummaryKind,
   workEntryViewedImagePath,
 } from "@t3tools/client-runtime/work-log/presentation";
@@ -836,6 +840,11 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
 ) {
   const { row, expanded } = props;
   const navigation = useNavigation();
+  const fetchedDetail = useTurnItemDetail(
+    expanded && row.fetchesDetail
+      ? { environmentId: props.environmentId, row: row.projectedItem }
+      : null,
+  );
   const failureItem = row.projectedItem.item;
   if (failureItem.type === "error" && failureItem.status === "failed") {
     const warning = failureItem.failure.class === "usage_limit";
@@ -917,7 +926,44 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
       : undefined;
   const canExpand = row.canExpand && notifiedSubagentThreadId === undefined;
   const reasoning = row.projectedItem.item.type === "reasoning" ? row.projectedItem.item : null;
-  const fullDetail = expanded && !reasoning ? row.getFullDetail() : null;
+  const fetchedItem = fetchedDetail.data?.item ?? null;
+  // Reads keep their path list; the fetched file contents show as output.
+  const isRead = toolGroupAction(row.workEntry) === "read";
+  // Tool calls show the call in the foreground and the result muted below it.
+  const shownItem = fetchedItem ?? row.projectedItem.item;
+  const call =
+    expanded && !isRead && shownItem.type === "command_execution"
+      ? toolCallLines({ command: shownItem.input })
+      : expanded && !isRead && shownItem.type === "dynamic_tool"
+        ? toolCallLines({ args: shownItem.input })
+        : expanded && shownItem.type === "file_search"
+          ? toolCallLines({ args: { pattern: shownItem.pattern } })
+          : expanded && shownItem.type === "web_search"
+            ? toolCallLines({ args: { query: shownItem.patterns?.join(", ") } })
+            : null;
+  const failedExitCode =
+    call && shownItem.type === "command_execution" && shownItem.exitCode
+      ? shownItem.exitCode
+      : null;
+  const fullDetail =
+    expanded && !reasoning && !call
+      ? fetchedItem && !isRead
+        ? formatItemFullDetail(row.projectedItem, fetchedItem)
+        : row.getFullDetail()
+      : null;
+  const fetchedOutput = !expanded
+    ? null
+    : shownItem.type === "file_search" || shownItem.type === "web_search"
+      ? turnItemOutputText(shownItem)
+      : fetchedItem
+        ? (turnItemOutputText(fetchedItem) ?? "No output.")
+        : fetchedDetail.error
+          ? `Couldn't load output: ${fetchedDetail.error}`
+          : row.fetchesDetail
+            ? fetchedDetail.data
+              ? "Output is no longer available."
+              : "Loading output…"
+            : null;
   const viewedImagePath = workEntryViewedImagePath(row.workEntry);
   const toolPresentation = resolveWorkEntryToolPresentation(row.workEntry);
   const previewText = workEntryRowLabel(row.workEntry);
@@ -1060,7 +1106,13 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
         </View>
       </WorkLogPressable>
 
-      {expanded && (reasoning || fullDetail || viewedImagePath || row.workEntry.questionAnswer) ? (
+      {expanded &&
+      (reasoning ||
+        fullDetail ||
+        call ||
+        fetchedOutput ||
+        viewedImagePath ||
+        row.workEntry.questionAnswer) ? (
         <Animated.View
           entering={WORK_LOG_DETAIL_ENTER_TRANSITION}
           exiting={WORK_LOG_DETAIL_EXIT_TRANSITION}
@@ -1087,11 +1139,43 @@ const ThreadWorkLogRow = memo(function ThreadWorkLogRow(
           >
             {reasoning ? (
               props.renderReasoning(reasoning.text)
-            ) : (
+            ) : call ? (
+              [
+                call.command,
+                ...(call.args ?? []).map(([key, value]) => `${key} ${value}`),
+                call.argsText,
+              ]
+                .filter((line): line is string => Boolean(line))
+                .map((line, index) => (
+                  <Text
+                    key={`${index}:${line}`}
+                    selectable
+                    className="font-mono text-2xs leading-normal text-foreground"
+                  >
+                    {line}
+                  </Text>
+                ))
+            ) : fullDetail ? (
               <Text selectable className="font-mono text-2xs leading-normal text-foreground-muted">
                 {fullDetail}
               </Text>
-            )}
+            ) : null}
+            {fetchedOutput ? (
+              <Text
+                selectable
+                className={cn(
+                  "font-mono text-2xs leading-normal text-foreground-muted",
+                  (!call || call.command || call.args || call.argsText) && "mt-1.5",
+                )}
+              >
+                {fetchedOutput}
+              </Text>
+            ) : null}
+            {failedExitCode !== null ? (
+              <Text className="mt-1.5 font-mono text-2xs leading-normal text-danger-foreground">
+                exit {failedExitCode}
+              </Text>
+            ) : null}
           </ScrollView>
         </Animated.View>
       ) : null}
diff --git a/apps/mobile/src/features/threads/use-composer-command-menu.test.ts b/apps/mobile/src/features/threads/use-composer-command-menu.test.ts
index 3b748f2a99d0..ecf4cd8b4191 100644
--- a/apps/mobile/src/features/threads/use-composer-command-menu.test.ts
+++ b/apps/mobile/src/features/threads/use-composer-command-menu.test.ts
@@ -1,5 +1,14 @@
-import { describe, expect, it, vi } from "vite-plus/test";
-import { ProviderDriverKind } from "@t3tools/contracts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import {
+  EnvironmentId,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  type ServerProvider,
+} from "@t3tools/contracts";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+
+const refreshProviders = vi.hoisted(() => vi.fn());
 vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } }));
 
 vi.mock("../../state/queries", () => ({
@@ -8,6 +17,7 @@ vi.mock("../../state/queries", () => ({
 }));
 vi.mock("../../state/use-composer-drafts", () => ({
   getComposerDraftSnapshot: vi.fn(),
+  readComposerDraftSelection: vi.fn(),
   setComposerDraftContext: vi.fn(),
 }));
 vi.mock("../../lib/uuid", () => ({ uuidv4: () => "context-id" }));
@@ -15,12 +25,13 @@ vi.mock("../../state/server", () => ({
   serverEnvironment: { refreshProviders: Symbol("refreshProviders") },
 }));
 vi.mock("../../state/use-atom-command", () => ({
-  useAtomCommand: () => vi.fn(),
+  useAtomCommand: () => refreshProviders,
 }));
 
 import {
   buildComposerSlashCommandItems,
   resolveComposerCommandSelection,
+  useComposerCommandMenu,
 } from "./use-composer-command-menu";
 
 describe("mobile slash commands", () => {
@@ -101,3 +112,214 @@ describe("mobile slash commands", () => {
     ).toEqual({ text: "/plan ", cursor: 6, interactionMode: null });
   });
 });
+
+describe("workspace command discovery retry", () => {
+  let root: Root;
+  const environmentId = EnvironmentId.make("test-environment");
+  const instanceId = ProviderInstanceId.make("claude");
+  const provider = {
+    instanceId,
+    driver: ProviderDriverKind.make("claude"),
+    enabled: true,
+    installed: true,
+    version: "1.0.0",
+    status: "ready",
+    auth: { status: "authenticated" },
+    checkedAt: "2026-01-01T00:00:00.000Z",
+    models: [],
+    slashCommands: [],
+    skills: [],
+    workspaceSnapshots: [
+      {
+        cwd: "/project-a",
+        checkedAt: "2026-01-01T00:00:00.000Z",
+        slashCommandsPending: true,
+        slashCommands: [{ name: "compact" }],
+        skills: [],
+      },
+    ],
+  } satisfies ServerProvider;
+
+  function Probe({ cwd, status = provider }: { cwd: string; status?: ServerProvider }) {
+    useComposerCommandMenu({
+      draftMessage: "/project",
+      ownerKey: null,
+      environmentId,
+      projectCwd: cwd,
+      selectedProviderStatus: status,
+      provisionedSkills: undefined,
+      hasThread: false,
+      hasCompactableConversation: false,
+      onChangeDraftMessage: () => {},
+    });
+    return null;
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    refreshProviders.mockReset();
+    refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [provider] } });
+    const document = { nodeType: 9, addEventListener() {}, removeEventListener() {} };
+    const container = {
+      nodeType: 1,
+      tagName: "DIV",
+      namespaceURI: "http://www.w3.org/1999/xhtml",
+      ownerDocument: document,
+      addEventListener() {},
+      removeEventListener() {},
+    };
+    vi.stubGlobal("document", document);
+    vi.stubGlobal("window", { document, HTMLIFrameElement: EventTarget });
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    root = createRoot(container as unknown as HTMLElement);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("retries partial commands after the cooldown without editing the draft", async () => {
+    const recovered = {
+      ...provider,
+      workspaceSnapshots: [{ ...provider.workspaceSnapshots[0], slashCommandsPending: false }],
+    };
+    refreshProviders.mockResolvedValueOnce({ _tag: "Success", value: { providers: [provider] } });
+    refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a" }));
+    });
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    await act(() => vi.advanceTimersByTimeAsync(9_999));
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    await act(() => vi.advanceTimersByTimeAsync(1));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+    expect(refreshProviders).toHaveBeenLastCalledWith({
+      environmentId,
+      input: { instanceId, cwd: "/project-a" },
+    });
+    await act(() => vi.advanceTimersByTimeAsync(20_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+  });
+
+  it.each(["pi", "acpRegistry"])(
+    "does not poll a healthy %s workspace without discovery",
+    async (driver) => {
+      const unsupported = {
+        ...provider,
+        driver: ProviderDriverKind.make(driver),
+        workspaceSnapshots: [],
+      };
+      refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [unsupported] } });
+      await act(async () => {
+        root.render(createElement(Probe, { cwd: "/project-a", status: unsupported }));
+      });
+      expect(refreshProviders).toHaveBeenCalledTimes(1);
+      await act(() => vi.advanceTimersByTimeAsync(30_000));
+      expect(refreshProviders).toHaveBeenCalledTimes(1);
+      expect(vi.getTimerCount()).toBe(0);
+    },
+  );
+
+  it("arms the remaining cooldown when a concurrent scan publishes partial commands", async () => {
+    const missing = { ...provider, workspaceSnapshots: [] };
+    const recovered = {
+      ...provider,
+      workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
+        ...snapshot,
+        slashCommandsPending: false,
+      })),
+    };
+    refreshProviders.mockResolvedValueOnce({ _tag: "Success", value: { providers: [missing] } });
+    refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a", status: missing }));
+    });
+    await act(() => vi.advanceTimersByTimeAsync(5_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a", status: provider }));
+    });
+    await act(() => vi.advanceTimersByTimeAsync(4_999));
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    await act(() => vi.advanceTimersByTimeAsync(1));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+    await act(() => vi.advanceTimersByTimeAsync(20_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry when a concurrent scan publishes a complete workspace", async () => {
+    const missing = { ...provider, workspaceSnapshots: [] };
+    const recovered = {
+      ...provider,
+      workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
+        ...snapshot,
+        slashCommandsPending: false,
+      })),
+    };
+    refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [missing] } });
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a", status: missing }));
+    });
+    await act(() => vi.advanceTimersByTimeAsync(5_000));
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a", status: recovered }));
+    });
+    await act(() => vi.advanceTimersByTimeAsync(30_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("retries a rejected refresh while published discovery remains pending", async () => {
+    const recovered = {
+      ...provider,
+      workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
+        ...snapshot,
+        slashCommandsPending: false,
+      })),
+    };
+    refreshProviders.mockRejectedValueOnce(new Error("Connection lost"));
+    refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a" }));
+    });
+    await act(() => vi.advanceTimersByTimeAsync(10_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+    await act(() => vi.advanceTimersByTimeAsync(20_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+  });
+
+  it("cancels the old workspace retry and does not duplicate an in-flight request", async () => {
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a" }));
+    });
+    refreshProviders.mockImplementationOnce(() => new Promise(() => {}));
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-b" }));
+    });
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+    await act(() => vi.advanceTimersByTimeAsync(20_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(2);
+    expect(refreshProviders).toHaveBeenLastCalledWith({
+      environmentId,
+      input: { instanceId, cwd: "/project-b" },
+    });
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("cancels a scheduled retry when the composer unmounts", async () => {
+    await act(async () => {
+      root.render(createElement(Probe, { cwd: "/project-a" }));
+    });
+    await act(async () => {
+      root.unmount();
+    });
+    await act(() => vi.advanceTimersByTimeAsync(20_000));
+    expect(refreshProviders).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});
diff --git a/apps/mobile/src/features/threads/use-composer-command-menu.ts b/apps/mobile/src/features/threads/use-composer-command-menu.ts
index 46f7bd17ee04..83e961b6d723 100644
--- a/apps/mobile/src/features/threads/use-composer-command-menu.ts
+++ b/apps/mobile/src/features/threads/use-composer-command-menu.ts
@@ -37,6 +37,7 @@ import {
   getProviderSkillsForSlashMenu,
   getProviderSlashCommandsForSlashMenu,
   isProviderSkillUserInvocable,
+  hasCompleteProviderWorkspaceSnapshot,
   resolveProviderSkillsForCwd,
   resolveProviderSlashCommandsForCwd,
 } from "@t3tools/client-runtime/providerSkills";
@@ -251,17 +252,43 @@ export function useComposerCommandMenu({
     reportFailure: false,
   });
   const selectedProviderInstanceId = selectedProviderStatus?.instanceId;
-  const hasWorkspaceSnapshot = Boolean(
-    projectCwd &&
-    selectedProviderStatus?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === projectCwd),
+  const hasWorkspaceSnapshot = hasCompleteProviderWorkspaceSnapshot(
+    selectedProviderStatus,
+    projectCwd,
   );
   const workspaceRefreshKeyRef = useRef<string | null>(null);
-  const workspaceRefreshRetryRef = useRef<{ key: string; notBefore: number } | null>(null);
+  const [workspaceRefreshRetry, setWorkspaceRefreshRetry] = useState<{
+    key: string;
+    notBefore: number;
+  } | null>(null);
+  const workspaceRefreshScopeKey =
+    environmentId && projectCwd && selectedProviderInstanceId
+      ? `${environmentId}:${selectedProviderInstanceId}:${projectCwd}`
+      : null;
+  const workspaceSlashCommandsPending =
+    selectedProviderStatus?.workspaceSnapshots?.some(
+      (snapshot) => snapshot.cwd === projectCwd && snapshot.slashCommandsPending === true,
+    ) ?? false;
+  useEffect(() => {
+    if (
+      !workspaceSlashCommandsPending ||
+      !workspaceRefreshRetry ||
+      workspaceRefreshRetry.key !== workspaceRefreshScopeKey
+    )
+      return;
+    const timeout = setTimeout(
+      () => {
+        setWorkspaceRefreshRetry((current) => (current === workspaceRefreshRetry ? null : current));
+      },
+      Math.max(0, workspaceRefreshRetry.notBefore - Date.now()),
+    );
+    return () => clearTimeout(timeout);
+  }, [workspaceRefreshRetry, workspaceRefreshScopeKey, workspaceSlashCommandsPending]);
   const hadWorkspaceSnapshotRef = useRef(false);
   useEffect(() => {
     if (hadWorkspaceSnapshotRef.current && !hasWorkspaceSnapshot) {
       workspaceRefreshKeyRef.current = null;
-      workspaceRefreshRetryRef.current = null;
+      setWorkspaceRefreshRetry(null);
     }
     hadWorkspaceSnapshotRef.current = hasWorkspaceSnapshot;
   }, [hasWorkspaceSnapshot]);
@@ -271,19 +298,19 @@ export function useComposerCommandMenu({
     if (workspaceRefreshKeyRef.current === key) return;
     if (hasWorkspaceSnapshot) {
       workspaceRefreshKeyRef.current = key;
-      workspaceRefreshRetryRef.current = null;
+      setWorkspaceRefreshRetry(null);
       return;
     }
-    const retry = workspaceRefreshRetryRef.current;
+    const retry = workspaceRefreshRetry;
     if (retry?.key === key && Date.now() < retry.notBefore) return;
     workspaceRefreshKeyRef.current = key;
     const retryLater = () => {
       if (workspaceRefreshKeyRef.current !== key) return;
       workspaceRefreshKeyRef.current = null;
-      workspaceRefreshRetryRef.current = {
+      setWorkspaceRefreshRetry({
         key,
         notBefore: Date.now() + WORKSPACE_SNAPSHOT_RETRY_COOLDOWN_MS,
-      };
+      });
     };
     void refreshProviders({
       environmentId,
@@ -291,9 +318,12 @@ export function useComposerCommandMenu({
     }).then((result) => {
       const refreshed =
         result._tag === "Success" &&
-        result.value.providers
-          .find((provider) => provider.instanceId === selectedProviderInstanceId)
-          ?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === projectCwd);
+        hasCompleteProviderWorkspaceSnapshot(
+          result.value.providers.find(
+            (provider) => provider.instanceId === selectedProviderInstanceId,
+          ),
+          projectCwd,
+        );
       if (!refreshed && workspaceRefreshKeyRef.current === key) {
         retryLater();
       }
@@ -305,6 +335,7 @@ export function useComposerCommandMenu({
     projectCwd,
     refreshProviders,
     selectedProviderInstanceId,
+    workspaceRefreshRetry,
   ]);
 
   const trigger = useMemo(() => {
diff --git a/apps/mobile/src/lib/nativeMarkdownText.test.ts b/apps/mobile/src/lib/nativeMarkdownText.test.ts
index fca30deea89a..0a4357ee1240 100644
--- a/apps/mobile/src/lib/nativeMarkdownText.test.ts
+++ b/apps/mobile/src/lib/nativeMarkdownText.test.ts
@@ -138,7 +138,7 @@ describe("nativeMarkdownTextRuns", () => {
         {
           type: "link",
           href: "file:///repo/README.md#L12",
-          children: [{ type: "text", content: "ignored label" }],
+          children: [{ type: "text", content: "validates the input" }],
         },
       ],
     };
@@ -150,14 +150,116 @@ describe("nativeMarkdownTextRuns", () => {
         externalHost: "example.com",
       },
       { text: " " },
+      {
+        text: "validates the input ",
+        href: "file:///repo/README.md#L12",
+        sourceText: "[validates the input](<file:///repo/README.md#L12>)",
+      },
       {
         text: "README.md:12",
         href: "file:///repo/README.md#L12",
         fileIcon: "markdown",
+        sourceText: "[validates the input](<file:///repo/README.md#L12>)",
+      },
+    ]);
+  });
+
+  it.each([true, false])("copies descriptive file links with collapsed chips=%s", (collapsed) => {
+    const link: MarkdownNode = {
+      type: "link",
+      href: "/repo/src/example.ts:12",
+      children: [
+        { type: "text", content: "validates " },
+        { type: "bold", children: [{ type: "text", content: "the input" }] },
+      ],
+    };
+    const runs = nativeMarkdownTextRuns({ type: "paragraph", children: [link, link] });
+    expect(runs.map((run) => run.text).join("")).toBe(
+      "validates the input example.ts:12validates the input example.ts:12",
+    );
+    expect(runs.filter((run) => run.bold).map((run) => run.text)).toEqual([
+      "the input",
+      "the input",
+    ]);
+    const ranges = nativeMarkdownContextCopyRanges(
+      runs.map((run) => ({
+        run,
+        text: collapsed && run.fileIcon ? "" : run.text,
+        inlineImageLength: run.fileIcon ? 1 : 0,
+      })),
+    );
+    const length = "validates the input ".length + (collapsed ? 1 : "example.ts:12".length + 1);
+    expect(ranges).toEqual([
+      { start: 0, end: length, text: "[validates **the input**](</repo/src/example.ts:12>)" },
+      {
+        start: length,
+        end: length * 2,
+        text: "[validates **the input**](</repo/src/example.ts:12>)",
       },
     ]);
   });
 
+  it("keeps filename-labelled links as chips", () => {
+    expect(
+      nativeMarkdownTextRuns({
+        type: "paragraph",
+        children: [
+          {
+            type: "link",
+            href: "/repo/src/example.ts:12",
+            children: [{ type: "code_inline", content: "src/example.ts:12" }],
+          },
+        ],
+      }),
+    ).toEqual([{ text: "example.ts:12", href: "/repo/src/example.ts:12", fileIcon: "typescript" }]);
+  });
+
+  it.each([
+    [{ type: "italic", children: [{ type: "text", content: "details" }] }, "*details*"],
+    [{ type: "strikethrough", children: [{ type: "text", content: "details" }] }, "~~details~~"],
+    [{ type: "code_inline", content: "`details`" }, "`` `details` ``"],
+    [{ type: "code_inline", content: " details " }, "`  details  `"],
+    [{ type: "text", content: "[details] *literal*" }, "\\[details\\] \\*literal\\*"],
+    [{ type: "soft_break" }, "\n"],
+    [{ type: "line_break" }, "  \n"],
+    [
+      { type: "image", alt: "details", href: "https://example.com/icon.png" },
+      "![details](<https://example.com/icon.png>)",
+    ],
+  ] satisfies ReadonlyArray<readonly [MarkdownNode, string]>)(
+    "keeps descriptive label markup when copying %j",
+    (child, source) => {
+      const runs = nativeMarkdownTextRuns({
+        type: "paragraph",
+        children: [
+          {
+            type: "link",
+            href: "/repo/a.ts",
+            children: [{ type: "text", content: "see " }, child],
+          },
+        ],
+      });
+      expect(
+        nativeMarkdownContextCopyRanges(
+          runs.map((run) => ({
+            run,
+            text: run.fileIcon ? "" : run.text,
+            inlineImageLength: run.fileIcon ? 1 : 0,
+          })),
+        ),
+      ).toEqual([
+        {
+          start: 0,
+          end:
+            runs
+              .filter((run) => !run.fileIcon)
+              .reduce((length, run) => length + run.text.length, 0) + 1,
+          text: `[see ${source}](</repo/a.ts>)`,
+        },
+      ]);
+    },
+  );
+
   it("keeps hard breaks and collapses soft breaks", () => {
     const node: MarkdownNode = {
       type: "paragraph",
diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts
index 16fd407f537b..5471f24704a9 100644
--- a/apps/mobile/src/lib/threadActivity.test.ts
+++ b/apps/mobile/src/lib/threadActivity.test.ts
@@ -271,6 +271,35 @@ describe("buildThreadFeed", () => {
     expect(items[0]).toMatchObject({ output: rawOutput });
   });
 
+  it("expands tool rows only when they have detail or withheld output", () => {
+    const items: OrchestrationV2TurnItem[] = [
+      { ...command(), input: "", outputOmitted: true },
+      {
+        ...base("dynamic-empty", "2026-06-20T00:00:03.000Z", 2),
+        type: "dynamic_tool",
+        toolName: "example",
+        input: {},
+      },
+      {
+        ...base("read-omitted", "2026-06-20T00:00:04.000Z", 3),
+        type: "dynamic_tool",
+        toolName: "Read",
+        input: { path: "src/env.ts" },
+        outputOmitted: true,
+      },
+    ];
+    const activities = buildThreadFeed(items.map((item, index) => projected(item, index))).flatMap(
+      (entry) => (entry.type === "activity-group" ? entry.activities : []),
+    );
+    expect(
+      activities.map(({ canExpand, fetchesDetail }) => ({ canExpand, fetchesDetail })),
+    ).toEqual([
+      { canExpand: true, fetchesDetail: true },
+      { canExpand: false, fetchesDetail: false },
+      { canExpand: true, fetchesDetail: true },
+    ]);
+  });
+
   it("recognizes automation attribution after projecting a user message", () => {
     const feed = buildThreadFeed([
       projected(
@@ -1236,6 +1265,7 @@ describe("buildThreadFeed", () => {
       summary: `Tool ${id}`,
       detail: null,
       canExpand: false,
+      fetchesDetail: false,
       getFullDetail: () => null,
       getCopyText: () => id,
       icon: "command",
diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts
index 3a77324a7ac8..a77491795704 100644
--- a/apps/mobile/src/lib/threadActivity.ts
+++ b/apps/mobile/src/lib/threadActivity.ts
@@ -6,6 +6,10 @@ import type {
 import { turnItemIsWorkspacePreparation } from "@t3tools/client-runtime/state/turn-item-presentation";
 import { formatSubagentDisplayTitle } from "@t3tools/client-runtime/state/subagent-display";
 import { extractToolActivityPresentation } from "@t3tools/client-runtime/work-log/tool-presentation";
+import {
+  turnItemHasDetail,
+  turnItemNeedsDetailFetch,
+} from "@t3tools/client-runtime/work-log/item-detail";
 import {
   commandDisplayText,
   commandProgramName,
@@ -74,6 +78,8 @@ export interface ThreadFeedActivity {
   readonly summary: string;
   readonly detail: string | null;
   readonly canExpand: boolean;
+  /** Expanding fetches the withheld input and output with getTurnItem. */
+  readonly fetchesDetail: boolean;
   readonly getFullDetail: () => string | null;
   readonly getCopyText: () => string;
   readonly icon:
@@ -721,6 +727,23 @@ function toWorkLogEntry(
   }
 }
 
+/** Expanded detail for a row, from its wire item or the full item from getTurnItem. */
+export function formatItemFullDetail(
+  row: OrchestrationV2ProjectedTurnItem,
+  item: OrchestrationV2TurnItem,
+): string {
+  return JSON.stringify(
+    {
+      visibility: row.visibility,
+      sourceThreadId: row.sourceThreadId,
+      sourceItemId: row.sourceItemId,
+      item: toolItemForDisplay(item),
+    },
+    null,
+    2,
+  );
+}
+
 function toFeedActivity(
   row: OrchestrationV2ProjectedTurnItem,
   attemptId: RunAttemptId | null,
@@ -735,21 +758,9 @@ function toFeedActivity(
     item.type === "dynamic_tool" && toolGroupAction(workEntry) === "read"
       ? collectToolFilePaths(item)
       : null;
-  const getFullDetail = memoizeValue(() => {
-    if (readPaths) {
-      return readPaths.join("\n") || null;
-    }
-    return JSON.stringify(
-      {
-        visibility: row.visibility,
-        sourceThreadId: row.sourceThreadId,
-        sourceItemId: row.sourceItemId,
-        item: toolItemForDisplay(item),
-      },
-      null,
-      2,
-    );
-  });
+  const getFullDetail = memoizeValue(() =>
+    readPaths ? readPaths.join("\n") || null : formatItemFullDetail(row, item),
+  );
   const getCopyText = memoizeValue(() =>
     [summary, detail, getFullDetail()]
       .filter(
@@ -765,7 +776,13 @@ function toFeedActivity(
     attemptId,
     summary,
     detail,
-    canExpand: !(item.type === "error" && item.status === "failed") && (readPaths?.length ?? 1) > 0,
+    canExpand:
+      !(item.type === "error" && item.status === "failed") &&
+      (readPaths
+        ? readPaths.length > 0 || turnItemNeedsDetailFetch(item)
+        : turnItemHasDetail(item) || workEntry.questionAnswer !== undefined),
+    // Read rows show their paths, then the fetched file contents.
+    fetchesDetail: turnItemNeedsDetailFetch(item),
     getFullDetail,
     getCopyText,
     icon: workEntry.toolSurface ?? itemIcon(item),
diff --git a/apps/mobile/src/lib/uniwind-platform-variants.test.ts b/apps/mobile/src/lib/uniwind-platform-variants.test.ts
index 12fa86b33c08..32e0323e7a19 100644
--- a/apps/mobile/src/lib/uniwind-platform-variants.test.ts
+++ b/apps/mobile/src/lib/uniwind-platform-variants.test.ts
@@ -10,7 +10,7 @@ import { beforeAll, describe, expect, it } from "vite-plus/test";
 // `@media ios { ... }` block, and uniwind's CSS processor used to drop the
 // block's media queries after its first nested rule. Everything past the first
 // utility compiled unguarded and shipped to both platforms. These tests run
-// the installed (patched) uniwind compiler over real Tailwind output, per
+// the installed uniwind compiler over real Tailwind output, per
 // platform, and assert what each bundle receives. The compiler itself runs in
 // a plain Node child process (uniwind-platform-variants.fixture.cjs) so no
 // test-runner module transforms sit between the test and the shipped code.
@@ -215,11 +215,9 @@ describe("uniwind keeps media rules nested inside class rules attached to the cl
   });
 });
 
-// The patch file carries three independent uniwind fixes (state/data selector
-// variants, the Metro native-styles fingerprint, and this media-query scoping
-// fix). Regenerating it for one fix must not silently drop the others — this
-// suite exercises the shipped transformer and compiler for the other two.
-describe("uniwind patch keeps pre-existing selector and transformer behavior", () => {
+// Keep guarding selector variants and the Metro native-styles fingerprint
+// alongside media-query scoping when upgrading the installed Uniwind package.
+describe("uniwind keeps selector and transformer behavior", () => {
   let output: FixtureOutput;
 
   beforeAll(() => {
diff --git a/apps/mobile/src/state/environments.ts b/apps/mobile/src/state/environments.ts
index 88d80631ad31..776a615f46af 100644
--- a/apps/mobile/src/state/environments.ts
+++ b/apps/mobile/src/state/environments.ts
@@ -1,6 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
 import {
   connectionCatalogDisplayUrl,
+  hasRelayRoute,
   type EnvironmentPresentation as BaseEnvironmentPresentation,
 } from "@t3tools/client-runtime/connection";
 import type { EnvironmentId } from "@t3tools/contracts";
@@ -26,7 +27,7 @@ export function projectEnvironmentPresentation(
     environmentId,
     label: presentation.entry.target.label,
     displayUrl: connectionCatalogDisplayUrl(presentation.entry),
-    relayManaged: presentation.entry.target._tag === "RelayConnectionTarget",
+    relayManaged: hasRelayRoute(presentation.entry),
   };
 }
 
diff --git a/apps/mobile/src/state/queries.ts b/apps/mobile/src/state/queries.ts
index d9cce63b65ac..db8269ff130b 100644
--- a/apps/mobile/src/state/queries.ts
+++ b/apps/mobile/src/state/queries.ts
@@ -2,6 +2,7 @@ import { filterComposerPullRequestMatches } from "@t3tools/shared/composerPullRe
 import type { VcsRefTarget } from "@t3tools/client-runtime/state/vcs";
 import type {
   EnvironmentId,
+  OrchestrationV2ProjectedTurnItem,
   ProjectId,
   ThreadId,
   VcsListRefsResult,
@@ -14,6 +15,7 @@ import {
 } from "@t3tools/client-runtime/state/thread-search";
 import { useAtomValue } from "@effect/atom-react";
 import * as Cause from "effect/Cause";
+import { turnItemDetailRevision } from "@t3tools/client-runtime/work-log/item-detail";
 import * as Option from "effect/Option";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 import { useCallback, useEffect, useMemo, useState } from "react";
@@ -351,3 +353,24 @@ export function useCheckpointDiff(target: CheckpointDiffTarget) {
   );
   return targets.fullThread === null ? turn : fullThread;
 }
+
+/** Full input and output for one tool row; pass null to skip fetching. */
+export function useTurnItemDetail(
+  target: {
+    readonly environmentId: EnvironmentId;
+    readonly row: OrchestrationV2ProjectedTurnItem;
+  } | null,
+) {
+  return useEnvironmentQuery(
+    target === null
+      ? null
+      : orchestrationEnvironment.turnItem({
+          environmentId: target.environmentId,
+          input: {
+            threadId: target.row.sourceThreadId,
+            itemId: target.row.sourceItemId,
+            revision: turnItemDetailRevision(target.row.item),
+          },
+        }),
+  );
+}
diff --git a/apps/mobile/src/state/remote-environment-projections.ts b/apps/mobile/src/state/remote-environment-projections.ts
index b1315c299d66..48b9649f5475 100644
--- a/apps/mobile/src/state/remote-environment-projections.ts
+++ b/apps/mobile/src/state/remote-environment-projections.ts
@@ -52,7 +52,10 @@ export function createRemoteEnvironmentProjectionAtoms(input: {
             : displayUrl.replace(/^http:/, "ws:")
           : new URL(socketUrl).origin;
       const authorization = prepared?.httpAuthorization ?? null;
-      const relayManaged = presentation.entry.target._tag === "RelayConnectionTarget";
+      // Credentials follow the route in use, which may not be the preferred one.
+      const relayManaged = prepared
+        ? prepared.target._tag === "RelayConnectionTarget"
+        : presentation.entry.target._tag === "RelayConnectionTarget";
 
       previousEntry = presentation.entry;
       previousPrepared = prepared;
diff --git a/apps/mobile/src/state/thread-composer-error.test.ts b/apps/mobile/src/state/thread-composer-error.test.ts
new file mode 100644
index 000000000000..7c3ef653ebba
--- /dev/null
+++ b/apps/mobile/src/state/thread-composer-error.test.ts
@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, it } from "vite-plus/test";
+
+import { appAtomRegistry } from "./atom-registry";
+import {
+  clearThreadComposerError,
+  clearThreadComposerErrorsForEnvironment,
+  setThreadComposerError,
+  threadComposerErrorsAtom,
+} from "./thread-composer-error";
+
+afterEach(() => {
+  appAtomRegistry.set(threadComposerErrorsAtom, {});
+});
+
+describe("thread composer errors", () => {
+  it("clears a message-scoped error only for that message", () => {
+    setThreadComposerError("environment-1:thread-1", "rejected", "message-1");
+
+    clearThreadComposerError("environment-1:thread-1", "message-2");
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)["environment-1:thread-1"]?.message).toBe(
+      "rejected",
+    );
+
+    clearThreadComposerError("environment-1:thread-1");
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
+  });
+
+  it("clears every thread's error for a removed environment and no others", () => {
+    setThreadComposerError("environment-1:thread-1", "one");
+    setThreadComposerError("environment-1:thread-2", "two");
+    setThreadComposerError("environment-10:thread-1", "other environment");
+
+    clearThreadComposerErrorsForEnvironment("environment-1");
+
+    expect(Object.keys(appAtomRegistry.get(threadComposerErrorsAtom))).toEqual([
+      "environment-10:thread-1",
+    ]);
+  });
+});
diff --git a/apps/mobile/src/state/thread-composer-error.ts b/apps/mobile/src/state/thread-composer-error.ts
new file mode 100644
index 000000000000..bf51139ede97
--- /dev/null
+++ b/apps/mobile/src/state/thread-composer-error.ts
@@ -0,0 +1,56 @@
+import { Atom } from "effect/unstable/reactivity";
+
+import { appAtomRegistry } from "./atom-registry";
+
+interface ThreadComposerError {
+  readonly message: string;
+  /** The queued message this error is about, when it is about one. */
+  readonly messageId: string | null;
+}
+
+/**
+ * Why a thread's last message did not go out, shown above that thread's
+ * composer. The outbox drain can reject a message after the user has left the
+ * thread, so the reason is kept per thread until they dismiss it, send again,
+ * or the message it describes is delivered after all. Keyed by `scopedThreadKey`.
+ */
+export const threadComposerErrorsAtom = Atom.make<Readonly<Record<string, ThreadComposerError>>>(
+  {},
+).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-composer-errors"));
+
+export function setThreadComposerError(
+  threadKey: string,
+  message: string,
+  messageId: string | null = null,
+): void {
+  appAtomRegistry.set(threadComposerErrorsAtom, {
+    ...appAtomRegistry.get(threadComposerErrorsAtom),
+    [threadKey]: { message, messageId },
+  });
+}
+
+/** With `messageId`, clears only an error that describes that message. */
+export function clearThreadComposerError(threadKey: string, messageId?: string): void {
+  const current = appAtomRegistry.get(threadComposerErrorsAtom);
+  const error = current[threadKey];
+  if (!error || (messageId !== undefined && error.messageId !== messageId)) {
+    return;
+  }
+  const next = { ...current };
+  delete next[threadKey];
+  appAtomRegistry.set(threadComposerErrorsAtom, next);
+}
+
+export function clearThreadComposerErrorsForEnvironment(environmentId: string): void {
+  const current = appAtomRegistry.get(threadComposerErrorsAtom);
+  const prefix = `${environmentId}:`;
+  const keys = Object.keys(current).filter((key) => key.startsWith(prefix));
+  if (keys.length === 0) {
+    return;
+  }
+  const next = { ...current };
+  for (const key of keys) {
+    delete next[key];
+  }
+  appAtomRegistry.set(threadComposerErrorsAtom, next);
+}
diff --git a/apps/mobile/src/state/use-remote-environment-registry.ts b/apps/mobile/src/state/use-remote-environment-registry.ts
index 6a2b72c8f8c7..3a8a1022d665 100644
--- a/apps/mobile/src/state/use-remote-environment-registry.ts
+++ b/apps/mobile/src/state/use-remote-environment-registry.ts
@@ -110,10 +110,10 @@ export function useRemoteConnections() {
   }, []);
 
   const onConnectPress = useCallback(
-    async (pairingUrl?: string) => {
+    async (pairingUrl?: string, expectedEnvironmentId?: EnvironmentId) => {
       const nextPairingUrl = pairingUrl ?? connectionPairingUrl;
       setPendingConnectionError(null);
-      const result = await controller.connectPairingUrl(nextPairingUrl);
+      const result = await controller.connectPairingUrl(nextPairingUrl, expectedEnvironmentId);
       if (AsyncResult.isFailure(result)) {
         const error = Cause.squash(result.cause);
         const message =
diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts
index 1f9eed3d675c..9688eddc65a4 100644
--- a/apps/mobile/src/state/use-thread-composer-state.ts
+++ b/apps/mobile/src/state/use-thread-composer-state.ts
@@ -96,6 +96,7 @@ import {
   useQueuedRunEdit,
 } from "./queued-run-edit";
 import { setPendingConnectionError } from "../state/use-remote-environment-registry";
+import { clearThreadComposerError, setThreadComposerError } from "./thread-composer-error";
 import {
   useSelectedThreadProjection,
   useSelectedThreadVisibleTurnItems,
@@ -452,7 +453,8 @@ export function useThreadComposerState() {
       });
     }
     endQueuedRunEdit(selectedThreadKey, { deferAttachmentCleanup: keepable });
-    setPendingConnectionError(
+    setThreadComposerError(
+      selectedThreadKey,
       keepable
         ? "That message already started. Your edit is back in the composer."
         : "That message already started, so the edit was discarded.",
@@ -670,6 +672,8 @@ export function useThreadComposerState() {
 
       const metadata = makeQueuedMessageMetadata();
       const messageId = MessageId.make(metadata.messageId);
+      // A new send supersedes the reason the previous one bounced back.
+      clearThreadComposerError(threadKey);
       // Enqueue publishes the queued atom synchronously (the durable write
       // happens behind it), so clearing the draft here gives send feedback on
       // the tap frame instead of after file I/O. If the write fails the message
@@ -706,7 +710,8 @@ export function useThreadComposerState() {
             attachments: [],
           });
           appendComposerDraftAttachments(threadKey, attachments, { allowOverflow: true });
-          setPendingConnectionError(
+          setThreadComposerError(
+            threadKey,
             error instanceof Error ? error.message : "Failed to save the queued message.",
           );
         },
diff --git a/apps/mobile/src/state/use-thread-outbox-drain.test.ts b/apps/mobile/src/state/use-thread-outbox-drain.test.ts
index b0e6497fe8f8..3a9b98237356 100644
--- a/apps/mobile/src/state/use-thread-outbox-drain.test.ts
+++ b/apps/mobile/src/state/use-thread-outbox-drain.test.ts
@@ -19,7 +19,6 @@ const harness = vi.hoisted(() => ({
   removePersistedFile: vi.fn(async () => undefined),
   removeOutboxMessage: vi.fn(async (_message: QueuedThreadMessage) => undefined),
   prepareTurnAttachments: vi.fn<typeof import("../lib/attachmentUpload").prepareTurnAttachments>(),
-  setPendingConnectionError: vi.fn(),
   draftFile: (() => {
     let document = "";
     let writeError: Error | null = null;
@@ -106,7 +105,6 @@ vi.mock("./use-thread-outbox", async () => {
 });
 
 vi.mock("./use-remote-environment-registry", () => ({
-  setPendingConnectionError: harness.setPendingConnectionError,
   useRemoteConnectionStatus: () => ({ connectedEnvironments: [] }),
 }));
 
@@ -139,6 +137,11 @@ import {
   clearPendingThreadCreationOutcome,
   pendingThreadCreationOutcomesAtom,
 } from "./pending-thread-creation";
+import {
+  clearThreadComposerError,
+  setThreadComposerError,
+  threadComposerErrorsAtom,
+} from "./thread-composer-error";
 import type { QueuedThreadMessage } from "./thread-outbox-model";
 import * as composerDrafts from "./use-composer-drafts";
 import { recoverFailedThreadDraft } from "./recover-failed-thread-draft";
@@ -211,11 +214,11 @@ afterEach(() => {
   appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {} });
   appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
   appAtomRegistry.set(pendingThreadCreationOutcomesAtom, {});
+  appAtomRegistry.set(threadComposerErrorsAtom, {});
   harness.draftFile.setWriteError(null);
   harness.removePersistedFile.mockClear();
   harness.removeOutboxMessage.mockClear();
   harness.prepareTurnAttachments.mockReset();
-  harness.setPendingConnectionError.mockClear();
 });
 
 describe("thread outbox attachment preparation", () => {
@@ -444,6 +447,25 @@ describe("thread outbox drain delivery cleanup", () => {
     expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]);
   });
 
+  it("clears an error about the delivered message but keeps one about another message", async () => {
+    const threadKey = "environment-1:thread-1";
+    const retried = queuedMessage({ messageId: "message-retried", text: "retried" });
+    await harness.manager.enqueue(retried);
+    // A failed recovery left this message queued with an error about it.
+    setThreadComposerError(threadKey, "could not be restored", retried.messageId);
+
+    await completeQueuedMessageDelivery(retried, harness.manager.revisionOf(retried.messageId));
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]).toBeUndefined();
+
+    const other = queuedMessage({ messageId: "message-other", text: "other" });
+    await harness.manager.enqueue(other);
+    // The thread's error explains a different, rejected message still in the draft.
+    setThreadComposerError(threadKey, "rejected", "message-rejected");
+
+    await completeQueuedMessageDelivery(other, harness.manager.revisionOf(other.messageId));
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.message).toBe("rejected");
+  });
+
   it("keeps a delivered message when its editor opens during storage removal", async () => {
     const message = queuedMessage({
       messageId: "message-editor-removal-race",
@@ -699,7 +721,8 @@ describe("thread outbox recovery rollback", () => {
       },
     });
     expect(remainingMessages()).toEqual([]);
-    expect(harness.setPendingConnectionError).toHaveBeenCalledWith("rejected by server");
+    // The creation's failure card shows the reason; the composer is hidden.
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
     // The thread screen opened for this creation reads the failure from here.
     expect(
       appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[
@@ -708,6 +731,37 @@ describe("thread outbox recovery rollback", () => {
     ).toEqual({ kind: "failed", message, reason: "rejected by server" });
   });
 
+  it("drops an earlier recovery error once a rejected new task is restored", async () => {
+    const message: QueuedThreadMessage = {
+      ...queuedMessage({ messageId: "message-creation-retried", text: "new task text" }),
+      modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" },
+      creation: {
+        projectId: ProjectId.make("project-1"),
+        workspaceMode: "local",
+        branch: null,
+        worktreePath: null,
+      },
+    };
+    await harness.manager.enqueue(message);
+    harness.draftFile.setWriteError(new Error("disk full"));
+    await expect(restoreRejectedQueuedMessage(message, "rejected by server")).resolves.toBe(
+      "retry",
+    );
+    const threadKey = `${message.environmentId}:${message.threadId}`;
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)[threadKey]?.messageId).toBe(
+      message.messageId,
+    );
+
+    harness.draftFile.setWriteError(null);
+    await expect(restoreRejectedQueuedMessage(message, "rejected by server")).resolves.toBe(
+      "restored",
+    );
+
+    // The failure card carries the reason now; nothing stale sits above it.
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
+    expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[threadKey]?.kind).toBe("failed");
+  });
+
   it("keeps a failed outcome until its thread screen consumes it", async () => {
     const message: QueuedThreadMessage = {
       ...queuedMessage({ messageId: "message-creation-kept", text: "new task text" }),
@@ -736,6 +790,46 @@ describe("thread outbox recovery rollback", () => {
     await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored");
 
     expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({});
+    // The thread screen shows why the message came back into the composer.
+    expect(
+      appAtomRegistry.get(threadComposerErrorsAtom)[`${message.environmentId}:${message.threadId}`],
+    ).toEqual({ message: "rejected", messageId: message.messageId });
+  });
+
+  it("leaves no error when the restored text is resent before recovery finishes", async () => {
+    const message = queuedMessage({ messageId: "message-resent", text: "resend me" });
+    const threadKey = `${message.environmentId}:${message.threadId}`;
+    await harness.manager.enqueue(message);
+    // The user sees the restored text as soon as the merge publishes it and
+    // sends it again while the recovery is still awaiting persistence.
+    const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
+      if (drafts[threadKey]?.text === "resend me") {
+        unsubscribe();
+        clearThreadComposerError(threadKey);
+        void composerDrafts.clearComposerDraftContent(threadKey);
+      }
+    });
+
+    await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored");
+
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
+  });
+
+  it("withdraws the error when an edit makes the recovery back out", async () => {
+    const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" });
+    const threadKey = `${message.environmentId}:${message.threadId}`;
+    await harness.manager.enqueue(message);
+    const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
+      if (drafts[threadKey]?.text === "edit me") {
+        unsubscribe();
+        appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
+      }
+    });
+
+    await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("deferred");
+
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
+    expect(remainingMessages()).toEqual([message]);
   });
 
   it("rolls a failed recovery merge back so the retry cannot duplicate the text", async () => {
@@ -761,6 +855,6 @@ describe("thread outbox recovery rollback", () => {
       "typed offline\n\nqueued text",
     );
     expect(remainingMessages()).toEqual([]);
-    expect(harness.setPendingConnectionError).toHaveBeenCalledWith("too large");
+    expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large");
   });
 });
diff --git a/apps/mobile/src/state/use-thread-outbox-drain.ts b/apps/mobile/src/state/use-thread-outbox-drain.ts
index 62e21199d6da..831ffef6cba3 100644
--- a/apps/mobile/src/state/use-thread-outbox-drain.ts
+++ b/apps/mobile/src/state/use-thread-outbox-drain.ts
@@ -81,10 +81,8 @@ import {
   useThreadOutboxMessages,
   useThreadOutboxShellStatuses,
 } from "./use-thread-outbox";
-import {
-  setPendingConnectionError,
-  useRemoteConnectionStatus,
-} from "./use-remote-environment-registry";
+import { clearThreadComposerError, setThreadComposerError } from "./thread-composer-error";
+import { useRemoteConnectionStatus } from "./use-remote-environment-registry";
 
 // Ordinary offline behavior (a socket dropping mid-request, a retryable
 // attachment upload failure) must not spam `console.warn` on every backoff
@@ -283,6 +281,12 @@ export async function completeQueuedMessageDelivery(
   queuedMessage: QueuedThreadMessage,
   deliveryRevision: number,
 ): Promise<"removed" | "edited" | "failed"> {
+  // The server took it after all: an error left by an earlier failed recovery
+  // of this same message no longer applies.
+  clearThreadComposerError(
+    scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
+    queuedMessage.messageId,
+  );
   try {
     await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => {
       console.warn("[thread-outbox] could not update sign-out snapshot after delivery", {
@@ -439,6 +443,7 @@ export async function restoreRejectedQueuedMessage(
   message: string,
 ): Promise<"restored" | "deferred" | "blocked" | "retry"> {
   const draftKey = recoveryDraftKey(queuedMessage);
+  const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId);
   // Set once the merge publishes, cleared once the queued message is removed.
   // The catch below uses it to take the merged content back out, so a retry
   // after a mid-recovery failure cannot append the recovered text again.
@@ -468,12 +473,21 @@ export async function restoreRejectedQueuedMessage(
       (attachment) => !existingAttachmentIds.has(attachment.id),
     ).length;
     if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
-      setPendingConnectionError(
+      setThreadComposerError(
+        threadKey,
         `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`,
+        queuedMessage.messageId,
       );
       return "blocked";
     }
 
+    // Shown before the merge publishes the text, so a resend of that text,
+    // which can happen while this recovery still awaits persistence, clears
+    // it. Withdrawn below wherever the recovery backs out.
+    const withdrawError = () => clearThreadComposerError(threadKey, queuedMessage.messageId);
+    if (!queuedMessage.creation) {
+      setThreadComposerError(threadKey, message, queuedMessage.messageId);
+    }
     let mergedDraft: ComposerDraft;
     try {
       stampRecoveryDraftProject(queuedMessage, draftKey);
@@ -493,6 +507,7 @@ export async function restoreRejectedQueuedMessage(
       rollback = { snapshot: originalDraft, merged: mergedDraft };
     }
     if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
+      withdrawError();
       await undoComposerDraftMerge(draftKey, originalDraft, mergedDraft);
       return "deferred";
     }
@@ -521,6 +536,7 @@ export async function restoreRejectedQueuedMessage(
       !(await confirmThreadOutboxMessageQueued(queuedMessage)) ||
       appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]
     ) {
+      withdrawError();
       await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
       return "deferred";
     }
@@ -533,6 +549,7 @@ export async function restoreRejectedQueuedMessage(
         () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId],
       ))
     ) {
+      withdrawError();
       await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
       return "deferred";
     }
@@ -540,15 +557,17 @@ export async function restoreRejectedQueuedMessage(
     // must never be rolled back.
     rollback = null;
     if (queuedMessage.creation) {
+      // The failure card shows the reason, so an error left by an earlier
+      // failed attempt at this recovery no longer applies.
+      withdrawError();
       // The thread screen for this creation is likely open; it reads the
-      // outcome to offer reopening the restored draft.
+      // outcome to offer reopening the restored draft, and shows the reason.
       recordPendingThreadCreationOutcome({
         kind: "failed",
         message: queuedMessage,
         reason: message,
       });
     }
-    setPendingConnectionError(message);
     return "restored";
   } catch (error) {
     if (rollback !== null) {
@@ -562,8 +581,10 @@ export async function restoreRejectedQueuedMessage(
       );
     }
     console.warn("[thread-outbox] failed to restore an undeliverable message", error);
-    setPendingConnectionError(
+    setThreadComposerError(
+      threadKey,
       error instanceof Error ? error.message : "The unsent message could not be restored.",
+      queuedMessage.messageId,
     );
     return "retry";
   }
diff --git a/apps/server/scripts/acp-mock-agent.ts b/apps/server/scripts/acp-mock-agent.ts
index 6e426b52c4e0..5548bebac84c 100644
--- a/apps/server/scripts/acp-mock-agent.ts
+++ b/apps/server/scripts/acp-mock-agent.ts
@@ -1077,6 +1077,70 @@ const program = Effect.gen(function* () {
             status: "completed",
             rawInput: { query: "TODO", path: "apps/web" },
           },
+          // Grok backend searches: the query only arrives in the completed rawOutput.
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "grok-x-search",
+            title: "X search:",
+            kind: "search",
+            status: "in_progress",
+            rawInput: { variant: "XSearch", backend: true },
+          },
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "grok-x-search",
+            title: "X search:",
+            status: "completed",
+            rawOutput: {
+              call_id: "xs_call-1",
+              input: '{"query":"conversation_id:42","limit":"10","mode":"Latest"}',
+              name: "x_keyword_search",
+              id: "grok-x-search",
+            },
+          },
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "grok-web-search",
+            title: "Web search:",
+            kind: "search",
+            status: "completed",
+            rawInput: { variant: "WebSearch", backend: true },
+            rawOutput: {
+              action: {
+                type: "search",
+                query: "t3 code",
+                sources: [
+                  { type: "url", url: "https://t3.codes" },
+                  { type: "url", url: "https://t3.codes" },
+                  { type: "url", url: "https://github.com/pingdotgg/t3code" },
+                ],
+              },
+              id: "grok-web-search",
+              status: "completed",
+            },
+          },
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "grok-web-fetch",
+            title: "Fetch: https://t3.codes",
+            kind: "fetch",
+            status: "completed",
+            rawInput: { variant: "WebFetch", url: "https://t3.codes" },
+            rawOutput: {
+              type: "WebFetch",
+              Content: { url: "https://t3.codes", content: "T3 Code page" },
+            },
+            content: [{ type: "content", content: { type: "text", text: "T3 Code page" } }],
+          },
+          {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "antigravity-shell",
+            title: "run_command",
+            kind: "execute",
+            status: "completed",
+            rawInput: { command: "cat probe.txt" },
+            rawOutput: { commandLine: "cat probe.txt", exitCode: 0, combinedOutput: "after\n" },
+          },
           {
             sessionUpdate: "compaction_update",
             compactionId: "compact-1",
diff --git a/apps/server/src/assets/AssetAccess.test.ts b/apps/server/src/assets/AssetAccess.test.ts
index a596ca55c32a..35844a6be11a 100644
--- a/apps/server/src/assets/AssetAccess.test.ts
+++ b/apps/server/src/assets/AssetAccess.test.ts
@@ -2,6 +2,7 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as NodeHttpPlatform from "@effect/platform-node/NodeHttpPlatform";
 import * as NodeFSP from "node:fs/promises";
+import * as NodeOS from "node:os";
 import { AssetAccessError, AssetPreviewTypeValidationError, ThreadId } from "@t3tools/contracts";
 import { PROJECT_FAVICON_FALLBACK_MARKER } from "@t3tools/shared/projectFavicon";
 import { describe, expect, it } from "@effect/vitest";
@@ -35,6 +36,11 @@ vi.mock("node:fs/promises", async (importOriginal) => {
   return { ...actual, open: vi.fn(actual.open), realpath: vi.fn(actual.realpath) };
 });
 
+vi.mock("node:os", async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeOS>();
+  return { ...actual, homedir: vi.fn(actual.homedir) };
+});
+
 const configLayer = ServerConfig.ServerConfig.layerTest(process.cwd(), {
   prefix: "t3-asset-access-test-",
 });
@@ -183,6 +189,55 @@ describe("AssetAccess", () => {
     }).pipe(Effect.provide(testLayer)),
   );
 
+  it.effect("resolves home-relative media paths independently of the workspace", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-media-home-" });
+      const home = path.join(directory, "var", "home", "alice");
+      const filePath = path.join(home, "Downloads", "repro.mp4");
+      yield* fs.makeDirectory(path.dirname(filePath), { recursive: true });
+      yield* fs.writeFileString(filePath, "recording bytes");
+      const canonicalFile = yield* fs.realPath(filePath);
+      const homeSpy = vi.mocked(NodeOS.homedir).mockReturnValue(home);
+      try {
+        for (const workspaceRoot of [
+          path.join(home, "project"),
+          path.join(directory, "srv", "project"),
+          undefined,
+        ]) {
+          if (workspaceRoot) yield* fs.makeDirectory(workspaceRoot, { recursive: true });
+          for (const requestedPath of ["~/Downloads/repro.mp4", "~\\Downloads/repro.mp4"]) {
+            const result = yield* issueAssetUrl({
+              resource: {
+                _tag: "media-file",
+                threadId: ThreadId.make("thread-1"),
+                path: requestedPath,
+              },
+              ...(workspaceRoot ? { workspaceRoot } : {}),
+            });
+            const suffix = result.relativeUrl.slice(`${ASSET_ROUTE_PREFIX}/`.length);
+            const separator = suffix.indexOf("/");
+            const asset = yield* resolveAsset(
+              suffix.slice(0, separator),
+              suffix.slice(separator + 1),
+            );
+            expect(asset).toMatchObject({
+              kind: "file",
+              path: canonicalFile,
+              mimeType: "video/mp4",
+            });
+            if (asset?.kind !== "file") throw new Error("Expected a resolved home media file");
+            const response = HttpServerResponse.toWeb(yield* assetFileResponse(asset));
+            expect(yield* Effect.promise(() => response.text())).toBe("recording bytes");
+          }
+        }
+      } finally {
+        homeSpy.mockRestore();
+      }
+    }).pipe(Effect.provide(testLayer)),
+  );
+
   it.effect.skipIf(!symlinksSupported)(
     "rejects non-previewable files, disguised targets, and directories",
     () =>
diff --git a/apps/server/src/assets/AssetAccess.ts b/apps/server/src/assets/AssetAccess.ts
index 25a2748cd9e5..be0d280fef76 100644
--- a/apps/server/src/assets/AssetAccess.ts
+++ b/apps/server/src/assets/AssetAccess.ts
@@ -49,6 +49,7 @@ import {
 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
 import { parseAttachmentFileExtension, resolveAttachmentPathById } from "../attachmentStore.ts";
 import * as ServerConfig from "../config.ts";
+import { expandHomePathWith } from "../pathExpansion.ts";
 import * as ProjectFaviconResolver from "../project/ProjectFaviconResolver.ts";
 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
 import * as NativeAppIconResolver from "./NativeAppIconResolver.ts";
@@ -433,7 +434,7 @@ export const issueAssetUrl = Effect.fn("AssetAccess.issueAssetUrl")(function* (i
 
   switch (input.resource._tag) {
     case "media-file": {
-      let requestedPath = input.resource.path;
+      let requestedPath = expandHomePathWith(input.resource.path, path);
       if (!path.isAbsolute(requestedPath)) {
         if (!input.workspaceRoot) {
           return yield* new AssetWorkspaceContextNotFoundError({ resource: input.resource });
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index 970ba88050b9..3f5eb6dedca5 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -35,6 +35,7 @@ export const RPC_REQUIRED_SCOPES = {
   [ORCHESTRATION_V2_WS_METHODS.searchThreads]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getArchivedShellSnapshot]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getThreadProjection]: AuthOrchestrationReadScope,
+  [ORCHESTRATION_V2_WS_METHODS.getTurnItem]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.launchThread]: AuthOrchestrationOperateScope,
   [ORCHESTRATION_V2_WS_METHODS.subscribeArchivedShell]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.subscribeShell]: AuthOrchestrationReadScope,
diff --git a/apps/server/src/binCli.ts b/apps/server/src/binCli.ts
index a4148e707bf6..c39fa3e3b620 100644
--- a/apps/server/src/binCli.ts
+++ b/apps/server/src/binCli.ts
@@ -15,7 +15,7 @@ import { pairCommand } from "./cli/pair.ts";
 import { hasCloudPublicConfig } from "./cloud/publicConfig.ts";
 import { sharedServerCommandFlags } from "./cli/config.ts";
 import { projectCommand } from "./cli/project.ts";
-import { runServerCommand, serveCommand, startCommand } from "./cli/server.ts";
+import { runDefaultServerCommand, serveCommand, startCommand } from "./cli/server.ts";
 import { updateCommand } from "./cli/update.ts";
 import { uninstallCommand } from "./cli/uninstall.ts";
 import { serviceLauncherCommand } from "./cli/serviceLauncher.ts";
@@ -56,8 +56,14 @@ const connectUnavailableCommand = Command.make("connect", {
 export const makeCli = ({ cloudEnabled = hasCloudPublicConfig } = {}) =>
   Command.make("t3", { ...sharedServerCommandFlags }).pipe(
     Command.withDescription("Run the T3 Code server."),
-    Command.withHandler((flags) => runServerCommand(flags)),
+    Command.withHandler(runDefaultServerCommand),
     Command.withSubcommands([
+      Command.make("help").pipe(
+        Command.withDescription("Show command help."),
+        Command.withHandler(() =>
+          Effect.fail(new CliError.ShowHelp({ commandPath: ["t3"], errors: [] })),
+        ),
+      ),
       acpMcpBridgeCommand,
       acpMcpCallCommand,
       startCommand,
diff --git a/apps/server/src/claudeModelOptions.ts b/apps/server/src/claudeModelOptions.ts
index d018c2f0af32..ef7b92e1a2e9 100644
--- a/apps/server/src/claudeModelOptions.ts
+++ b/apps/server/src/claudeModelOptions.ts
@@ -37,7 +37,7 @@ export function compileClaudeModelSelection(
   const resolvedEffort = resolveClaudeCatalogEffort(catalog, selection.model, rawEffort);
   const effort = normalizeClaudeCatalogEffort(catalog, resolvedEffort, selection.model);
   const fastMode = supportsBoolean("fastMode")
-    ? getModelSelectionBooleanOptionValue(selection, "fastMode")
+    ? (getModelSelectionBooleanOptionValue(selection, "fastMode") ?? false)
     : undefined;
   const thinking = supportsBoolean("thinking")
     ? getModelSelectionBooleanOptionValue(selection, "thinking")
diff --git a/apps/server/src/cli/app.test.ts b/apps/server/src/cli/app.test.ts
index e478f66f0731..a91ea416ffca 100644
--- a/apps/server/src/cli/app.test.ts
+++ b/apps/server/src/cli/app.test.ts
@@ -17,10 +17,12 @@ import * as NetService from "@t3tools/shared/Net";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import { Command } from "effect/unstable/cli";
 import { afterEach, describe, expect, vi } from "vite-plus/test";
 
 import { makeCli } from "../binCli.ts";
+import { PersistedServerRuntimeState } from "../serverRuntimeState.ts";
 
 vi.mock("node:os", async (importOriginal) => {
   const os = await importOriginal<typeof import("node:os")>();
@@ -29,6 +31,8 @@ vi.mock("node:os", async (importOriginal) => {
 
 afterEach(() => vi.mocked(NodeOS.homedir).mockReset());
 
+const encodeRuntimeState = Schema.encodeEffect(Schema.fromJsonString(PersistedServerRuntimeState));
+
 const runCli = (args: ReadonlyArray<string>, env: Record<string, string> = {}) =>
   Command.runWith(makeCli(), { version: "0.0.0" })(args).pipe(
     Effect.provide(
@@ -130,6 +134,88 @@ const withTempDirectory = <A, E, R>(
     (root) => Effect.promise(() => NodeFSP.rm(root, { recursive: true, force: true })),
   );
 
+describe("t3 server command safety", () => {
+  it.effect("rejects unknown command words without creating a home or project", () =>
+    withTempDirectory("t3-cli-unknown-", (root) =>
+      Effect.gen(function* () {
+        const baseDir = NodePath.join(root, "home");
+        for (const word of [
+          "account",
+          "login",
+          "clients",
+          "conenct",
+          "package.json",
+          "C:new-project",
+        ]) {
+          const error = yield* runCli([word, "--base-dir", baseDir]).pipe(
+            Effect.provideService(HostProcessPlatform, "linux"),
+            Effect.flip,
+          );
+          expect(String(error)).toContain(`Unknown command "${word}"`);
+          expect(yield* pathExists(word)).toBe(word === "package.json");
+          expect(yield* pathExists(baseDir)).toBe(false);
+        }
+      }),
+    ),
+  );
+
+  it.effect("shows help without creating state", () =>
+    withTempDirectory("t3-cli-help-", (root) =>
+      Effect.gen(function* () {
+        const baseDir = NodePath.join(root, "home");
+        const help = yield* runCli(["help"], { T3CODE_HOME: baseDir }).pipe(Effect.flip);
+        expect(help).toMatchObject({ _tag: "ShowHelp", commandPath: ["t3"], errors: [] });
+        expect(yield* pathExists(baseDir)).toBe(false);
+      }),
+    ),
+  );
+
+  it.effect("refuses manual startup over a live server before creating directories", () =>
+    withTempDirectory("t3-cli-running-", (root) =>
+      Effect.gen(function* () {
+        const baseDir = NodePath.join(root, "home");
+        const stateDir = NodePath.join(baseDir, "userdata");
+        const statePath = NodePath.join(stateDir, "server-runtime.json");
+        const record = yield* encodeRuntimeState({
+          version: 1,
+          pid: process.pid,
+          port: 3773,
+          origin: "http://127.0.0.1:3773",
+          startedAt: "2026-10-01T00:00:00.000Z",
+          serviceManaged: true,
+        });
+        yield* Effect.promise(() => NodeFSP.mkdir(stateDir, { recursive: true }));
+        yield* Effect.promise(() => NodeFSP.writeFile(statePath, record));
+        const newDirectory = NodePath.join(root, "new-project");
+        const platform = yield* HostProcessPlatform;
+        for (const args of [
+          [],
+          ["start"],
+          ["."],
+          ["node_modules"],
+          ["C:new-project"],
+          [newDirectory],
+          ["start", newDirectory],
+        ]) {
+          const error = yield* runCli(args, { T3CODE_HOME: baseDir }).pipe(
+            Effect.provideService(
+              HostProcessPlatform,
+              args[0] === "C:new-project" ? "win32" : platform,
+            ),
+            Effect.flip,
+          );
+          expect(String(error)).toContain("A T3 Code server is already running");
+          expect(yield* Effect.promise(() => NodeFSP.readFile(statePath, "utf8"))).toBe(record);
+          expect(yield* pathExists(newDirectory)).toBe(false);
+          expect(yield* Effect.promise(() => NodeFSP.readdir(stateDir))).toEqual([
+            "server-runtime.json",
+          ]);
+        }
+      }),
+    ),
+  );
+});
+
 describe("t3 app", () => {
   it.effect("rejects SSH before it tries to reach a desktop app", () =>
     withTempDirectory("t3-app-ssh-test-", (root) =>
diff --git a/apps/server/src/cli/config.test.ts b/apps/server/src/cli/config.test.ts
index 093e92f248e6..c08761c79871 100644
--- a/apps/server/src/cli/config.test.ts
+++ b/apps/server/src/cli/config.test.ts
@@ -80,6 +80,53 @@ it.layer(NodeServices.layer)("cli config resolution", (it) => {
     );
   });
 
+  it.effect("keeps stale records and supervised startup out of the manual launch preflight", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-cli-preflight-" });
+      for (const [name, pid, mode, rejectRunningServer] of [
+        ["stale", 2_147_483_647, "web", true],
+        ["desktop", process.pid, "desktop", true],
+        ["serve", process.pid, "web", false],
+      ] as const) {
+        const baseDir = path.join(root, name);
+        const stateDir = path.join(baseDir, "userdata");
+        yield* fs.makeDirectory(stateDir, { recursive: true });
+        yield* fs.writeFileString(
+          path.join(stateDir, "server-runtime.json"),
+          yield* encodeUnknownJson({
+            version: 1,
+            pid,
+            port: 3773,
+            origin: "http://127.0.0.1:3773",
+            startedAt: "2026-10-01T00:00:00.000Z",
+          }),
+        );
+        const cwd = path.join(root, `${name}-project`);
+        const config = yield* resolveServerConfig(
+          {
+            ...minimalWebFlags(baseDir),
+            mode: Option.some(mode),
+            port: Option.some(8788),
+            cwd: Option.some(cwd),
+          },
+          Option.none(),
+          { rejectRunningServer },
+        ).pipe(
+          Effect.provide(
+            Layer.merge(
+              NetService.layer,
+              ConfigProvider.layer(ConfigProvider.fromEnv({ env: {} })),
+            ),
+          ),
+        );
+        expect(config.cwd).toBe(cwd);
+        expect(yield* fs.exists(cwd)).toBe(true);
+      }
+    }),
+  );
+
   it.effect("enables a trimmed reusable auth token only for web dev mode", () =>
     Effect.gen(function* () {
       const baseDir = yield* FileSystem.FileSystem.pipe(
diff --git a/apps/server/src/cli/config.ts b/apps/server/src/cli/config.ts
index 0395a2cd204e..ce9ac4a42da5 100644
--- a/apps/server/src/cli/config.ts
+++ b/apps/server/src/cli/config.ts
@@ -19,10 +19,12 @@ import * as Schema from "effect/Schema";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaTransformation from "effect/SchemaTransformation";
 import { Argument, Flag } from "effect/unstable/cli";
+import * as CliError from "effect/unstable/cli/CliError";
 
 import { readBootstrapEnvelope } from "../bootstrap.ts";
 import * as ServerConfig from "../config.ts";
 import { expandHomePath, resolveBaseDir } from "../os-jank.ts";
+import { isProcessAlive, readPersistedServerRuntimeState } from "../serverRuntimeState.ts";
 
 const modeFlag = Flag.Literals("mode", ServerConfig.RuntimeMode.literals).pipe(
   Flag.withDescription("Runtime mode. `desktop` keeps loopback defaults unless overridden."),
@@ -255,6 +257,7 @@ export const resolveServerConfig = (
   options?: {
     readonly startupPresentation?: ServerConfig.StartupPresentation;
     readonly forceAutoBootstrapProjectFromCwd?: boolean;
+    readonly rejectRunningServer?: boolean;
   },
 ) =>
   Effect.gen(function* () {
@@ -325,10 +328,20 @@ export const resolveServerConfig = (
     );
     const rawCwd = Option.getOrElse(normalizedFlags.cwd, () => process.cwd());
     const cwd = path.resolve(yield* expandHomePath(rawCwd.trim()));
-    yield* fs.makeDirectory(cwd, { recursive: true });
     const derivedPaths = yield* ServerConfig.deriveServerPaths(baseDir, devUrl, {
       baseDirIsExplicit: Option.isSome(explicitBaseDir),
     });
+    // An interactive CLI must not start over a discovered server. Lifetime locking
+    // and supervisor handoff are separate; this preflight cannot arbitrate two starts.
+    if (options?.rejectRunningServer && mode === "web") {
+      const runtime = yield* readPersistedServerRuntimeState(derivedPaths.serverRuntimeStatePath);
+      if (Option.isSome(runtime) && runtime.value.pid > 0 && isProcessAlive(runtime.value.pid)) {
+        return yield* new CliError.UserError({
+          cause: `A T3 Code server is already running for ${baseDir} (pid ${runtime.value.pid}, ${runtime.value.origin}). Connect to that server, stop it before starting another, or use a different --base-dir.`,
+        });
+      }
+    }
+    yield* fs.makeDirectory(cwd, { recursive: true });
     yield* ServerConfig.ensureServerDirectories(derivedPaths);
     const persistedObservabilitySettings = yield* loadPersistedObservabilitySettings(
       derivedPaths.settingsPath,
diff --git a/apps/server/src/cli/invocation.test.ts b/apps/server/src/cli/invocation.test.ts
index 067d9fa09d80..4c20f6106afa 100644
--- a/apps/server/src/cli/invocation.test.ts
+++ b/apps/server/src/cli/invocation.test.ts
@@ -1,6 +1,16 @@
-import { assert, it } from "@effect/vitest";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, expect, it } from "@effect/vitest";
+import {
+  HostProcessArguments,
+  HostProcessExecutablePath,
+  HostProcessIsExecutable,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 
-import { formatCliCommand } from "./invocation.ts";
+import { formatCliCommand, resolveServerInstallation } from "./invocation.ts";
 
 it("formats package runner commands from their cache entry paths", () => {
   for (const [entryPath, expected] of [
@@ -87,3 +97,123 @@ it("formats serve suggestions to match the launching command", () => {
     "t3 serve",
   );
 });
+
+it.layer(NodeServices.layer)("manual server installation ownership", (it) => {
+  it.effect("recognizes runner caches for both script and executable packages", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped();
+      for (const [relative, kind] of [
+        ["npm/_npx/hash/node_modules/t3/dist/bin.mjs", "npx"],
+        ["npm/_npx/hash/node_modules/@t3code/t3-linux-x64/t3", "npx"],
+        ["pnpm/dlx/hash/node_modules/t3/dist/bin.mjs", "pnpm-dlx"],
+        [".bun/install/cache/t3/dist/bin.mjs", "bunx"],
+      ] as const) {
+        const entry = path.join(root, relative);
+        yield* fs.makeDirectory(path.dirname(entry), { recursive: true });
+        yield* fs.writeFileString(entry, "");
+        const installation = yield* resolveServerInstallation.pipe(
+          Effect.provideService(HostProcessArguments, ["node", entry]),
+          Effect.provideService(HostProcessExecutablePath, entry),
+          Effect.provideService(HostProcessIsExecutable, entry.endsWith("/t3")),
+        );
+        expect(installation).toEqual({ kind });
+      }
+    }),
+  );
+
+  it.effect("requires the npm prefix's bin to point to the running package", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped();
+      const prefix = path.join(root, "bunx-tools");
+      const packageRoot = path.join(prefix, "lib/node_modules/t3");
+      const entry = path.join(packageRoot, "dist/bin.mjs");
+      const globalBin = path.join(prefix, "bin/t3");
+      yield* fs.makeDirectory(path.dirname(entry), { recursive: true });
+      yield* fs.makeDirectory(path.dirname(globalBin), { recursive: true });
+      yield* fs.writeFileString(entry, "");
+      yield* fs.writeFileString(
+        path.join(packageRoot, "package.json"),
+        '{"name":"t3","version":"0.0.45","bin":{"t3":"./dist/bin.mjs"}}',
+      );
+      const resolve = resolveServerInstallation.pipe(
+        Effect.provideService(HostProcessArguments, ["node", entry]),
+        Effect.provideService(HostProcessIsExecutable, false),
+        Effect.provideService(HostProcessPlatform, "linux"),
+      );
+      expect(yield* resolve).toBeNull();
+      yield* fs.symlink(entry, globalBin);
+      expect(yield* resolve).toEqual({ kind: "npm-global", prefix });
+      yield* fs.remove(globalBin);
+      yield* fs.writeFileString(globalBin, "an unrelated t3 command");
+      expect(yield* resolve).toBeNull();
+      expect(yield* resolve.pipe(Effect.provideService(HostProcessPlatform, "win32"))).toBeNull();
+    }),
+  );
+
+  it.effect("proves the native executable belongs to the npm launcher", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped();
+      const prefix = path.join(root, "bunx-tools");
+      const packageRoot = path.join(prefix, "lib/node_modules/t3");
+      const launcher = path.join(packageRoot, "bin/t3.js");
+      const entry = path.join(packageRoot, "node_modules/@t3code/t3-linux-x64/t3");
+      yield* fs.makeDirectory(path.dirname(launcher), { recursive: true });
+      yield* fs.makeDirectory(path.dirname(entry), { recursive: true });
+      yield* fs.makeDirectory(path.join(prefix, "bin"));
+      yield* fs.writeFileString(launcher, "");
+      yield* fs.writeFileString(entry, "");
+      yield* fs.writeFileString(
+        path.join(packageRoot, "package.json"),
+        '{"name":"t3","version":"0.0.45","bin":{"t3":"./bin/t3.js"},"optionalDependencies":{"@t3code/t3-linux-x64":"0.0.45"}}',
+      );
+      yield* fs.symlink(launcher, path.join(prefix, "bin/t3"));
+      const resolve = resolveServerInstallation.pipe(
+        Effect.provideService(HostProcessExecutablePath, entry),
+        Effect.provideService(HostProcessIsExecutable, true),
+        Effect.provideService(HostProcessPlatform, "linux"),
+      );
+      for (const [version, expected] of [
+        ["0.0.44", null],
+        ["0.0.45", { kind: "npm-global", prefix }],
+      ]) {
+        yield* fs.writeFileString(
+          path.join(path.dirname(entry), "package.json"),
+          `{"name":"@t3code/t3-linux-x64","version":"${version}"}`,
+        );
+        expect(yield* resolve).toEqual(expected);
+      }
+    }),
+  );
+
+  it.effect("leaves local, standalone, missing and unreadable installs unknown", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const root = yield* fs.makeTempDirectoryScoped();
+      for (const relative of [
+        "project/node_modules/t3/dist/bin.mjs",
+        "project/apps/server/dist/bin.mjs",
+        ".t3/runtime/0.0.45/t3",
+        "missing/dist/bin.mjs",
+      ]) {
+        const entry = path.join(root, relative);
+        if (!relative.startsWith("missing")) {
+          yield* fs.makeDirectory(path.dirname(entry), { recursive: true });
+          yield* fs.writeFileString(entry, "");
+        }
+        expect(
+          yield* resolveServerInstallation.pipe(
+            Effect.provideService(HostProcessArguments, ["node", entry]),
+            Effect.provideService(HostProcessIsExecutable, false),
+          ),
+        ).toBeNull();
+      }
+    }),
+  );
+});
diff --git a/apps/server/src/cli/invocation.ts b/apps/server/src/cli/invocation.ts
index 1fc0e774129f..96c367f92ebf 100644
--- a/apps/server/src/cli/invocation.ts
+++ b/apps/server/src/cli/invocation.ts
@@ -1,6 +1,15 @@
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
 
-import { HostProcessArguments } from "@t3tools/shared/hostProcess";
+import type { ServerInstallation } from "@t3tools/contracts";
+import {
+  HostProcessArguments,
+  HostProcessExecutablePath,
+  HostProcessIsExecutable,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
 
 import packageJson from "../../package.json" with { type: "json" };
 
@@ -36,6 +45,68 @@ function detectCliRunner(entryPath: string): CliRunner | null {
   return null;
 }
 
+const InstallManifest = Schema.Struct({
+  name: Schema.String,
+  version: Schema.String,
+  bin: Schema.optionalKey(Schema.Struct({ t3: Schema.String })),
+  optionalDependencies: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+});
+const decodeInstallManifest = Schema.decodeUnknownEffect(Schema.fromJsonString(InstallManifest));
+
+/** Prove the running package and its global bin belong together before suggesting an update. */
+export const resolveServerInstallation = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const args = yield* HostProcessArguments;
+  const executable = yield* HostProcessIsExecutable;
+  const executablePath = yield* HostProcessExecutablePath;
+  const platform = yield* HostProcessPlatform;
+  const entry = yield* fs.realPath(executable ? executablePath : (args[1] ?? ""));
+  const match =
+    /^(.*)\/lib\/node_modules\/t3\/(?:dist\/bin\.mjs|bin\/t3\.js|node_modules\/@t3code\/t3-[^/]+\/t3)$/.exec(
+      entry,
+    );
+  if (!match) {
+    const runner = detectCliRunner(entry);
+    return runner === null
+      ? null
+      : ({ kind: runner === "pnpm dlx" ? "pnpm-dlx" : runner } satisfies ServerInstallation);
+  }
+  // A global prefix can contain runner-like names; prove its ownership first.
+  // Windows shims and other package managers need their own ownership proof.
+  if (platform === "win32") return null;
+  const prefix = match[1] || "/";
+  if (
+    prefix.includes("/node_modules/") ||
+    /\/(?:Cellar|Caskroom)\//i.test(prefix) ||
+    /\/mise\/installs\/(?!node\/)[^/]+\//.test(prefix)
+  )
+    return null;
+
+  const packageRoot = path.join(prefix, "lib/node_modules/t3");
+  const manifest = yield* fs
+    .readFileString(path.join(packageRoot, "package.json"))
+    .pipe(Effect.flatMap(decodeInstallManifest));
+  if (manifest.name !== "t3" || !manifest.bin) return null;
+  const bin = yield* fs.realPath(path.join(packageRoot, manifest.bin.t3));
+  const globalBin = yield* fs.realPath(path.join(prefix, "bin/t3"));
+  if (globalBin !== bin) return null;
+  if (executable) {
+    const nativeManifest = yield* fs
+      .readFileString(path.join(path.dirname(entry), "package.json"))
+      .pipe(Effect.flatMap(decodeInstallManifest));
+    if (
+      manifest.bin.t3 !== "./bin/t3.js" ||
+      manifest.optionalDependencies?.[nativeManifest.name] !== nativeManifest.version ||
+      nativeManifest.version !== manifest.version
+    )
+      return null;
+  } else if (bin !== entry) {
+    return null;
+  }
+  return { kind: "npm-global", prefix } satisfies ServerInstallation;
+}).pipe(Effect.orElseSucceed(() => null));
+
 /**
  * The `t3` package spec to suggest. The literal spec the user typed (e.g.
  * `t3@nightly`) is resolved away before our process starts, so re-derive it
diff --git a/apps/server/src/cli/server.ts b/apps/server/src/cli/server.ts
index 298109abdb5f..44662c36b540 100644
--- a/apps/server/src/cli/server.ts
+++ b/apps/server/src/cli/server.ts
@@ -1,15 +1,23 @@
+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import { Command, GlobalFlag } from "effect/unstable/cli";
+import * as CliError from "effect/unstable/cli/CliError";
 
 import * as ServerConfig from "../config.ts";
 import { runServer } from "../server.ts";
 import { type CliServerFlags, resolveServerConfig, sharedServerCommandFlags } from "./config.ts";
 
-export const runServerCommand = (
+const encodeCommand = Schema.encodeEffect(Schema.fromJsonString(Schema.String));
+
+const runServerCommand = (
   flags: CliServerFlags,
   options?: {
     readonly startupPresentation?: ServerConfig.StartupPresentation;
     readonly forceAutoBootstrapProjectFromCwd?: boolean;
+    readonly rejectRunningServer?: boolean;
   },
 ) =>
   Effect.gen(function* () {
@@ -18,9 +26,35 @@ export const runServerCommand = (
     return yield* runServer.pipe(Effect.provideService(ServerConfig.ServerConfig, config));
   });
 
+/** Bare words can name existing directories, but must not create typo projects. */
+export const runDefaultServerCommand = (flags: CliServerFlags) =>
+  Effect.gen(function* () {
+    if (Option.isSome(flags.cwd)) {
+      const cwd = flags.cwd.value.trim();
+      const fs = yield* FileSystem.FileSystem;
+      const platform = yield* HostProcessPlatform;
+      const explicitPath =
+        cwd === "." ||
+        cwd === ".." ||
+        cwd === "~" ||
+        /[/\\]/.test(cwd) ||
+        (platform === "win32" && /^[a-z]:/i.test(cwd));
+      if (
+        !explicitPath &&
+        (!(yield* fs.exists(cwd)) || (yield* fs.stat(cwd)).type !== "Directory")
+      ) {
+        return yield* new CliError.UserError({
+          cause: cwd,
+          userMessage: `Unknown command ${yield* encodeCommand(cwd)}. Use "t3 --help" for commands or an explicit path such as "t3 ./my-project" for a new directory.`,
+        });
+      }
+    }
+    return yield* runServerCommand(flags, { rejectRunningServer: true });
+  });
+
 export const startCommand = Command.make("start", { ...sharedServerCommandFlags }).pipe(
   Command.withDescription("Run the T3 Code server."),
-  Command.withHandler((flags) => runServerCommand(flags)),
+  Command.withHandler((flags) => runServerCommand(flags, { rejectRunningServer: true })),
 );
 
 export const serveCommand = Command.make("serve", { ...sharedServerCommandFlags }).pipe(
diff --git a/apps/server/src/device/LocalDeviceHost.test.ts b/apps/server/src/device/LocalDeviceHost.test.ts
index 5c9a6dcaf4d4..3f299db6d0c4 100644
--- a/apps/server/src/device/LocalDeviceHost.test.ts
+++ b/apps/server/src/device/LocalDeviceHost.test.ts
@@ -4,9 +4,11 @@ import {
   HostProcessEnvironment,
   HostProcessPlatform,
   HostProcessIsExecutable,
+  HostProcessUserId,
 } from "@t3tools/shared/hostProcess";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as FileSystem from "effect/FileSystem";
 
@@ -134,6 +136,54 @@ it.effect("puts detected Android tools on the helper PATH without losing existin
   }).pipe(Effect.provide(NodePath.layer)),
 );
 
+it.effect(
+  "recovers an owned Linux runtime directory without overriding explicit environments",
+  () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const directory = yield* fs.makeTempDirectoryScoped();
+      const stat = yield* fs.stat(directory);
+      for (const [platform, uid, runtimeDir, type, owner, expected] of [
+        ["linux", 1000, undefined, "Directory", 1000, "/run/user/1000"],
+        ["linux", 1000, "/custom/runtime", "Directory", 1000, "/custom/runtime"],
+        ["linux", 1000, "", "Directory", 1000, ""],
+        ["linux", 1000, undefined, "Directory", 1001, undefined],
+        ["linux", 1000, undefined, "File", 1000, undefined],
+        ["linux", undefined, undefined, "Directory", 1000, undefined],
+        ["darwin", 1000, undefined, "Directory", 1000, undefined],
+        ["win32", 1000, undefined, "Directory", 1000, undefined],
+      ] as const) {
+        const environment = { PATH: "/usr/bin", XDG_RUNTIME_DIR: runtimeDir };
+        const result = yield* LocalDeviceHost.__testing.hubEnvironment(environment).pipe(
+          Effect.provideService(HostProcessPlatform, platform),
+          Effect.provideService(HostProcessUserId, uid),
+          Effect.provideService(
+            FileSystem.FileSystem,
+            FileSystem.makeNoop({
+              stat: (path) => {
+                expect(path).toBe("/run/user/1000");
+                return Effect.succeed({ ...stat, type, uid: Option.some(owner) });
+              },
+            }),
+          ),
+        );
+        expect(result.XDG_RUNTIME_DIR).toBe(expected);
+        expect(result.PATH).toBe("/usr/bin");
+        expect(result.FORCE_COLOR).toBe("0");
+        expect(result.NO_COLOR).toBe("1");
+        expect(environment.XDG_RUNTIME_DIR).toBe(runtimeDir);
+      }
+      const missing = yield* LocalDeviceHost.__testing
+        .hubEnvironment({})
+        .pipe(
+          Effect.provideService(HostProcessPlatform, "linux"),
+          Effect.provideService(HostProcessUserId, 1000),
+          Effect.provideService(FileSystem.FileSystem, FileSystem.makeNoop({})),
+        );
+      expect(missing.XDG_RUNTIME_DIR).toBeUndefined();
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);
+
 it.effect(
   "constructs and inspects an unconfigured host without installing or starting helpers",
   () =>
diff --git a/apps/server/src/device/LocalDeviceHost.ts b/apps/server/src/device/LocalDeviceHost.ts
index 5d0ba5176a1e..096b8312f89e 100644
--- a/apps/server/src/device/LocalDeviceHost.ts
+++ b/apps/server/src/device/LocalDeviceHost.ts
@@ -19,7 +19,11 @@ import {
   LOCAL_DEVICE_HOST_ID,
 } from "@t3tools/contracts";
 import { waitForHttpReady } from "@t3tools/shared/httpReadiness";
-import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  HostProcessEnvironment,
+  HostProcessPlatform,
+  HostProcessUserId,
+} from "@t3tools/shared/hostProcess";
 import {
   resolveNodeExecutable,
   type NodeRuntimeUnavailableError,
@@ -32,8 +36,8 @@ 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 Option from "effect/Option";
+import * as Path from "effect/Path";
 import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
@@ -199,6 +203,28 @@ const deviceHostEnvironment = (
     : environment;
 };
 
+const hubEnvironment = Effect.fn("LocalDeviceHost.hubEnvironment")(function* (
+  environment: NodeJS.ProcessEnv,
+) {
+  const env: NodeJS.ProcessEnv = { ...environment, FORCE_COLOR: "0", NO_COLOR: "1" };
+  const platform = yield* HostProcessPlatform;
+  const uid = yield* HostProcessUserId;
+  if (platform === "linux" && env.XDG_RUNTIME_DIR === undefined && uid !== undefined) {
+    // SSH sessions may omit the directory where the emulator publishes its gRPC token.
+    const runtimeDir = `/run/user/${uid}`;
+    const fs = yield* FileSystem.FileSystem;
+    const stat = yield* fs.stat(runtimeDir).pipe(Effect.option);
+    if (
+      stat._tag === "Some" &&
+      stat.value.type === "Directory" &&
+      Option.contains(stat.value.uid, uid)
+    ) {
+      env.XDG_RUNTIME_DIR = runtimeDir;
+    }
+  }
+  return env;
+});
+
 export const make = Effect.fn("LocalDeviceHost.make")(function* () {
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const config = yield* ServerConfig.ServerConfig;
@@ -267,12 +293,6 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
     };
   });
 
-  const hubEnvironment = (): NodeJS.ProcessEnv => ({
-    ...hostEnvironment,
-    FORCE_COLOR: "0",
-    NO_COLOR: "1",
-  });
-
   const stopHub = (hub: HubProcess | undefined) =>
     hub ? Scope.close(hub.scope, Exit.void).pipe(Effect.ignore) : Effect.void;
 
@@ -376,7 +396,10 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
             shell: false,
             stdout: "pipe",
             stderr: "pipe",
-            env: hubEnvironment(),
+            env: yield* hubEnvironment(hostEnvironment).pipe(
+              Effect.provideService(FileSystem.FileSystem, fs),
+              Effect.provideService(HostProcessPlatform, hostPlatform),
+            ),
           },
         ),
       )
@@ -766,4 +789,5 @@ export const __testing = {
   androidSdk,
   platformReason,
   deviceHostEnvironment,
+  hubEnvironment,
 };
diff --git a/apps/server/src/environment/DirectEndpoints.test.ts b/apps/server/src/environment/DirectEndpoints.test.ts
new file mode 100644
index 000000000000..5bbce9d86686
--- /dev/null
+++ b/apps/server/src/environment/DirectEndpoints.test.ts
@@ -0,0 +1,207 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { it as effectIt } from "@effect/vitest";
+import type * as NodeOS from "node:os";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import { describe, expect, it } from "vite-plus/test";
+
+import * as ServerConfig from "../config.ts";
+import * as DirectEndpoints from "./DirectEndpoints.ts";
+import { resolveBoundEndpoints } from "./DirectEndpoints.ts";
+
+const INTERFACES: ReturnType<typeof NodeOS.networkInterfaces> = {
+  lo0: [
+    {
+      address: "127.0.0.1",
+      netmask: "255.0.0.0",
+      family: "IPv4",
+      mac: "00:00:00:00:00:00",
+      internal: true,
+      cidr: "127.0.0.1/8",
+    },
+  ],
+  en0: [
+    {
+      address: "192.168.1.10",
+      netmask: "255.255.255.0",
+      family: "IPv4",
+      mac: "aa:bb:cc:dd:ee:ff",
+      internal: false,
+      cidr: "192.168.1.10/24",
+    },
+    {
+      address: "fe80::1",
+      netmask: "ffff:ffff:ffff:ffff::",
+      family: "IPv6",
+      mac: "aa:bb:cc:dd:ee:ff",
+      internal: false,
+      cidr: "fe80::1/64",
+      scopeid: 4,
+    },
+  ],
+  en1: [
+    {
+      address: "203.0.113.20",
+      netmask: "255.255.255.0",
+      family: "IPv4",
+      mac: "aa:bb:cc:dd:ee:00",
+      internal: false,
+      cidr: "203.0.113.20/24",
+    },
+  ],
+  utun4: [
+    {
+      address: "100.101.102.103",
+      netmask: "255.255.255.255",
+      family: "IPv4",
+      mac: "00:00:00:00:00:00",
+      internal: false,
+      cidr: "100.101.102.103/32",
+    },
+  ],
+};
+
+const virtualInterface = (address: string) => [
+  {
+    address,
+    netmask: "255.255.0.0",
+    family: "IPv4" as const,
+    mac: "02:42:ac:11:00:01",
+    internal: false,
+    cidr: `${address}/16`,
+  },
+];
+
+describe("resolveBoundEndpoints", () => {
+  it("lists nothing for a loopback-only server", () => {
+    expect(resolveBoundEndpoints({ host: undefined, port: 3773, interfaces: INTERFACES })).toEqual(
+      [],
+    );
+    expect(
+      resolveBoundEndpoints({ host: "127.0.0.1", port: 3773, interfaces: INTERFACES }),
+    ).toEqual([]);
+  });
+
+  it("lists every external IPv4 address for a wildcard bind, tagging the tailnet one", () => {
+    expect(resolveBoundEndpoints({ host: "0.0.0.0", port: 3773, interfaces: INTERFACES })).toEqual([
+      { kind: "lan", httpBaseUrl: "http://192.168.1.10:3773/" },
+      { kind: "tailnet", httpBaseUrl: "http://100.101.102.103:3773/" },
+    ]);
+  });
+
+  it("skips container and VM networks, which only this machine reaches", () => {
+    const interfaces = {
+      ...INTERFACES,
+      docker0: virtualInterface("172.17.0.1"),
+      "br-3f2a1b": virtualInterface("172.18.0.1"),
+      virbr0: virtualInterface("192.168.122.1"),
+      "vEthernet (WSL)": virtualInterface("172.24.0.1"),
+      bridge100: virtualInterface("192.168.64.1"),
+      vmbr0: virtualInterface("192.168.1.20"),
+    };
+    expect(resolveBoundEndpoints({ host: "0.0.0.0", port: 3773, interfaces })).toEqual([
+      { kind: "lan", httpBaseUrl: "http://192.168.1.10:3773/" },
+      { kind: "tailnet", httpBaseUrl: "http://100.101.102.103:3773/" },
+      { kind: "lan", httpBaseUrl: "http://192.168.1.20:3773/" },
+    ]);
+  });
+
+  it("lists only the bound address for a specific bind", () => {
+    expect(
+      resolveBoundEndpoints({ host: "100.101.102.103", port: 3773, interfaces: INTERFACES }),
+    ).toEqual([{ kind: "tailnet", httpBaseUrl: "http://100.101.102.103:3773/" }]);
+  });
+
+  it("never reports a host name, which can resolve to another machine per client", () => {
+    for (const host of ["server.local", "devbox", "devbox.home.arpa"]) {
+      expect(resolveBoundEndpoints({ host, port: 3773, interfaces: INTERFACES })).toEqual([]);
+    }
+  });
+
+  it("never reports a public address, which would carry the credential over plain HTTP", () => {
+    expect(
+      resolveBoundEndpoints({ host: "203.0.113.20", port: 3773, interfaces: INTERFACES }),
+    ).toEqual([]);
+  });
+});
+
+const TAILSCALE_STATUS_JSON = JSON.stringify({
+  Self: { DNSName: "bb-1.tail1234.ts.net.", TailscaleIPs: ["100.64.1.2"] },
+});
+
+/** `tailscale status --json` reporting a MagicDNS name. */
+const tailscaleUpLayer = Layer.succeed(
+  ChildProcessSpawner.ChildProcessSpawner,
+  ChildProcessSpawner.make(() =>
+    Effect.succeed(
+      ChildProcessSpawner.makeHandle({
+        pid: ChildProcessSpawner.ProcessId(1),
+        exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
+        isRunning: Effect.succeed(false),
+        kill: () => Effect.void,
+        unref: Effect.succeed(Effect.void),
+        stdin: Sink.drain,
+        stdout: Stream.make(new TextEncoder().encode(TAILSCALE_STATUS_JSON)),
+        stderr: Stream.empty,
+        all: Stream.empty,
+        getInputFd: () => Sink.drain,
+        getOutputFd: () => Stream.empty,
+      }),
+    ),
+  ),
+);
+
+/** Answers the Serve probe with `status`. */
+const serveProbeLayer = (status: number) =>
+  Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) =>
+      Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status }))),
+    ),
+  );
+
+/** A loopback-only server with Tailscale Serve on, so only the Serve name can be listed. */
+const serveConfigLayer = Layer.effect(
+  ServerConfig.ServerConfig,
+  Effect.map(ServerConfig.ServerConfig, (config) => ({
+    ...config,
+    host: "127.0.0.1",
+    tailscaleServeEnabled: true,
+    tailscaleServePort: 443,
+  })),
+).pipe(
+  Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-direct-" })),
+  Layer.provide(NodeServices.layer),
+);
+
+const resolveWithServe = (probeStatus: number) =>
+  Effect.flatMap(DirectEndpoints.DirectEndpoints, (service) => service.resolve()).pipe(
+    Effect.provide(
+      DirectEndpoints.layer.pipe(
+        Layer.provide(
+          Layer.mergeAll(serveConfigLayer, tailscaleUpLayer, serveProbeLayer(probeStatus)),
+        ),
+      ),
+    ),
+  );
+
+describe("DirectEndpoints Tailscale Serve", () => {
+  effectIt.effect("lists the tailnet name once Serve answers for this server", () =>
+    Effect.gen(function* () {
+      expect(yield* resolveWithServe(200)).toEqual([
+        { kind: "tailnet", httpBaseUrl: "https://bb-1.tail1234.ts.net/" },
+      ]);
+    }),
+  );
+
+  effectIt.effect("leaves the tailnet name out when Serve is not forwarding", () =>
+    Effect.gen(function* () {
+      expect(yield* resolveWithServe(502)).toEqual([]);
+    }),
+  );
+});
diff --git a/apps/server/src/environment/DirectEndpoints.ts b/apps/server/src/environment/DirectEndpoints.ts
new file mode 100644
index 000000000000..aa333a598ca4
--- /dev/null
+++ b/apps/server/src/environment/DirectEndpoints.ts
@@ -0,0 +1,143 @@
+/**
+ * DirectEndpoints - the LAN and tailnet addresses this server listens on now.
+ *
+ * Clients connected one way (often T3 Connect) save these as extra routes so
+ * they can move to a faster path when one is reachable, and replace a saved
+ * LAN address when DHCP or a new Wi-Fi network changes it. Only addresses the
+ * server is actually bound to are listed: a loopback-only server lists none,
+ * because its loopback address means a different machine to every client.
+ */
+import type { ServerDirectEndpoint } from "@t3tools/contracts";
+import {
+  buildTailscaleHttpsBaseUrl,
+  isTailscaleIpv4Address,
+  probeTailscaleHttpsEndpoint,
+  readTailscaleStatus,
+} from "@t3tools/tailscale";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { HttpClient } from "effect/unstable/http";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+
+import { isPrivateNetworkHost } from "@t3tools/shared/hostClassification";
+
+import * as ServerConfig from "../config.ts";
+import { formatHostForUrl, isLoopbackHost, isWildcardHost } from "../startupAccess.ts";
+
+type NetworkInterfacesMap = ReturnType<typeof NodeOS.networkInterfaces>;
+
+/**
+ * Stays under the config read's own discovery timeout, so a slow `tailscale`
+ * CLI drops only the tailnet name and never the LAN addresses. An empty list
+ * would make clients forget the routes they learned.
+ */
+const TAILSCALE_ENDPOINT_TIMEOUT = Duration.seconds(3);
+
+export class DirectEndpoints extends Context.Service<
+  DirectEndpoints,
+  {
+    readonly resolve: () => Effect.Effect<ReadonlyArray<ServerDirectEndpoint>>;
+  }
+>()("t3/environment/DirectEndpoints") {}
+
+/**
+ * Only numeric private-network and tailnet IPv4 addresses are reported. These
+ * routes are plain HTTP and carry the client's credential, so a public address
+ * would send it across the internet unencrypted, and a name (`server.local`)
+ * can resolve to a different machine on each client's network.
+ */
+const isAdvertisableAddress = (address: string): boolean =>
+  NodeNet.isIPv4(address) &&
+  !address.startsWith("127.") &&
+  !address.startsWith("169.254.") &&
+  (isTailscaleIpv4Address(address) || isPrivateNetworkHost(address));
+
+/**
+ * Container and VM networks (Docker, libvirt, VMware, VirtualBox, Hyper-V, and
+ * macOS's `bridge100`+) have private addresses only this machine reaches. A
+ * host bridge such as `br0` or Proxmox's `vmbr0` carries the LAN address, so
+ * it stays listed.
+ */
+const VIRTUAL_INTERFACE =
+  /^(docker|br-|veth|virbr|vmnet|vboxnet|vEthernet|podman|cni|flannel|cali|lxcbr|lxdbr|bridge1\d\d)/;
+
+/**
+ * Plain HTTP endpoints for the private addresses a server bound to `host`
+ * accepts. IPv4 only: link-local and temporary IPv6 addresses change too
+ * often to be worth saving.
+ */
+export function resolveBoundEndpoints(input: {
+  readonly host: string | undefined;
+  readonly port: number;
+  readonly interfaces: NetworkInterfacesMap;
+}): ReadonlyArray<ServerDirectEndpoint> {
+  if (isLoopbackHost(input.host)) return [];
+  const addresses = isWildcardHost(input.host)
+    ? Object.entries(input.interfaces)
+        .flatMap(([name, entries]) => (VIRTUAL_INTERFACE.test(name) ? [] : (entries ?? [])))
+        .filter(
+          (entry) =>
+            !entry.internal && entry.family === "IPv4" && isAdvertisableAddress(entry.address),
+        )
+        .map((entry) => entry.address)
+    : [input.host!].filter(isAdvertisableAddress);
+  return [...new Set(addresses)].map((address) => ({
+    kind: isTailscaleIpv4Address(address) ? "tailnet" : "lan",
+    httpBaseUrl: `http://${formatHostForUrl(address)}:${input.port}/`,
+  }));
+}
+
+/** @public Service construction is part of the canonical Effect module API. */
+export const make = Effect.gen(function* () {
+  const config = yield* ServerConfig.ServerConfig;
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const httpClient = yield* HttpClient.HttpClient;
+
+  const resolve = Effect.gen(function* () {
+    const endpoints = [
+      ...resolveBoundEndpoints({
+        host: config.host,
+        port: config.port,
+        interfaces: NodeOS.networkInterfaces(),
+      }),
+    ];
+    // Tailscale Serve terminates HTTPS on the tailnet name and forwards to
+    // loopback, so it works even for a loopback-only server. The name is only
+    // listed once it answers as this server: Serve setup can fail without
+    // stopping startup. Anything slower than the probe leaves it out rather
+    // than holding back the addresses already found.
+    if (config.tailscaleServeEnabled) {
+      const servedUrl = yield* readTailscaleStatus.pipe(
+        Effect.map((status) => status.magicDnsName),
+        Effect.flatMap((magicDnsName) => {
+          if (magicDnsName === null) return Effect.succeed(null);
+          const httpBaseUrl = buildTailscaleHttpsBaseUrl({
+            magicDnsName,
+            servePort: config.tailscaleServePort,
+          });
+          return probeTailscaleHttpsEndpoint({ baseUrl: httpBaseUrl }).pipe(
+            Effect.map((reachable) => (reachable ? httpBaseUrl : null)),
+          );
+        }),
+        Effect.timeoutOption(TAILSCALE_ENDPOINT_TIMEOUT),
+        Effect.map(Option.flatMap(Option.fromNullishOr)),
+        Effect.orElseSucceed(() => Option.none<string>()),
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        Effect.provideService(HttpClient.HttpClient, httpClient),
+      );
+      if (Option.isSome(servedUrl)) {
+        endpoints.push({ kind: "tailnet", httpBaseUrl: servedUrl.value });
+      }
+    }
+    return endpoints;
+  });
+
+  return DirectEndpoints.of({ resolve: () => resolve });
+});
+
+export const layer = Layer.effect(DirectEndpoints, make);
diff --git a/apps/server/src/environment/ServerEnvironment.test.ts b/apps/server/src/environment/ServerEnvironment.test.ts
index 9e151474fe11..b6479f5c5132 100644
--- a/apps/server/src/environment/ServerEnvironment.test.ts
+++ b/apps/server/src/environment/ServerEnvironment.test.ts
@@ -10,6 +10,12 @@ import * as PlatformError from "effect/PlatformError";
 import * as Schema from "effect/Schema";
 
 import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
+import {
+  HostProcessArguments,
+  HostProcessEnvironment,
+  HostProcessIsExecutable,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
 import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
 
 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
@@ -80,6 +86,47 @@ const makeServerConfig = Effect.fn(function* (baseDir: string) {
 });
 
 it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
+  it.effect("publishes proven install ownership only for manually updated servers", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const baseDir = yield* fs.makeTempDirectoryScoped();
+      const prefix = `${baseDir}/node`;
+      const entry = `${prefix}/lib/node_modules/t3/dist/bin.mjs`;
+      yield* fs.makeDirectory(`${prefix}/lib/node_modules/t3/dist`, { recursive: true });
+      yield* fs.makeDirectory(`${prefix}/bin`, { recursive: true });
+      yield* fs.writeFileString(entry, "");
+      yield* fs.writeFileString(
+        `${prefix}/lib/node_modules/t3/package.json`,
+        '{"name":"t3","version":"0.0.45","bin":{"t3":"./dist/bin.mjs"}}',
+      );
+      yield* fs.symlink(entry, `${prefix}/bin/t3`);
+      const config = yield* makeServerConfig(baseDir);
+      yield* fs.makeDirectory(config.stateDir, { recursive: true });
+      for (const mode of ["web", "desktop"] as const) {
+        const descriptor = yield* Effect.gen(function* () {
+          const environment = yield* ServerEnvironment.ServerEnvironment;
+          return yield* environment.getDescriptor;
+        }).pipe(
+          Effect.provide(
+            ServerEnvironment.layer.pipe(
+              Layer.provide(emptySecretStoreLayer),
+              Layer.provide(ServerConfig.layer({ ...config, mode })),
+            ),
+          ),
+          Effect.provideService(HostProcessArguments, ["node", entry]),
+          Effect.provideService(HostProcessIsExecutable, false),
+          Effect.provideService(HostProcessPlatform, "linux"),
+          Effect.provideService(HostProcessEnvironment, {}),
+        );
+        expect(descriptor.capabilities.serverInstallation).toEqual(
+          mode === "web" ? { kind: "npm-global", prefix } : undefined,
+        );
+        expect(descriptor.capabilities.serverSelfUpdate).toBe(
+          mode === "web" ? undefined : "desktop-managed",
+        );
+      }
+    }),
+  );
   it.effect.each([
     { name: "missing", content: undefined },
     { name: "empty", content: "" },
diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts
index 16a4a93b3f20..ef66b6d5419a 100644
--- a/apps/server/src/environment/ServerEnvironment.ts
+++ b/apps/server/src/environment/ServerEnvironment.ts
@@ -15,6 +15,7 @@ import * as Schema from "effect/Schema";
 
 import packageJson from "../../package.json" with { type: "json" };
 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import { resolveServerInstallation } from "../cli/invocation.ts";
 import { readAgentActivityPublishingActive } from "../cloud/config.ts";
 import { resolveServerSelfUpdateCapability } from "../cloud/selfUpdate.ts";
 import { resolveServiceLauncherMode } from "../cloud/serviceLauncherClient.ts";
@@ -196,6 +197,7 @@ export const make = Effect.gen(function* () {
     desktopManaged: serverConfig.mode === "desktop",
     launcherManaged: launcher.managed,
   });
+  const serverInstallation = serverSelfUpdate === null ? yield* resolveServerInstallation : null;
   // Static is correct: the control fd is known at bootstrap, and the desktop
   // app and its bundled server ship in one artifact, so a present fd means
   // the app speaks the requestDesktopUpdate protocol. WSL backends never get
@@ -248,6 +250,7 @@ export const make = Effect.gen(function* () {
       environmentIcon: true,
       projectCloneTracking: true,
       ...(serverSelfUpdate === null ? {} : { serverSelfUpdate }),
+      ...(serverInstallation === null ? {} : { serverInstallation }),
       // V2 restart recovery uses the environment-owned opt-in. The old
       // per-update request flag is not wired into the V2 update RPC path.
       ...(serverSelfUpdate === "boot-service" || desktopAppUpdate
diff --git a/apps/server/src/git/GitManager.test.ts b/apps/server/src/git/GitManager.test.ts
index 1b6b44008467..501e97cedad5 100644
--- a/apps/server/src/git/GitManager.test.ts
+++ b/apps/server/src/git/GitManager.test.ts
@@ -3116,6 +3116,53 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
     }),
   );
 
+  it.effect.each([undefined, ["README.md"]])(
+    "a failed generation preserves staging changed while generating (paths: %s)",
+    (filePaths) =>
+      Effect.gen(function* () {
+        const repoDir = yield* makeTempDir("t3code-git-manager-");
+        yield* initRepo(repoDir);
+        NodeFS.writeFileSync(NodePath.join(repoDir, "README.md"), "hello\nstaged\n");
+        yield* runGit(repoDir, ["add", "README.md"]);
+        NodeFS.appendFileSync(NodePath.join(repoDir, "README.md"), "unstaged\n");
+        NodeFS.writeFileSync(NodePath.join(repoDir, "untracked.txt"), "untracked\n");
+        const indexBefore = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
+        const headBefore = (yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout;
+        const gitDriver = yield* GitVcsDriver.GitVcsDriver;
+        let indexDuring: Buffer | undefined;
+        let indexAfterUserStage: Buffer | undefined;
+        const { manager } = yield* makeManager({
+          textGeneration: {
+            generateCommitMessage: () =>
+              Effect.gen(function* () {
+                indexDuring = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
+                yield* runGit(repoDir, ["add", "untracked.txt"]).pipe(
+                  Effect.provideService(GitVcsDriver.GitVcsDriver, gitDriver),
+                  Effect.orDie,
+                );
+                indexAfterUserStage = NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"));
+                return yield* new TextGenerationError({
+                  operation: "generateCommitMessage",
+                  detail: "Provider rejected generation",
+                });
+              }),
+          },
+        });
+        const result = yield* runStackedAction(manager, {
+          cwd: repoDir,
+          action: "commit",
+          ...(filePaths ? { filePaths } : {}),
+        }).pipe(Effect.result);
+        expect(Result.isFailure(result)).toBe(true);
+        expect(indexDuring).toEqual(indexBefore);
+        expect(NodeFS.readFileSync(NodePath.join(repoDir, ".git/index"))).toEqual(
+          indexAfterUserStage,
+        );
+        expect((yield* runGit(repoDir, ["rev-parse", "HEAD"])).stdout).toBe(headBefore);
+        expect((yield* runGit(repoDir, ["diff"])).stdout).toContain("+unstaged");
+      }),
+  );
+
   it.effect("uses custom commit message when provided", () =>
     Effect.gen(function* () {
       const repoDir = yield* makeTempDir("t3code-git-manager-");
diff --git a/apps/server/src/git/GitManager.ts b/apps/server/src/git/GitManager.ts
index 2b88cd79f8e6..2829502c8cbd 100644
--- a/apps/server/src/git/GitManager.ts
+++ b/apps/server/src/git/GitManager.ts
@@ -1985,6 +1985,7 @@ export const make = Effect.gen(function* () {
         : null;
     const { commitSha } = yield* gitCore.commit(cwd, suggestion.subject, suggestion.body, {
       timeoutMs: COMMIT_TIMEOUT_MS,
+      stage: filePaths ? { filePaths } : {},
       ...(commitProgress ? { progress: commitProgress } : {}),
     });
     if (currentHookName !== null) {
diff --git a/apps/server/src/mcp/McpDeviceToolkit.test.ts b/apps/server/src/mcp/McpDeviceToolkit.test.ts
index 3a9307314c39..f5aba005f9a8 100644
--- a/apps/server/src/mcp/McpDeviceToolkit.test.ts
+++ b/apps/server/src/mcp/McpDeviceToolkit.test.ts
@@ -19,9 +19,13 @@ const environmentId = EnvironmentId.make("environment-device-test");
 const threadId = ThreadId.make("thread-device-test");
 const invocation = (capabilities: ReadonlyArray<McpInvocationContext.McpCapability>) => ({
   environmentId,
-  threadId,
-  providerSessionId: "provider-session-device-test",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "provider-session-device-test",
+  thread: {
+    threadId,
+    providerSessionId: "provider-session-device-test",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(capabilities),
   issuedAt: 1,
 });
diff --git a/apps/server/src/mcp/McpHttpServer.test.ts b/apps/server/src/mcp/McpHttpServer.test.ts
index 69801ee06100..96a0de29f3d0 100644
--- a/apps/server/src/mcp/McpHttpServer.test.ts
+++ b/apps/server/src/mcp/McpHttpServer.test.ts
@@ -27,9 +27,13 @@ const alternateTabId = PreviewTabId.make("tab-mcp-alternate");
 const decodeJsonText = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
 const invocation = {
   environmentId,
-  threadId,
-  providerSessionId: "provider-session-mcp-test",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "provider-session-mcp-test",
+  thread: {
+    threadId,
+    providerSessionId: "provider-session-mcp-test",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(["preview"] as const),
   issuedAt: 1,
 };
diff --git a/apps/server/src/mcp/McpInvocationContext.test.ts b/apps/server/src/mcp/McpInvocationContext.test.ts
index 4314c82e6ddc..1daa9740f019 100644
--- a/apps/server/src/mcp/McpInvocationContext.test.ts
+++ b/apps/server/src/mcp/McpInvocationContext.test.ts
@@ -13,9 +13,13 @@ import * as McpInvocationContext from "./McpInvocationContext.ts";
 it.effect("reports the scoped credential context when preview capability is unavailable", () => {
   const invocation: McpInvocationContext.McpInvocationScope = {
     environmentId: EnvironmentId.make("environment-1"),
-    threadId: ThreadId.make("thread-1"),
-    providerSessionId: "provider-session-1",
-    providerInstanceId: ProviderInstanceId.make("codex"),
+    requestNamespace: "provider-session-1",
+    thread: {
+      threadId: ThreadId.make("thread-1"),
+      providerSessionId: "provider-session-1",
+      providerInstanceId: ProviderInstanceId.make("codex"),
+    },
+    client: undefined,
     capabilities: new Set(),
     issuedAt: 1,
   };
@@ -30,9 +34,9 @@ it.effect("reports the scoped credential context when preview capability is unav
     expect(error).toMatchObject({
       capability: "preview",
       environmentId: invocation.environmentId,
-      threadId: invocation.threadId,
-      providerSessionId: invocation.providerSessionId,
-      providerInstanceId: invocation.providerInstanceId,
+      threadId: invocation.thread?.threadId,
+      providerSessionId: invocation.thread?.providerSessionId,
+      providerInstanceId: invocation.thread?.providerInstanceId,
     });
     expect(error.message).toContain("MCP credential does not grant the preview capability");
     expect(error.message).toContain("use a headless browser from the shell");
@@ -42,9 +46,13 @@ it.effect("reports the scoped credential context when preview capability is unav
 it.effect("reports other missing capabilities with the neutral error", () => {
   const invocation: McpInvocationContext.McpInvocationScope = {
     environmentId: EnvironmentId.make("environment-1"),
-    threadId: ThreadId.make("thread-1"),
-    providerSessionId: "provider-session-1",
-    providerInstanceId: ProviderInstanceId.make("codex"),
+    requestNamespace: "provider-session-1",
+    thread: {
+      threadId: ThreadId.make("thread-1"),
+      providerSessionId: "provider-session-1",
+      providerInstanceId: ProviderInstanceId.make("codex"),
+    },
+    client: undefined,
     capabilities: new Set(["preview"]),
     issuedAt: 1,
   };
@@ -56,7 +64,10 @@ it.effect("reports other missing capabilities with the neutral error", () => {
     );
 
     expect(error).toBeInstanceOf(McpCapabilityUnavailableError);
-    expect(error).toMatchObject({ capability: "pull-requests", threadId: invocation.threadId });
+    expect(error).toMatchObject({
+      capability: "pull-requests",
+      threadId: invocation.thread?.threadId,
+    });
 
     const scope = yield* McpInvocationContext.requireMcpCapability("preview").pipe(
       Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
@@ -64,3 +75,24 @@ it.effect("reports other missing capabilities with the neutral error", () => {
     expect(scope).toBe(invocation);
   });
 });
+
+it.effect("refuses thread-owned capabilities to a caller signed in from outside a thread", () => {
+  const invocation: McpInvocationContext.McpInvocationScope = {
+    environmentId: EnvironmentId.make("environment-1"),
+    requestNamespace: "client:session-1",
+    thread: undefined,
+    client: { sessionId: "session-1", label: "Claude Code", runtimeModeCeiling: "auto" },
+    capabilities: new Set(["preview", "orchestration"]),
+    issuedAt: 1,
+  };
+
+  return Effect.gen(function* () {
+    const error = yield* McpInvocationContext.requireThreadMcpCapability("preview").pipe(
+      Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
+      Effect.flip,
+    );
+    expect(error).toBeInstanceOf(PreviewAutomationUnavailableError);
+    expect(error).toMatchObject({ capability: "preview", environmentId: "environment-1" });
+    expect(error.threadId).toBeUndefined();
+  });
+});
diff --git a/apps/server/src/mcp/McpInvocationContext.ts b/apps/server/src/mcp/McpInvocationContext.ts
index eff1d01cba29..01906c1b44f6 100644
--- a/apps/server/src/mcp/McpInvocationContext.ts
+++ b/apps/server/src/mcp/McpInvocationContext.ts
@@ -1,8 +1,10 @@
 import {
   type EnvironmentId,
   McpCapabilityUnavailableError,
+  OrchestratorMcpFailure,
   PreviewAutomationUnavailableError,
   type ProviderInstanceId,
+  type RuntimeMode,
   type ThreadId,
 } from "@t3tools/contracts";
 import * as Context from "effect/Context";
@@ -17,13 +19,35 @@ const ALL_MCP_CAPABILITIES = [
 ] as const;
 export type McpCapability = (typeof ALL_MCP_CAPABILITIES)[number];
 
-export interface McpInvocationScope {
-  readonly environmentId: EnvironmentId;
+/** A provider session T3 Code launched for one thread. */
+export interface McpThreadCaller {
   readonly threadId: ThreadId;
   readonly providerSessionId: string;
   readonly providerInstanceId: ProviderInstanceId;
+}
+
+/** An agent T3 Code did not launch, signed in through MCP OAuth. */
+export interface McpClientCaller {
+  readonly sessionId: string;
+  readonly label: string;
+  readonly runtimeModeCeiling: RuntimeMode;
+}
+
+/**
+ * Who is calling and what they may do. Tool parameters choose the target
+ * (thread, project); the caller sets the limits. A thread caller's omitted
+ * target falls back to its own thread; a client caller has no own thread, so
+ * tools that act as the caller (delegate_task, preview, worktree handoff)
+ * need `thread`.
+ */
+export interface McpInvocationScope {
+  readonly environmentId: EnvironmentId;
   readonly capabilities: ReadonlySet<McpCapability>;
   readonly issuedAt: number;
+  /** Namespaces idempotency keys so two callers reusing a clientRequestId cannot collide. */
+  readonly requestNamespace: string;
+  readonly thread: McpThreadCaller | undefined;
+  readonly client: McpClientCaller | undefined;
 }
 
 export class McpInvocationContext extends Context.Service<
@@ -42,9 +66,13 @@ const missingCapability = (
 ): PreviewAutomationUnavailableError | McpCapabilityUnavailableError => {
   const fields = {
     environmentId: invocation.environmentId,
-    threadId: invocation.threadId,
-    providerSessionId: invocation.providerSessionId,
-    providerInstanceId: invocation.providerInstanceId,
+    ...(invocation.thread === undefined
+      ? {}
+      : {
+          threadId: invocation.thread.threadId,
+          providerSessionId: invocation.thread.providerSessionId,
+          providerInstanceId: invocation.thread.providerInstanceId,
+        }),
   };
   return capability === "preview"
     ? new PreviewAutomationUnavailableError({ capability, ...fields })
@@ -62,3 +90,34 @@ export const requireMcpCapability = <const C extends McpCapability>(
     ),
     Effect.withSpan("mcp.requireCapability"),
   );
+
+/**
+ * Preview tabs and device sessions belong to the calling thread, so their
+ * capabilities are only ever granted to thread callers. A scope that carries
+ * one without a thread is refused the same way as a missing capability.
+ */
+export const requireThreadMcpCapability = <const C extends "preview" | "device">(
+  capability: C,
+): Effect.Effect<McpThreadInvocationScope, McpCapabilityError<C>, McpInvocationContext> =>
+  McpInvocationContext.pipe(
+    Effect.filterOrFail(
+      (invocation): invocation is McpThreadInvocationScope =>
+        invocation.capabilities.has(capability) && invocation.thread !== undefined,
+      (invocation) => missingCapability(invocation, capability) as McpCapabilityError<C>,
+    ),
+    Effect.withSpan("mcp.requireCapability"),
+  );
+
+const threadCallerRequired = (operation: string) =>
+  new OrchestratorMcpFailure({
+    code: "thread_credential_required",
+    message: `${operation} acts as the calling T3 thread, so it needs an agent running inside T3 Code. This MCP client signed in from outside a thread.`,
+  });
+
+/** A scope with a thread caller, for tools whose whole surface acts as the caller. */
+export type McpThreadInvocationScope = McpInvocationScope & { readonly thread: McpThreadCaller };
+
+export const requireThreadScope = (scope: McpInvocationScope, operation: string) =>
+  scope.thread === undefined
+    ? Effect.fail(threadCallerRequired(operation))
+    : Effect.succeed(scope as McpThreadInvocationScope);
diff --git a/apps/server/src/mcp/McpSessionRegistry.test.ts b/apps/server/src/mcp/McpSessionRegistry.test.ts
index ba3c20968d10..719bed1ed4e7 100644
--- a/apps/server/src/mcp/McpSessionRegistry.test.ts
+++ b/apps/server/src/mcp/McpSessionRegistry.test.ts
@@ -47,7 +47,7 @@ it.effect("stores only a token hash, resolves the bearer token, and revokes by t
     expect(token.length).toBeGreaterThan(20);
 
     const resolved = yield* registry.resolve(token);
-    expect(resolved?.threadId).toBe(threadId);
+    expect(resolved?.thread.threadId).toBe(threadId);
     expect(resolved?.capabilities).toEqual(
       new Set(["preview", "orchestration", "worktree", "pull-requests"]),
     );
@@ -158,7 +158,7 @@ it.effect("keeps a credential alive across turns that never touch an MCP tool",
       yield* registry.touch(threadId);
     }
 
-    expect((yield* registry.resolve(token))?.threadId).toBe(threadId);
+    expect((yield* registry.resolve(token))?.thread.threadId).toBe(threadId);
   }),
 );
 
diff --git a/apps/server/src/mcp/McpSessionRegistry.ts b/apps/server/src/mcp/McpSessionRegistry.ts
index c62c3ca5043c..10b933d4f45b 100644
--- a/apps/server/src/mcp/McpSessionRegistry.ts
+++ b/apps/server/src/mcp/McpSessionRegistry.ts
@@ -32,7 +32,7 @@ export interface McpSessionRegistryShape {
   readonly issue: (request: McpCredentialRequest) => Effect.Effect<McpIssuedCredential>;
   readonly resolve: (
     rawToken: string,
-  ) => Effect.Effect<McpInvocationContext.McpInvocationScope | undefined>;
+  ) => Effect.Effect<McpInvocationContext.McpThreadInvocationScope | undefined>;
   /**
    * Records a sign of life for every credential bound to `threadId`. Provider
    * turns call this so that a session which is plainly alive keeps its
@@ -49,9 +49,10 @@ export class McpSessionRegistry extends Context.Service<
   McpSessionRegistryShape
 >()("t3/mcp/McpSessionRegistry") {}
 
+/** Registry credentials always belong to a provider session, so their scope has a thread. */
 interface CredentialRecord {
   readonly tokenHash: string;
-  readonly scope: McpInvocationContext.McpInvocationScope;
+  readonly scope: McpInvocationContext.McpThreadInvocationScope;
   readonly lastAliveAt: number;
 }
 
@@ -127,11 +128,15 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       const rawToken = yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie);
       const tokenHash = yield* hashToken(rawToken);
       const browserToolsAvailable = request.browserToolsAvailable ?? true;
-      const scope: McpInvocationContext.McpInvocationScope = {
+      const scope: McpInvocationContext.McpThreadInvocationScope = {
         environmentId,
-        threadId: ThreadId.make(request.threadId),
-        providerSessionId,
-        providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
+        requestNamespace: providerSessionId,
+        thread: {
+          threadId: ThreadId.make(request.threadId),
+          providerSessionId,
+          providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
+        },
+        client: undefined,
         capabilities: new Set<McpInvocationContext.McpCapability>([
           "orchestration",
           "worktree",
@@ -148,9 +153,9 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       return {
         config: {
           environmentId,
-          threadId: scope.threadId,
+          threadId: scope.thread.threadId,
           providerSessionId,
-          providerInstanceId: scope.providerInstanceId,
+          providerInstanceId: scope.thread.providerInstanceId,
           endpoint,
           authorizationHeader: `Bearer ${rawToken}`,
           browserToolsAvailable: scope.capabilities.has("preview"),
@@ -183,7 +188,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
         const current = pruneDead(records, timestamp);
         const next = new Map(current);
         for (const [tokenHash, record] of current) {
-          if (record.scope.threadId === threadId) {
+          if (record.scope.thread.threadId === threadId) {
             next.set(tokenHash, { ...record, lastAliveAt: timestamp });
           }
         }
@@ -203,11 +208,11 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
     touch,
     revokeProviderSession: Effect.fn("McpSessionRegistry.revokeProviderSession")(
       function* (providerSessionId) {
-        yield* revokeWhere((record) => record.scope.providerSessionId === providerSessionId);
+        yield* revokeWhere((record) => record.scope.thread.providerSessionId === providerSessionId);
       },
     ),
     revokeThread: Effect.fn("McpSessionRegistry.revokeThread")(function* (threadId) {
-      yield* revokeWhere((record) => record.scope.threadId === threadId);
+      yield* revokeWhere((record) => record.scope.thread.threadId === threadId);
     }),
     revokeAll: SynchronizedRef.set(state, { records: new Map() }),
   });
diff --git a/apps/server/src/mcp/OrchestratorMcpService.activity.test.ts b/apps/server/src/mcp/OrchestratorMcpService.activity.test.ts
index 06eff1e6f8b1..2433eb8a704a 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.activity.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.activity.test.ts
@@ -2,10 +2,12 @@ import {
   EnvironmentId,
   NodeId,
   type OrchestrationV2ThreadProjection,
+  type OrchestrationV2ThreadShell,
   ProjectId,
   ProviderDriverKind,
   ProviderInstanceId,
   RunId,
+  ScheduledTaskId,
   ThreadId,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
@@ -16,6 +18,7 @@ import { expect, it } from "vite-plus/test";
 
 import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterRegistry.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import type * as McpInvocationContext from "./McpInvocationContext.ts";
@@ -37,9 +40,13 @@ const parentInstanceId = ProviderInstanceId.make("codex");
 
 const makeScope = (): McpInvocationContext.McpInvocationScope => ({
   environmentId,
-  threadId: parentThreadId,
-  providerSessionId: "provider-session-mcp-orchestrator-detail",
-  providerInstanceId: parentInstanceId,
+  requestNamespace: "provider-session-mcp-orchestrator-detail",
+  thread: {
+    threadId: parentThreadId,
+    providerSessionId: "provider-session-mcp-orchestrator-detail",
+    providerInstanceId: parentInstanceId,
+  },
+  client: undefined,
   capabilities: new Set(["orchestration"]),
   issuedAt: 1,
 });
@@ -127,10 +134,21 @@ it("readThread prefers activity-run status over a newer cancelled queued run", a
             threadId === parentThreadId
               ? Effect.succeed(projection)
               : Effect.die(`unexpected thread ${threadId}`),
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === parentThreadId
+                ? (projection.thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
+          getProjectThreadRecords: (input) =>
+            input.threadId === parentThreadId
+              ? Effect.succeed(projection)
+              : Effect.die(`unexpected thread ${input.threadId}`),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
@@ -180,10 +198,21 @@ it("readThread prefers waiting activity status over a newer cancelled queued run
             threadId === parentThreadId
               ? Effect.succeed(projection)
               : Effect.die(`unexpected thread ${threadId}`),
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === parentThreadId
+                ? (projection.thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
+          getProjectThreadRecords: (input) =>
+            input.threadId === parentThreadId
+              ? Effect.succeed(projection)
+              : Effect.die(`unexpected thread ${input.threadId}`),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
@@ -295,6 +324,7 @@ it("taskStatus returns task.providerInstanceId rather than the driver kind", asy
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
@@ -317,34 +347,12 @@ it("taskStatus returns task.providerInstanceId rather than the driver kind", asy
   }).pipe(Effect.provide(layer), Effect.runPromise);
 });
 
-it("readThread reaches a thread the user attached as context, but not one an agent attached", async () => {
+it("readThread and sendToThread reach threads in other projects", async () => {
+  let parentRuns: ReadonlyArray<unknown> = [
+    makeRun({ id: RunId.make("run-parent-live"), ordinal: 1, status: "running" }),
+  ];
   const foreignProjectId = ProjectId.make("project-mcp-orchestrator-foreign");
   const foreignThreadId = ThreadId.make("thread-mcp-orchestrator-foreign");
-  const agentOnlyThreadId = ThreadId.make("thread-mcp-orchestrator-agent-only");
-  const threadRecord = (threadId: ThreadId) => ({
-    version: 1,
-    kind: "thread",
-    contextId: `thread_${threadId}`,
-    label: "Attached",
-    environmentId,
-    threadId,
-    title: "Attached",
-  });
-  const message = (input: { createdBy: "user" | "agent"; threadId: ThreadId }) => ({
-    id: `message-${input.threadId}`,
-    threadId: parentThreadId,
-    runId: null,
-    nodeId: null,
-    role: "user",
-    text: `[Attached](t3-context://v1/thread/thread_${input.threadId})`,
-    context: { version: 1, records: [threadRecord(input.threadId)] },
-    attachments: [],
-    streaming: false,
-    createdBy: input.createdBy,
-    creationSource: input.createdBy === "user" ? "user" : "mcp",
-    createdAt: now,
-    updatedAt: now,
-  });
   const parentProjection = {
     thread: baseThread({
       threadId: parentThreadId,
@@ -352,13 +360,12 @@ it("readThread reaches a thread the user attached as context, but not one an age
       instanceId: parentInstanceId,
       model: "gpt-5.4",
     }),
-    runs: [],
+    get runs() {
+      return parentRuns;
+    },
     visibleTurnItems: [],
     runtimeRequests: [],
-    messages: [
-      message({ createdBy: "user", threadId: foreignThreadId }),
-      message({ createdBy: "agent", threadId: agentOnlyThreadId }),
-    ],
+    messages: [],
     contextTransfers: [],
     subagents: [],
     updatedAt: now,
@@ -406,11 +413,15 @@ it("readThread reaches a thread the user attached as context, but not one an age
         Layer.mock(ThreadManagementService.ThreadManagementService)({
           getThreadRecords: (threadId) => {
             if (threadId === parentThreadId) return Effect.succeed(parentProjection);
-            if (threadId === foreignThreadId || threadId === agentOnlyThreadId) {
-              return Effect.succeed(foreignProjection(threadId));
-            }
+            if (threadId === foreignThreadId) return Effect.succeed(foreignProjection(threadId));
             return Effect.die(`unexpected thread ${threadId}`);
           },
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === foreignThreadId
+                ? (foreignProjection(threadId).thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
           getTimelinePage: (threadId) =>
             Effect.succeed({
               items: foreignProjection(threadId).visibleTurnItems,
@@ -418,18 +429,36 @@ it("readThread reaches a thread the user attached as context, but not one an age
               hasMore: false,
             }),
           getProjectThreadRecords: (input) =>
-            Effect.fail(
-              new ThreadManagementService.ThreadManagementThreadNotFoundError({
-                projectId: input.projectId,
-                threadId: input.threadId,
-              }),
-            ),
+            input.threadId === foreignThreadId && input.projectId === foreignProjectId
+              ? Effect.succeed(foreignProjection(input.threadId))
+              : Effect.fail(
+                  new ThreadManagementService.ThreadManagementThreadNotFoundError({
+                    projectId: input.projectId,
+                    threadId: input.threadId,
+                  }),
+                ),
+          sendToThread: () =>
+            Effect.succeed({
+              run: { id: "run-foreign", status: "queued" },
+              delivery: "started",
+            } as unknown as ThreadManagementService.ThreadManagementSendResult),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
-          list: () => Effect.succeed({ tasks: [] }),
+          list: () =>
+            Effect.succeed({
+              tasks: [
+                {
+                  id: "task-foreign",
+                  projectId: foreignProjectId,
+                  runtimeMode: "approval-required",
+                  interactionMode: "default",
+                } as never,
+              ],
+            }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
@@ -441,18 +470,47 @@ it("readThread reaches a thread the user attached as context, but not one an age
 
   await Effect.gen(function* () {
     const service = yield* OrchestratorMcpService.OrchestratorMcpService;
-    const attached = yield* service.readThread(makeScope(), { threadId: foreignThreadId });
-    expect(attached.thread.threadId).toBe(foreignThreadId);
-    expect(attached.items.map((item) => item.text)).toEqual(["Foreign thread said hello"]);
+    const foreign = yield* service.readThread(makeScope(), { threadId: foreignThreadId });
+    expect(foreign.thread.threadId).toBe(foreignThreadId);
+    expect(foreign.thread.projectId).toBe(foreignProjectId);
+    expect(foreign.items.map((item) => item.text)).toEqual(["Foreign thread said hello"]);
 
-    const denied = yield* service
-      .readThread(makeScope(), { threadId: agentOnlyThreadId })
-      .pipe(Effect.flip);
-    expect(denied.code).toBe("thread_not_found");
+    const sent = yield* service.sendToThread(makeScope(), {
+      threadId: foreignThreadId,
+      message: "hi",
+    });
+    expect(sent.threadId).toBe(foreignThreadId);
 
-    const write = yield* service
-      .sendToThread(makeScope(), { threadId: foreignThreadId, message: "hi" })
+    // Once the caller's run ends, it can still read other threads but no longer write to them.
+    parentRuns = [];
+    yield* service.readThread(makeScope(), { threadId: foreignThreadId });
+    const stale = yield* service
+      .sendToThread(makeScope(), { threadId: foreignThreadId, message: "hi again" })
+      .pipe(Effect.flip);
+    expect(stale.code).toBe("parent_not_active");
+    const staleInterrupt = yield* service
+      .interruptThread(makeScope(), { threadId: foreignThreadId })
+      .pipe(Effect.flip);
+    expect(staleInterrupt.code).toBe("parent_not_active");
+    // Nor create, change or remove scheduled work in another project.
+    const staleSchedule = yield* service
+      .scheduleTask(makeScope(), {
+        projectId: foreignProjectId,
+        prompt: "check in later",
+        schedule: { type: "interval", everyMs: 3_600_000 },
+      })
+      .pipe(Effect.flip);
+    expect(staleSchedule.code).toBe("parent_not_active");
+    const staleUpdate = yield* service
+      .updateScheduledTask(makeScope(), {
+        scheduledTaskId: ScheduledTaskId.make("task-foreign"),
+        enabled: false,
+      })
+      .pipe(Effect.flip);
+    expect(staleUpdate.code).toBe("parent_not_active");
+    const staleDelete = yield* service
+      .deleteScheduledTask(makeScope(), { scheduledTaskId: ScheduledTaskId.make("task-foreign") })
       .pipe(Effect.flip);
-    expect(write.code).toBe("thread_not_found");
+    expect(staleDelete.code).toBe("parent_not_active");
   }).pipe(Effect.provide(layer), Effect.runPromise);
 });
diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts
index eae4ffa8c0b1..5d8025c5fe12 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts
@@ -22,6 +22,7 @@ import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterReg
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
 import { buildUnavailableProviderSnapshot } from "../provider/unavailableProviderSnapshot.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import type { McpInvocationScope } from "./McpInvocationContext.ts";
 import * as OrchestratorMcpService from "./OrchestratorMcpService.ts";
@@ -118,13 +119,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-ack"),
-        threadId: parentThreadId,
-        providerSessionId: "provider-session:mcp-ack",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "provider-session:mcp-ack",
+        thread: {
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-ack",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
@@ -202,13 +208,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-restart"),
-        threadId: parentThreadId,
-        providerSessionId: "provider-session:mcp-restart",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "provider-session:mcp-restart",
+        thread: {
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-restart",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
@@ -278,13 +289,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel"),
-        threadId: parentThreadId,
-        providerSessionId: "provider-session:mcp-cancel",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "provider-session:mcp-cancel",
+        thread: {
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
@@ -346,13 +362,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel-failed"),
-        threadId: parentThreadId,
-        providerSessionId: "provider-session:mcp-cancel-failed",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "provider-session:mcp-cancel-failed",
+        thread: {
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel-failed",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
@@ -421,13 +442,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel-dispose-failed"),
-        threadId: parentThreadId,
-        providerSessionId: "provider-session:mcp-cancel-dispose-failed",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "provider-session:mcp-cancel-dispose-failed",
+        thread: {
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel-dispose-failed",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
@@ -460,9 +486,13 @@ describe("OrchestratorMcpService provider resolution", () => {
 
   const scope: McpInvocationScope = {
     environmentId: EnvironmentId.make("environment:mcp-providers"),
-    threadId: parentThreadId,
-    providerSessionId: "provider-session:mcp-providers",
-    providerInstanceId: codexInstanceId,
+    requestNamespace: "provider-session:mcp-providers",
+    thread: {
+      threadId: parentThreadId,
+      providerSessionId: "provider-session:mcp-providers",
+      providerInstanceId: codexInstanceId,
+    },
+    client: undefined,
     capabilities: new Set(["orchestration"]),
     issuedAt: 1,
   };
@@ -613,6 +643,7 @@ describe("OrchestratorMcpService provider resolution", () => {
             antigravityInstanceId,
             disabledAntigravityInstanceId,
           ]),
+          Layer.mock(ProjectService.ProjectService)({}),
           Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
         );
 
@@ -756,6 +787,7 @@ describe("OrchestratorMcpService provider resolution", () => {
             ]),
           }),
           adapterRegistryLayer([codexInstanceId, antigravityInstanceId]),
+          Layer.mock(ProjectService.ProjectService)({}),
           Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
         );
 
@@ -849,6 +881,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           ]),
         }),
         adapterRegistryLayer([codexInstanceId, antigravityInstanceId]),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
 
@@ -897,6 +930,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           ]),
         }),
         adapterRegistryLayer([codexInstanceId]),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
 
@@ -1060,6 +1094,7 @@ describe("OrchestratorMcpService provider resolution", () => {
               ]),
             }),
             adapterRegistryLayer([codexInstanceId, codexAltInstanceId]),
+            Layer.mock(ProjectService.ProjectService)({}),
             Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
           );
 
diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
index 83a7a4cbfde6..097ce0356264 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.ts
@@ -29,6 +29,8 @@ import {
   type OrchestratorMcpTaskCancelInput,
   type OrchestratorMcpTaskCancelResult,
   type OrchestratorMcpUpdateScheduledTaskInput,
+  type OrchestratorMcpListScheduledTasksInput,
+  type ProjectId,
   type OrchestratorMcpThreadDetail,
   type OrchestratorMcpThreadInterruptInput,
   type OrchestratorMcpThreadInterruptResult,
@@ -68,9 +70,14 @@ import {
   delegatedTaskProgress,
 } from "../orchestration-v2/SubagentProjection.ts";
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
-import type { McpInvocationScope } from "./McpInvocationContext.ts";
+import {
+  type McpInvocationScope,
+  type McpThreadInvocationScope,
+  requireThreadScope,
+} from "./McpInvocationContext.ts";
 
 const DEFAULT_WAIT_TIMEOUT_MS = 10 * 60 * 1_000;
 const MAX_WAIT_TIMEOUT_MS = 60 * 60 * 1_000;
@@ -115,6 +122,7 @@ export interface OrchestratorMcpServiceShape {
   ) => Effect.Effect<OrchestratorMcpScheduleTaskResult, OrchestratorMcpFailure>;
   readonly listScheduledTasks: (
     scope: McpInvocationScope,
+    input: OrchestratorMcpListScheduledTasksInput,
   ) => Effect.Effect<OrchestratorMcpListScheduledTasksResult, OrchestratorMcpFailure>;
   readonly updateScheduledTask: (
     scope: McpInvocationScope,
@@ -486,7 +494,7 @@ function stableCommandId(input: {
     [
       "command",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       stablePart(input.operation),
       stablePart(input.requestKey),
       ...(input.index === undefined ? [] : [String(input.index)]),
@@ -503,7 +511,7 @@ function stableThreadId(input: {
     [
       "thread",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       stablePart(input.requestKey),
       String(input.index),
     ].join(":"),
@@ -519,7 +527,7 @@ function stableMessageId(input: {
     [
       "message",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       stablePart(input.requestKey),
       String(input.index),
     ].join(":"),
@@ -535,7 +543,7 @@ function stableOperationMessageId(input: {
     [
       "message",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       stablePart(input.operation),
       stablePart(input.requestKey),
     ].join(":"),
@@ -760,6 +768,35 @@ const make = Effect.gen(function* () {
   const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
   const providerAdapters = yield* ProviderAdapterRegistry.ProviderAdapterRegistryV2;
   const scheduledTasks = yield* ScheduledTaskService.ScheduledTaskService;
+  const projects = yield* ProjectService.ProjectService;
+
+  /** A caller-named project, which must exist before anything is recorded against it. */
+  const requireProject = (projectId: ProjectId) =>
+    projects.getById(projectId).pipe(
+      Effect.mapError((error) =>
+        failure("orchestration_error", `Unable to read project ${projectId}: ${error.message}`),
+      ),
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.fail(failure("invalid_request", `Project ${projectId} was not found.`)),
+          onSome: Effect.succeed,
+        }),
+      ),
+    );
+
+  /** A client has no thread to inherit a model from, so it falls back to the project default. */
+  const projectDefaultModelSelection = (
+    project: Effect.Success<ReturnType<typeof requireProject>>,
+  ) =>
+    project.defaultModelSelection === null
+      ? Effect.fail(
+          failure(
+            "invalid_request",
+            `Project ${project.id} has no default model, so this caller cannot pick one for it.`,
+          ),
+        )
+      : Effect.succeed(project.defaultModelSelection);
 
   const requireCapability = (scope: McpInvocationScope) =>
     scope.capabilities.has("orchestration")
@@ -817,61 +854,133 @@ const make = Effect.gen(function* () {
       )
       .pipe(Effect.mapError(threadManagementFailure));
 
-  const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
+  /**
+   * The caller's own thread and the most it may hand to threads it targets. A
+   * thread caller is capped by its own modes; an OAuth client by the ceiling
+   * chosen when it was approved.
+   */
+  const loadCaller = (scope: McpInvocationScope) =>
     Effect.gen(function* () {
       yield* requireCapability(scope);
-      const parent = yield* loadProjection(scope.threadId);
+      if (scope.thread === undefined) {
+        return {
+          parent: undefined,
+          limits: {
+            runtimeMode: scope.client?.runtimeModeCeiling ?? "approval-required",
+            interactionMode: "default",
+          } satisfies { runtimeMode: RuntimeMode; interactionMode: ProviderInteractionMode },
+        } as const;
+      }
+      const parent = yield* loadProjection(scope.thread.threadId);
+      return {
+        parent,
+        limits: {
+          runtimeMode: parent.thread.runtimeMode,
+          interactionMode: parent.thread.interactionMode,
+        },
+      } as const;
+    });
+
+  /** The caller's own thread, for operations that act as the caller. */
+  const loadThreadCaller = (scope: McpInvocationScope, operation: string) =>
+    Effect.gen(function* () {
+      yield* requireCapability(scope);
+      const threadScope = yield* requireThreadScope(scope, operation);
+      const parent = yield* loadProjection(threadScope.thread.threadId);
+      return { scope: threadScope, parent } as const;
+    });
+
+  /** A target project: the one passed, else the calling thread's. */
+  const resolveProjectTarget = (
+    parent: Pick<OrchestrationV2ThreadProjection, "thread"> | undefined,
+    projectId: ProjectId | undefined,
+  ) =>
+    projectId !== undefined
+      ? Effect.succeed(projectId)
+      : parent !== undefined
+        ? Effect.succeed(parent.thread.projectId)
+        : Effect.fail(
+            failure(
+              "target_required",
+              "Pass projectId: this MCP client is not running inside a T3 thread.",
+            ),
+          );
+
+  /** Any live thread in the environment. */
+  const loadTargetThread = (threadId: ThreadId) =>
+    Effect.gen(function* () {
+      const shell = yield* threadManagement
+        .getThreadShell(threadId)
+        .pipe(Effect.mapError(threadManagementFailure));
+      if (shell === null || shell.deletedAt !== null) {
+        return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
+      }
+      return yield* loadProjectThread(shell.projectId, threadId);
+    });
+
+  const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
+    Effect.gen(function* () {
+      const caller = yield* loadCaller(scope);
       const target =
-        threadId === scope.threadId
-          ? parent
-          : yield* loadProjectThread(parent.thread.projectId, threadId);
-      return { parent, target } as const;
+        caller.parent !== undefined && threadId === caller.parent.thread.id
+          ? caller.parent
+          : yield* loadTargetThread(threadId);
+      return { ...caller, target } as const;
     });
 
   /**
-   * A thread the user attached as context (a `thread` record on one of their own messages)
-   * is readable even outside the calling project. Only records the user authored count:
-   * an agent cannot widen its own reach by writing a record.
+   * A thread caller writes to another thread only while its own run is live,
+   * so a credential that outlived its session cannot reach across threads.
    */
-  const userAttachedThreadIds = (
-    parent: Pick<OrchestrationV2ThreadProjection, "messages">,
-  ): Set<ThreadId> => {
-    const ids = new Set<ThreadId>();
-    for (const message of parent.messages) {
-      if (message.role !== "user" || message.createdBy !== "user") continue;
-      for (const record of message.context?.records ?? []) {
-        if (record.kind === "thread" && "threadId" in record) ids.add(record.threadId);
-      }
-    }
-    return ids;
+  const assertLiveCallerForOtherThread = (
+    scope: McpInvocationScope,
+    parent: Pick<OrchestrationV2ThreadProjection, "thread" | "runs"> | undefined,
+    target: Pick<OrchestrationV2ThreadProjection, "thread">,
+  ) =>
+    parent === undefined || target.thread.id === parent.thread.id
+      ? Effect.void
+      : assertLiveCaller(scope, parent);
+
+  /** Scheduled work outside the caller's own project needs the same live run. */
+  const assertLiveCallerForOtherProject = (
+    scope: McpInvocationScope,
+    parent: Pick<OrchestrationV2ThreadProjection, "thread" | "runs"> | undefined,
+    projectId: ProjectId,
+  ) =>
+    parent === undefined || projectId === parent.thread.projectId
+      ? Effect.void
+      : assertLiveCaller(scope, parent);
+
+  const assertLiveCaller = (
+    scope: McpInvocationScope,
+    parent: Pick<OrchestrationV2ThreadProjection, "thread" | "runs">,
+  ) => {
+    const activeRun = ThreadManagementService.latestActiveRun(parent);
+    return parent.thread.archivedAt !== null ||
+      activeRun === undefined ||
+      activeRun.providerInstanceId !== scope.thread?.providerInstanceId
+      ? Effect.fail(
+          failure("parent_not_active", "The calling provider no longer owns an active thread run."),
+        )
+      : Effect.void;
   };
 
   const loadReadableThread = (scope: McpInvocationScope, threadId: ThreadId) =>
     Effect.gen(function* () {
-      yield* requireCapability(scope);
-      const parent = yield* loadProjection(scope.threadId);
-      const loadTarget = () =>
-        threadManagement
-          .getThreadRecords(threadId, ["runs", "runtimeRequests", "contextTransfers"])
-          .pipe(Effect.mapError(threadManagementFailure));
-      if (threadId === scope.threadId) return { parent, target: yield* loadTarget() } as const;
+      const { parent } = yield* loadCaller(scope);
+      const shell = yield* threadManagement
+        .getThreadShell(threadId)
+        .pipe(Effect.mapError(threadManagementFailure));
+      if (shell === null || shell.deletedAt !== null) {
+        return yield* failure("thread_not_found", `Thread ${threadId} is no longer available.`);
+      }
       const target = yield* threadManagement
-        .getProjectThreadRecords({ projectId: parent.thread.projectId, threadId }, [
+        .getProjectThreadRecords({ projectId: shell.projectId, threadId }, [
           "runs",
           "runtimeRequests",
           "contextTransfers",
         ])
-        .pipe(
-          Effect.mapError(threadManagementFailure),
-          Effect.catchIf(
-            (error) =>
-              error.code === "thread_not_found" && userAttachedThreadIds(parent).has(threadId),
-            loadTarget,
-          ),
-        );
-      if (target.thread.deletedAt !== null) {
-        return yield* failure("thread_not_found", `Thread ${threadId} is no longer available.`);
-      }
+        .pipe(Effect.mapError(threadManagementFailure));
       return { parent, target } as const;
     });
 
@@ -1010,7 +1119,7 @@ const make = Effect.gen(function* () {
       : Effect.succeed(clientRequestId);
 
   const readTask = (
-    scope: McpInvocationScope,
+    scope: McpThreadInvocationScope,
     taskId: NodeId,
     waitTimedOut = false,
     acknowledgeTerminal = false,
@@ -1018,17 +1127,17 @@ const make = Effect.gen(function* () {
   ): Effect.Effect<OrchestratorMcpDelegateTaskResult, OrchestratorMcpFailure> =>
     Effect.gen(function* () {
       yield* requireCapability(scope);
-      const parentProjection = yield* loadProjection(scope.threadId);
+      const parentProjection = yield* loadProjection(scope.thread.threadId);
       const task = parentProjection.subagents.find(
         (candidate) =>
           candidate.id === taskId &&
           candidate.origin === "app_owned" &&
-          candidate.threadId === scope.threadId,
+          candidate.threadId === scope.thread.threadId,
       );
       if (task === undefined || task.childThreadId === null) {
         return yield* failure(
           "task_not_found",
-          `Delegated task ${taskId} does not belong to thread ${scope.threadId}.`,
+          `Delegated task ${taskId} does not belong to thread ${scope.thread.threadId}.`,
         );
       }
       const childControls = yield* threadManagement
@@ -1094,7 +1203,7 @@ const make = Effect.gen(function* () {
         (transfer) =>
           transfer.type === "subagent_result" &&
           transfer.sourceThreadId === task.childThreadId &&
-          transfer.targetThreadId === scope.threadId,
+          transfer.targetThreadId === scope.thread.threadId,
       );
       const resultTransferForRun = (run: OrchestrationV2Run | undefined) =>
         !canExposeTaskRunResult(run)
@@ -1145,10 +1254,10 @@ const make = Effect.gen(function* () {
               requestKey: acknowledgementRequestKey,
               operation: acknowledgementOperation,
             }),
-            parentThreadId: scope.threadId,
+            parentThreadId: scope.thread.threadId,
             taskId,
             observedByRunId:
-              observingRun?.providerInstanceId === scope.providerInstanceId
+              observingRun?.providerInstanceId === scope.thread.providerInstanceId
                 ? observingRun.id
                 : null,
           })
@@ -1164,7 +1273,7 @@ const make = Effect.gen(function* () {
       return response;
     });
 
-  const waitForTask = (scope: McpInvocationScope, taskId: NodeId, timeoutMs: number) =>
+  const waitForTask = (scope: McpThreadInvocationScope, taskId: NodeId, timeoutMs: number) =>
     Effect.gen(function* () {
       while (true) {
         const result = yield* readTask(scope, taskId, false, true);
@@ -1173,11 +1282,17 @@ const make = Effect.gen(function* () {
       }
     }).pipe(Effect.timeoutOption(Duration.millis(timeoutMs)));
 
-  // Load a single scheduled task and enforce that it belongs to the calling
-  // thread's project, so agents can only read/mutate tasks in their own scope.
-  const loadScopedScheduledTask = (
-    projectId: ScheduledTask["projectId"],
+  /**
+   * A scheduled task the caller may change: one whose modes are no broader
+   * than the caller's own, so editing its prompt cannot run work above the
+   * caller's limits.
+   */
+  const loadScheduledTask = (
     scheduledTaskId: ScheduledTask["id"],
+    limits: {
+      readonly runtimeMode: RuntimeMode;
+      readonly interactionMode: ProviderInteractionMode;
+    },
   ): Effect.Effect<ScheduledTask, OrchestratorMcpFailure> =>
     Effect.gen(function* () {
       const { tasks } = yield* scheduledTasks
@@ -1188,21 +1303,38 @@ const make = Effect.gen(function* () {
           ),
         );
       const task = tasks.find((candidate) => candidate.id === scheduledTaskId);
-      if (task === undefined || task.projectId !== projectId) {
-        return yield* failure(
-          "task_not_found",
-          `Scheduled task ${scheduledTaskId} was not found in the calling project.`,
-        );
+      if (task === undefined) {
+        return yield* failure("task_not_found", `Scheduled task ${scheduledTaskId} was not found.`);
       }
+      yield* resolveRuntimeMode(limits.runtimeMode, task.runtimeMode);
+      yield* resolveInteractionMode(limits.interactionMode, task.interactionMode);
       return task;
     });
 
   return OrchestratorMcpService.of({
     scheduleTask: (scope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
-        const bindToCurrentThread = input.bindToCurrentThread ?? true;
+        const { parent, limits } = yield* loadCaller(scope);
+        const projectId = yield* resolveProjectTarget(parent, input.projectId);
+        yield* assertLiveCallerForOtherProject(scope, parent, projectId);
+        const project = yield* requireProject(projectId);
+        // Binding means "wake this thread", which only a thread caller in that project has.
+        const bindToCurrentThread =
+          input.bindToCurrentThread ??
+          (parent !== undefined && parent.thread.projectId === projectId);
+        if (
+          bindToCurrentThread &&
+          (parent === undefined || parent.thread.projectId !== projectId)
+        ) {
+          return yield* failure(
+            "invalid_request",
+            parent === undefined
+              ? "bindToCurrentThread needs an agent running inside a T3 thread."
+              : "bindToCurrentThread binds to this thread, which belongs to a different project.",
+          );
+        }
+        const modelSelection =
+          parent?.thread.modelSelection ?? (yield* projectDefaultModelSelection(project));
         const derivedTitle = input.prompt.split("\n")[0]?.trim() ?? "";
         const title =
           input.title ?? (derivedTitle.length > 0 ? derivedTitle.slice(0, 80) : "Scheduled task");
@@ -1211,12 +1343,12 @@ const make = Effect.gen(function* () {
           prompt: input.prompt,
           enabled: input.enabled ?? true,
           schedule: input.schedule,
-          projectId: parent.thread.projectId,
-          threadId: bindToCurrentThread ? scope.threadId : null,
+          projectId,
+          threadId: bindToCurrentThread && parent !== undefined ? parent.thread.id : null,
           workspaceStrategy: scheduledTaskWorkspaceStrategy(bindToCurrentThread),
-          modelSelection: parent.thread.modelSelection,
-          runtimeMode: parent.thread.runtimeMode,
-          interactionMode: parent.thread.interactionMode,
+          modelSelection,
+          runtimeMode: limits.runtimeMode,
+          interactionMode: limits.interactionMode,
           createdBy: "agent",
           creationSource: "mcp",
           // Scope the idempotency key by provider session so two callers
@@ -1240,10 +1372,10 @@ const make = Effect.gen(function* () {
           );
         return scheduledTaskSummary(task);
       }),
-    listScheduledTasks: (scope) =>
+    listScheduledTasks: (scope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
+        const { parent } = yield* loadCaller(scope);
+        const projectId = input.projectId ?? parent?.thread.projectId;
         const { tasks } = yield* scheduledTasks
           .list()
           .pipe(
@@ -1251,26 +1383,33 @@ const make = Effect.gen(function* () {
               failure("orchestration_error", `Could not list scheduled tasks: ${error.message}`),
             ),
           );
-        // Only expose tasks belonging to the calling thread's project.
         return {
           tasks: tasks
-            .filter((task) => task.projectId === parent.thread.projectId)
+            .filter((task) => projectId === undefined || task.projectId === projectId)
             .map(scheduledTaskSummary),
         };
       }),
     updateScheduledTask: (scope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
-        const existing = yield* loadScopedScheduledTask(
-          parent.thread.projectId,
-          input.scheduledTaskId,
-        );
+        const { parent, limits } = yield* loadCaller(scope);
+        const existing = yield* loadScheduledTask(input.scheduledTaskId, limits);
+        yield* assertLiveCallerForOtherProject(scope, parent, existing.projectId);
+        if (
+          input.bindToCurrentThread === true &&
+          (parent === undefined || parent.thread.projectId !== existing.projectId)
+        ) {
+          return yield* failure(
+            "invalid_request",
+            parent === undefined
+              ? "bindToCurrentThread needs an agent running inside a T3 thread."
+              : "bindToCurrentThread binds to this thread, which belongs to a different project.",
+          );
+        }
         const threadId =
           input.bindToCurrentThread === undefined
             ? existing.threadId
-            : input.bindToCurrentThread
-              ? scope.threadId
+            : input.bindToCurrentThread && parent !== undefined
+              ? parent.thread.id
               : null;
         // Rebinding changes where runs execute, so the workspace strategy must
         // follow: unbinding a root-strategy task would otherwise run loose
@@ -1305,12 +1444,9 @@ const make = Effect.gen(function* () {
       }),
     deleteScheduledTask: (scope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
-        const existing = yield* loadScopedScheduledTask(
-          parent.thread.projectId,
-          input.scheduledTaskId,
-        );
+        const { parent, limits } = yield* loadCaller(scope);
+        const existing = yield* loadScheduledTask(input.scheduledTaskId, limits);
+        yield* assertLiveCallerForOtherProject(scope, parent, existing.projectId);
         yield* scheduledTasks
           .delete({ id: existing.id })
           .pipe(
@@ -1322,16 +1458,15 @@ const make = Effect.gen(function* () {
       }),
     capabilities: (scope) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
+        const { parent, limits } = yield* loadCaller(scope);
         const providers = yield* loadProviders;
         const orchestrationCapableInstanceIds = yield* loadOrchestrationCapableInstanceIds();
         return {
-          parentThreadId: scope.threadId,
-          inheritedProviderInstanceId: parent.thread.modelSelection.instanceId,
-          inheritedModel: parent.thread.modelSelection.model,
-          runtimeMode: parent.thread.runtimeMode,
-          interactionMode: parent.thread.interactionMode,
+          parentThreadId: parent?.thread.id ?? null,
+          inheritedProviderInstanceId: parent?.thread.modelSelection.instanceId ?? null,
+          inheritedModel: parent?.thread.modelSelection.model ?? null,
+          runtimeMode: limits.runtimeMode,
+          interactionMode: limits.interactionMode,
           providers: providers.map((provider) => {
             const constraints = providerConstraints(
               provider,
@@ -1366,17 +1501,16 @@ const make = Effect.gen(function* () {
           },
         };
       }),
-    delegateTask: (scope, input) =>
+    delegateTask: (callerScope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
+        const { scope, parent } = yield* loadThreadCaller(callerScope, "delegate_task");
         const parentRun = parent.runs
           .filter(ThreadManagementService.isActiveRun)
           .toSorted((left, right) => right.ordinal - left.ordinal)[0];
         if (
           parentRun === undefined ||
           parentRun.rootNodeId === null ||
-          parentRun.providerInstanceId !== scope.providerInstanceId
+          parentRun.providerInstanceId !== scope.thread.providerInstanceId
         ) {
           return yield* failure(
             "parent_not_active",
@@ -1406,7 +1540,7 @@ const make = Effect.gen(function* () {
             createdBy: "agent",
             creationSource: "mcp",
             commandId,
-            parentThreadId: scope.threadId,
+            parentThreadId: scope.thread.threadId,
             parentRunId: parentRun.id,
             parentNodeId: parentRun.rootNodeId,
             task: taskPrompt(input),
@@ -1462,7 +1596,7 @@ const make = Effect.gen(function* () {
               requestKey: key,
               operation: "delegate-task-wake-policy",
             }),
-            parentThreadId: scope.threadId,
+            parentThreadId: scope.thread.threadId,
             taskId,
             completionWake: "always",
           })
@@ -1491,12 +1625,17 @@ const make = Effect.gen(function* () {
           );
         return yield* readTask(scope, taskId, true, true);
       }),
-    taskStatus: (scope, taskId) => readTask(scope, taskId, false, true),
-    cancelTask: (scope, input) =>
+    taskStatus: (callerScope, taskId) =>
       Effect.gen(function* () {
+        const scope = yield* requireThreadScope(callerScope, "task_status");
+        return yield* readTask(scope, taskId, false, true);
+      }),
+    cancelTask: (callerScope, input) =>
+      Effect.gen(function* () {
+        const scope = yield* requireThreadScope(callerScope, "task_cancel");
         const current = yield* readTask(scope, input.taskId);
         const key = yield* requestKey(input.clientRequestId);
-        const parentProjection = yield* loadProjection(scope.threadId);
+        const parentProjection = yield* loadProjection(scope.thread.threadId);
         const parentTask = parentProjection.subagents.find(
           (task) => task.id === input.taskId && task.origin === "app_owned",
         );
@@ -1511,7 +1650,7 @@ const make = Effect.gen(function* () {
                     requestKey: key,
                     operation: "cancel-task-completion-delivery",
                   }),
-                  parentThreadId: scope.threadId,
+                  parentThreadId: scope.thread.threadId,
                   taskId: input.taskId,
                 })
                 .pipe(
@@ -1573,15 +1712,14 @@ const make = Effect.gen(function* () {
           status: "cancel_requested",
         };
       }),
-    createThreads: (scope, input) =>
+    createThreads: (callerScope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
+        const { scope, parent } = yield* loadThreadCaller(callerScope, "create_threads");
         const parentRun = ThreadManagementService.latestActiveRun(parent);
         if (
           parentRun === undefined ||
           parentRun.rootNodeId === null ||
-          parentRun.providerInstanceId !== scope.providerInstanceId
+          parentRun.providerInstanceId !== scope.thread.providerInstanceId
         ) {
           return yield* failure(
             "parent_not_active",
@@ -1660,7 +1798,7 @@ const make = Effect.gen(function* () {
                       index,
                     }),
                     threadId,
-                    senderThreadId: scope.threadId,
+                    senderThreadId: scope.thread.threadId,
                     messageId: stableMessageId({
                       scope,
                       requestKey: key,
@@ -1691,7 +1829,7 @@ const make = Effect.gen(function* () {
                     operation: "record-created-thread",
                     index,
                   }),
-                  parentThreadId: scope.threadId,
+                  parentThreadId: scope.thread.threadId,
                   parentRunId: parentRun.id,
                   parentNodeId,
                   targetThreadId: threadId,
@@ -1722,11 +1860,11 @@ const make = Effect.gen(function* () {
       }),
     listThreads: (scope, input) =>
       Effect.gen(function* () {
-        yield* requireCapability(scope);
-        const parent = yield* loadProjection(scope.threadId);
+        const { parent } = yield* loadCaller(scope);
+        const projectId = yield* resolveProjectTarget(parent, input.projectId);
         const projectThreads = yield* threadManagement
           .listProjectThreads({
-            projectId: parent.thread.projectId,
+            projectId,
             includeSubagents: input.includeSubagents !== false,
           })
           .pipe(
@@ -1755,8 +1893,8 @@ const make = Effect.gen(function* () {
         const page = filtered.slice(cursor, cursor + limit);
         const nextCursor = cursor + page.length < filtered.length ? cursor + page.length : null;
         return {
-          projectId: parent.thread.projectId,
-          currentThreadId: scope.threadId,
+          projectId,
+          currentThreadId: parent?.thread.id ?? null,
           threads: page.map(listItemFromShell),
           nextCursor,
           total: filtered.length,
@@ -1795,8 +1933,13 @@ const make = Effect.gen(function* () {
           { concurrency: 1 },
         );
         const messagesByThreadId = new Map(sourceMessages);
-        const task = directAppOwnedChildTask(parent, target);
-        if (task !== undefined && (input.textOffset ?? 0) === 0) {
+        const task = parent === undefined ? undefined : directAppOwnedChildTask(parent, target);
+        if (
+          parent !== undefined &&
+          scope.thread !== undefined &&
+          task !== undefined &&
+          (input.textOffset ?? 0) === 0
+        ) {
           const transfer = parent.contextTransfers.find(
             (transfer) =>
               transfer.type === "subagent_result" &&
@@ -1822,7 +1965,13 @@ const make = Effect.gen(function* () {
               maxChars,
             })
           ) {
-            yield* readTask(scope, task.id, false, true, "thread-read-acknowledge");
+            yield* readTask(
+              scope as McpThreadInvocationScope,
+              task.id,
+              false,
+              true,
+              "thread-read-acknowledge",
+            );
           }
         }
         return {
@@ -1845,9 +1994,10 @@ const make = Effect.gen(function* () {
       }),
     sendToThread: (scope, input) =>
       Effect.gen(function* () {
-        const { parent, target } = yield* loadScopedThread(scope, input.threadId);
-        yield* resolveRuntimeMode(parent.thread.runtimeMode, target.thread.runtimeMode);
-        yield* resolveInteractionMode(parent.thread.interactionMode, target.thread.interactionMode);
+        const { parent, limits, target } = yield* loadScopedThread(scope, input.threadId);
+        yield* assertLiveCallerForOtherThread(scope, parent, target);
+        yield* resolveRuntimeMode(limits.runtimeMode, target.thread.runtimeMode);
+        yield* resolveInteractionMode(limits.interactionMode, target.thread.interactionMode);
 
         const mode = input.mode ?? "auto";
         const key = yield* requestKey(input.clientRequestId);
@@ -1858,14 +2008,14 @@ const make = Effect.gen(function* () {
         });
         const result = yield* threadManagement
           .sendToThread({
-            projectId: parent.thread.projectId,
+            projectId: target.thread.projectId,
             commandId: stableCommandId({
               scope,
               requestKey: key,
               operation: "thread-send",
             }),
             threadId: input.threadId,
-            senderThreadId: scope.threadId,
+            ...(parent === undefined ? {} : { senderThreadId: parent.thread.id }),
             messageId,
             text: input.message,
             attachments: [],
@@ -1893,10 +2043,10 @@ const make = Effect.gen(function* () {
       }),
     waitForThread: (scope, input) =>
       Effect.gen(function* () {
-        const { parent } = yield* loadScopedThread(scope, input.threadId);
+        const { target } = yield* loadScopedThread(scope, input.threadId);
         const result = yield* threadManagement
           .waitForThread({
-            projectId: parent.thread.projectId,
+            projectId: target.thread.projectId,
             threadId: input.threadId,
             ...(input.runId === undefined ? {} : { runId: input.runId }),
             timeoutMs: Math.min(
@@ -1914,11 +2064,15 @@ const make = Effect.gen(function* () {
       }),
     interruptThread: (scope, input) =>
       Effect.gen(function* () {
-        const { parent } = yield* loadScopedThread(scope, input.threadId);
+        const { parent, limits, target } = yield* loadScopedThread(scope, input.threadId);
+        yield* assertLiveCallerForOtherThread(scope, parent, target);
+        // Stopping another thread's work is a write: it must run within the caller's modes.
+        yield* resolveRuntimeMode(limits.runtimeMode, target.thread.runtimeMode);
+        yield* resolveInteractionMode(limits.interactionMode, target.thread.interactionMode);
         const key = yield* requestKey(input.clientRequestId);
         const result = yield* threadManagement
           .interruptThread({
-            projectId: parent.thread.projectId,
+            projectId: target.thread.projectId,
             commandId: stableCommandId({
               scope,
               requestKey: key,
@@ -1962,4 +2116,5 @@ export const layer: Layer.Layer<
   | ProviderRegistry.ProviderRegistry
   | ProviderAdapterRegistry.ProviderAdapterRegistryV2
   | ScheduledTaskService.ScheduledTaskService
+  | ProjectService.ProjectService
 > = Layer.effect(OrchestratorMcpService, make);
diff --git a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
index ac447919be11..bbaf23424e2e 100644
--- a/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts
@@ -71,6 +71,7 @@ import {
   materializeReplayTranscriptWorkspace,
 } from "../orchestration-v2/testkit/ReplayTranscriptNdjson.ts";
 import { makeProviderRegistryLayer } from "../provider/testUtils/providerRegistryMock.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as McpHttpServer from "./McpHttpServer.ts";
 import * as McpInvocationContext from "./McpInvocationContext.ts";
@@ -632,6 +633,16 @@ describe("orchestrator MCP toolkit", () => {
             Layer.provide(registryLayer),
             Layer.provide(providerRegistryLayer),
             Layer.provide(scheduledTaskStubLayer),
+            Layer.provide(
+              Layer.mock(ProjectService.ProjectService)({
+                getById: (id) =>
+                  Effect.succeed(
+                    id === projectId
+                      ? Option.some({ id, defaultModelSelection: null } as never)
+                      : Option.none(),
+                  ),
+              }),
+            ),
             Layer.provide(NodeServices.layer),
           );
 
@@ -677,9 +688,13 @@ describe("orchestrator MCP toolkit", () => {
 
             const invocation: McpInvocationContext.McpInvocationScope = {
               environmentId: EnvironmentId.make("environment:mcp-orchestrator"),
-              threadId: parentThreadId,
-              providerSessionId: "mcp-provider-session-parent",
-              providerInstanceId: codexInstanceId,
+              requestNamespace: "mcp-provider-session-parent",
+              thread: {
+                threadId: parentThreadId,
+                providerSessionId: "mcp-provider-session-parent",
+                providerInstanceId: codexInstanceId,
+              },
+              client: undefined,
               capabilities: new Set(["orchestration"]),
               issuedAt: 1,
             };
@@ -2327,31 +2342,38 @@ describe("orchestrator MCP toolkit", () => {
               branch: null,
               worktreePath: cwd,
             });
+            // Targets reach the whole environment; the caller's modes still cap writes.
             const foreignOrganizeCall = yield* invoke("t3_thread_organize", {
               threadId: foreignThreadId,
               action: "pin",
             });
-            expect(foreignOrganizeCall.structuredContent).toMatchObject({
-              code: "thread_not_found",
-            });
-            expect((yield* orchestrator.getThreadShell(foreignThreadId))?.pinnedAt).toBeNull();
+            expect(foreignOrganizeCall.isError).toBe(false);
+            expect((yield* orchestrator.getThreadShell(foreignThreadId))?.pinnedAt).not.toBeNull();
 
             const foreignReadCall = yield* invoke("t3_thread_read", {
               threadId: foreignThreadId,
             });
             expect(foreignReadCall.structuredContent).toMatchObject({
-              _tag: "OrchestratorMcpFailure",
-              code: "thread_not_found",
+              thread: { threadId: foreignThreadId, projectId: "project:mcp-foreign" },
             });
             const foreignUpdateCall = yield* invoke("t3_thread_update", {
               threadId: foreignThreadId,
               action: "rename",
-              title: "Should stay foreign",
+              title: "Renamed from another project",
             });
             expect(foreignUpdateCall.structuredContent).toMatchObject({
-              _tag: "OrchestratorMcpFailure",
-              code: "thread_not_found",
+              threadId: foreignThreadId,
+              title: "Renamed from another project",
+            });
+            const foreignListCall = yield* invoke("t3_thread_list", {
+              projectId: "project:mcp-foreign",
             });
+            const foreignListed = yield* decodeThreadListResult(
+              foreignListCall.structuredContent,
+            ).pipe(Effect.orDie);
+            expect(foreignListed.threads.map((thread) => thread.threadId)).toEqual([
+              foreignThreadId,
+            ]);
             const listCall = yield* invoke("t3_thread_list", {
               includeSubagents: false,
               limit: 100,
@@ -3549,6 +3571,7 @@ describe("orchestrator MCP toolkit", () => {
           ),
           Layer.provide(providerRegistryLayer),
           Layer.provide(unusedScheduledTaskStubLayer),
+          Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
           Layer.provide(NodeServices.layer),
         );
 
@@ -3603,9 +3626,13 @@ describe("orchestrator MCP toolkit", () => {
 
           const invocation: McpInvocationContext.McpInvocationScope = {
             environmentId: EnvironmentId.make("environment:mcp-replay"),
-            threadId: parentThreadId,
-            providerSessionId: "mcp-provider-session-replay-parent",
-            providerInstanceId: codexInstanceId,
+            requestNamespace: "mcp-provider-session-replay-parent",
+            thread: {
+              threadId: parentThreadId,
+              providerSessionId: "mcp-provider-session-replay-parent",
+              providerInstanceId: codexInstanceId,
+            },
+            client: undefined,
             capabilities: new Set(["orchestration"]),
             issuedAt: 1,
           };
diff --git a/apps/server/src/mcp/PreviewAutomationBroker.test.ts b/apps/server/src/mcp/PreviewAutomationBroker.test.ts
index adf55cad5e91..fe08b0875ed1 100644
--- a/apps/server/src/mcp/PreviewAutomationBroker.test.ts
+++ b/apps/server/src/mcp/PreviewAutomationBroker.test.ts
@@ -36,9 +36,13 @@ const makeBroker = PreviewAutomationBroker.make.pipe(Effect.provide(NodeServices
 
 const scope = {
   environmentId: EnvironmentId.make("environment-1"),
-  threadId: ThreadId.make("thread-1"),
-  providerSessionId: "provider-session-1",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "provider-session-1",
+  thread: {
+    threadId: ThreadId.make("thread-1"),
+    providerSessionId: "provider-session-1",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(["preview"] as const),
   issuedAt: 1,
 };
@@ -366,9 +370,9 @@ it.effect("preserves bounded request and remote selector diagnostics", () => {
       expect(error).toMatchObject({
         operation: "click",
         environmentId: scope.environmentId,
-        threadId: scope.threadId,
-        providerSessionId: scope.providerSessionId,
-        providerInstanceId: scope.providerInstanceId,
+        threadId: scope.thread.threadId,
+        providerSessionId: scope.thread.providerSessionId,
+        providerInstanceId: scope.thread.providerInstanceId,
         clientId: "client-1",
         requestId: "preview-0",
         tabId: "tab-1",
@@ -468,7 +472,7 @@ it.effect.each([
         .pipe(Effect.flip);
       expect(error).toMatchObject({
         _tag: tag,
-        threadId: scope.threadId,
+        threadId: scope.thread.threadId,
       });
       expect(error.cause).toBe(remoteError);
       expect(error.message).toContain("remains on the desktop");
@@ -500,9 +504,9 @@ it.effect("distinguishes malformed remote failures", () =>
       expect(error).toMatchObject({
         operation: "status",
         environmentId: scope.environmentId,
-        threadId: scope.threadId,
-        providerSessionId: scope.providerSessionId,
-        providerInstanceId: scope.providerInstanceId,
+        threadId: scope.thread.threadId,
+        providerSessionId: scope.thread.providerSessionId,
+        providerInstanceId: scope.thread.providerInstanceId,
         clientId: "client-1",
         requestId: "preview-0",
         timeoutMs: 2_000,
@@ -522,9 +526,9 @@ it.effect("rejects calls when no connected host exists", () =>
     expect(error).toMatchObject({
       operation: "status",
       environmentId: scope.environmentId,
-      threadId: scope.threadId,
-      providerSessionId: scope.providerSessionId,
-      providerInstanceId: scope.providerInstanceId,
+      threadId: scope.thread.threadId,
+      providerSessionId: scope.thread.providerSessionId,
+      providerInstanceId: scope.thread.providerInstanceId,
     });
   }),
 );
@@ -590,8 +594,11 @@ it.effect("routes requests for background threads through an environment-level h
       const result = yield* broker.invoke<string>({
         scope: {
           ...scope,
-          threadId: backgroundThreadId,
-          providerSessionId: "provider-session-background",
+          thread: {
+            ...scope.thread,
+            threadId: backgroundThreadId,
+            providerSessionId: "provider-session-background",
+          },
         },
         operation: "status",
         input: {},
@@ -688,7 +695,7 @@ it.effect("pins a provider session to its initial host despite later focus chang
         environmentId: scope.environmentId,
         connectionId: "connection-stale",
         focused: true,
-        liveTabs: [{ threadId: scope.threadId, tabId: PreviewTabId.make("stale-tab") }],
+        liveTabs: [{ threadId: scope.thread.threadId, tabId: PreviewTabId.make("stale-tab") }],
       });
       expect(yield* broker.invoke<string>({ scope, operation: "status", input: {} })).toBe(
         "second",
@@ -702,7 +709,7 @@ it.effect("pins a provider session to its initial host despite later focus chang
 
       const firstPinnedScope = {
         ...scope,
-        providerSessionId: "provider-session-first-pinned",
+        thread: { ...scope.thread, providerSessionId: "provider-session-first-pinned" },
       };
       expect(
         yield* broker.invoke<string>({ scope: firstPinnedScope, operation: "status", input: {} }),
@@ -720,7 +727,10 @@ it.effect("pins a provider session to its initial host despite later focus chang
       ).toBe("first");
       expect(
         yield* broker.invoke<string>({
-          scope: { ...scope, providerSessionId: "provider-session-second-pinned" },
+          scope: {
+            ...scope,
+            thread: { ...scope.thread, providerSessionId: "provider-session-second-pinned" },
+          },
           operation: "status",
           input: {},
         }),
@@ -756,7 +766,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
         connectionId: connections.get("owner")!,
         focused: false,
         liveTabs: [
-          { threadId: scope.threadId, tabId: PreviewTabId.make("signed-in"), visible: true },
+          { threadId: scope.thread.threadId, tabId: PreviewTabId.make("signed-in"), visible: true },
         ],
       });
       yield* broker.focusHost({
@@ -765,7 +775,11 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
         connectionId: connections.get("other")!,
         focused: true,
         liveTabs: [
-          { threadId: scope.threadId, tabId: PreviewTabId.make("signed-in"), visible: false },
+          {
+            threadId: scope.thread.threadId,
+            tabId: PreviewTabId.make("signed-in"),
+            visible: false,
+          },
           {
             threadId: ThreadId.make("another-thread"),
             tabId: PreviewTabId.make("different-tab"),
@@ -778,7 +792,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
       );
       expect(
         yield* broker.invoke<string>({
-          scope: { ...scope, providerSessionId: "explicit-owner" },
+          scope: { ...scope, thread: { ...scope.thread, providerSessionId: "explicit-owner" } },
           tabId: PreviewTabId.make("signed-in"),
           operation: "snapshot",
           input: {},
@@ -786,7 +800,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
       ).toBe("owner");
       expect(
         yield* broker.invoke<string>({
-          scope: { ...scope, providerSessionId: "other-tab" },
+          scope: { ...scope, thread: { ...scope.thread, providerSessionId: "other-tab" } },
           tabId: PreviewTabId.make("different-tab"),
           operation: "evaluate",
           input: {},
@@ -805,7 +819,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
       );
       expect(
         yield* broker.invoke<string>({
-          scope: { ...scope, providerSessionId: "after-tab-closed" },
+          scope: { ...scope, thread: { ...scope.thread, providerSessionId: "after-tab-closed" } },
           operation: "evaluate",
           input: {},
         }),
@@ -1049,7 +1063,7 @@ it.effect("fails over a pinned provider session only after its host disconnects"
         environmentId: scope.environmentId,
         connectionId: firstConnectionId,
         focused: true,
-        liveTabs: [{ threadId: scope.threadId, tabId: firstTabId }],
+        liveTabs: [{ threadId: scope.thread.threadId, tabId: firstTabId }],
       });
       expect(yield* broker.invoke({ scope, operation: "open", input: {} })).toEqual({
         host: "first",
@@ -1193,9 +1207,9 @@ it.effect("fails requests assigned to the stream that is replaced", () =>
       expect(error).toMatchObject({
         operation: "status",
         environmentId: scope.environmentId,
-        threadId: scope.threadId,
-        providerSessionId: scope.providerSessionId,
-        providerInstanceId: scope.providerInstanceId,
+        threadId: scope.thread.threadId,
+        providerSessionId: scope.thread.providerSessionId,
+        providerInstanceId: scope.thread.providerInstanceId,
         clientId: "client-1",
         requestId: "preview-0",
         timeoutMs: 15_000,
diff --git a/apps/server/src/mcp/PreviewAutomationBroker.ts b/apps/server/src/mcp/PreviewAutomationBroker.ts
index 65e3064f49a5..2e0534fec25a 100644
--- a/apps/server/src/mcp/PreviewAutomationBroker.ts
+++ b/apps/server/src/mcp/PreviewAutomationBroker.ts
@@ -40,7 +40,8 @@ import * as SynchronizedRef from "effect/SynchronizedRef";
 import * as McpInvocationContext from "./McpInvocationContext.ts";
 
 export interface PreviewAutomationInvokeInput {
-  readonly scope: McpInvocationContext.McpInvocationScope;
+  /** Preview tabs belong to a thread, so only thread callers reach the broker. */
+  readonly scope: McpInvocationContext.McpThreadInvocationScope;
   readonly operation: PreviewAutomationOperation;
   readonly input: unknown;
   readonly tabId?: PreviewTabId;
@@ -103,9 +104,9 @@ interface HostAssignment {
 interface PreviewAutomationRequestErrorContext {
   readonly operation: PreviewAutomationOperation;
   readonly environmentId: McpInvocationContext.McpInvocationScope["environmentId"];
-  readonly threadId: McpInvocationContext.McpInvocationScope["threadId"];
+  readonly threadId: McpInvocationContext.McpThreadCaller["threadId"];
   readonly providerSessionId: string;
-  readonly providerInstanceId: McpInvocationContext.McpInvocationScope["providerInstanceId"];
+  readonly providerInstanceId: McpInvocationContext.McpThreadCaller["providerInstanceId"];
   readonly clientId: string;
   readonly connectionId: ClientConnection["connectionId"];
   readonly requestId: string;
@@ -160,8 +161,8 @@ const selectorDiagnosticsFromInput = (
   return {};
 };
 
-const hostAssignmentKey = (scope: McpInvocationContext.McpInvocationScope): string =>
-  `${scope.environmentId}\u0000${scope.providerSessionId}`;
+const hostAssignmentKey = (scope: McpInvocationContext.McpThreadInvocationScope): string =>
+  `${scope.environmentId}\u0000${scope.thread.providerSessionId}`;
 
 const isPreviewTabId = Schema.is(PreviewTabId);
 
@@ -498,7 +499,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
       const ownsTargetTab = (host: ClientConnection, visibleOnly = false) =>
         host.liveTabs.some(
           (tab) =>
-            tab.threadId === input.scope.threadId &&
+            tab.threadId === input.scope.thread.threadId &&
             (!visibleOnly || tab.visible === true) &&
             (input.tabId === undefined || tab.tabId === input.tabId),
         );
@@ -545,9 +546,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
       const context: PreviewAutomationRequestErrorContext = {
         operation: input.operation,
         environmentId: input.scope.environmentId,
-        threadId: input.scope.threadId,
-        providerSessionId: input.scope.providerSessionId,
-        providerInstanceId: input.scope.providerInstanceId,
+        threadId: input.scope.thread.threadId,
+        providerSessionId: input.scope.thread.providerSessionId,
+        providerInstanceId: input.scope.thread.providerInstanceId,
         clientId: connection.clientId,
         connectionId: connection.connectionId,
         requestId,
@@ -566,9 +567,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
       return yield* new PreviewAutomationNoAvailableHostError({
         operation: input.operation,
         environmentId: input.scope.environmentId,
-        threadId: input.scope.threadId,
-        providerSessionId: input.scope.providerSessionId,
-        providerInstanceId: input.scope.providerInstanceId,
+        threadId: input.scope.thread.threadId,
+        providerSessionId: input.scope.thread.providerSessionId,
+        providerInstanceId: input.scope.thread.providerInstanceId,
       });
     }
     const { connection, requestId, requestContext, requestSequence } = route;
@@ -594,7 +595,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
           connectionId: connection.connectionId,
           request: {
             requestId,
-            threadId: input.scope.threadId,
+            threadId: input.scope.thread.threadId,
             tabId: requestContext.tabId,
             tabIdExplicit: input.tabId !== undefined,
             operation: input.operation,
diff --git a/apps/server/src/mcp/ThreadMetadataMcpService.test.ts b/apps/server/src/mcp/ThreadMetadataMcpService.test.ts
index 2f6f8a8d2134..65ec00372167 100644
--- a/apps/server/src/mcp/ThreadMetadataMcpService.test.ts
+++ b/apps/server/src/mcp/ThreadMetadataMcpService.test.ts
@@ -12,9 +12,13 @@ import * as ThreadMetadataMcp from "./ThreadMetadataMcpService.ts";
 const threadId = ThreadId.make("thread:metadata-caller");
 const scope: McpInvocationContext.McpInvocationScope = {
   environmentId: EnvironmentId.make("environment:metadata-test"),
-  threadId,
-  providerSessionId: "provider-session:metadata-test",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "provider-session:metadata-test",
+  thread: {
+    threadId,
+    providerSessionId: "provider-session:metadata-test",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(["orchestration"]),
   issuedAt: 1,
 };
@@ -74,3 +78,91 @@ it.effect("keeps calling-thread storage failures as orchestration errors", () =>
     expect(error.code).toBe("orchestration_error");
   }),
 );
+
+it.effect("refuses to change a thread that runs above the caller's modes", () =>
+  Effect.gen(function* () {
+    const fullAccessThread = ThreadId.make("thread:metadata-full-access");
+    const shells = new Map([
+      [
+        threadId,
+        {
+          id: threadId,
+          projectId: "project",
+          runtimeMode: "auto",
+          interactionMode: "default",
+          activeRunId: "run-live",
+          archivedAt: null,
+          providerInstanceId: "codex",
+          deletedAt: null,
+        },
+      ],
+      [
+        fullAccessThread,
+        {
+          id: fullAccessThread,
+          projectId: "project",
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          deletedAt: null,
+        },
+      ],
+    ]);
+    const error = yield* Effect.gen(function* () {
+      const service = yield* ThreadMetadataMcp.ThreadMetadataMcpService;
+      return yield* service.update(scope, {
+        threadId: fullAccessThread,
+        action: "rename",
+        title: "Renamed from a narrower thread",
+      });
+    }).pipe(
+      Effect.provide(serviceLayer((id) => Effect.succeed((shells.get(id) ?? null) as never))),
+      Effect.flip,
+    );
+
+    expect(error.code).toBe("runtime_mode_escalation_denied");
+  }),
+);
+
+it.effect("refuses another thread's metadata to a thread caller whose run has ended", () =>
+  Effect.gen(function* () {
+    const otherThread = ThreadId.make("thread:metadata-other");
+    const shells = new Map([
+      [
+        threadId,
+        {
+          id: threadId,
+          projectId: "project",
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          activeRunId: null,
+          archivedAt: null,
+          providerInstanceId: "codex",
+          deletedAt: null,
+        },
+      ],
+      [
+        otherThread,
+        {
+          id: otherThread,
+          projectId: "project",
+          runtimeMode: "approval-required",
+          interactionMode: "default",
+          deletedAt: null,
+        },
+      ],
+    ]);
+    const error = yield* Effect.gen(function* () {
+      const service = yield* ThreadMetadataMcp.ThreadMetadataMcpService;
+      return yield* service.update(scope, {
+        threadId: otherThread,
+        action: "rename",
+        title: "Renamed after the run ended",
+      });
+    }).pipe(
+      Effect.provide(serviceLayer((id) => Effect.succeed((shells.get(id) ?? null) as never))),
+      Effect.flip,
+    );
+
+    expect(error.code).toBe("parent_not_active");
+  }),
+);
diff --git a/apps/server/src/mcp/ThreadMetadataMcpService.ts b/apps/server/src/mcp/ThreadMetadataMcpService.ts
index d5f029626b12..6c552511e722 100644
--- a/apps/server/src/mcp/ThreadMetadataMcpService.ts
+++ b/apps/server/src/mcp/ThreadMetadataMcpService.ts
@@ -16,6 +16,7 @@ import * as Layer from "effect/Layer";
 
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import type { McpInvocationScope } from "./McpInvocationContext.ts";
+import { assertTargetWithinLimits } from "./threadAccess.ts";
 
 export class ThreadMetadataMcpService extends Context.Service<
   ThreadMetadataMcpService,
@@ -57,7 +58,7 @@ function commandId(input: {
     [
       "command",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       "thread-update",
       stablePart(input.threadId),
       stablePart(input.action),
@@ -146,36 +147,65 @@ const make = Effect.gen(function* () {
       );
     }
 
-    const parentShell = yield* threadManagement
-      .getThreadShell(scope.threadId)
-      .pipe(
-        Effect.mapError((error) =>
-          failure(
-            "orchestration_error",
-            `Unable to locate calling thread ${scope.threadId}: ${errorMessage(error)}`,
-          ),
-        ),
+    const threadId = input.threadId ?? scope.thread?.threadId;
+    if (threadId === undefined) {
+      return yield* failure(
+        "target_required",
+        "Pass threadId: this MCP client is not running inside a T3 thread.",
       );
-    if (parentShell === null) {
-      return yield* failure("thread_not_found", `Calling thread ${scope.threadId} was not found.`);
     }
-    const parent = yield* threadManagement
-      .getThreadRecords(scope.threadId, [])
+    const shell = yield* threadManagement
+      .getThreadShell(threadId)
       .pipe(
         Effect.mapError((error) =>
           failure(
             "orchestration_error",
-            `Unable to read calling thread ${scope.threadId}: ${errorMessage(error)}`,
+            `Unable to locate thread ${threadId}: ${errorMessage(error)}`,
           ),
         ),
       );
-    const threadId = input.threadId ?? scope.threadId;
-    const target =
-      threadId === scope.threadId
-        ? parent
-        : yield* threadManagement
-            .getProjectThreadRecords({ projectId: parent.thread.projectId, threadId }, [])
-            .pipe(Effect.mapError(threadLookupFailure));
+    if (shell === null || shell.deletedAt !== null) {
+      return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
+    }
+    // Another thread may only be changed if it runs within the caller's own modes.
+    if (threadId !== scope.thread?.threadId) {
+      const limits =
+        scope.thread === undefined
+          ? {
+              runtimeMode: scope.client?.runtimeModeCeiling ?? ("approval-required" as const),
+              interactionMode: "default" as const,
+            }
+          : yield* threadManagement.getThreadShell(scope.thread.threadId).pipe(
+              Effect.mapError((error) =>
+                failure(
+                  "orchestration_error",
+                  `Unable to locate calling thread: ${errorMessage(error)}`,
+                ),
+              ),
+              Effect.flatMap((caller) =>
+                caller === null
+                  ? Effect.fail(failure("thread_not_found", "The calling thread was not found."))
+                  : // Like every other cross-thread write, a thread caller needs its live run.
+                    caller.archivedAt !== null ||
+                      caller.activeRunId === null ||
+                      caller.providerInstanceId !== scope.thread?.providerInstanceId
+                    ? Effect.fail(
+                        failure(
+                          "parent_not_active",
+                          "The calling provider no longer owns an active thread run.",
+                        ),
+                      )
+                    : Effect.succeed({
+                        runtimeMode: caller.runtimeMode,
+                        interactionMode: caller.interactionMode,
+                      }),
+              ),
+            );
+      yield* assertTargetWithinLimits(limits, shell);
+    }
+    const target = yield* threadManagement
+      .getProjectThreadRecords({ projectId: shell.projectId, threadId }, [])
+      .pipe(Effect.mapError(threadLookupFailure));
     const requestKey =
       input.clientRequestId === undefined
         ? yield* crypto.randomUUIDv4.pipe(Effect.orDie)
diff --git a/apps/server/src/mcp/WorktreeMcpService.test.ts b/apps/server/src/mcp/WorktreeMcpService.test.ts
index 06e997076647..6105e787d585 100644
--- a/apps/server/src/mcp/WorktreeMcpService.test.ts
+++ b/apps/server/src/mcp/WorktreeMcpService.test.ts
@@ -42,9 +42,13 @@ const makeScope = (
   capabilities: ReadonlySet<McpInvocationContext.McpCapability>,
 ): McpInvocationContext.McpInvocationScope => ({
   environmentId,
-  threadId,
-  providerSessionId: "provider-session-worktree-test",
-  providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+  requestNamespace: "provider-session-worktree-test",
+  thread: {
+    threadId,
+    providerSessionId: "provider-session-worktree-test",
+    providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+  },
+  client: undefined,
   capabilities,
   issuedAt: 1,
 });
diff --git a/apps/server/src/mcp/WorktreeMcpService.ts b/apps/server/src/mcp/WorktreeMcpService.ts
index fb0bd85d70d3..06eb43f41e6c 100644
--- a/apps/server/src/mcp/WorktreeMcpService.ts
+++ b/apps/server/src/mcp/WorktreeMcpService.ts
@@ -23,7 +23,7 @@ import * as ProjectService from "../project/ProjectService.ts";
 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
-import type { McpInvocationScope } from "./McpInvocationContext.ts";
+import type { McpInvocationScope, McpThreadInvocationScope } from "./McpInvocationContext.ts";
 
 export class WorktreeMcpService extends Context.Service<
   WorktreeMcpService,
@@ -70,6 +70,17 @@ const make = Effect.gen(function* () {
   // one untracked on disk.
   const handoffThreadsInFlight = new Set<string>();
 
+  // Worktree tools act on the calling thread's own checkout binding.
+  const requireThreadScope = (scope: McpInvocationScope) =>
+    scope.thread === undefined
+      ? Effect.fail(
+          failure(
+            "thread_credential_required",
+            "Worktree handoff and status act as the calling T3 thread, so they need an agent running inside T3 Code.",
+          ),
+        )
+      : Effect.succeed(scope as McpThreadInvocationScope);
+
   const requireCapability = (scope: McpInvocationScope) =>
     scope.capabilities.has("worktree")
       ? Effect.void
@@ -77,23 +88,23 @@ const make = Effect.gen(function* () {
           failure("capability_denied", "This MCP credential does not grant worktree capabilities."),
         );
 
-  const loadThread = (scope: McpInvocationScope) =>
-    threadManagement.getThreadRecords(scope.threadId, []).pipe(
+  const loadThread = (scope: McpThreadInvocationScope) =>
+    threadManagement.getThreadRecords(scope.thread.threadId, []).pipe(
       Effect.mapError((error) =>
         error._tag === "OrchestratorProjectionError"
-          ? failure("thread_not_found", `Thread '${scope.threadId}' was not found.`)
+          ? failure("thread_not_found", `Thread '${scope.thread.threadId}' was not found.`)
           : failure(
               "operation_failed",
-              `Unable to read thread ${scope.threadId}: ${errorMessage(error)}`,
+              `Unable to read thread ${scope.thread.threadId}: ${errorMessage(error)}`,
             ),
       ),
       Effect.filterOrFail(
         (projection) => projection.thread.deletedAt === null,
-        () => failure("thread_not_found", `Thread '${scope.threadId}' was not found.`),
+        () => failure("thread_not_found", `Thread '${scope.thread.threadId}' was not found.`),
       ),
     );
 
-  const loadProject = (scope: McpInvocationScope, projectId: ProjectId) =>
+  const loadProject = (scope: McpThreadInvocationScope, projectId: ProjectId) =>
     projects.getById(projectId).pipe(
       asOperationFailed(`Unable to read project ${projectId}`),
       Effect.flatMap(
@@ -102,7 +113,7 @@ const make = Effect.gen(function* () {
             Effect.fail(
               failure(
                 "project_not_found",
-                `Project '${projectId}' was not found for thread '${scope.threadId}'.`,
+                `Project '${projectId}' was not found for thread '${scope.thread.threadId}'.`,
               ),
             ),
           onSome: Effect.succeed,
@@ -115,11 +126,13 @@ const make = Effect.gen(function* () {
     asOperationFailed("Unable to read server settings"),
   );
 
-  const handoffIds = (scope: McpInvocationScope) =>
+  const handoffIds = (scope: McpThreadInvocationScope) =>
     crypto.randomUUIDv4.pipe(
       Effect.map((uuid) => {
         const part = (kind: string, operation: string) =>
-          [kind, "mcp", encodeURIComponent(scope.providerSessionId), operation, uuid].join(":");
+          [kind, "mcp", encodeURIComponent(scope.thread.providerSessionId), operation, uuid].join(
+            ":",
+          );
         return {
           commandId: CommandId.make(part("command", "worktree-handoff")),
           continuationCommandId: CommandId.make(part("command", "worktree-continuation")),
@@ -130,13 +143,13 @@ const make = Effect.gen(function* () {
     );
 
   const performHandoff = Effect.fn("WorktreeMcpService.performHandoff")(function* (
-    scope: McpInvocationScope,
+    scope: McpThreadInvocationScope,
     input: WorktreeMcpHandoffInput,
   ) {
     const alreadyInWorktree = (worktreePath: string) =>
       failure(
         "already_in_worktree",
-        `Thread '${scope.threadId}' is already attached to worktree '${worktreePath}'.`,
+        `Thread '${scope.thread.threadId}' is already attached to worktree '${worktreePath}'.`,
       );
 
     const projection = yield* loadThread(scope);
@@ -148,7 +161,7 @@ const make = Effect.gen(function* () {
     if (projection.thread.archivedAt !== null) {
       return yield* failure(
         "invalid_request",
-        `Thread '${scope.threadId}' is archived and cannot be handed off to a worktree.`,
+        `Thread '${scope.thread.threadId}' is archived and cannot be handed off to a worktree.`,
       );
     }
 
@@ -263,7 +276,7 @@ const make = Effect.gen(function* () {
           Effect.catchCause((cause: Cause.Cause<unknown>) => {
             const detail = errorMessage(Cause.squash(cause));
             return Effect.logWarning(logMessage, {
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               worktreePath,
               detail,
             }).pipe(Effect.as({ status: "failed", detail } as const));
@@ -301,14 +314,14 @@ const make = Effect.gen(function* () {
           if (recheck.thread.archivedAt !== null) {
             return yield* failure(
               "invalid_request",
-              `Thread '${scope.threadId}' was archived while the worktree was being created; the handoff was rolled back.`,
+              `Thread '${scope.thread.threadId}' was archived while the worktree was being created; the handoff was rolled back.`,
             );
           }
           yield* threadManagement
             .dispatch({
               type: "thread.metadata.update",
               commandId: ids.commandId,
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               branch: worktree.worktree.refName,
               worktreePath,
               expectedWorktreePath: null,
@@ -357,7 +370,7 @@ const make = Effect.gen(function* () {
                   .sendToThread({
                     projectId: projection.thread.projectId,
                     commandId: ids.continuationCommandId,
-                    threadId: scope.threadId,
+                    threadId: scope.thread.threadId,
                     messageId: ids.continuationMessageId,
                     text: input.continuationPrompt,
                     attachments: [],
@@ -386,7 +399,7 @@ const make = Effect.gen(function* () {
         if (input.runSetupScript ?? true) {
           setupScript = yield* setupScriptRunner
             .runForThread({
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               projectId: projection.thread.projectId,
               projectCwd,
               worktreePath,
@@ -430,8 +443,9 @@ const make = Effect.gen(function* () {
   });
 
   const handoff: WorktreeMcpService["Service"]["handoff"] = Effect.fn("WorktreeMcpService.handoff")(
-    function* (scope, input) {
-      yield* requireCapability(scope);
+    function* (callerScope, input) {
+      yield* requireCapability(callerScope);
+      const scope = yield* requireThreadScope(callerScope);
       // uninterruptibleMask: the guard acquisition and the registration of the
       // releasing finalizer happen with no interruptible gap in between. An
       // interrupt landing between a bare add() and the start of an ensured
@@ -439,17 +453,19 @@ const make = Effect.gen(function* () {
       // handoff for this thread until restart.
       return yield* Effect.uninterruptibleMask((restore) =>
         Effect.suspend(() => {
-          if (handoffThreadsInFlight.has(scope.threadId)) {
+          if (handoffThreadsInFlight.has(scope.thread.threadId)) {
             return Effect.fail(
               failure(
                 "handoff_in_progress",
-                `A worktree handoff is already in progress for thread '${scope.threadId}'.`,
+                `A worktree handoff is already in progress for thread '${scope.thread.threadId}'.`,
               ),
             );
           }
-          handoffThreadsInFlight.add(scope.threadId);
+          handoffThreadsInFlight.add(scope.thread.threadId);
           return restore(performHandoff(scope, input)).pipe(
-            Effect.ensuring(Effect.sync(() => handoffThreadsInFlight.delete(scope.threadId))),
+            Effect.ensuring(
+              Effect.sync(() => handoffThreadsInFlight.delete(scope.thread.threadId)),
+            ),
           );
         }),
       );
@@ -457,8 +473,9 @@ const make = Effect.gen(function* () {
   );
 
   const status: WorktreeMcpService["Service"]["status"] = Effect.fn("WorktreeMcpService.status")(
-    function* (scope) {
-      yield* requireCapability(scope);
+    function* (callerScope) {
+      yield* requireCapability(callerScope);
+      const scope = yield* requireThreadScope(callerScope);
       const projection = yield* loadThread(scope);
       const project = yield* loadProject(scope, projection.thread.projectId);
 
diff --git a/apps/server/src/mcp/threadAccess.ts b/apps/server/src/mcp/threadAccess.ts
index bd3a4de60010..a965b0823629 100644
--- a/apps/server/src/mcp/threadAccess.ts
+++ b/apps/server/src/mcp/threadAccess.ts
@@ -2,6 +2,9 @@ import type { ProjectionRecordField } from "../orchestration-v2/ProjectionStore.
 import {
   CommandId,
   OrchestratorMcpFailure,
+  type ProjectId,
+  type ProviderInteractionMode,
+  type RuntimeMode,
   type ThreadId,
   type OrchestrationV2ThreadShell,
 } from "@t3tools/contracts";
@@ -18,6 +21,24 @@ export const unavailable = () =>
     message: "The operation could not be completed.",
   });
 
+/**
+ * The most a caller may hand to the threads it targets. A thread caller is
+ * capped by its own thread's modes; an OAuth client by the ceiling chosen
+ * when it was approved.
+ */
+export interface CallerLimits {
+  readonly runtimeMode: RuntimeMode;
+  readonly interactionMode: ProviderInteractionMode;
+}
+
+export interface Caller {
+  readonly scope: McpInvocationContext.McpInvocationScope;
+  readonly threads: ThreadManagement.ThreadManagementService["Service"];
+  /** The calling thread, absent for a client signed in from outside T3. */
+  readonly caller: OrchestrationV2ThreadShell | undefined;
+  readonly limits: CallerLimits;
+}
+
 export const readCaller = Effect.fn("mcp.readCaller")(function* () {
   const scope = yield* McpInvocationContext.McpInvocationContext;
   if (!scope.capabilities.has("orchestration")) {
@@ -27,26 +48,54 @@ export const readCaller = Effect.fn("mcp.readCaller")(function* () {
     });
   }
   const threads = yield* ThreadManagement.ThreadManagementService;
-  const caller = yield* threads.getThreadShell(scope.threadId).pipe(Effect.mapError(unavailable));
+  if (scope.thread === undefined) {
+    return {
+      scope,
+      threads,
+      caller: undefined,
+      limits: {
+        runtimeMode: scope.client?.runtimeModeCeiling ?? "approval-required",
+        interactionMode: "default",
+      },
+    } satisfies Caller;
+  }
+  const caller = yield* threads
+    .getThreadShell(scope.thread.threadId)
+    .pipe(Effect.mapError(unavailable));
   if (caller === null || caller.deletedAt !== null) {
     return yield* new OrchestratorMcpFailure({
       code: "thread_not_found",
       message: "The calling thread was not found.",
     });
   }
-  return { scope, threads, caller };
+  return {
+    scope,
+    threads,
+    caller,
+    limits: { runtimeMode: caller.runtimeMode, interactionMode: caller.interactionMode },
+  } satisfies Caller;
 });
 
-function assertLiveCaller({
-  caller,
-  scope,
-}: {
-  caller: OrchestrationV2ThreadShell;
-  scope: McpInvocationContext.McpInvocationScope;
-}) {
+/**
+ * A caller may change another thread only if that thread runs within the
+ * caller's own modes. Its own thread is always within them.
+ */
+export const assertTargetWithinLimits = (
+  limits: CallerLimits,
+  target: { readonly runtimeMode: RuntimeMode; readonly interactionMode: ProviderInteractionMode },
+) =>
+  OrchestrationMcp.resolveRuntimeMode(limits.runtimeMode, target.runtimeMode).pipe(
+    Effect.andThen(
+      OrchestrationMcp.resolveInteractionMode(limits.interactionMode, target.interactionMode),
+    ),
+    Effect.asVoid,
+  );
+
+function assertLiveCaller({ caller, scope }: Caller) {
+  if (caller === undefined) return Effect.void;
   return caller.archivedAt !== null ||
     caller.activeRunId === null ||
-    caller.providerInstanceId !== scope.providerInstanceId
+    caller.providerInstanceId !== scope.thread?.providerInstanceId
     ? Effect.fail(
         new OrchestratorMcpFailure({
           code: "parent_not_active",
@@ -55,34 +104,91 @@ function assertLiveCaller({
       )
     : Effect.void;
 }
+
+/**
+ * Mutations from a thread need that thread's live run, so an agent whose turn
+ * ended cannot keep acting. An OAuth client has no run; its session and
+ * ceiling are its authority.
+ */
 export const readMutationCaller = Effect.fn("mcp.readMutationCaller")(function* () {
   const context = yield* readCaller();
   yield* assertLiveCaller(context);
   return context;
 });
 
-/** Resolve the credential's project before looking up a caller-supplied thread. */
+/**
+ * Actions that change the environment itself (projects, preferences, launching
+ * outside a project) need full access: a thread caller in full-access/default
+ * mode, or a client approved with a full-access ceiling.
+ */
+export const readFullAccessCaller = Effect.fn("mcp.readFullAccessCaller")(function* (
+  message: string,
+) {
+  const context = yield* readMutationCaller();
+  if (
+    (context.caller !== undefined && context.caller.archivedAt !== null) ||
+    context.limits.runtimeMode !== "full-access" ||
+    context.limits.interactionMode !== "default"
+  ) {
+    return yield* new OrchestratorMcpFailure({ code: "capability_denied", message });
+  }
+  return context;
+});
+
+/** A target project: the one passed, else the calling thread's. */
+export const resolveProjectId = (context: Caller, projectId: ProjectId | undefined) =>
+  projectId !== undefined
+    ? Effect.succeed(projectId)
+    : context.caller !== undefined
+      ? Effect.succeed(context.caller.projectId)
+      : Effect.fail(
+          new OrchestratorMcpFailure({
+            code: "target_required",
+            message: "Pass projectId: this MCP client is not running inside a T3 thread.",
+          }),
+        );
+
+/** A target thread: the one passed, else the calling thread. */
+const resolveThreadId = (context: Caller, threadId: ThreadId | undefined) =>
+  threadId !== undefined
+    ? Effect.succeed(threadId)
+    : context.caller !== undefined
+      ? Effect.succeed(context.caller.id)
+      : Effect.fail(
+          new OrchestratorMcpFailure({
+            code: "target_required",
+            message: "Pass threadId: this MCP client is not running inside a T3 thread.",
+          }),
+        );
+
+/** Load a target thread anywhere in the environment; an omitted id means the calling thread. */
 export const readThread = Effect.fn("mcp.readThread")(function* <
   K extends ProjectionRecordField = never,
 >(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {
-  const { scope, threads, caller } = yield* readCaller();
-  const projection = yield* threads
-    .getProjectThreadRecords(
-      { projectId: caller.projectId, threadId: threadId ?? caller.id },
-      fields,
-      { turnItemTypes: ["user_input_request"] },
-    )
+  const context = yield* readCaller();
+  const targetId = yield* resolveThreadId(context, threadId);
+  const shell = yield* context.threads.getThreadShell(targetId).pipe(Effect.mapError(unavailable));
+  if (shell === null || shell.deletedAt !== null) {
+    return yield* new OrchestratorMcpFailure({
+      code: "thread_not_found",
+      message: "The thread was not found.",
+    });
+  }
+  const projection = yield* context.threads
+    .getProjectThreadRecords({ projectId: shell.projectId, threadId: targetId }, fields, {
+      turnItemTypes: ["user_input_request"],
+    })
     .pipe(
       Effect.mapError((error) =>
         error._tag === "ThreadManagementThreadNotFoundError"
           ? new OrchestratorMcpFailure({
               code: "thread_not_found",
-              message: "The thread was not found in the calling project.",
+              message: "The thread was not found.",
             })
           : unavailable(),
       ),
     );
-  return { scope, threads, caller, projection };
+  return { ...context, projection };
 });
 
 export const readWritableThread = Effect.fn("mcp.readWritableThread")(function* <
@@ -90,14 +196,7 @@ export const readWritableThread = Effect.fn("mcp.readWritableThread")(function*
 >(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {
   const context = yield* readThread(threadId, fields);
   yield* assertLiveCaller(context);
-  yield* OrchestrationMcp.resolveRuntimeMode(
-    context.caller.runtimeMode,
-    context.projection.thread.runtimeMode,
-  );
-  yield* OrchestrationMcp.resolveInteractionMode(
-    context.caller.interactionMode,
-    context.projection.thread.interactionMode,
-  );
+  yield* assertTargetWithinLimits(context.limits, context.projection.thread);
   return context;
 });
 
diff --git a/apps/server/src/mcp/toolkits/attachment/handlers.ts b/apps/server/src/mcp/toolkits/attachment/handlers.ts
index 42866c8db872..e02110b63dea 100644
--- a/apps/server/src/mcp/toolkits/attachment/handlers.ts
+++ b/apps/server/src/mcp/toolkits/attachment/handlers.ts
@@ -47,7 +47,7 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({
     }),
   t3_thread_send_attachments: (input) =>
     Effect.gen(function* () {
-      const { caller, projection, scope } = yield* readWritableThread(input.threadId, ["messages"]);
+      const { caller, projection } = yield* readWritableThread(input.threadId, ["messages"]);
       if (projection.thread.archivedAt !== null)
         return yield* new OrchestratorMcpFailure({
           code: "invalid_request",
@@ -60,11 +60,11 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({
       const commandId = yield* newCommandId();
       const messageId = MessageId.make(commandId);
       const result = yield* ThreadMessageIntake.sendToThread({
-        projectId: caller.projectId,
+        projectId: projection.thread.projectId,
         threadId: projection.thread.id,
         commandId,
         messageId,
-        senderThreadId: scope.threadId,
+        ...(caller === undefined ? {} : { senderThreadId: caller.id }),
         text: input.message ?? "",
         attachments,
         mode: "auto",
diff --git a/apps/server/src/mcp/toolkits/attachment/tools.ts b/apps/server/src/mcp/toolkits/attachment/tools.ts
index 55820f035c17..f93bb06729e8 100644
--- a/apps/server/src/mcp/toolkits/attachment/tools.ts
+++ b/apps/server/src/mcp/toolkits/attachment/tools.ts
@@ -47,7 +47,7 @@ const AttachmentDiscardTool = Tool.make("t3_attachment_discard", {
 const AttachmentSendTool = Tool.make("t3_thread_send_attachments", {
   ...shared,
   description:
-    "Send uploaded attachments to this thread or another thread in the calling project. Each call is a new message, without a retry key. Acceptance does not mean the provider can consume the attachment or has finished the turn. The target cannot have broader permission modes than the caller; failures retain claimed files when dispatch outcome is uncertain.",
+    "Send uploaded attachments to this thread or any other thread in this environment. Each call is a new message, without a retry key. Acceptance does not mean the provider can consume the attachment or has finished the turn. The target cannot have broader permission modes than the caller; failures retain claimed files when dispatch outcome is uncertain.",
   parameters: Schema.Struct({
     threadId: Schema.optional(ThreadId),
     message: Schema.optional(Schema.String.check(Schema.isMaxLength(120000))),
diff --git a/apps/server/src/mcp/toolkits/core.test.ts b/apps/server/src/mcp/toolkits/core.test.ts
index 339e5eb9b2a8..99834a5ce5b4 100644
--- a/apps/server/src/mcp/toolkits/core.test.ts
+++ b/apps/server/src/mcp/toolkits/core.test.ts
@@ -14,7 +14,11 @@ import { McpAttachmentInput } from "./attachment/input.ts";
 import { McpSchema, McpServer, Tool } from "effect/unstable/ai";
 
 import { OrchestratorProjectionError } from "../../orchestration-v2/Orchestrator.ts";
+import * as ProviderAdapterRegistry from "../../orchestration-v2/ProviderAdapterRegistry.ts";
 import * as ThreadManagement from "../../orchestration-v2/ThreadManagementService.ts";
+import * as ProjectService from "../../project/ProjectService.ts";
+import * as ProviderRegistry from "../../provider/Services/ProviderRegistry.ts";
+import * as ScheduledTaskService from "../../scheduledTasks/ScheduledTaskService.ts";
 import * as McpHttpServer from "../McpHttpServer.ts";
 import * as McpInvocationContext from "../McpInvocationContext.ts";
 import { OrchestratorToolkit } from "./orchestrator/tools.ts";
@@ -78,9 +82,13 @@ it("publishes unique tool names with reference-free object-root inputs", () => {
 const threadId = ThreadId.make("mcp-core-thread");
 const scope: McpInvocationContext.McpInvocationScope = {
   environmentId: EnvironmentId.make("mcp-core-environment"),
-  threadId,
-  providerSessionId: "mcp-core-session",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "mcp-core-session",
+  thread: {
+    threadId,
+    providerSessionId: "mcp-core-session",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   issuedAt: 0,
   capabilities: new Set(["orchestration"]),
 };
@@ -207,3 +215,236 @@ it.effect("resolves reused attachment references from stored metadata", () =>
     expect(failure.code).toBe("invalid_request");
   }),
 );
+
+const clientScope = (
+  runtimeModeCeiling: "approval-required" | "auto-accept-edits" | "auto" | "full-access",
+): McpInvocationContext.McpInvocationScope => ({
+  environmentId: EnvironmentId.make("mcp-core-environment"),
+  requestNamespace: "client:session-1",
+  thread: undefined,
+  client: { sessionId: "session-1", label: "Claude Code", runtimeModeCeiling },
+  issuedAt: 0,
+  capabilities: new Set(["orchestration", "worktree", "pull-requests"]),
+});
+
+it.effect("a client caller targets any thread within its ceiling and cannot act as a thread", () =>
+  Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const call = (
+      name: string,
+      args: Record<string, unknown>,
+      invocation: McpInvocationContext.McpInvocationScope,
+    ) =>
+      server
+        .callTool({ name, arguments: args })
+        .pipe(
+          Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
+          Effect.provideService(McpSchema.McpServerClient, client),
+        );
+
+    const untargeted = yield* call("t3_thread_organize", { action: "pin" }, clientScope("auto"));
+    expect(untargeted.structuredContent).toMatchObject({ code: "target_required" });
+
+    const pinned = yield* call(
+      "t3_thread_organize",
+      { action: "pin", threadId: "other-project-thread" },
+      clientScope("auto"),
+    );
+    expect(pinned.isError).toBe(false);
+    expect(pinned.structuredContent).toMatchObject({ sequence: 7 });
+
+    const aboveCeiling = yield* call(
+      "t3_thread_organize",
+      { action: "pin", threadId: "other-project-thread" },
+      clientScope("approval-required"),
+    );
+    expect(aboveCeiling.structuredContent).toMatchObject({
+      code: "runtime_mode_escalation_denied",
+    });
+
+    const forked = yield* call(
+      "t3_thread_fork",
+      { sourcePoint: { type: "latest_stable" } },
+      clientScope("auto"),
+    );
+    expect(forked.structuredContent).toMatchObject({ code: "target_required" });
+  }).pipe(
+    Effect.provide(
+      McpHttpServer.ThreadToolkitRegistrationLive.pipe(
+        Layer.provideMerge(McpServer.McpServer.layer),
+        Layer.provide(NodeCrypto.layer),
+        Layer.provide(
+          Layer.mock(ThreadManagement.ThreadManagementService)({
+            getThreadShell: () =>
+              Effect.succeed({
+                id: ThreadId.make("other-project-thread"),
+                projectId: "other-project",
+                deletedAt: null,
+              } as never),
+            getProjectThreadRecords: () =>
+              Effect.succeed({
+                thread: {
+                  id: ThreadId.make("other-project-thread"),
+                  projectId: "other-project",
+                  runtimeMode: "auto",
+                  interactionMode: "default",
+                  deletedAt: null,
+                },
+              } as never),
+            dispatch: () => Effect.succeed({ sequence: 7 } as never),
+          }),
+        ),
+      ),
+    ),
+  ),
+);
+
+it.effect("refuses act-as-caller tools to a client caller", () =>
+  Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const result = yield* server
+      .callTool({
+        name: "delegate_task",
+        arguments: { task: "Review", mode: "async" },
+      })
+      .pipe(
+        Effect.provideService(
+          McpInvocationContext.McpInvocationContext,
+          clientScope("full-access"),
+        ),
+        Effect.provideService(McpSchema.McpServerClient, client),
+      );
+    expect(result.structuredContent).toMatchObject({ code: "thread_credential_required" });
+  }).pipe(
+    Effect.provide(
+      McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
+        Layer.provideMerge(McpServer.McpServer.layer),
+        Layer.provide(NodeCrypto.layer),
+        Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
+        Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
+        Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
+        Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
+        Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
+      ),
+    ),
+  ),
+);
+
+it.effect("a caller cannot rewrite a scheduled task that runs above its own modes", () =>
+  Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const call = (name: string, args: Record<string, unknown>) =>
+      server
+        .callTool({ name, arguments: args })
+        .pipe(
+          Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
+          Effect.provideService(McpSchema.McpServerClient, client),
+        );
+    const update = yield* call("update_scheduled_task", {
+      scheduledTaskId: "task-full-access",
+      prompt: "Run something else",
+    });
+    expect(update.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
+    const remove = yield* call("delete_scheduled_task", { scheduledTaskId: "task-full-access" });
+    expect(remove.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
+    const allowed = yield* call("update_scheduled_task", {
+      scheduledTaskId: "task-auto",
+      enabled: false,
+    });
+    expect(allowed.isError).toBe(false);
+  }).pipe(
+    Effect.provide(
+      McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
+        Layer.provideMerge(McpServer.McpServer.layer),
+        Layer.provide(NodeCrypto.layer),
+        Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
+        Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
+        Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
+        Layer.provide(
+          Layer.mock(ScheduledTaskService.ScheduledTaskService)({
+            list: () =>
+              Effect.succeed({
+                tasks: [
+                  scheduledTask("task-full-access", "full-access"),
+                  scheduledTask("task-auto", "auto"),
+                ],
+              }),
+            upsert: (input) =>
+              Effect.succeed({
+                task: { ...(scheduledTask(input.id ?? "task-auto", "auto") as object), ...input },
+              } as never),
+          }),
+        ),
+        Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
+      ),
+    ),
+  ),
+);
+
+function scheduledTask(id: string, runtimeMode: "auto" | "full-access"): never {
+  return {
+    id,
+    title: id,
+    prompt: "Check the build",
+    enabled: true,
+    projectId: "project-a",
+    threadId: null,
+    schedule: { type: "interval", everyMs: 3_600_000 },
+    workspaceStrategy: { type: "worktree", baseRef: "main", startFromOrigin: true },
+    modelSelection: { instanceId: "codex", model: "gpt-5" },
+    runtimeMode,
+    interactionMode: "default",
+    createdBy: "user",
+    creationSource: "web",
+    nextRunAt: null,
+    lastRunStatus: "never",
+    lastRunAt: null,
+    lastRunThreadId: null,
+    lastRunError: null,
+    runCount: 0,
+    createdAt: "2026-10-01T00:00:00.000Z",
+    updatedAt: "2026-10-01T00:00:00.000Z",
+  } as never;
+}
+
+it.effect("a caller cannot interrupt a thread that runs above its own modes", () =>
+  Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const result = yield* server
+      .callTool({ name: "t3_thread_interrupt", arguments: { threadId: "full-access-thread" } })
+      .pipe(
+        Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
+        Effect.provideService(McpSchema.McpServerClient, client),
+      );
+    expect(result.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
+  }).pipe(
+    Effect.provide(
+      McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
+        Layer.provideMerge(McpServer.McpServer.layer),
+        Layer.provide(NodeCrypto.layer),
+        Layer.provide(
+          Layer.mock(ThreadManagement.ThreadManagementService)({
+            getThreadShell: () =>
+              Effect.succeed({ projectId: "project-a", deletedAt: null } as never),
+            getProjectThreadRecords: () =>
+              Effect.succeed({
+                thread: {
+                  id: ThreadId.make("full-access-thread"),
+                  projectId: "project-a",
+                  runtimeMode: "full-access",
+                  interactionMode: "default",
+                  deletedAt: null,
+                },
+                runs: [],
+              } as never),
+            interruptThread: () => Effect.die("interrupt must not dispatch above the ceiling"),
+          }),
+        ),
+        Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
+        Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
+        Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
+        Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
+      ),
+    ),
+  ),
+);
diff --git a/apps/server/src/mcp/toolkits/device/handlers.ts b/apps/server/src/mcp/toolkits/device/handlers.ts
index 2a8172a63411..6c6850673a39 100644
--- a/apps/server/src/mcp/toolkits/device/handlers.ts
+++ b/apps/server/src/mcp/toolkits/device/handlers.ts
@@ -66,7 +66,7 @@ export function agentDeviceQuickStart(
   ].join("\n");
 }
 
-const requireDeviceAccess = McpInvocationContext.requireMcpCapability("device").pipe(
+const requireDeviceAccess = McpInvocationContext.requireThreadMcpCapability("device").pipe(
   Effect.mapError(
     () =>
       new DeviceToolUnavailableError({
@@ -132,7 +132,7 @@ const handlers = {
       }
       const hostId = input?.hostId;
       const open = state.sessions
-        .filter((session) => session.threadId === scope.threadId)
+        .filter((session) => session.threadId === scope.thread.threadId)
         .map((session) => ({ hostId: session.hostId, deviceId: session.deviceId }));
       return {
         hostStatuses: Object.fromEntries(
@@ -159,12 +159,12 @@ const handlers = {
       const target = yield* pickDevice(state.devices, input);
       // Resolve consent and agent connectivity before booting or registering a session.
       const agentArgs = yield* devices.agentTarget({
-        threadId: scope.threadId,
+        threadId: scope.thread.threadId,
         hostId: target.hostId,
         deviceId: target.id,
       });
       const session = yield* devices.open({
-        threadId: scope.threadId,
+        threadId: scope.thread.threadId,
         hostId: target.hostId,
         deviceId: target.id,
         platform: target.platform,
@@ -207,7 +207,7 @@ const handlers = {
     Effect.gen(function* () {
       const scope = yield* requireDeviceAccess;
       const devices = yield* DeviceService.DeviceService;
-      const sessions = yield* devices.sessionsForThread(scope.threadId);
+      const sessions = yield* devices.sessionsForThread(scope.thread.threadId);
       const target =
         input.deviceId !== undefined
           ? { hostId: input.hostId ?? LOCAL_DEVICE_HOST_ID, deviceId: input.deviceId }
@@ -234,7 +234,7 @@ const handlers = {
       const scope = yield* requireDeviceAccess;
       const devices = yield* DeviceService.DeviceService;
       yield* devices.close({
-        threadId: scope.threadId,
+        threadId: scope.thread.threadId,
         ...(input.hostId === undefined ? {} : { hostId: input.hostId }),
         ...(input.deviceId === undefined ? {} : { deviceId: input.deviceId }),
         ...(input.shutdown === undefined ? {} : { shutdown: input.shutdown }),
diff --git a/apps/server/src/mcp/toolkits/environment/handlers.ts b/apps/server/src/mcp/toolkits/environment/handlers.ts
index 2c01841611dc..f95ac72bbdb9 100644
--- a/apps/server/src/mcp/toolkits/environment/handlers.ts
+++ b/apps/server/src/mcp/toolkits/environment/handlers.ts
@@ -4,7 +4,7 @@ import * as Environment from "../../../environment/ServerEnvironment.ts";
 import * as ThreadCommandExecutor from "../../../orchestration-v2/ThreadCommandExecutor.ts";
 import * as Settings from "../../../serverSettings.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
-import { readCaller, readMutationCaller, unavailable } from "../../threadAccess.ts";
+import { readCaller, readFullAccessCaller, unavailable } from "../../threadAccess.ts";
 import { EnvironmentToolkit } from "./tools.ts";
 
 export function preferences(settings: ServerSettings) {
@@ -30,7 +30,11 @@ export function preferences(settings: ServerSettings) {
 }
 const access = (writable = false) =>
   Effect.gen(function* () {
-    const context = yield* writable ? readMutationCaller() : readCaller();
+    const context = yield* writable
+      ? readFullAccessCaller(
+          "Preference updates require a live full-access/default thread or a full-access client.",
+        )
+      : readCaller();
     const environment = yield* Environment.ServerEnvironment;
     const descriptor = yield* environment.getDescriptor;
     if (descriptor.environmentId !== context.scope.environmentId)
@@ -57,23 +61,15 @@ export const EnvironmentHandlersLive = EnvironmentToolkit.toLayer({
     Effect.gen(function* () {
       const scope = yield* McpInvocationContext.McpInvocationContext;
       const executor = yield* ThreadCommandExecutor.ThreadCommandExecutor;
-      return yield* executor.withLock(
-        scope.threadId,
-        Effect.gen(function* () {
-          const { caller, settings } = yield* access(true);
-          if (
-            caller.archivedAt !== null ||
-            caller.runtimeMode !== "full-access" ||
-            caller.interactionMode !== "default"
-          )
-            return yield* new OrchestratorMcpFailure({
-              code: "capability_denied",
-              message: "Preference updates require a live full-access/default thread.",
-            });
-          return preferences(
-            yield* settings.updateSettings(patch).pipe(Effect.mapError(unavailable)),
-          );
-        }),
-      );
+      const update = Effect.gen(function* () {
+        const { settings } = yield* access(true);
+        return preferences(
+          yield* settings.updateSettings(patch).pipe(Effect.mapError(unavailable)),
+        );
+      });
+      // A thread caller serializes with its own turn; a client has no thread to lock.
+      return yield* scope.thread === undefined
+        ? update
+        : executor.withLock(scope.thread.threadId, update);
     }),
 });
diff --git a/apps/server/src/mcp/toolkits/orchestrator/handlers.ts b/apps/server/src/mcp/toolkits/orchestrator/handlers.ts
index 7dbbd21cb624..d45197b22c9c 100644
--- a/apps/server/src/mcp/toolkits/orchestrator/handlers.ts
+++ b/apps/server/src/mcp/toolkits/orchestrator/handlers.ts
@@ -36,11 +36,11 @@ const handlers = {
       const service = yield* OrchestratorMcpService.OrchestratorMcpService;
       return yield* service.scheduleTask(scope, input);
     }),
-  list_scheduled_tasks: () =>
+  list_scheduled_tasks: (input) =>
     Effect.gen(function* () {
       const scope = yield* McpInvocationContext.McpInvocationContext;
       const service = yield* OrchestratorMcpService.OrchestratorMcpService;
-      return yield* service.listScheduledTasks(scope);
+      return yield* service.listScheduledTasks(scope, input);
     }),
   update_scheduled_task: (input) =>
     Effect.gen(function* () {
diff --git a/apps/server/src/mcp/toolkits/orchestrator/tools.ts b/apps/server/src/mcp/toolkits/orchestrator/tools.ts
index a86f1ce214c5..540de4e1ca06 100644
--- a/apps/server/src/mcp/toolkits/orchestrator/tools.ts
+++ b/apps/server/src/mcp/toolkits/orchestrator/tools.ts
@@ -7,6 +7,7 @@ import {
   OrchestratorMcpDeleteScheduledTaskInput,
   OrchestratorMcpDeleteScheduledTaskResult,
   OrchestratorMcpFailure,
+  OrchestratorMcpListScheduledTasksInput,
   OrchestratorMcpListScheduledTasksResult,
   OrchestratorMcpScheduleTaskInput,
   OrchestratorMcpScheduleTaskResult,
@@ -44,7 +45,7 @@ const threadMetadataDependencies = [
 
 const OrchestratorCapabilitiesTool = Tool.make("orchestrator_capabilities", {
   description:
-    "List the V2 provider instances and their current models from the same live catalog as the composer, including configured custom models, inherited runtime settings, and app-owned orchestration features available to this T3 thread. For a separate top-level thread in a new or existing worktree, use t3_thread_launch with workspaceStrategy.",
+    "List the V2 provider instances and their current models from the same live catalog as the composer, including configured custom models, inherited runtime settings, and app-owned orchestration features available to this caller. For a separate top-level thread in a new or existing worktree, use t3_thread_launch with workspaceStrategy.",
   success: OrchestratorMcpCapabilitiesResult,
   failure: OrchestratorMcpFailure,
   failureMode: "return",
@@ -57,7 +58,7 @@ const OrchestratorCapabilitiesTool = Tool.make("orchestrator_capabilities", {
 
 export const DelegateTaskTool = Tool.make("delegate_task", {
   description:
-    "Delegate one task to a T3-owned child agent/subagent of THIS thread and run it with only the supplied task prompt, without copying parent conversation history. Choose providers and models from orchestrator_capabilities, which uses the same live catalog as the composer. Prefer native subagent tools for same-provider work only when they support the chosen model. Use this for any model missing from the native tool, including same-provider work, for cross-provider work, or for explicitly T3-owned child tasks. For every T3 delegated review round, call delegate_task again with the original brief, prior findings, responses, and unresolved objections in the task prompt. Track each round by its own taskId and use a distinct clientRequestId per round, stable across retries of that round. The childThreadId is backing storage, not the target for starting another delegated review round through t3_thread_send. Provider, model, model options (see orchestrator_capabilities), runtime mode, and interaction mode inherit unless target overrides them. Prefer mode='async' for long work; mode='wait' blocks until completion or timeout. timeoutMs on mode=wait is only the parent's wait budget and does not cancel the child. waitTimedOut on that wait call means the timeout fired; keep that taskId and read status on later task_status. An async child's completion wakes this thread through a notification, steered into active turns where supported or queued otherwise, so end the turn instead of polling or spawning watchers; use task_status only when the result is needed mid-turn.",
+    "Needs an agent running inside a T3 thread. Delegate one task to a T3-owned child agent/subagent of THIS thread and run it with only the supplied task prompt, without copying parent conversation history. Choose providers and models from orchestrator_capabilities, which uses the same live catalog as the composer. Prefer native subagent tools for same-provider work only when they support the chosen model. Use this for any model missing from the native tool, including same-provider work, for cross-provider work, or for explicitly T3-owned child tasks. For every T3 delegated review round, call delegate_task again with the original brief, prior findings, responses, and unresolved objections in the task prompt. Track each round by its own taskId and use a distinct clientRequestId per round, stable across retries of that round. The childThreadId is backing storage, not the target for starting another delegated review round through t3_thread_send. Provider, model, model options (see orchestrator_capabilities), runtime mode, and interaction mode inherit unless target overrides them. Prefer mode='async' for long work; mode='wait' blocks until completion or timeout. timeoutMs on mode=wait is only the parent's wait budget and does not cancel the child. waitTimedOut on that wait call means the timeout fired; keep that taskId and read status on later task_status. An async child's completion wakes this thread through a notification, steered into active turns where supported or queued otherwise, so end the turn instead of polling or spawning watchers; use task_status only when the result is needed mid-turn.",
   parameters: OrchestratorMcpDelegateTaskInput,
   success: OrchestratorMcpDelegateTaskResult,
   failure: OrchestratorMcpFailure,
@@ -70,7 +71,7 @@ export const DelegateTaskTool = Tool.make("delegate_task", {
 
 const TaskStatusTool = Tool.make("task_status", {
   description:
-    "Read a T3-owned delegated task created by this parent thread. childRunId identifies the original delegated run. workState distinguishes working, waiting_for_children, and result_available; a completed turn with live nested work is not a completed task. summary is the final task result, including provider errors on failure, and remains stable after publication. hasPendingChildRuns reports later queued or executing turns in the backing child thread, even after the task is terminal; it does not reopen the task or extend task_cancel to those turns. latestTerminal* provides later non-monitor turn results. Reading a terminal result acknowledges its automatic parent delivery.",
+    "Needs an agent running inside a T3 thread. Read a T3-owned delegated task created by this parent thread. childRunId identifies the original delegated run. workState distinguishes working, waiting_for_children, and result_available; a completed turn with live nested work is not a completed task. summary is the final task result, including provider errors on failure, and remains stable after publication. hasPendingChildRuns reports later queued or executing turns in the backing child thread, even after the task is terminal; it does not reopen the task or extend task_cancel to those turns. latestTerminal* provides later non-monitor turn results. Reading a terminal result acknowledges its automatic parent delivery.",
   parameters: OrchestratorMcpTaskStatusInput,
   success: OrchestratorMcpDelegateTaskResult,
   failure: OrchestratorMcpFailure,
@@ -84,7 +85,7 @@ const TaskStatusTool = Tool.make("task_status", {
 
 const TaskCancelTool = Tool.make("task_cancel", {
   description:
-    "Request interruption of an active T3-owned delegated task and dispose its automatic parent delivery. For a terminal task, return its existing status and dispose delivery without interrupting later child-thread runs, even when task_status reports hasPendingChildRuns=true. Published task results remain available. Use t3_thread_interrupt for a later active run.",
+    "Needs an agent running inside a T3 thread. Request interruption of an active T3-owned delegated task and dispose its automatic parent delivery. For a terminal task, return its existing status and dispose delivery without interrupting later child-thread runs, even when task_status reports hasPendingChildRuns=true. Published task results remain available. Use t3_thread_interrupt for a later active run.",
   parameters: OrchestratorMcpTaskCancelInput,
   success: OrchestratorMcpTaskCancelResult,
   failure: OrchestratorMcpFailure,
@@ -96,7 +97,7 @@ const TaskCancelTool = Tool.make("task_cancel", {
 
 export const ScheduleTaskTool = Tool.make("schedule_task", {
   description:
-    "Create persistent recurring work in the app scheduler, which runs even when no turn is active. Pass schedule as a STRUCTURED OBJECT, never JSON text: {type:'interval', everyMs:3600000} means hourly; {type:'fixed_time', timeOfDay:'09:00', weekdays:[1,2,3,4,5]} means weekday mornings. By default (bindToCurrentThread=true) each run posts into THIS thread; use false only when the user wants a fresh top-level thread per run. Provider, model, and runtime settings inherit from this thread. Report the returned schedule and nextRunAt after success.",
+    "Create persistent recurring work in the app scheduler, which runs even when no turn is active. Pass schedule as a STRUCTURED OBJECT, never JSON text: {type:'interval', everyMs:3600000} means hourly; {type:'fixed_time', timeOfDay:'09:00', weekdays:[1,2,3,4,5]} means weekday mornings. Omit projectId for this thread's project. In this thread's project, runs post into THIS thread by default (bindToCurrentThread=true); use false only when the user wants a fresh top-level thread per run. Elsewhere each run launches a fresh thread. Provider, model, and runtime settings inherit from this thread, or from the project default when there is no calling thread. Report the returned schedule and nextRunAt after success.",
   parameters: OrchestratorMcpScheduleTaskInput,
   success: OrchestratorMcpScheduleTaskResult,
   failure: OrchestratorMcpFailure,
@@ -108,8 +109,9 @@ export const ScheduleTaskTool = Tool.make("schedule_task", {
   .annotate(Tool.OpenWorld, true);
 
 const ListScheduledTasksTool = Tool.make("list_scheduled_tasks", {
+  parameters: OrchestratorMcpListScheduledTasksInput,
   description:
-    "List the recurring scheduled tasks in the calling thread's project, including their id, schedule, prompt, enabled state, bound thread, next run time, and last run status. Use the returned scheduledTaskId with update_scheduled_task or delete_scheduled_task.",
+    "List recurring scheduled tasks in a project (omit projectId for the calling thread's project, or every project when there is no calling thread), including their id, schedule, prompt, enabled state, bound thread, next run time, and last run status. Use the returned scheduledTaskId with update_scheduled_task or delete_scheduled_task.",
   success: OrchestratorMcpListScheduledTasksResult,
   failure: OrchestratorMcpFailure,
   failureMode: "return",
@@ -146,7 +148,7 @@ const DeleteScheduledTaskTool = Tool.make("delete_scheduled_task", {
 
 export const CreateThreadsTool = Tool.make("create_threads", {
   description:
-    "Create one or more ORDINARY TOP-LEVEL T3 conversations. This is not delegation and does not create child agents/subagents. For delegated work, choose models from orchestrator_capabilities. Prefer native subagents only when they support the chosen model; otherwise call delegate_task, including for same-provider work. Use create_threads for a batch of separate top-level threads sharing this checkout. Prefer t3_thread_launch for a single thread. Both require the user to request separate/new/top-level threads or conversations. Each entry may override provider, model, options, runtime mode, and interaction mode; omitted settings inherit. Project, branch, and worktree always inherit and cannot be overridden here. For independent implementation or a PR stack in its own worktree, use t3_thread_launch with workspaceStrategy instead of asking the agent to create a worktree in its prompt.",
+    "Needs an agent running inside a T3 thread. Create one or more ORDINARY TOP-LEVEL T3 conversations. This is not delegation and does not create child agents/subagents. For delegated work, choose models from orchestrator_capabilities. Prefer native subagents only when they support the chosen model; otherwise call delegate_task, including for same-provider work. Use create_threads for a batch of separate top-level threads sharing this checkout. Prefer t3_thread_launch for a single thread. Both require the user to request separate/new/top-level threads or conversations. Each entry may override provider, model, options, runtime mode, and interaction mode; omitted settings inherit. Project, branch, and worktree always inherit and cannot be overridden here. For independent implementation or a PR stack in its own worktree, use t3_thread_launch with workspaceStrategy instead of asking the agent to create a worktree in its prompt.",
   parameters: OrchestratorMcpCreateThreadsInput,
   success: OrchestratorMcpCreateThreadsResult,
   failure: OrchestratorMcpFailure,
@@ -159,7 +161,7 @@ export const CreateThreadsTool = Tool.make("create_threads", {
 
 const ThreadListTool = Tool.make("t3_thread_list", {
   description:
-    "List T3 threads in the calling thread's project, newest first. Filter by durable run status, title, or settled state (settled=true lists threads the user or auto-settlement moved out of the active list) and paginate with the returned cursor. Threads from other projects are never exposed.",
+    "List T3 threads in a project, newest first. Omit projectId for the calling thread's project. Filter by durable run status, title, or settled state (settled=true lists threads the user or auto-settlement moved out of the active list) and paginate with the returned cursor.",
   parameters: OrchestratorMcpThreadListInput,
   success: OrchestratorMcpThreadListResult,
   failure: OrchestratorMcpFailure,
@@ -173,7 +175,7 @@ const ThreadListTool = Tool.make("t3_thread_list", {
 
 const ThreadReadTool = Tool.make("t3_thread_read", {
   description:
-    "Read durable state and a paginated timeline from a T3 thread in the calling project, or from a thread the user attached to this conversation as context. The default messages view returns user messages, assistant messages, and proposed plans; activity returns all summarized timeline items. Reading an untruncated terminal assistant result from this parent thread's direct app-owned child acknowledges that child's automatic completion delivery. Continue with afterPosition=nextPosition. Recover long item text with itemId and textOffset=nextTextOffset until nextTextOffset is null; offsets count UTF-16 code units.",
+    "Read durable state and a paginated timeline from any T3 thread in this environment. The default messages view returns user messages, assistant messages, and proposed plans; activity returns all summarized timeline items. Reading an untruncated terminal assistant result from this parent thread's direct app-owned child acknowledges that child's automatic completion delivery. Continue with afterPosition=nextPosition. Recover long item text with itemId and textOffset=nextTextOffset until nextTextOffset is null; offsets count UTF-16 code units.",
   parameters: OrchestratorMcpThreadReadInput,
   success: OrchestratorMcpThreadReadResult,
   failure: OrchestratorMcpFailure,
@@ -187,7 +189,7 @@ const ThreadReadTool = Tool.make("t3_thread_read", {
 
 export const ThreadUpdateTool = Tool.make("t3_thread_update", {
   description:
-    "Update metadata for a thread in the calling project. Omit threadId to update this thread. Use action='rename' with title, action='regenerate_title' with no extra field, action='link_pull_request' with pullRequest, or action='unlink_pull_request'. Workspace and branch changes are intentionally not supported. clientRequestId makes retries idempotent.",
+    "Update metadata for a thread. Omit threadId to update this thread. Use action='rename' with title, action='regenerate_title' with no extra field, action='link_pull_request' with pullRequest, or action='unlink_pull_request'. Workspace and branch changes are intentionally not supported. clientRequestId makes retries idempotent.",
   parameters: ThreadMetadataMcpUpdateInput,
   success: ThreadMetadataMcpUpdateResult,
   failure: OrchestratorMcpFailure,
@@ -200,7 +202,7 @@ export const ThreadUpdateTool = Tool.make("t3_thread_update", {
 
 const ThreadSendTool = Tool.make("t3_thread_send", {
   description:
-    "Send a message to a T3 thread in the calling project. Do not use a delegated task's childThreadId to start another review round here; use delegate_task with the full review context and a new clientRequestId for that round. Thread messages do not create a new delegated task or reopen a completed task. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. clientRequestId makes retries idempotent.",
+    "Send a message to any T3 thread in this environment. The target cannot have broader permission modes than the caller. Do not use a delegated task's childThreadId to start another review round here; use delegate_task with the full review context and a new clientRequestId for that round. Thread messages do not create a new delegated task or reopen a completed task. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. clientRequestId makes retries idempotent.",
   parameters: OrchestratorMcpThreadSendInput,
   success: OrchestratorMcpThreadSendResult,
   failure: OrchestratorMcpFailure,
@@ -227,7 +229,7 @@ const ThreadWaitTool = Tool.make("t3_thread_wait", {
 
 const ThreadInterruptTool = Tool.make("t3_thread_interrupt", {
   description:
-    "Request interruption of a running turn in a T3 thread in the calling project. Without runId, the newest interruptible run is selected. Terminal runs and threads without an active turn return without another side effect. clientRequestId makes retries idempotent.",
+    "Request interruption of a running turn in any T3 thread in this environment. Without runId, the newest interruptible run is selected. Terminal runs and threads without an active turn return without another side effect. clientRequestId makes retries idempotent.",
   parameters: OrchestratorMcpThreadInterruptInput,
   success: OrchestratorMcpThreadInterruptResult,
   failure: OrchestratorMcpFailure,
diff --git a/apps/server/src/mcp/toolkits/preview/handlers.ts b/apps/server/src/mcp/toolkits/preview/handlers.ts
index b70e68862683..9bbbc13a7109 100644
--- a/apps/server/src/mcp/toolkits/preview/handlers.ts
+++ b/apps/server/src/mcp/toolkits/preview/handlers.ts
@@ -60,7 +60,7 @@ const invoke = Effect.fn("PreviewToolkit.invoke")(function* <A>(
   import("@t3tools/contracts").PreviewAutomationError,
   McpInvocationContext.McpInvocationContext | PreviewAutomationBroker.PreviewAutomationBroker
 > {
-  const scope = yield* McpInvocationContext.requireMcpCapability("preview");
+  const scope = yield* McpInvocationContext.requireThreadMcpCapability("preview");
   const broker = yield* PreviewAutomationBroker.PreviewAutomationBroker;
   let targetTabId = tabId;
   const result = yield* broker.invoke<A>({
@@ -218,7 +218,7 @@ const handlers = {
     invokeTargeted<PreviewAutomationRecordingStatus>("recordingStart", input ?? {}),
   preview_recording_stop: (input) =>
     Effect.gen(function* () {
-      const scope = yield* McpInvocationContext.requireMcpCapability("preview");
+      const scope = yield* McpInvocationContext.requireThreadMcpCapability("preview");
       const { tabId, ...operationInput } = input;
       const response = yield* invoke<unknown>(
         "recordingStop",
@@ -226,7 +226,7 @@ const handlers = {
         PREVIEW_RECORDING_STOP_TIMEOUT_MS,
         tabId,
       );
-      const artifact = yield* claimPreviewRecording(scope.threadId, response.result);
+      const artifact = yield* claimPreviewRecording(scope.thread.threadId, response.result);
       return { ...artifact, ...(response.toolIcon ? { toolIcon: response.toolIcon } : {}) };
     }),
 } satisfies Parameters<typeof PreviewToolkit.toLayer>[0];
diff --git a/apps/server/src/mcp/toolkits/previewControls/handlers.test.ts b/apps/server/src/mcp/toolkits/previewControls/handlers.test.ts
index 8764dc55fd21..700eeb808154 100644
--- a/apps/server/src/mcp/toolkits/previewControls/handlers.test.ts
+++ b/apps/server/src/mcp/toolkits/previewControls/handlers.test.ts
@@ -35,9 +35,13 @@ it.effect.each([
       const effective = resolveProjectSettings(settings, projectId).settings;
       const scope: McpInvocationContext.McpInvocationScope = {
         environmentId: EnvironmentId.make("preview-controls-environment"),
-        threadId,
-        providerSessionId: "preview-controls-provider-session",
-        providerInstanceId: ProviderInstanceId.make("codex"),
+        requestNamespace: "preview-controls-provider-session",
+        thread: {
+          threadId,
+          providerSessionId: "preview-controls-provider-session",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(effective.enableAgentBrowserAccess ? ["preview"] : []),
         issuedAt: 0,
       };
diff --git a/apps/server/src/mcp/toolkits/previewControls/handlers.ts b/apps/server/src/mcp/toolkits/previewControls/handlers.ts
index 213a7437353a..16f2449aad35 100644
--- a/apps/server/src/mcp/toolkits/previewControls/handlers.ts
+++ b/apps/server/src/mcp/toolkits/previewControls/handlers.ts
@@ -1,19 +1,19 @@
 import * as Effect from "effect/Effect";
 import * as Preview from "../../../preview/Manager.ts";
-import { requireMcpCapability } from "../../McpInvocationContext.ts";
+import { requireThreadMcpCapability } from "../../McpInvocationContext.ts";
 import { unavailable } from "../../threadAccess.ts";
 import { PreviewControlsToolkit } from "./tools.ts";
 
 const access = Effect.gen(function* () {
   // The preview capability already reflects the calling project's access setting.
-  const scope = yield* requireMcpCapability("preview");
+  const scope = yield* requireThreadMcpCapability("preview");
   return { scope, manager: yield* Preview.PreviewManager };
 });
 export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({
   t3_preview_list: (input) =>
     Effect.gen(function* () {
       const { scope, manager } = yield* access;
-      const result = yield* manager.list({ threadId: scope.threadId });
+      const result = yield* manager.list({ threadId: scope.thread.threadId });
       const start = input.cursor ?? 0;
       const end = start + (input.limit ?? 20);
       return {
@@ -26,7 +26,7 @@ export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({
     Effect.gen(function* () {
       const { scope, manager } = yield* access;
       yield* manager
-        .close({ threadId: scope.threadId, tabId: input.tabId })
+        .close({ threadId: scope.thread.threadId, tabId: input.tabId })
         .pipe(Effect.mapError(unavailable));
       return {};
     }),
diff --git a/apps/server/src/mcp/toolkits/project/handlers.test.ts b/apps/server/src/mcp/toolkits/project/handlers.test.ts
index 68dc746d2499..fa3569906739 100644
--- a/apps/server/src/mcp/toolkits/project/handlers.test.ts
+++ b/apps/server/src/mcp/toolkits/project/handlers.test.ts
@@ -5,6 +5,7 @@ import {
   ProviderInstanceId,
   ThreadId,
   type OrchestrationV2ThreadShell,
+  type Project as ProjectRecord,
 } from "@t3tools/contracts";
 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
 import * as NodeServices from "@effect/platform-node/NodeServices";
@@ -44,9 +45,13 @@ it.effect("attributes a launched thread's first message to the calling thread",
       NodeCrypto.layer,
       Layer.succeed(McpInvocationContext.McpInvocationContext, {
         environmentId: EnvironmentId.make("environment"),
-        threadId: sourceThreadId,
-        providerSessionId: "session",
-        providerInstanceId,
+        requestNamespace: "session",
+        thread: {
+          threadId: sourceThreadId,
+          providerSessionId: "session",
+          providerInstanceId,
+        },
+        client: undefined,
         issuedAt: 0,
         capabilities: new Set(["orchestration" as const]),
       }),
@@ -106,9 +111,13 @@ it.effect("launches a scratch thread into the Scratch project", () =>
       NodeCrypto.layer,
       Layer.succeed(McpInvocationContext.McpInvocationContext, {
         environmentId: EnvironmentId.make("environment"),
-        threadId: sourceThreadId,
-        providerSessionId: "session",
-        providerInstanceId,
+        requestNamespace: "session",
+        thread: {
+          threadId: sourceThreadId,
+          providerSessionId: "session",
+          providerInstanceId,
+        },
+        client: undefined,
         issuedAt: 0,
         capabilities: new Set(["orchestration" as const]),
       }),
@@ -194,9 +203,13 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()
       NodeCrypto.layer,
       Layer.succeed(McpInvocationContext.McpInvocationContext, {
         environmentId: EnvironmentId.make("environment"),
-        threadId: sourceThreadId,
-        providerSessionId: "session",
-        providerInstanceId,
+        requestNamespace: "session",
+        thread: {
+          threadId: sourceThreadId,
+          providerSessionId: "session",
+          providerInstanceId,
+        },
+        client: undefined,
         issuedAt: 0,
         capabilities: new Set(["orchestration" as const]),
       }),
@@ -263,3 +276,87 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()
     expect(named).toEqual(["Pinball Stats"]);
   }),
 );
+
+const clientLaunchHarness = (input: {
+  readonly runtimeModeCeiling: "approval-required" | "auto-accept-edits" | "auto" | "full-access";
+  readonly launched: Array<ThreadLaunch.ThreadLaunchInput>;
+}) => {
+  const projectId = ProjectId.make("project:client-target");
+  const modelSelection = { instanceId: ProviderInstanceId.make("claude"), model: "claude-opus" };
+  const dependencies = Layer.mergeAll(
+    NodeCrypto.layer,
+    Layer.succeed(McpInvocationContext.McpInvocationContext, {
+      environmentId: EnvironmentId.make("environment"),
+      requestNamespace: "client:session-1",
+      thread: undefined,
+      client: {
+        sessionId: "session-1",
+        label: "Claude Code",
+        runtimeModeCeiling: input.runtimeModeCeiling,
+      },
+      issuedAt: 0,
+      capabilities: new Set(["orchestration" as const]),
+    }),
+    Layer.mock(ThreadManagement.ThreadManagementService)({}),
+    Layer.mock(ThreadLaunch.ThreadLaunchService)({
+      launch: (launch) => {
+        input.launched.push(launch);
+        return Effect.succeed({
+          threadId: launch.threadId,
+          projection: {
+            thread: {
+              id: launch.threadId,
+              projectId: launch.projectId,
+              modelSelection: launch.modelSelection,
+            },
+            runs: [],
+          },
+          resumed: false,
+        } as unknown as ThreadLaunch.ThreadLaunchResult);
+      },
+    }),
+    Layer.mock(Project.ProjectService)({
+      getById: (id) =>
+        Effect.succeed(
+          id === projectId
+            ? Option.some({ id, defaultModelSelection: modelSelection } as unknown as ProjectRecord)
+            : Option.none(),
+        ),
+    }),
+    Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ namedProjectsRoot: "/projects" }),
+    NodeServices.layer,
+    ServerConfig.layerTest(process.cwd(), { prefix: "t3-client-launch-" }).pipe(
+      Layer.provide(NodeServices.layer),
+    ),
+  );
+  return { projectId, modelSelection, dependencies };
+};
+
+it.effect("a client launches at its ceiling with the project's default model", () =>
+  Effect.gen(function* () {
+    const launched: Array<ThreadLaunch.ThreadLaunchInput> = [];
+    const { projectId, modelSelection, dependencies } = clientLaunchHarness({
+      runtimeModeCeiling: "auto-accept-edits",
+      launched,
+    });
+    const toolkit = yield* ProjectToolkit.pipe(
+      Effect.provide(ProjectHandlersLive.pipe(Layer.provide(dependencies))),
+    );
+    const handle = (params: Parameters<typeof toolkit.handle<"t3_thread_launch">>[1]) =>
+      toolkit
+        .handle("t3_thread_launch", params)
+        .pipe(Stream.unwrap, Stream.runCollect, Effect.provide(dependencies));
+
+    const result = yield* handle({ title: "Fix", projectId, message: "Fix the bug" });
+    expect(result.at(-1)?.result).toMatchObject({ projectId, modelSelection });
+    expect(launched[0]?.runtimeMode).toBe("auto-accept-edits");
+    expect(launched[0]?.initialMessage?.senderThreadId).toBeUndefined();
+
+    const escalated = yield* handle({ title: "Fix", projectId, runtimeMode: "full-access" });
+    expect(escalated.at(-1)?.result).toMatchObject({ code: "runtime_mode_escalation_denied" });
+
+    const untargeted = yield* handle({ title: "Fix" });
+    expect(untargeted.at(-1)?.result).toMatchObject({ code: "target_required" });
+    expect(launched).toHaveLength(1);
+  }),
+);
diff --git a/apps/server/src/mcp/toolkits/project/handlers.ts b/apps/server/src/mcp/toolkits/project/handlers.ts
index 346e884f3032..e97119f3132d 100644
--- a/apps/server/src/mcp/toolkits/project/handlers.ts
+++ b/apps/server/src/mcp/toolkits/project/handlers.ts
@@ -6,7 +6,15 @@ import * as Claims from "../../../orchestration-v2/AttachmentClaims.ts";
 import * as Project from "../../../project/ProjectService.ts";
 import * as ManagedProjectFolders from "../../../project/ManagedProjectFolders.ts";
 import * as Repositories from "../../../sourceControl/SourceControlRepositoryService.ts";
-import { newCommandId, readCaller, readMutationCaller, unavailable } from "../../threadAccess.ts";
+import { resolveRuntimeMode } from "../../OrchestratorMcpService.ts";
+import {
+  newCommandId,
+  readCaller,
+  readFullAccessCaller,
+  readMutationCaller,
+  resolveProjectId,
+  unavailable,
+} from "../../threadAccess.ts";
 import { ProjectToolkit } from "./tools.ts";
 
 function projectFailure(error: Project.ProjectServiceError) {
@@ -25,27 +33,30 @@ const access = Effect.gen(function* () {
   return yield* Project.ProjectService;
 });
 const mutation = Effect.gen(function* () {
-  const { caller } = yield* readMutationCaller();
-  if (
-    caller.archivedAt !== null ||
-    caller.runtimeMode !== "full-access" ||
-    caller.interactionMode !== "default"
-  )
-    return yield* new OrchestratorMcpFailure({
-      code: "capability_denied",
-      message: "Project changes require a live full-access/default calling thread.",
-    });
+  yield* readFullAccessCaller(
+    "Project changes require a live full-access/default calling thread or a full-access client.",
+  );
   return yield* Project.ProjectService;
 });
 export const ProjectHandlersLive = ProjectToolkit.toLayer({
   t3_thread_launch: (input) =>
     Effect.gen(function* () {
-      const { caller, scope } = yield* readMutationCaller();
-      if (caller.runtimeMode !== "full-access" || caller.interactionMode !== "default")
+      const context = yield* readMutationCaller();
+      const { caller, limits } = context;
+      // A thread caller launches only as itself (full-access/default), as before. A client
+      // launches anything up to its ceiling.
+      if (
+        caller !== undefined &&
+        (caller.runtimeMode !== "full-access" || caller.interactionMode !== "default")
+      )
         return yield* new OrchestratorMcpFailure({
           code: "capability_denied",
           message: "Project launches require a full-access/default calling thread.",
         });
+      const runtimeMode = yield* resolveRuntimeMode(
+        limits.runtimeMode,
+        input.runtimeMode ?? caller?.runtimeMode,
+      );
       const commandId = yield* newCommandId();
       const threadId = ThreadId.make(commandId);
       const messageId = MessageId.make(commandId);
@@ -76,22 +87,38 @@ export const ProjectHandlersLive = ProjectToolkit.toLayer({
                   }),
               ),
             )).projectId
-          : (input.projectId ?? caller.projectId);
+          : yield* resolveProjectId(context, input.projectId);
+      const modelSelection =
+        input.modelSelection ??
+        caller?.modelSelection ??
+        (yield* Project.ProjectService.pipe(
+          Effect.flatMap((projects) => projects.getById(projectId)),
+          Effect.mapError(unavailable),
+          Effect.map((project) =>
+            Option.getOrUndefined(Option.flatMapNullishOr(project, (p) => p.defaultModelSelection)),
+          ),
+        ));
+      if (modelSelection === undefined)
+        return yield* new OrchestratorMcpFailure({
+          code: "invalid_request",
+          message:
+            "Pass modelSelection: the project has no default model. orchestrator_capabilities lists providers and models.",
+        });
       const result = yield* ThreadMessageIntake.launchThread({
         commandId,
         threadId,
         projectId,
         title: input.title,
-        modelSelection: input.modelSelection ?? caller.modelSelection,
-        runtimeMode: input.runtimeMode ?? caller.runtimeMode,
-        interactionMode: input.interactionMode ?? caller.interactionMode,
+        modelSelection,
+        runtimeMode,
+        interactionMode: input.interactionMode ?? caller?.interactionMode ?? "default",
         workspaceStrategy: input.workspaceStrategy ?? { type: "root" },
         ...(input.message === undefined && attachments.length === 0
           ? {}
           : {
               initialMessage: {
                 messageId,
-                senderThreadId: scope.threadId,
+                ...(caller === undefined ? {} : { senderThreadId: caller.id }),
                 text: input.message ?? "",
                 attachments,
               },
diff --git a/apps/server/src/mcp/toolkits/project/tools.ts b/apps/server/src/mcp/toolkits/project/tools.ts
index 693a76854bb6..e42b0012dd69 100644
--- a/apps/server/src/mcp/toolkits/project/tools.ts
+++ b/apps/server/src/mcp/toolkits/project/tools.ts
@@ -102,7 +102,7 @@ const ProjectCloneTool = Tool.make("t3_project_clone", {
 const ThreadLaunchTool = Tool.make("t3_thread_launch", {
   ...shared,
   description:
-    'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. Requires a full-access/default caller.',
+    'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings from the calling thread; a caller outside a T3 thread must pass projectId and gets the project\'s default model. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. Requires a full-access/default calling thread; a caller outside a T3 thread launches up to its approved permission mode.',
   parameters: Schema.Struct({
     projectId: Schema.optional(ProjectId),
     scratch: Schema.optional(
diff --git a/apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts b/apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts
index e329ade90d9e..93485a41175c 100644
--- a/apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts
+++ b/apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts
@@ -38,9 +38,13 @@ const invocation = (
   capabilities: ReadonlyArray<McpInvocationContext.McpCapability>,
 ): McpInvocationContext.McpInvocationScope => ({
   environmentId: EnvironmentId.make("environment-1"),
-  threadId: THREAD_ID,
-  providerSessionId: "provider-session-1",
-  providerInstanceId: ProviderInstanceId.make("codex"),
+  requestNamespace: "provider-session-1",
+  thread: {
+    threadId: THREAD_ID,
+    providerSessionId: "provider-session-1",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(capabilities),
   issuedAt: 1,
 });
diff --git a/apps/server/src/mcp/toolkits/pullRequests/handlers.ts b/apps/server/src/mcp/toolkits/pullRequests/handlers.ts
index 97af65e1a7bc..e43208256ea9 100644
--- a/apps/server/src/mcp/toolkits/pullRequests/handlers.ts
+++ b/apps/server/src/mcp/toolkits/pullRequests/handlers.ts
@@ -26,6 +26,7 @@ import * as Option from "effect/Option";
 import * as Orchestrator from "../../../orchestration-v2/Orchestrator.ts";
 import * as ProjectService from "../../../project/ProjectService.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
+import { assertTargetWithinLimits } from "../../threadAccess.ts";
 import {
   type ListThreadPullRequestsResult,
   PullRequestLinkFailedError,
@@ -38,6 +39,8 @@ import {
   type PullRequestTargetInput,
   PullRequestWatchFailedError,
   PullRequestThreadNotFoundError,
+  PullRequestThreadAboveLimitsError,
+  PullRequestThreadRequiredError,
   PullRequestsToolkit,
   type ThreadPullRequestEntry,
 } from "./tools.ts";
@@ -168,18 +171,64 @@ const make = Effect.gen(function* () {
       | typeof PullRequestUnlinkFailedError
       | typeof PullRequestListFailedError
       | typeof PullRequestWatchFailedError,
+    requested: ThreadId | undefined,
   ) {
     const scope = yield* McpInvocationContext.requireMcpCapability("pull-requests");
+    const threadId = requested ?? scope.thread?.threadId;
+    if (threadId === undefined) {
+      return yield* new PullRequestThreadRequiredError();
+    }
     const thread = yield* engine
-      .getThreadShell(scope.threadId)
+      .getThreadShell(threadId)
       .pipe(Effect.map(Option.fromNullishOr))
       .pipe(Effect.mapError((cause) => new Failure({ cause })));
-    if (Option.isNone(thread)) {
-      return yield* new PullRequestThreadNotFoundError({ threadId: scope.threadId });
+    if (Option.isNone(thread) || thread.value.deletedAt !== null) {
+      return yield* new PullRequestThreadNotFoundError({ threadId });
     }
     return thread.value;
   });
 
+  /**
+   * A thread whose pull requests the caller may change: its own, or one that
+   * runs within the caller's modes.
+   */
+  const requireWritableThread = Effect.fn("PullRequestsToolkit.requireWritableThread")(function* (
+    Failure:
+      | typeof PullRequestLinkFailedError
+      | typeof PullRequestUnlinkFailedError
+      | typeof PullRequestWatchFailedError,
+    requested: ThreadId | undefined,
+  ) {
+    const thread = yield* requireThread(Failure, requested);
+    const scope = yield* McpInvocationContext.McpInvocationContext;
+    if (thread.id === scope.thread?.threadId) return thread;
+    const limits =
+      scope.thread === undefined
+        ? {
+            runtimeMode: scope.client?.runtimeModeCeiling ?? ("approval-required" as const),
+            interactionMode: "default" as const,
+          }
+        : yield* engine.getThreadShell(scope.thread.threadId).pipe(
+            Effect.mapError((cause) => new Failure({ cause })),
+            Effect.map((caller) =>
+              // A thread caller changes other threads only while its own run is live.
+              caller === null ||
+              caller.archivedAt !== null ||
+              caller.activeRunId === null ||
+              caller.providerInstanceId !== scope.thread?.providerInstanceId
+                ? undefined
+                : { runtimeMode: caller.runtimeMode, interactionMode: caller.interactionMode },
+            ),
+          );
+    if (limits === undefined) {
+      return yield* new PullRequestThreadAboveLimitsError({ threadId: thread.id });
+    }
+    yield* assertTargetWithinLimits(limits, thread).pipe(
+      Effect.mapError(() => new PullRequestThreadAboveLimitsError({ threadId: thread.id })),
+    );
+    return thread;
+  });
+
   const projectOf = (
     thread: OrchestrationV2ThreadShell,
     Failure:
@@ -217,7 +266,7 @@ const make = Effect.gen(function* () {
     input: PullRequestTargetInput,
     watching: boolean,
   ) {
-    const thread = yield* requireThread(PullRequestWatchFailedError);
+    const thread = yield* requireWritableThread(PullRequestWatchFailedError, input.threadId);
     const project = yield* projectOf(thread, PullRequestWatchFailedError);
     const target = yield* resolveTarget(input, project);
     const watchedLink = (shell: OrchestrationV2ThreadShell) =>
@@ -241,7 +290,7 @@ const make = Effect.gen(function* () {
         ...(watching ? { link: { url: target.url, source: "agent" as const } } : {}),
       })
       .pipe(Effect.catchCause(dispatchFailure(PullRequestWatchFailedError)));
-    const after = yield* requireThread(PullRequestWatchFailedError);
+    const after = yield* requireThread(PullRequestWatchFailedError, thread.id);
     return {
       host: target.host,
       repository: target.repository,
@@ -255,7 +304,7 @@ const make = Effect.gen(function* () {
   return PullRequestsToolkit.of({
     link_pull_request: (input) =>
       Effect.gen(function* () {
-        const thread = yield* requireThread(PullRequestLinkFailedError);
+        const thread = yield* requireWritableThread(PullRequestLinkFailedError, input.threadId);
         const project = yield* projectOf(thread, PullRequestLinkFailedError);
         const target = yield* resolveTarget(input, project);
         const existing = threadPullRequestsOf(thread).find((link) =>
@@ -285,7 +334,7 @@ const make = Effect.gen(function* () {
       }),
     unlink_pull_request: (input) =>
       Effect.gen(function* () {
-        const thread = yield* requireThread(PullRequestUnlinkFailedError);
+        const thread = yield* requireWritableThread(PullRequestUnlinkFailedError, input.threadId);
         const project = yield* projectOf(thread, PullRequestUnlinkFailedError);
         const target = yield* resolveTarget(input, project);
         if (!threadPullRequestsOf(thread).some((link) => threadPullRequestKeysEqual(link, target)))
@@ -316,8 +365,10 @@ const make = Effect.gen(function* () {
           wasLinked,
         };
       }),
-    list_thread_pull_requests: () =>
-      requireThread(PullRequestListFailedError).pipe(Effect.map(listThreadPullRequests)),
+    list_thread_pull_requests: (input) =>
+      requireThread(PullRequestListFailedError, input.threadId).pipe(
+        Effect.map(listThreadPullRequests),
+      ),
     watch_pull_request: (input) => setWatching(input, true),
     unwatch_pull_request: (input) => setWatching(input, false),
   });
diff --git a/apps/server/src/mcp/toolkits/pullRequests/tools.ts b/apps/server/src/mcp/toolkits/pullRequests/tools.ts
index 52ac473a3d50..f17b22204f45 100644
--- a/apps/server/src/mcp/toolkits/pullRequests/tools.ts
+++ b/apps/server/src/mcp/toolkits/pullRequests/tools.ts
@@ -4,6 +4,7 @@ import {
   PullRequestState,
   ThreadPullRequestLinkSource,
   TrimmedNonEmptyString,
+  ThreadId,
 } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import * as Tool from "effect/unstable/ai/Tool";
@@ -28,6 +29,11 @@ const REGISTER_EVERY_PR =
  * the host CLI handed back.
  */
 export const PullRequestTargetInput = Schema.Struct({
+  threadId: Schema.optional(
+    ThreadId.annotate({
+      description: "Thread to act on. Omit for this thread.",
+    }),
+  ),
   url: Schema.optional(
     TrimmedNonEmptyString.annotate({
       description:
@@ -81,6 +87,24 @@ export class PullRequestHostRequiredError extends Schema.TaggedError<PullRequest
   }
 }
 
+export class PullRequestThreadRequiredError extends Schema.TaggedError<PullRequestThreadRequiredError>()(
+  "PullRequestThreadRequiredError",
+  {},
+) {
+  override get message(): string {
+    return "Pass threadId: this MCP client is not running inside a T3 thread.";
+  }
+}
+
+export class PullRequestThreadAboveLimitsError extends Schema.TaggedError<PullRequestThreadAboveLimitsError>()(
+  "PullRequestThreadAboveLimitsError",
+  { threadId: Schema.String },
+) {
+  override get message(): string {
+    return `Thread ${this.threadId} cannot be changed from here: it runs with broader permissions than this caller, or the calling thread has no active run.`;
+  }
+}
+
 export class PullRequestThreadNotFoundError extends Schema.TaggedError<PullRequestThreadNotFoundError>()(
   "PullRequestThreadNotFoundError",
   { threadId: Schema.String },
@@ -140,6 +164,8 @@ export const PullRequestToolError = Schema.Union([
   PullRequestUrlInvalidError,
   PullRequestTargetIncompleteError,
   PullRequestHostRequiredError,
+  PullRequestThreadRequiredError,
+  PullRequestThreadAboveLimitsError,
   PullRequestThreadNotFoundError,
   PullRequestLinkFailedError,
   PullRequestUnlinkFailedError,
@@ -245,7 +271,12 @@ const UnlinkPullRequestTool = Tool.make("unlink_pull_request", {
   .annotate(Tool.OpenWorld, false);
 
 const ListThreadPullRequestsTool = Tool.make("list_thread_pull_requests", {
-  description: `List the pull requests linked to this thread with their last known host state, and how they chain into stacks (bottom to top). ${REGISTER_EVERY_PR}`,
+  description: `List the pull requests linked to a thread (omit threadId for this thread) with their last known host state, and how they chain into stacks (bottom to top). ${REGISTER_EVERY_PR}`,
+  parameters: Schema.Struct({
+    threadId: Schema.optional(
+      ThreadId.annotate({ description: "Thread to list. Omit for this thread." }),
+    ),
+  }),
   success: ListThreadPullRequestsResult,
   failure: PullRequestToolError,
   dependencies,
diff --git a/apps/server/src/mcp/toolkits/thread/handlers.ts b/apps/server/src/mcp/toolkits/thread/handlers.ts
index c0f5d135b6cc..b3c3b75eb32e 100644
--- a/apps/server/src/mcp/toolkits/thread/handlers.ts
+++ b/apps/server/src/mcp/toolkits/thread/handlers.ts
@@ -13,7 +13,7 @@ import { modelSelectionCommandType } from "@t3tools/shared/model";
 import {
   newCommandId,
   readCaller,
-  readMutationCaller,
+  readFullAccessCaller,
   readThread,
   readWritableThread,
   unavailable,
@@ -78,22 +78,15 @@ const readQuestion = Effect.fn("mcp.readQuestion")(function* (
 export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
   run_scheduled_task_now: (input) =>
     Effect.gen(function* () {
-      const { caller } = yield* readMutationCaller();
-      if (
-        caller.archivedAt !== null ||
-        caller.runtimeMode !== "full-access" ||
-        caller.interactionMode !== "default"
-      )
-        return yield* new OrchestratorMcpFailure({
-          code: "capability_denied",
-          message: "Running a scheduled task requires a live full-access/default thread.",
-        });
+      yield* readFullAccessCaller(
+        "Running a scheduled task requires a live full-access/default thread or a full-access client.",
+      );
       const scheduler = yield* ScheduledTasks.ScheduledTaskService;
       const { tasks } = yield* scheduler.list().pipe(Effect.mapError(unavailable));
-      if (!tasks.some((task) => task.id === input.taskId && task.projectId === caller.projectId))
+      if (!tasks.some((task) => task.id === input.taskId))
         return yield* new OrchestratorMcpFailure({
           code: "invalid_request",
-          message: "The task was not found in the calling project.",
+          message: "The scheduled task was not found.",
         });
       const { task } = yield* scheduler
         .runNow({ id: input.taskId })
@@ -109,13 +102,22 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
   t3_thread_search: (input) =>
     Effect.gen(function* () {
       const { caller } = yield* readCaller();
+      const { projectId: requested, ...query } = input;
+      // Like the other project tools, an omitted project means the caller's own; a client
+      // outside a thread searches every project.
+      const projectId = requested ?? caller?.projectId;
       const threadSearch = yield* ThreadSearch.ThreadSearch;
-      const result = yield* threadSearch.search(input).pipe(Effect.mapError(unavailable));
-      return { matches: result.matches.filter((match) => match.projectId === caller.projectId) };
+      const result = yield* threadSearch.search(query).pipe(Effect.mapError(unavailable));
+      return {
+        matches:
+          projectId === undefined
+            ? result.matches
+            : result.matches.filter((match) => match.projectId === projectId),
+      };
     }),
   t3_thread_fork: (input) =>
     Effect.gen(function* () {
-      const { threads, projection } = yield* readWritableThread();
+      const { threads, projection } = yield* readWritableThread(input.threadId);
       const commandId = yield* newCommandId();
       const targetThreadId = ThreadId.make(`${commandId}:fork`);
       const result = yield* threads
@@ -134,12 +136,13 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
     }),
   t3_thread_merge_back: (input) =>
     Effect.gen(function* () {
-      const { threads, caller } = yield* readWritableThread(input.targetThreadId);
-      const result = yield* threads
+      const context = yield* readWritableThread(input.targetThreadId);
+      const source = yield* readWritableThread(input.sourceThreadId);
+      const result = yield* context.threads
         .dispatch({
           type: "thread.merge_back",
           commandId: yield* newCommandId(),
-          sourceThreadId: caller.id,
+          sourceThreadId: source.projection.thread.id,
           targetThreadId: input.targetThreadId,
           sourcePoint: input.sourcePoint,
           createdBy: "agent",
@@ -179,7 +182,7 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
       const {
         threads,
         projection: { thread },
-      } = yield* readWritableThread();
+      } = yield* readWritableThread(input.threadId);
       const type = modelSelectionCommandType(thread.providerInstanceId, input.modelSelection);
       const result = yield* threads
         .dispatch({
diff --git a/apps/server/src/mcp/toolkits/thread/tools.ts b/apps/server/src/mcp/toolkits/thread/tools.ts
index 1517763b936e..bc2188037246 100644
--- a/apps/server/src/mcp/toolkits/thread/tools.ts
+++ b/apps/server/src/mcp/toolkits/thread/tools.ts
@@ -17,6 +17,7 @@ import {
   ThreadId,
   RunId,
   NonNegativeInt,
+  ProjectId,
 } from "@t3tools/contracts";
 import * as Crypto from "effect/Crypto";
 import * as Schema from "effect/Schema";
@@ -29,7 +30,7 @@ import * as McpInvocationContext from "../../McpInvocationContext.ts";
 
 const ThreadOrganizeTool = Tool.make("t3_thread_organize", {
   description:
-    "Pin, snooze, settle, archive, or mark a thread unread in the calling project. Omit threadId for this thread. snooze requires snoozedUntil. Existing thread lifecycle rules apply; this does not schedule a future action.",
+    "Pin, snooze, settle, archive, or mark a thread unread. Omit threadId for this thread. snooze requires snoozedUntil. Existing thread lifecycle rules apply; this does not schedule a future action.",
   parameters: Schema.Struct({
     threadId: Schema.optional(ThreadId),
     action: Schema.Literals([
@@ -91,7 +92,7 @@ const QueueListTool = Tool.make("t3_queue_list", {
   .annotate(Tool.Destructive, false);
 const QueueReadTool = Tool.make("t3_queue_read", {
   ...commandTool,
-  description: "Read up to 16,000 characters of a queued message in the calling project.",
+  description: "Read up to 16,000 characters of a queued message. Omit threadId for this thread.",
   parameters: Schema.Struct(queueTarget),
   success: queueEntry,
 })
@@ -146,7 +147,7 @@ const pendingRequest = Schema.Struct({
 const PendingRequestListTool = Tool.make("t3_pending_request_list", {
   ...commandTool,
   description:
-    "List pending user questions in a thread in the calling project. Approval requests are not included.",
+    "List pending user questions in a thread. Omit threadId for this thread. Approval requests are not included.",
   parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
   success: Schema.Struct({ requestIds: Schema.Array(RuntimeRequestId) }),
 })
@@ -173,7 +174,7 @@ const PendingRequestRespondTool = Tool.make("t3_pending_request_respond", {
 const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {
   ...commandTool,
   description:
-    "Read a thread's provider/model selection and modes in the calling project. orchestrator_capabilities lists available providers and models.",
+    "Read a thread's provider/model selection and modes. Omit threadId for this thread. orchestrator_capabilities lists available providers and models.",
   parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
   success: Schema.Struct({
     threadId: ThreadId,
@@ -187,16 +188,20 @@ const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {
 const ThreadConfigureTool = Tool.make("t3_thread_configure", {
   ...commandTool,
   description:
-    "Set this calling thread's provider, model and options with the existing selection command. This does not change permission modes or other threads. Use orchestrator_capabilities to choose a selection.",
-  parameters: Schema.Struct({ modelSelection: ModelSelection }),
+    "Set a thread's provider, model and options with the existing selection command. Omit threadId for this thread. This does not change permission modes. Use orchestrator_capabilities to choose a selection.",
+  parameters: Schema.Struct({
+    threadId: Schema.optional(ThreadId),
+    modelSelection: ModelSelection,
+  }),
 }).annotate(Tool.Destructive, true);
 
 const transferResult = Schema.Struct({ sequence: NonNegativeInt, targetThreadId: ThreadId });
 const ThreadForkTool = Tool.make("t3_thread_fork", {
   ...commandTool,
   description:
-    "Fork this thread from a stable run or checkpoint using the existing fork command. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",
+    "Fork a thread from a stable run or checkpoint using the existing fork command. Omit threadId to fork this thread. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",
   parameters: Schema.Struct({
+    threadId: Schema.optional(ThreadId),
     sourcePoint: OrchestrationV2ThreadForkSourcePoint,
     title: Schema.optional(TrimmedNonEmptyString),
   }),
@@ -205,8 +210,9 @@ const ThreadForkTool = Tool.make("t3_thread_fork", {
 const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {
   ...commandTool,
   description:
-    "Merge context from this thread back to a related thread in the same project. Existing lineage and transfer rules apply.",
+    "Merge context from a thread back to a related thread in the same project. Omit sourceThreadId to merge from this thread. Existing lineage and transfer rules apply.",
   parameters: Schema.Struct({
+    sourceThreadId: Schema.optional(ThreadId),
     targetThreadId: ThreadId,
     sourcePoint: OrchestrationV2ThreadForkSourcePoint,
   }),
@@ -214,7 +220,7 @@ const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {
 }).annotate(Tool.Destructive, true);
 const ThreadTransfersTool = Tool.make("t3_thread_transfers", {
   ...commandTool,
-  description: "Read context transfer status for a thread in the calling project.",
+  description: "Read context transfer status for a thread. Omit threadId for this thread.",
   parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
   success: Schema.Struct({
     transfers: Schema.Array(
@@ -233,8 +239,11 @@ const ThreadTransfersTool = Tool.make("t3_thread_transfers", {
 const ThreadSearchTool = Tool.make("t3_thread_search", {
   ...commandTool,
   description:
-    "Search active thread titles and content with the app's existing bounded search. Returns matches in the calling project from the global top matches; other-project matches are omitted, so this may return fewer than limit. No pagination or exhaustive-result guarantee.",
-  parameters: OrchestrationSearchThreadsInput,
+    "Search active thread titles and content with the app's existing bounded search. Matches are limited to one project (projectId, else the calling thread's project) out of the global top matches, so this may return fewer than limit. A caller outside a T3 thread that omits projectId searches every project. No pagination or exhaustive-result guarantee.",
+  parameters: Schema.Struct({
+    ...OrchestrationSearchThreadsInput.fields,
+    projectId: Schema.optional(ProjectId),
+  }),
   success: OrchestrationSearchThreadsResult,
   dependencies: [...commandTool.dependencies, ThreadSearch.ThreadSearch],
 })
@@ -244,7 +253,7 @@ const ThreadSearchTool = Tool.make("t3_thread_search", {
 const ScheduledTaskRunTool = Tool.make("run_scheduled_task_now", {
   ...commandTool,
   description:
-    "Run a scheduled task in the calling project now through the existing scheduler. Requires a full-access/default caller. Each call is a new manual run; completion means dispatch/bookkeeping completed, not that the provider turn finished.",
+    "Run a scheduled task now through the existing scheduler. Requires a full-access/default caller. Each call is a new manual run; completion means dispatch/bookkeeping completed, not that the provider turn finished.",
   parameters: Schema.Struct({ taskId: ScheduledTaskId }),
   success: Schema.Struct({
     taskId: ScheduledTaskId,
diff --git a/apps/server/src/mcp/toolkits/worktree/handlers.ts b/apps/server/src/mcp/toolkits/worktree/handlers.ts
index 0ecabdaecb97..dbb7c59f4fb7 100644
--- a/apps/server/src/mcp/toolkits/worktree/handlers.ts
+++ b/apps/server/src/mcp/toolkits/worktree/handlers.ts
@@ -2,7 +2,7 @@ import { OrchestratorMcpFailure } from "@t3tools/contracts";
 import * as Option from "effect/Option";
 import * as GitWorkflow from "../../../git/GitWorkflowService.ts";
 import * as Project from "../../../project/ProjectService.ts";
-import { readCaller, unavailable } from "../../threadAccess.ts";
+import { readThread, unavailable } from "../../threadAccess.ts";
 import * as Effect from "effect/Effect";
 
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
@@ -18,9 +18,12 @@ const handlers = {
           code: "capability_denied",
           message: "This credential cannot inspect worktrees.",
         });
-      const { caller } = yield* readCaller();
+      const { threadId, ...refs } = input;
+      const {
+        projection: { thread },
+      } = yield* readThread(threadId);
       const projects = yield* Project.ProjectService;
-      const project = yield* projects.getById(caller.projectId).pipe(Effect.mapError(unavailable));
+      const project = yield* projects.getById(thread.projectId).pipe(Effect.mapError(unavailable));
       if (Option.isNone(project))
         return yield* new OrchestratorMcpFailure({
           code: "invalid_request",
@@ -28,7 +31,7 @@ const handlers = {
         });
       const git = yield* GitWorkflow.GitWorkflowService;
       return yield* git
-        .listRefs({ ...input, cwd: caller.worktreePath ?? project.value.workspaceRoot })
+        .listRefs({ ...refs, cwd: thread.worktreePath ?? project.value.workspaceRoot })
         .pipe(Effect.mapError(unavailable));
     }),
   t3_worktree_handoff: (input) =>
diff --git a/apps/server/src/mcp/toolkits/worktree/tools.ts b/apps/server/src/mcp/toolkits/worktree/tools.ts
index d4cff97dbf75..373be5d3e46d 100644
--- a/apps/server/src/mcp/toolkits/worktree/tools.ts
+++ b/apps/server/src/mcp/toolkits/worktree/tools.ts
@@ -6,6 +6,7 @@ import {
   WorktreeMcpHandoffInput,
   WorktreeMcpHandoffResult,
   WorktreeMcpStatusResult,
+  ThreadId,
 } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import * as GitWorkflowService from "../../../git/GitWorkflowService.ts";
@@ -23,7 +24,7 @@ const dependencies = [
 
 const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {
   description:
-    "Move this agent thread into a new git worktree. To launch a separate agent already bound to a new or existing worktree, use t3_thread_launch with workspaceStrategy instead. Creates the worktree branch (optionally from origin), re-points the thread at the worktree, and by default runs the project's setup script there. Changing the workspace detaches the live provider session, so the current turn ends shortly after the handoff is recorded; call this as the last action of the turn. To keep working after the handoff, pass continuationPrompt with the remaining work: it is queued as the thread's next message and starts a new turn inside the worktree with the conversation preserved. Without it the thread stays idle until the next message. The worktree is not removed automatically when the thread is deleted. Fails if the thread is already attached to a worktree.",
+    "Needs an agent running inside a T3 thread. Move this agent thread into a new git worktree. To launch a separate agent already bound to a new or existing worktree, use t3_thread_launch with workspaceStrategy instead. Creates the worktree branch (optionally from origin), re-points the thread at the worktree, and by default runs the project's setup script there. Changing the workspace detaches the live provider session, so the current turn ends shortly after the handoff is recorded; call this as the last action of the turn. To keep working after the handoff, pass continuationPrompt with the remaining work: it is queued as the thread's next message and starts a new turn inside the worktree with the conversation preserved. Without it the thread stays idle until the next message. The worktree is not removed automatically when the thread is deleted. Fails if the thread is already attached to a worktree.",
   parameters: WorktreeMcpHandoffInput,
   success: WorktreeMcpHandoffResult,
   failure: WorktreeMcpFailure,
@@ -38,7 +39,7 @@ const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {
 
 const WorktreeStatusTool = Tool.make("t3_worktree_status", {
   description:
-    "Report this agent thread's worktree binding: whether it is attached to a git worktree, the worktree path and branch, the project's main workspace root, and the server default for t3_worktree_handoff's startFromOrigin. Call this before t3_worktree_handoff to check whether a handoff is possible or has already happened.",
+    "Needs an agent running inside a T3 thread. Report this agent thread's worktree binding: whether it is attached to a git worktree, the worktree path and branch, the project's main workspace root, and the server default for t3_worktree_handoff's startFromOrigin. Call this before t3_worktree_handoff to check whether a handoff is possible or has already happened.",
   // No `parameters`: Tool.make defaults to Tool.EmptyParams, which serializes
   // to a top-level `type: "object"` JSON Schema. An explicit empty
   // Schema.Struct({}) serializes to `anyOf: [object, array]`, which is not a
@@ -56,8 +57,9 @@ const WorktreeStatusTool = Tool.make("t3_worktree_status", {
 
 const WorktreeListTool = Tool.make("t3_worktree_list", {
   description:
-    "List branch refs and their associated checkout paths for this thread's workspace using the app's ref inventory. Detached worktrees without a branch are not included. Use t3_worktree_status for the thread binding and t3_worktree_handoff to create a new worktree.",
+    "List branch refs and their associated checkout paths for a thread's workspace (omit threadId for this thread) using the app's ref inventory. Detached worktrees without a branch are not included. Use t3_worktree_status for the thread binding and t3_worktree_handoff to create a new worktree.",
   parameters: Schema.Struct({
+    threadId: Schema.optional(ThreadId),
     query: VcsListRefsInput.fields.query,
     cursor: VcsListRefsInput.fields.cursor,
     limit: VcsListRefsInput.fields.limit,
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
index b6cb0be45acf..031fa17c0506 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
@@ -1008,9 +1008,12 @@ describe("AcpAdapterV2", () => {
       );
       type Runtime = AcpSessionRuntime.AcpSessionRuntime["Service"];
       let handler: Parameters<Runtime["handleSessionUpdate"]>[0] | undefined;
+      let createTerminal: Parameters<Runtime["handleCreateTerminal"]>[0] | undefined;
       const instanceId = ProviderInstanceId.make("devin-replay");
       const adapter = makeAcpAdapterV2({
         instanceId,
+        // Production Devin runs commands through client terminals.
+        clientTerminals: { childProcessSpawner, shellCommands: true },
         crypto: yield* Crypto.Crypto,
         fileSystem: yield* FileSystem.FileSystem,
         idAllocator,
@@ -1031,9 +1034,18 @@ describe("AcpAdapterV2", () => {
                 Effect.sync(() => {
                   handler = next;
                 }).pipe(Effect.andThen(runtime.handleSessionUpdate(next))),
+              handleCreateTerminal: (next) =>
+                Effect.sync(() => {
+                  createTerminal = next;
+                }).pipe(Effect.andThen(runtime.handleCreateTerminal(next))),
               prompt: () =>
                 Effect.gen(function* () {
                   assert.isDefined(handler);
+                  assert.isDefined(createTerminal);
+                  const fallbackTerminal = yield* createTerminal(
+                    { sessionId: "mock-session-1", command: "true acp-mcp-call task_status {}" },
+                    { requestId: "child-mcp-terminal", method: "terminal/create" },
+                  );
                   // Production thread 54aeb6d7 split after "(command". Metadata shapes
                   // below were captured from live Devin sessions showy-mile/fragrant-chamomile.
                   const updates = [
@@ -1075,6 +1087,48 @@ describe("AcpAdapterV2", () => {
                         "cognition.ai/subagent_context": { parentAgentId: "child-a" },
                       },
                     },
+                    {
+                      sessionUpdate: "tool_call",
+                      toolCallId: "child-weather",
+                      title: "Check weather",
+                      status: "completed",
+                      rawInput: { server: "weather", tool: "get_weather", city: "Berlin" },
+                      rawOutput: {
+                        result: {
+                          _meta: {
+                            source: { name: "Weather", logoUrl: "https://example.com/weather.png" },
+                          },
+                          content: [{ type: "text", text: "Sunny" }],
+                        },
+                      },
+                      _meta: {
+                        is_mcp_tool_call: true,
+                        "cognition.ai/subagent_context": { parentAgentId: "child-a" },
+                      },
+                    },
+                    {
+                      sessionUpdate: "tool_call",
+                      toolCallId: "child-mcp-fallback",
+                      title: "Ran command",
+                      kind: "execute",
+                      status: "completed",
+                      content: [{ type: "terminal", terminalId: fallbackTerminal.terminalId }],
+                      _meta: { "cognition.ai/subagent_context": { parentAgentId: "child-a" } },
+                    },
+                    {
+                      sessionUpdate: "tool_call",
+                      toolCallId: "parent-weather",
+                      title: "Check weather",
+                      status: "completed",
+                      rawInput: { server: "weather", tool: "get_weather", city: "Berlin" },
+                      rawOutput: {
+                        _meta: {
+                          source: { name: "Weather", logoUrl: "https://example.com/weather.png" },
+                        },
+                        content: [{ type: "text", text: "Sunny" }],
+                      },
+                      _meta: { is_mcp_tool_call: true },
+                    },
                     {
                       sessionUpdate: "agent_message_chunk",
                       content: { type: "text", text: " → decider → event)." },
@@ -1192,6 +1246,37 @@ describe("AcpAdapterV2", () => {
       );
       assert.deepEqual([...childMessages.values()], ["Checking the code.", "ONE"]);
       assert.equal(task?.prompt, "Run pwd, then reply ONE.");
+      // Terminal-fallback MCP calls in a child session keep their T3 identity.
+      assert.isTrue(
+        items.some(
+          (item) =>
+            item.threadId === task?.childThreadId &&
+            item.type === "dynamic_tool" &&
+            item.toolName === "t3-code.task_status",
+        ),
+      );
+      const childMcp = items.find(
+        (item) =>
+          item.threadId === task?.childThreadId &&
+          item.type === "dynamic_tool" &&
+          item.toolName === "weather.get_weather",
+      );
+      const parentMcp = items.find(
+        (item) =>
+          item.threadId === threadId &&
+          item.type === "dynamic_tool" &&
+          item.toolName === "weather.get_weather",
+      );
+      for (const item of [parentMcp, childMcp]) {
+        assert.equal(item?.title, "get weather");
+        assert.deepEqual(item?.toolSource, {
+          key: "mcp:weather",
+          name: "Weather",
+          kind: "integration",
+          icon: { _tag: "themed-logo", logoUrl: "https://example.com/weather.png" },
+        });
+        assert.deepEqual(item?.toolIcon, item?.toolSource?.icon);
+      }
       assert.isTrue(
         items.some(
           (item) =>
@@ -1216,7 +1301,7 @@ describe("AcpAdapterV2", () => {
       const parentTools = items.filter(
         (item) => item.threadId === threadId && item.type === "dynamic_tool",
       );
-      assert.equal(parentTools.length, 1);
+      assert.equal(parentTools.length, 2);
       assert.equal(parentTools[0]?.title, "Parent tool finished");
     }).pipe(Effect.provide(testLayer), Effect.scoped),
   );
@@ -1324,6 +1409,12 @@ describe("AcpAdapterV2", () => {
         ),
         { input: "printf proof", output: "proof" },
       );
+      assert.deepInclude(
+        items.flatMap((item) =>
+          item.type === "command_execution" ? [{ input: item.input, output: item.output }] : [],
+        ),
+        { input: "cat probe.txt", output: "after\n" },
+      );
       assert.isTrue(
         items.some((item) => item.title === "Action required" && item.status === "waiting"),
       );
@@ -1345,6 +1436,35 @@ describe("AcpAdapterV2", () => {
         search?.type === "file_search" ? { title: search.title, pattern: search.pattern } : null,
         { title: "Searched TODO in web", pattern: "apps/web" },
       );
+      const webItem = (nativeId: string, status: string) => {
+        const item = items.findLast(
+          (candidate) =>
+            candidate.type === "web_search" &&
+            candidate.status === status &&
+            candidate.nativeItemRef?.nativeId?.endsWith(nativeId) === true,
+        );
+        return item?.type === "web_search"
+          ? { title: item.title, patterns: item.patterns, results: item.results }
+          : null;
+      };
+      assert.deepEqual(webItem("grok-x-search", "running"), {
+        title: "X search",
+        patterns: undefined,
+        results: undefined,
+      });
+      assert.deepEqual(webItem("grok-x-search", "completed"), {
+        title: "X search: conversation_id:42",
+        patterns: ["conversation_id:42"],
+        results: undefined,
+      });
+      assert.deepEqual(webItem("grok-web-search", "completed"), {
+        title: "Web search: t3 code",
+        patterns: ["t3 code"],
+        results: [{ url: "https://t3.codes" }, { url: "https://github.com/pingdotgg/t3code" }],
+      });
+      assert.deepEqual(webItem("grok-web-fetch", "completed")?.results, [
+        { url: "https://t3.codes", snippet: "T3 Code page" },
+      ]);
       const completedCompaction = items.find(
         (item) =>
           item.type === "compaction" &&
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.ts
index bf01d9cb2d7d..e5ae85129e2f 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.ts
@@ -19,6 +19,7 @@ import {
   type OrchestrationV2Subagent,
   type OrchestrationV2TurnItem,
   type OrchestrationV2UserInputQuestion,
+  type OrchestrationV2WebSearchResult,
   type ProviderApprovalDecision,
   type ProviderApprovalOption,
   type ProviderInstanceId,
@@ -62,6 +63,7 @@ import {
   makeAcpMcpOverAcpBridge,
   type AcpMcpOverAcpBridge,
 } from "../../mcp/AcpMcpOverAcpBridge.ts";
+import { mcpToolPresentation } from "../../provider/McpToolPresentation.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import {
   applyAcpAgentTerminalUpdate,
@@ -846,11 +848,14 @@ function textFromUnknown(value: unknown): string | undefined {
     return undefined;
   }
   // Prefer prompt-facing Grok fields before nested envelopes.
+  // Antigravity reports shell output as combinedOutput.
   for (const key of [
     "output_for_prompt",
     "stdout",
     "stderr",
     "output",
+    "combinedOutput",
+    "combined_output",
     "content",
     "text",
     "message",
@@ -989,6 +994,46 @@ function pathFromToolCall(toolCall: AcpToolCallState): string | undefined {
   return undefined;
 }
 
+/**
+ * Grok runs X and web searches server-side as `search` tools whose rawInput is
+ * only `{ variant: "XSearch" | "WebSearch", backend: true }`. The query arrives
+ * with completion: web searches report `action: { query, sources }`, X searches
+ * the backend call `{ name, input }` with JSON-encoded arguments.
+ */
+function acpBackendWebSearch(
+  rawInput: Record<string, unknown> | undefined,
+  rawOutput: Record<string, unknown> | undefined,
+):
+  | { readonly query: string | undefined; readonly results: OrchestrationV2WebSearchResult[] }
+  | undefined {
+  const variant = typeof rawInput?.variant === "string" ? rawInput.variant.toLowerCase() : "";
+  const action = unknownRecord(rawOutput?.action);
+  if (variant !== "xsearch" && variant !== "websearch" && action?.type !== "search") {
+    return undefined;
+  }
+  let args: Record<string, unknown> | undefined;
+  if (typeof rawOutput?.input === "string") {
+    try {
+      args = unknownRecord(JSON.parse(rawOutput.input));
+    } catch {
+      args = undefined;
+    }
+  }
+  const argsText = Object.entries(args ?? {})
+    .filter(([, value]) => typeof value === "string" || typeof value === "number")
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(", ");
+  const query = [action?.query, args?.query, argsText]
+    .find((value): value is string => typeof value === "string" && value.trim().length > 0)
+    ?.trim();
+  const urls = new Set<string>();
+  for (const source of Array.isArray(action?.sources) ? action.sources : []) {
+    const url = unknownRecord(source)?.url;
+    if (typeof url === "string" && url.trim().length > 0) urls.add(url.trim());
+  }
+  return { query, results: [...urls].map((url) => ({ url })) };
+}
+
 function providerRequestKind(kind: string | "unknown"): ProviderRequestKind {
   switch (kind) {
     case "execute":
@@ -1588,6 +1633,21 @@ export function makeAcpAdapterV2(
             embeddedTerminalsByToolCallId.delete(oldest);
           }
         };
+        // Command lines of the terminals embedded in a tool call, so MCP calls
+        // made through the acp-mcp-call terminal fallback keep their identity.
+        const embeddedTerminalCommands = (
+          sessionId: string,
+          toolCallId: string,
+        ): ReadonlyArray<string> =>
+          (
+            embeddedTerminalsByToolCallId.get(sessionScopedId(sessionId, toolCallId))
+              ?.terminalIds ?? []
+          ).flatMap((terminalId) => {
+            const command =
+              clientTerminals?.readCommandLine(terminalId) ??
+              agentTerminalsById.get(sessionScopedId(sessionId, terminalId))?.command;
+            return command === undefined ? [] : [command];
+          });
         // Client terminals (Devin) run with the T3 server's privileges, so they
         // are policy-checked against the active turn policy; a command the user
         // already approved satisfies an "ask" disposition.
@@ -3223,17 +3283,10 @@ export function makeAcpAdapterV2(
           // agent-specific shape and project the same branded dynamic_tool
           // item native providers produce (e.g. the T3 orchestration tools).
           const mcpIdentity = extractMcpToolCallIdentity(toolCall, {
-            embeddedTerminalCommands: (
-              embeddedTerminalsByToolCallId.get(
-                sessionScopedId(context.nativeThreadId, toolCall.toolCallId),
-              )?.terminalIds ?? []
-            ).flatMap((terminalId) => {
-              const command =
-                clientTerminals?.readCommandLine(terminalId) ??
-                agentTerminalsById.get(sessionScopedId(context.nativeThreadId, terminalId))
-                  ?.command;
-              return command === undefined ? [] : [command];
-            }),
+            embeddedTerminalCommands: embeddedTerminalCommands(
+              context.nativeThreadId,
+              toolCall.toolCallId,
+            ),
           });
           let turnItem: OrchestrationV2TurnItem;
           if (toolCall.toolCallId.startsWith("acp-compaction:")) {
@@ -3258,9 +3311,14 @@ export function makeAcpAdapterV2(
           } else if (mcpIdentity !== undefined) {
             turnItem = {
               ...base,
-              // Identity lives in toolName, like native Codex MCP items; the
-              // agent's own title (e.g. "Ran command") would shadow it.
               title: null,
+              ...mcpToolPresentation({
+                serverName: mcpIdentity.server,
+                toolName: mcpIdentity.tool,
+                source: unknownRecord(
+                  (unknownRecord(rawOutputRecord?.result) ?? rawOutputRecord)?._meta,
+                )?.source,
+              }),
               type: "dynamic_tool",
               toolName: `${mcpIdentity.server}.${mcpIdentity.tool}`,
               input:
@@ -3297,7 +3355,30 @@ export function makeAcpAdapterV2(
                   ...(rawOutput === undefined ? {} : { output: rawOutput }),
                 };
                 break;
-              case "search":
+              case "search": {
+                const backendSearch = acpBackendWebSearch(rawInputRecord, rawOutputRecord);
+                if (backendSearch !== undefined) {
+                  // Grok titles these "X search:" / "Web search:" awaiting the query.
+                  const label = nonEmptyText(toolCall.data.title, title ?? "Web search").replace(
+                    /:\s*$/u,
+                    "",
+                  );
+                  turnItem = {
+                    ...base,
+                    title:
+                      backendSearch.query === undefined
+                        ? label
+                        : `${label}: ${backendSearch.query}`,
+                    type: "web_search",
+                    ...(backendSearch.query === undefined
+                      ? {}
+                      : { patterns: [backendSearch.query] }),
+                    ...(backendSearch.results.length === 0
+                      ? {}
+                      : { results: backendSearch.results }),
+                  };
+                  break;
+                }
                 turnItem = {
                   ...base,
                   title:
@@ -3322,6 +3403,7 @@ export function makeAcpAdapterV2(
                       }),
                 };
                 break;
+              }
               case "execute": {
                 const exitCode = acpProjectedCommandExitCode(status, rawOutput);
                 turnItem = {
@@ -3345,7 +3427,11 @@ export function makeAcpAdapterV2(
                   ...(diffText === undefined ? {} : { diffStr: diffText }),
                 };
                 break;
-              case "fetch":
+              case "fetch": {
+                // Grok nests the page under rawOutput.Content, which textFromUnknown
+                // cannot read; the (bounded) content blocks carry the same text.
+                const snippet =
+                  textFromUnknown(toolCall.data.content) ?? textFromUnknown(rawOutput);
                 turnItem = {
                   ...base,
                   type: "web_search",
@@ -3356,14 +3442,13 @@ export function makeAcpAdapterV2(
                         results: [
                           {
                             url: path,
-                            ...(textFromUnknown(rawOutput) === undefined
-                              ? {}
-                              : { snippet: textFromUnknown(rawOutput) }),
+                            ...(snippet === undefined ? {} : { snippet }),
                           },
                         ],
                       }),
                 };
                 break;
+              }
               default:
                 if (projectAsCommandExecution) {
                   const exitCode = acpProjectedCommandExitCode(status, rawOutput);
@@ -4257,7 +4342,8 @@ export function makeAcpAdapterV2(
             return;
           }
           if (context.finalized) return;
-          if (notification.sessionId !== (yield* Ref.get(activeSessionId))) {
+          const rootSessionId = yield* Ref.get(activeSessionId);
+          if (notification.sessionId !== rootSessionId) {
             // Finalize may have completed during the activeSessionId yield.
             if (context.finalized) return;
             if (flavor.extractSubagentUpdate === undefined) return;
@@ -4285,6 +4371,17 @@ export function makeAcpAdapterV2(
                 const key = `${nativeTaskId}:tool:${toolCall.toolCallId}`;
                 const merged = mergeToolCallState(context.tools.get(key), toolCall);
                 context.tools.set(key, merged);
+                // Terminals are remembered under the raw session id: the child's
+                // own session, or the root one when the flavor routes child
+                // updates out of it (Devin).
+                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;
@@ -4309,7 +4406,22 @@ export function makeAcpAdapterV2(
                     completedAt: completedAtForStatus(status, now),
                     updatedAt: now,
                     type: "dynamic_tool",
-                    toolName: merged.title ?? merged.kind ?? "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,
                   },
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index b837575c1faf..9bb9ee2dce16 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -126,6 +126,7 @@ function makeClaudeTestTurnInput(input: {
   readonly text: string;
   readonly attachments: ProviderAdapterV2TurnInput["message"]["attachments"];
   readonly providerTurnOrdinal?: number;
+  readonly nativeThreadHasTurns?: boolean;
   readonly messageCreatedBy?: ProviderAdapterV2TurnInput["message"]["createdBy"];
   readonly messageCreationSource?: ProviderAdapterV2TurnInput["message"]["creationSource"];
   readonly modelSelection?: ModelSelection;
@@ -137,6 +138,9 @@ function makeClaudeTestTurnInput(input: {
     runId: RunId.make(`run-${input.attemptId}`),
     runOrdinal: 1,
     providerTurnOrdinal: input.providerTurnOrdinal ?? 1,
+    ...(input.nativeThreadHasTurns === undefined
+      ? {}
+      : { nativeThreadHasTurns: input.nativeThreadHasTurns }),
     attemptId: input.attemptId,
     rootNodeId: NodeId.make(`node-${input.attemptId}`),
     providerThread: input.providerThread,
@@ -867,6 +871,20 @@ describe("ClaudeAdapterV2 context usage", () => {
 });
 
 describe("ClaudeAdapterV2 session permissions", () => {
+  it("keeps explicit user refusals classified as user_reject", () => {
+    const result = ClaudeAdapterV2.permissionResultFromDecision({
+      toolName: "Bash",
+      decision: "decline",
+      toolInput: { command: "make" },
+      toolUseID: "denied-build",
+    });
+    assert.equal(result.behavior, "deny");
+    if (result.behavior !== "deny") return;
+    assert.equal(result.decisionClassification, "user_reject");
+    assert.equal(result.message, "User declined tool execution.");
+    assert.equal(result.interrupt, undefined);
+  });
+
   it("forces suggested permission updates to session scope", () => {
     const result = ClaudeAdapterV2.permissionResultFromDecision({
       toolName: "Bash",
@@ -1783,7 +1801,7 @@ describe("ClaudeAdapterV2 native fork", () => {
 });
 
 describe("ClaudeAdapterV2 native session identity", () => {
-  const openTurnWithOrdinal = (providerTurnOrdinal: number) =>
+  const openTurnWithOrdinal = (providerTurnOrdinal: number, nativeThreadHasTurns?: boolean) =>
     Effect.scoped(
       Effect.gen(function* () {
         const fileSystem = yield* FileSystem.FileSystem;
@@ -1842,6 +1860,7 @@ describe("ClaudeAdapterV2 native session identity", () => {
             text: "Respond with identity ok",
             attachments: [],
             providerTurnOrdinal,
+            ...(nativeThreadHasTurns === undefined ? {} : { nativeThreadHasTurns }),
           }),
         );
         return openedQueries;
@@ -1867,6 +1886,14 @@ describe("ClaudeAdapterV2 native session identity", () => {
         assert.equal(openedQueries[0]?.options.sessionId, undefined);
       }),
   );
+
+  it.effect("creates a fresh native session despite earlier provider-thread turns", () =>
+    Effect.gen(function* () {
+      const openedQueries = yield* openTurnWithOrdinal(4, false);
+      assert.equal(openedQueries[0]?.options.sessionId, "native-session-identity");
+      assert.equal(openedQueries[0]?.options.resume, undefined);
+    }),
+  );
 });
 
 const encodeJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
@@ -2182,6 +2209,173 @@ describe("ClaudeAdapterV2 background wake turns", () => {
     });
   const makeWakeHarness = makeWakeHarnessWithOptions();
 
+  it.effect.each([
+    { isError: false, title: "Check weather" },
+    { isError: true, title: "Check weather" },
+    { isError: false, title: undefined },
+  ])("keeps late MCP display metadata with %j", ({ isError, title }) =>
+    Effect.gen(function* () {
+      const harness = yield* makeWakeHarness;
+      yield* harness.runtime.startTurn(
+        makeClaudeTestTurnInput({
+          threadId: harness.threadId,
+          providerThread: harness.providerThread,
+          now: yield* DateTime.now,
+          attemptId: RunAttemptId.make("mcp-presentation"),
+          text: "Check the weather",
+          attachments: [],
+        }),
+      );
+      const toolName = "mcp__weather__get_weather";
+      const id = "weather-call";
+      yield* Effect.promise(() =>
+        harness.getOpenedOptions()!.canUseTool!(
+          toolName,
+          { city: "Berlin" },
+          {
+            signal: new AbortController().signal,
+            toolUseID: id,
+            requestId: "weather-request",
+          },
+        ),
+      );
+      yield* harness.offerAndWait(
+        claudeSdkFrame({
+          type: "assistant",
+          uuid: "weather-assistant",
+          session_id: WAKE_NATIVE_SESSION,
+          parent_tool_use_id: null,
+          message: {
+            id: "weather-message",
+            type: "message",
+            role: "assistant",
+            model: "claude-sonnet-4-6",
+            content: [{ type: "tool_use", id, name: toolName, input: { city: "Berlin" } }],
+          },
+          tool_use_meta: [
+            {
+              id,
+              display_name: title,
+              server_display_name: "Weather",
+              icon_url: "https://example.com/weather.png",
+            },
+          ],
+        }),
+      );
+      yield* harness.offerAndWait(
+        claudeSdkFrame({
+          type: "user",
+          uuid: "weather-result",
+          session_id: WAKE_NATIVE_SESSION,
+          parent_tool_use_id: null,
+          message: {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: id,
+                content: "Weather result",
+                is_error: isError,
+              },
+            ],
+          },
+        }),
+      );
+      yield* Queue.offer(
+        harness.sdkMessages,
+        makeResultFrame({ uuid: "weather-terminal", result: "Weather checked" }),
+      );
+      yield* Queue.take(harness.terminalReceipts);
+      const items = harness.events.flatMap((event) =>
+        event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool"
+          ? [event.turnItem]
+          : [],
+      );
+      assert.deepEqual(
+        items.map((item) => item.status),
+        ["running", "running", isError ? "failed" : "completed"],
+      );
+      assert.isNull(items[0]?.title);
+      for (const item of items.slice(1)) {
+        assert.equal(item.title, title ?? "get weather");
+        assert.deepEqual(item.toolIcon, {
+          _tag: "themed-logo",
+          logoUrl: "https://example.com/weather.png",
+        });
+        assert.deepEqual(item.toolSource, {
+          key: "mcp:weather",
+          name: "Weather",
+          kind: "integration",
+          icon: { _tag: "themed-logo", logoUrl: "https://example.com/weather.png" },
+        });
+        assert.deepEqual(item.input, { city: "Berlin" });
+      }
+      assert.equal(new Set(items.map((item) => item.id)).size, 1);
+    }).pipe(Effect.scoped, Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
+  );
+
+  it.effect(
+    "reuses a background shell's query for omitted and explicit Normal, but blocks Fast",
+    () =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const harness = yield* makeWakeHarness;
+          const now = yield* DateTime.now;
+          const normal = {
+            instanceId: ClaudeAdapterV2.CLAUDE_DEFAULT_INSTANCE_ID,
+            model: "claude-opus-5-5",
+          } satisfies ModelSelection;
+          const turn = (ordinal: number, modelSelection: ModelSelection) =>
+            makeClaudeTestTurnInput({
+              threadId: harness.threadId,
+              providerThread: harness.providerThread,
+              now,
+              attemptId: RunAttemptId.make(`attempt-normal-background:${ordinal}`),
+              text: `Request ${ordinal}`,
+              attachments: [],
+              providerTurnOrdinal: ordinal,
+              modelSelection,
+            });
+          yield* harness.runtime.startTurn(turn(1, normal));
+          const originalOptions = harness.getOpenedOptions();
+          yield* harness.offerAndWait(wakeTaskStarted);
+          yield* harness.offerAndWait(turnOneResult);
+          yield* Queue.take(harness.terminalReceipts);
+          assert.isTrue(yield* harness.hasPendingBackgroundWork);
+
+          yield* harness.runtime.startTurn(
+            turn(2, {
+              ...normal,
+              options: [{ id: "fastMode", value: false }],
+            }),
+          );
+          assert.strictEqual(harness.getOpenedOptions(), originalOptions);
+          assert.lengthOf(harness.offeredMessages, 2);
+          yield* harness.offerAndWait(turnOneResult);
+          yield* Queue.take(harness.terminalReceipts);
+
+          const refused = yield* harness.runtime
+            .startTurn(
+              turn(3, {
+                ...normal,
+                options: [{ id: "fastMode", value: true }],
+              }),
+            )
+            .pipe(Effect.result);
+          assert.equal(refused._tag, "Failure");
+          if (refused._tag === "Failure") {
+            assert.instanceOf(
+              refused.failure.cause,
+              ClaudeAdapterV2.ClaudeBackgroundWorkBlocksQueryReplacementError,
+            );
+          }
+          assert.strictEqual(harness.getOpenedOptions(), originalOptions);
+          assert.lengthOf(harness.offeredMessages, 2);
+          assert.isTrue(yield* harness.hasPendingBackgroundWork);
+        }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
+      ),
+  );
+
   it.effect.each(["completed", "interrupted"] as const)(
     "projects Claude thinking blocks when %s",
     (status) =>
@@ -2300,6 +2494,77 @@ describe("ClaudeAdapterV2 background wake turns", () => {
       }).pipe(Effect.scoped, Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
   );
 
+  it.effect.each(["cancelled", "denied", "permission_denied", undefined])(
+    "preserves native tool non-execution metadata %s without inferring a denial from text",
+    (kind) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const harness = yield* makeWakeHarness;
+          yield* harness.runtime.startTurn(
+            makeClaudeTestTurnInput({
+              threadId: harness.threadId,
+              providerThread: harness.providerThread,
+              now: yield* DateTime.now,
+              attemptId: RunAttemptId.make("attempt-tool-non-execution"),
+              text: "Run the tool.",
+              attachments: [],
+            }),
+          );
+          // Same error text can describe a cancellation or a real refusal.
+          // Each result must use its own metadata, even in a multi-result frame.
+          yield* harness.offerAndWait(
+            claudeSdkFrame({
+              type: "user",
+              uuid: "tool-non-execution",
+              session_id: WAKE_NATIVE_SESSION,
+              parent_tool_use_id: null,
+              message: {
+                role: "user",
+                content: [
+                  {
+                    type: "tool_result",
+                    tool_use_id: "tool-error",
+                    is_error: true,
+                    content: "STOP and wait for the user.",
+                  },
+                  { type: "tool_result", tool_use_id: "tool-ok", is_error: false, content: "OK" },
+                ],
+              },
+              ...(kind === undefined
+                ? {}
+                : {
+                    tool_result_meta: [
+                      { id: "tool-error", non_execution_kind: kind },
+                      { id: "tool-ok", non_execution_kind: null },
+                    ],
+                  }),
+            }),
+          );
+          yield* Queue.offer(
+            harness.sdkMessages,
+            makeResultFrame({ uuid: "result-non-execution", result: "Done" }),
+          );
+          yield* Queue.take(harness.terminalReceipts);
+          const items = harness.events.flatMap((event) =>
+            event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool"
+              ? [event.turnItem]
+              : [],
+          );
+          const failed = items.findLast((item) => item.nativeItemRef?.nativeId === "tool-error")!;
+          assert.equal(failed.status, kind === "cancelled" ? "cancelled" : "failed");
+          assert.equal(failed.toolNonExecutionKind, kind);
+          const ok = items.findLast((item) => item.nativeItemRef?.nativeId === "tool-ok")!;
+          assert.equal(ok.status, "completed");
+          assert.equal(ok.toolNonExecutionKind, undefined);
+          const node = harness.events.findLast(
+            (event) =>
+              event.type === "node.updated" && event.node.nativeItemRef?.nativeId === "tool-error",
+          );
+          assert.equal(node?.type === "node.updated" ? node.node.status : undefined, failed.status);
+        }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
+      ),
+  );
+
   it.effect.each(
     (["aborted_tools", "aborted_streaming"] as const).flatMap((terminalReason) =>
       [true, false].map((steered) => ({ terminalReason, steered })),
@@ -4325,6 +4590,89 @@ describe("ClaudeAdapterV2 background wake turns", () => {
       ),
   );
 
+  it.effect("stores a Bash result's stdout and stderr as command output", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeWakeHarness;
+        const now = yield* DateTime.now;
+        const attemptId = RunAttemptId.make("attempt-claude-bash-output");
+        const bashToolUseId = "toolu_01BashOutput";
+
+        yield* harness.runtime.startTurn(
+          makeClaudeTestTurnInput({
+            threadId: harness.threadId,
+            providerThread: harness.providerThread,
+            now,
+            attemptId,
+            text: "Run it.",
+            attachments: [],
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          claudeSdkFrame({
+            type: "assistant",
+            message: {
+              model: "claude-sonnet-4-6",
+              id: "msg_bash_output",
+              type: "message",
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_use",
+                  id: bashToolUseId,
+                  name: "Bash",
+                  input: { command: "git status" },
+                },
+              ],
+            },
+            parent_tool_use_id: null,
+            uuid: "00000000-0000-4000-8000-000000000790",
+            session_id: WAKE_NATIVE_SESSION,
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          claudeSdkFrame({
+            type: "user",
+            message: {
+              role: "user",
+              content: [
+                { type: "tool_result", tool_use_id: bashToolUseId, content: "On branch main" },
+              ],
+            },
+            parent_tool_use_id: null,
+            uuid: "00000000-0000-4000-8000-000000000791",
+            session_id: WAKE_NATIVE_SESSION,
+            tool_use_result: {
+              stdout: "On branch main",
+              stderr: "warning: dirty",
+              interrupted: false,
+              isImage: false,
+            },
+          }),
+        );
+        yield* Queue.offer(
+          harness.sdkMessages,
+          makeResultFrame({ uuid: "00000000-0000-4000-8000-000000000792", result: "Done." }),
+        );
+        yield* awaitUntil(() => harness.terminalEvents().length === 1, "turn terminal");
+
+        const bash = harness.events.findLast(
+          (event) =>
+            event.type === "turn_item.updated" &&
+            event.turnItem.nativeItemRef?.nativeId === bashToolUseId,
+        );
+        assert.equal(
+          bash?.type === "turn_item.updated" && bash.turnItem.type === "command_execution"
+            ? bash.turnItem.output
+            : undefined,
+          "On branch main\nwarning: dirty",
+        );
+      }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
+    ),
+  );
+
   it.effect("answers an approval a held wake turn raises without waiting for the echo", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index 0aca36abe77c..a9e3b8cfff0a 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -67,7 +67,6 @@ import {
   type ProviderUserInputAnswers,
   type ProviderThreadId,
   type ThreadId,
-  type ToolActivitySource,
 } from "@t3tools/contracts";
 
 import * as Cause from "effect/Cause";
@@ -116,6 +115,7 @@ import type { ServerProviderShape } from "../../provider/Services/ServerProvider
 import { mergeProviderInstanceEnvironment } from "../../provider/ProviderInstanceEnvironment.ts";
 import { T3_CODE_ORCHESTRATION_INSTRUCTIONS } from "../../provider/T3OrchestrationInstructions.ts";
 import { buildRuntimeInstructions } from "../../provider/RuntimeInstructions.ts";
+import { mcpToolPresentation, normalizeMcpText } from "../../provider/McpToolPresentation.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import * as IdAllocator from "../IdAllocator.ts";
 import { makeProviderFailure, makeProviderRetryTurnItem } from "../ProviderFailure.ts";
@@ -198,6 +198,7 @@ export const ClaudeProviderCapabilitiesV2 = {
     emitsTurnCompleted: true,
     supportsInterrupt: true,
     supportsActiveSteering: true,
+    activeSteeringInterruptsTools: true,
     supportsSteeringByInterruptRestart: false,
     supportsQueuedMessages: true,
     terminalStatusQuality: "strong",
@@ -1864,6 +1865,28 @@ function claudeNativeToolOutputText(output: ClaudeNativeToolOutput): string {
   return typeof value === "string" ? value : value === undefined ? "" : jsonStringifyForTool(value);
 }
 
+/**
+ * Bash results arrive as `{ stdout, stderr, interrupted, ... }`; keep only the
+ * text. A background run has empty streams, so keep its acknowledgement instead.
+ */
+function claudeCommandOutputText(output: ClaudeNativeToolOutput): string {
+  const value = claudeNativeToolOutputValue(output);
+  if (typeof value === "object" && value !== null) {
+    const stdout = Reflect.get(value, "stdout");
+    const stderr = Reflect.get(value, "stderr");
+    if (typeof stdout === "string" || typeof stderr === "string") {
+      const text = [stdout, stderr]
+        .filter((part): part is string => typeof part === "string" && part.trim().length > 0)
+        .join("\n");
+      if (text.length > 0) return text;
+      return output.type === "structured_tool_use_result" && output.fallbackValue !== undefined
+        ? claudeSubagentResultText({ type: "content_block", value: output.fallbackValue })
+        : "";
+    }
+  }
+  return claudeNativeToolOutputText(output);
+}
+
 function claudeSubagentResultText(output: ClaudeNativeToolOutput): string {
   const value = claudeNativeToolOutputValue(output);
   const content = Array.isArray(value)
@@ -1904,6 +1927,8 @@ function isClaudeSubagentAsyncLaunchAck(output: ClaudeNativeToolOutput): boolean
   return claudeSubagentResultText(output).startsWith("Async agent launched successfully.");
 }
 
+const WEB_FETCH_SNIPPET_MAX_CHARS = 8_000;
+
 function webSearchPatternsFromClaudeTool(input: {
   readonly toolInput: ClaudeNativeToolInput;
   readonly output: ClaudeNativeToolOutput;
@@ -2065,62 +2090,33 @@ function claudeToolUseBlocksFromAssistantMessage(
   return message.message.content.filter(isClaudeToolUseContentBlock);
 }
 
-interface ClaudeToolPresentation {
-  readonly title: string;
-  readonly toolSource?: ToolActivitySource;
-}
-
-function boundedMetaText(value: unknown, maxLength: number): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const text = value.trim().replace(/\s+/gu, " ");
-  return text.length > 0 && text.length <= maxLength ? text : undefined;
-}
-
-function metaHttpUrl(value: unknown): string | undefined {
-  if (typeof value !== "string" || value.length > 4096) return undefined;
-  try {
-    const url = new URL(value);
-    return (url.protocol === "https:" || url.protocol === "http:") && url.href.length <= 4096
-      ? url.href
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
+type ClaudeToolPresentation = ReturnType<typeof mcpToolPresentation>;
 
-/**
- * Claude Code's own label for each tool use (the MCP tool's title, or its
- * humanized name) plus the server's name and icon. The CLI sends these as
- * `tool_use_meta` on assistant frames; the SDK types do not declare it yet.
- */
 function claudeToolPresentationsFromAssistantMessage(
   message: SDKMessage,
 ): ReadonlyMap<string, ClaudeToolPresentation> {
   const presentations = new Map<string, ClaudeToolPresentation>();
   const meta = message.type === "assistant" ? Reflect.get(message, "tool_use_meta") : undefined;
   if (!Array.isArray(meta)) return presentations;
+  const toolNames = new Map(
+    claudeToolUseBlocksFromAssistantMessage(message).map((tool) => [
+      tool.id,
+      tool.name.replace(/^mcp__claude_ai_/u, "mcp__"),
+    ]),
+  );
   for (const entry of meta) {
     if (typeof entry !== "object" || entry === null) continue;
-    const id = boundedMetaText(Reflect.get(entry, "id"), 512);
-    const title = boundedMetaText(Reflect.get(entry, "display_name"), 160);
-    if (id === undefined || title === undefined) continue;
-    const serverName = boundedMetaText(Reflect.get(entry, "server_display_name"), 160);
-    const iconUrl = metaHttpUrl(Reflect.get(entry, "icon_url"));
-    presentations.set(id, {
-      title,
-      ...(serverName === undefined
-        ? {}
-        : {
-            toolSource: {
-              key: `mcp:${serverName.toLowerCase()}`,
-              name: serverName,
-              kind: "integration",
-              ...(iconUrl === undefined
-                ? {}
-                : { icon: { _tag: "themed-logo", logoUrl: iconUrl } as const }),
-            },
-          }),
-    });
+    const id = normalizeMcpText(Reflect.get(entry, "id"), 512);
+    if (id === undefined) continue;
+    presentations.set(
+      id,
+      mcpToolPresentation({
+        toolName: toolNames.get(id),
+        title: Reflect.get(entry, "display_name"),
+        serverDisplayName: Reflect.get(entry, "server_display_name"),
+        iconUrl: Reflect.get(entry, "icon_url"),
+      }),
+    );
   }
   return presentations;
 }
@@ -2168,6 +2164,24 @@ function claudeToolResultEntriesFromMessage(message: SDKMessage): ReadonlyArray<
   ];
 }
 
+// These wire fields are not yet declared by the SDK's SDKUserMessage type.
+const ClaudeToolResultMetadata = Schema.Struct({
+  tool_result_meta: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      non_execution_kind: Schema.optional(Schema.NullOr(Schema.String)),
+    }),
+  ),
+});
+const isClaudeToolResultMetadata = Schema.is(ClaudeToolResultMetadata);
+
+function claudeToolNonExecutionKind(message: SDKMessage, toolUseId: string) {
+  return isClaudeToolResultMetadata(message)
+    ? (message.tool_result_meta.find((meta) => meta.id === toolUseId)?.non_execution_kind ??
+        undefined)
+    : undefined;
+}
+
 function parentToolUseIdFromSdkMessage(message: SDKMessage): string | null {
   return message.type === "assistant" || message.type === "user"
     ? message.parent_tool_use_id
@@ -3710,6 +3724,7 @@ export function makeClaudeAdapterV2(
           readonly startedAt: DateTime.Utc;
           readonly updatedAt: DateTime.Utc;
           readonly presentation: ClaudeToolPresentation | undefined;
+          readonly toolNonExecutionKind?: string;
         }) => {
           const completedAt = input.status === "running" ? null : input.updatedAt;
           const nodeId = idAllocator.derive.nodeFromProviderItem({
@@ -3757,6 +3772,9 @@ export function makeClaudeAdapterV2(
               })
             : undefined;
           const itemBase = {
+            ...(input.toolNonExecutionKind === undefined
+              ? {}
+              : { toolNonExecutionKind: input.toolNonExecutionKind }),
             id: turnItemId,
             threadId: input.threadId,
             runId: input.runId,
@@ -3807,8 +3825,12 @@ export function makeClaudeAdapterV2(
             output: input.output,
           });
           const webSearchResults = webSearchResultsFromClaudeOutput(input.output);
+          const webFetchUrl = firstStringInputField(input.toolInput, ["url"])?.trim();
           const outputValue = claudeNativeToolOutputValue(input.output);
-          const outputText = claudeNativeToolOutputText(input.output);
+          const outputText =
+            itemType === "command_execution"
+              ? claudeCommandOutputText(input.output)
+              : claudeNativeToolOutputText(input.output);
           const turnItem: OrchestrationV2TurnItem =
             itemType === "command_execution"
               ? {
@@ -3831,11 +3853,28 @@ export function makeClaudeAdapterV2(
                       ...(webSearchPatterns.length === 0
                         ? {}
                         : { patterns: [...webSearchPatterns] }),
-                      ...(webSearchResults.length === 0 ? {} : { results: [...webSearchResults] }),
+                      ...(webSearchResults.length > 0
+                        ? { results: [...webSearchResults] }
+                        : input.classification.normalizedName === "webfetch" &&
+                            outputText.trim().length > 0
+                          ? {
+                              // WebFetch returns page text, not search hits. Keep a
+                              // bounded preview so the row has something to show.
+                              results: [
+                                {
+                                  ...(webFetchUrl === undefined ? {} : { url: webFetchUrl }),
+                                  snippet: outputText.slice(0, WEB_FETCH_SNIPPET_MAX_CHARS),
+                                },
+                              ],
+                            }
+                          : {}),
                     }
                   : {
                       ...itemBase,
                       type: "dynamic_tool",
+                      ...(input.presentation?.toolIcon === undefined
+                        ? {}
+                        : { toolIcon: input.presentation.toolIcon }),
                       ...(input.presentation?.toolSource === undefined
                         ? {}
                         : { toolSource: input.presentation.toolSource }),
@@ -6011,7 +6050,11 @@ export function makeClaudeAdapterV2(
               toolName: toolUse.name,
               toolInput: nativeToolInput,
               parentToolUseId: parentToolUseIdFromSdkMessage(message),
-              presentation: toolPresentations.get(toolUse.id),
+              presentation:
+                toolPresentations.get(toolUse.id) ??
+                mcpToolPresentation({
+                  toolName: toolUse.name.replace(/^mcp__claude_ai_/u, "mcp__"),
+                }),
             });
             const heldPlan = heldProposedPlansByToolUseId.get(toolUse.id);
             if (heldPlan !== undefined) {
@@ -6060,6 +6103,10 @@ export function makeClaudeAdapterV2(
                 parentToolUseId,
               }));
             const completedAt = yield* DateTime.now;
+            const toolNonExecutionKind = claudeToolNonExecutionKind(
+              message,
+              toolResult.tool_use_id,
+            );
             const artifacts = buildToolCallArtifacts({
               context,
               nativeItemId: toolCall.nativeItemId,
@@ -6072,7 +6119,13 @@ export function makeClaudeAdapterV2(
               parentNodeId: toolCall.parentNodeId,
               ordinal: toolCall.ordinal,
               output,
-              status: isClaudeToolResultError(toolResult) ? "failed" : "completed",
+              status:
+                toolNonExecutionKind === "cancelled"
+                  ? "cancelled"
+                  : isClaudeToolResultError(toolResult)
+                    ? "failed"
+                    : "completed",
+              ...(toolNonExecutionKind === undefined ? {} : { toolNonExecutionKind }),
               startedAt: toolCall.startedAt,
               updatedAt: completedAt,
               presentation: toolCall.presentation,
@@ -6927,11 +6980,12 @@ export function makeClaudeAdapterV2(
 
           const openedWithResume = (yield* Ref.get(openedNativeThreads)).has(nativeThreadId);
           // openedNativeThreads is per session instance and is lost when the
-          // provider session is idle-released. A prior persisted provider turn
-          // proves the native session already exists, so the query must resume
-          // it; reopening with a fixed session id makes the CLI fail fast with
-          // "Session ID ... is already in use".
-          const hasPersistedProviderTurn = turnInput.providerTurnOrdinal > 1;
+          // provider session is idle-released. A prior turn on this native id
+          // requires resume; sessionId would fail with "already in use".
+          // A fresh-session fallback keeps provider-thread history but binds
+          // a new native id, which must be created before it can be resumed.
+          const hasPersistedProviderTurn =
+            turnInput.nativeThreadHasTurns ?? turnInput.providerTurnOrdinal > 1;
           const shouldResume =
             resumeSessionAt !== undefined || openedWithResume || hasPersistedProviderTurn;
           const queryOptions = makeClaudeQueryOptions({
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
index 85748fa056e7..f8b635a9fa9c 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
@@ -823,14 +823,62 @@ describe("CodexAdapterV2 dynamic tool projection", () => {
     );
     assert.equal(
       CodexAdapterV2.projectCodexDynamicToolItem({ ...call, arguments: { title: "  " } }).title,
-      undefined,
+      "js",
     );
     assert.equal(
       CodexAdapterV2.projectCodexDynamicToolItem({ ...call, server: "github" }).title,
-      undefined,
+      "js",
     );
   });
 
+  it.each(["inProgress", "completed", "failed"] as const)(
+    "presents ordinary MCP calls when %s",
+    (status) => {
+      const projection = CodexAdapterV2.projectCodexDynamicToolItem({
+        type: "mcpToolCall",
+        id: "weather-call",
+        server: "weather",
+        tool: "get_weather",
+        status,
+        arguments: { city: "Berlin" },
+      });
+      assert.equal(projection.title, "get weather");
+      assert.deepEqual(projection.toolSource, {
+        key: "mcp:weather",
+        name: "weather",
+        kind: "integration",
+      });
+      assert.deepEqual(projection.input, { city: "Berlin" });
+    },
+  );
+
+  it("uses Codex connector names without reading a display title from arguments", () => {
+    const projection = CodexAdapterV2.projectCodexDynamicToolItem({
+      type: "mcpToolCall",
+      id: "connector-call",
+      server: "_apps",
+      tool: "connector_get_weather",
+      status: "completed",
+      arguments: { title: "Argument, not display metadata" },
+      appContext: {
+        connectorId: "weather-app",
+        appName: "Weather",
+        actionName: "Check weather",
+      },
+      result: {
+        content: [],
+        _meta: { source: { logoUrl: "https://example.com/weather.png" } },
+      },
+    });
+    assert.equal(projection.title, "Check weather");
+    assert.equal(projection.toolSource?.name, "Weather");
+    assert.deepEqual(projection.toolIcon, {
+      _tag: "themed-logo",
+      logoUrl: "https://example.com/weather.png",
+    });
+    assert.deepEqual(projection.toolSource?.icon, projection.toolIcon);
+  });
+
   it("preserves native browser and app icons alongside MCP tool output", () => {
     const browser = CodexAdapterV2.projectCodexDynamicToolItem({
       type: "mcpToolCall",
@@ -3869,7 +3917,9 @@ describe("CodexAdapterV2 post-settle continuation", () => {
       ),
   );
 
-  const backgroundStopCases = [true, false, "still_running"] as const;
+  // "thread_unloaded": the thread was settled, so T3 unsubscribed and Codex
+  // unloaded it (killing its terminals) before Stop arrived.
+  const backgroundStopCases = [true, false, "still_running", "thread_unloaded"] as const;
   const makeBackgroundStopTranscript = (terminated: (typeof backgroundStopCases)[number]) => {
     const stillRunning = terminated === "still_running";
     return makeCodexReplayTranscript({
@@ -3888,9 +3938,15 @@ describe("CodexAdapterV2 post-settle continuation", () => {
         {
           type: "emit_inbound",
           label: "terminate-background-command",
-          frame: { id: 4, result: { terminated: terminated === true } },
+          frame:
+            terminated === "thread_unloaded"
+              ? {
+                  id: 4,
+                  error: { code: -32600, message: `thread not found: ${BG_NATIVE_THREAD}` },
+                }
+              : { id: 4, result: { terminated: terminated === true } },
         },
-        ...(terminated !== true
+        ...(terminated === false || stillRunning
           ? [
               {
                 type: "expect_outbound" as const,
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
index 3727b419fe1d..019919807908 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
@@ -489,9 +489,10 @@ export function projectCodexDynamicToolItem(
     item.type === "mcpToolCall"
       ? `${item.server}.${item.tool}`
       : [trimText(item.namespace), item.tool].filter(Boolean).join(".");
-  const title = dynamicToolTitle(toolName, item.arguments);
+  const presentation = item.type === "mcpToolCall" ? mcpToolPresentation(item) : {};
+  const title = dynamicToolTitle(toolName, item.arguments) ?? presentation.title;
   const projection: CodexDynamicToolProjection = {
-    ...(item.type === "mcpToolCall" ? mcpToolPresentation(item) : {}),
+    ...presentation,
     toolName,
     ...(title ? { title } : {}),
     input: item.arguments,
@@ -2053,6 +2054,13 @@ export function makeCodexAdapterV2(adapterOptions: CodexAdapterV2Options): Provi
                 Effect.catchTags({
                   CodexAppServerProcessExitedError: () => Effect.succeed({ terminated: true }),
                   CodexAppServerInputStreamEndedError: () => Effect.succeed({ terminated: true }),
+                  // The thread is unloaded, as Codex does a minute after a
+                  // settle or archive unsubscribes it. Unloading kills the
+                  // thread's terminals, so nothing is left to stop.
+                  CodexAppServerRequestError: (error) =>
+                    error.code === -32600 && error.errorMessage.startsWith("thread not found:")
+                      ? Effect.succeed({ terminated: true })
+                      : Effect.fail(error),
                 }),
               );
             const result = yield* decodeCodexBackgroundTerminalTerminateResponse(response);
diff --git a/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.test.ts
index 3a172baa67c8..60ece7a42f3a 100644
--- a/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.test.ts
@@ -359,6 +359,22 @@ describe("CursorAdapterV2", () => {
         numFiles: 0,
       };
       const updates: ReadonlyArray<InteractionUpdate> = [
+        ...(["tool-call-started", "tool-call-completed"] as const).map((type) => ({
+          type,
+          modelCallId: "native-model-call",
+          callId: "mcp-weather",
+          toolCall: {
+            type: "mcp" as const,
+            args: {
+              providerIdentifier: "weather",
+              toolName: "get_weather",
+              args: { city: "Berlin" },
+            },
+            ...(type === "tool-call-completed"
+              ? { result: { status: "success" as const, value: { content: [], isError: false } } }
+              : {}),
+          },
+        })),
         {
           type: "tool-call-completed",
           modelCallId: "native-model-call",
@@ -430,6 +446,26 @@ describe("CursorAdapterV2", () => {
             result: { status: "error", error: "ENOENT" },
           },
         },
+        {
+          type: "tool-call-completed",
+          modelCallId: "native-model-call",
+          callId: "grep-failed",
+          toolCall: {
+            type: "grep",
+            args: { pattern: "TODO", path: "src" },
+            result: { status: "error", error: "search failed" },
+          },
+        },
+        {
+          type: "tool-call-completed",
+          modelCallId: "native-model-call",
+          callId: "glob-failed",
+          toolCall: {
+            type: "glob",
+            args: { globPattern: "*.ts" },
+            result: { status: "error", error: "search failed" },
+          },
+        },
         {
           type: "tool-call-completed",
           modelCallId: "native-model-call",
@@ -605,6 +641,30 @@ describe("CursorAdapterV2", () => {
         Stream.takeUntil((event) => event.type === "turn.terminal"),
         Stream.runCollect,
       );
+      const mcpItems = events.flatMap((event) =>
+        event.type === "turn_item.updated" &&
+        event.turnItem.type === "dynamic_tool" &&
+        event.turnItem.toolName === "mcp__weather__get_weather"
+          ? [event.turnItem]
+          : [],
+      );
+      assert.deepEqual(
+        mcpItems.map((item) => item.status),
+        ["running", "completed"],
+      );
+      for (const item of mcpItems) {
+        assert.equal(item.title, "get weather");
+        assert.deepEqual(item.toolSource, {
+          key: "mcp:weather",
+          name: "weather",
+          kind: "integration",
+        });
+        assert.deepEqual(item.input, {
+          providerIdentifier: "weather",
+          toolName: "get_weather",
+          args: { city: "Berlin" },
+        });
+      }
       const fileSearchItems = events.flatMap((event) =>
         event.type === "turn_item.updated" &&
         event.turnItem.type === "file_search" &&
@@ -648,7 +708,17 @@ describe("CursorAdapterV2", () => {
           {
             pattern: path.join(workspace, "missing"),
             status: "failed",
-            results: undefined,
+            results: [{ fileName: path.join(workspace, "missing"), preview: "ENOENT" }],
+          },
+          {
+            pattern: "TODO",
+            status: "failed",
+            results: [{ fileName: "src", preview: "search failed" }],
+          },
+          {
+            pattern: "*.ts",
+            status: "failed",
+            results: [{ fileName: ".", preview: "search failed" }],
           },
           {
             pattern: "src/a.ts, src/b.ts",
@@ -667,7 +737,7 @@ describe("CursorAdapterV2", () => {
           {
             pattern: "src/a.ts",
             status: "failed",
-            results: undefined,
+            results: [{ fileName: "src/a.ts", preview: "lint failed" }],
           },
         ],
       );
diff --git a/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.ts
index bb9de20da64f..948d74762492 100644
--- a/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CursorAdapterV2.ts
@@ -44,6 +44,7 @@ import * as Stream from "effect/Stream";
 
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import * as ServerConfig from "../../config.ts";
+import { mcpToolPresentation } from "../../provider/McpToolPresentation.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import { CursorTransportFailure } from "../../provider/acp/CursorTransportFailure.ts";
 import { cursorSdkModelSelection } from "../../provider/cursorSdkModel.ts";
@@ -1227,7 +1228,10 @@ export function makeCursorAdapterV2(
                 toolCall.result?.status === "success" &&
                 toolCall.result.value.diffString !== undefined
                   ? { diffStr: toolCall.result.value.diffString }
-                  : {}),
+                  : // A failed change keeps its error where the diff would be.
+                    toolCall.result?.status === "error" && outputText.trim().length > 0
+                    ? { diffStr: outputText }
+                    : {}),
                 ...(toolCall.type === "write" ? { newStr: toolCall.args.fileText } : {}),
               };
               break;
@@ -1248,8 +1252,20 @@ export function makeCursorAdapterV2(
             case "ls":
             case "readLints":
             case "semSearch": {
-              const results = cursorToolSearchResults(toolCall, path);
               const pattern = cursorToolSearchPattern(toolCall);
+              const searchPath =
+                toolCall.type === "grep"
+                  ? toolCall.args.path
+                  : toolCall.type === "glob"
+                    ? toolCall.args.targetDirectory
+                    : toolCall.type === "semSearch"
+                      ? toolCall.args.targetDirectories?.join(", ")
+                      : pattern;
+              // A failed search keeps its error as one row under the searched path.
+              const results =
+                toolCall.result?.status === "error" && outputText.trim().length > 0
+                  ? [{ fileName: searchPath?.trim() || ".", preview: outputText }]
+                  : cursorToolSearchResults(toolCall, path);
               turnItem = {
                 ...base,
                 title:
@@ -1267,6 +1283,12 @@ export function makeCursorAdapterV2(
               turnItem = {
                 ...base,
                 type: "dynamic_tool",
+                ...(toolCall.type === "mcp"
+                  ? mcpToolPresentation({
+                      serverName: toolCall.args.providerIdentifier,
+                      toolName: toolCall.args.toolName,
+                    })
+                  : {}),
                 toolName: cursorToolName(toolCall),
                 input: toolCall.args,
                 ...(cursorToolOutput(toolCall) === undefined
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.ts
index d1e81eb725c4..bcc9bcc646bb 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.ts
@@ -78,6 +78,7 @@ import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import { buildRuntimeInstructions } from "../../provider/RuntimeInstructions.ts";
 import { t3OrchestrationSystemPrompt } from "../../provider/T3OrchestrationInstructions.ts";
 import { SKILL_MENTION_PATTERN } from "@t3tools/shared/composerInlineTokens";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import { getModelSelectionStringOptionValue, modelSelectionsEqual } from "@t3tools/shared/model";
 import { causeErrorTag } from "@t3tools/shared/observability";
 
@@ -887,18 +888,13 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
     const stagedReverts = new Set<string>();
     // Starting a turn and cutting the history take turns on a session: each
     // checks that the other is not running before its own requests yield.
-    const sessionGates = new Map<string, Semaphore.Semaphore>();
+    const sessionGates = yield* KeyedLock.make<string>();
     const exclusive =
       (providerThread: OrchestrationV2ProviderThread) =>
       <A, E, R>(effect: Effect.Effect<A, E, R>) => {
         const sessionId = providerThread.nativeThreadRef?.nativeId;
         if (sessionId == null) return effect;
-        let gate = sessionGates.get(sessionId);
-        if (gate === undefined) {
-          gate = Semaphore.makeUnsafe(1);
-          sessionGates.set(sessionId, gate);
-        }
-        return gate.withPermit(effect);
+        return sessionGates.withLock(sessionId, effect);
       };
     const emit = (event: ProviderAdapter.ProviderAdapterV2Event) =>
       Queue.offer(events, event).pipe(Effect.asVoid);
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts
index eca4aa9115a4..5ae9368a784e 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts
@@ -833,10 +833,12 @@ describe("OpenCodeAdapterV2", () => {
         Stream.runCollect,
         Effect.forkScoped,
       );
-      for (const [tool, input] of [
-        ["read", { filePath: "src/env.ts" }],
-        ["grep", { pattern: "TODO", path: "apps/web" }],
-        ["websearch", { query: "OpenCode documentation" }],
+      for (const [tool, input, output] of [
+        ["read", { filePath: "src/env.ts" }, "---\nfile body"],
+        ["grep", { pattern: "TODO", path: "apps/web" }, "---\nfile body"],
+        ["websearch", { query: "OpenCode documentation" }, "---\nfile body"],
+        ["glob", { pattern: "missing", path: "apps/web" }, ""],
+        ["codesearch", {}, " \n\t"],
       ] as const) {
         yield* Effect.promise(() =>
           nativeEvents.push({
@@ -853,7 +855,7 @@ describe("OpenCodeAdapterV2", () => {
                 state: {
                   status: "completed",
                   input,
-                  output: "---\nfile body",
+                  output,
                   title: tool,
                   metadata: {},
                   time: { start: 1, end: 2 },
@@ -877,10 +879,270 @@ describe("OpenCodeAdapterV2", () => {
       const grep = items.find((item) => item.type === "file_search");
       assert.equal(grep?.title, "Searched TODO in web");
       assert.equal(grep?.type === "file_search" ? grep.pattern : null, "TODO");
+      assert.deepEqual(grep?.type === "file_search" ? grep.results : null, [
+        { fileName: "apps/web", preview: "---\nfile body" },
+      ]);
       const webSearch = items.find((item) => item.type === "web_search");
       assert.deepEqual(webSearch?.type === "web_search" ? webSearch.patterns : null, [
         "OpenCode documentation",
       ]);
+      assert.deepEqual(webSearch?.type === "web_search" ? webSearch.results : null, [
+        { snippet: "---\nfile body" },
+      ]);
+      const emptyFileSearch = items.find(
+        (item) => item.type === "file_search" && item.pattern === "missing",
+      );
+      assert.ok(emptyFileSearch?.type === "file_search");
+      assert.equal(emptyFileSearch.results, undefined);
+      const emptyWebSearch = items.find(
+        (item) => item.type === "web_search" && item.patterns === undefined,
+      );
+      assert.ok(emptyWebSearch?.type === "web_search");
+      assert.equal(emptyWebSearch.results, undefined);
+    }).pipe(Effect.provide(IdAllocator.layer), Effect.scoped),
+  );
+
+  it.effect("presents OpenCode MCP calls without treating remote tools as local edits", () =>
+    Effect.gen(function* () {
+      const nativeEvents = asyncEventStream();
+      const nativeSessionId = "native-opencode-mcp";
+      let statusReads = 0;
+      const harness = yield* makeOpenCodeRuntimeHarness("mcp-presentation", nativeSessionId, {
+        event: {
+          subscribe: async (_input: unknown, options: { signal?: AbortSignal }) => {
+            options.signal?.addEventListener("abort", () => nativeEvents.close(), { once: true });
+            return { stream: nativeEvents.stream };
+          },
+        },
+        session: {
+          create: async () => ({ data: { id: nativeSessionId, time: { created: 1, updated: 1 } } }),
+          promptAsync: async () => ({ data: true }),
+        },
+        mcp: {
+          status: async () => {
+            statusReads++;
+            return {
+              data: {
+                "my.server_with_underscores": { status: "connected" },
+                ambiguous: { status: "connected" },
+                ambiguous_server: { status: "connected" },
+                code: { status: "connected" },
+                apply: { status: "connected" },
+              },
+            };
+          },
+        },
+      });
+      yield* harness.startTurn();
+      const received = yield* harness.runtime.events.pipe(
+        Stream.takeUntil(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "compaction",
+        ),
+        Stream.runCollect,
+        Effect.forkScoped,
+      );
+      for (const status of ["running", "completed", "error"] as const) {
+        yield* Effect.promise(() =>
+          nativeEvents.push({
+            type: "message.part.updated",
+            properties: {
+              sessionID: nativeSessionId,
+              part: {
+                id: "mcp-part",
+                sessionID: nativeSessionId,
+                messageID: "mcp-assistant",
+                type: "tool",
+                callID: "mcp-call",
+                tool: "my_server_with_underscores_edit_document",
+                state: {
+                  status,
+                  input: { document: "remote-doc" },
+                  title: "Edit remote document",
+                  metadata: {},
+                  output: "saved",
+                  error: "failed",
+                  time: { start: 1, end: 2 },
+                },
+              },
+            },
+          }),
+        );
+      }
+      yield* Effect.promise(() =>
+        nativeEvents.push({
+          type: "message.part.updated",
+          properties: {
+            sessionID: nativeSessionId,
+            part: {
+              id: "ambiguous-part",
+              sessionID: nativeSessionId,
+              messageID: "mcp-assistant",
+              type: "tool",
+              callID: "ambiguous-call",
+              tool: "ambiguous_server_edit_document",
+              state: {
+                status: "completed",
+                input: {},
+                title: "Ambiguous tool",
+                metadata: {},
+                output: "",
+                time: { start: 1, end: 2 },
+              },
+            },
+          },
+        }),
+      );
+      for (const tool of ["code_search", "apply_patch"]) {
+        yield* Effect.promise(() =>
+          nativeEvents.push({
+            type: "message.part.updated",
+            properties: {
+              sessionID: nativeSessionId,
+              part: {
+                id: `native-${tool}`,
+                sessionID: nativeSessionId,
+                messageID: "mcp-assistant",
+                type: "tool",
+                callID: `native-${tool}`,
+                tool,
+                state: {
+                  status: "completed",
+                  input: { query: "needle", filePath: "local.ts" },
+                  title: `Native ${tool}`,
+                  metadata: {},
+                  output: "done",
+                  time: { start: 1, end: 2 },
+                },
+              },
+            },
+          }),
+        );
+      }
+      yield* Effect.promise(() =>
+        nativeEvents.push({
+          type: "session.compacted",
+          properties: { sessionID: nativeSessionId },
+        }),
+      );
+      const allItems = (yield* Fiber.join(received)).flatMap((event) =>
+        event.type === "turn_item.updated" ? [event.turnItem] : [],
+      );
+      assert.equal(
+        allItems.find((item) => item.title === "Native code_search")?.type,
+        "web_search",
+      );
+      assert.equal(
+        allItems.find((item) => item.title === "Native apply_patch")?.type,
+        "file_change",
+      );
+      const items = allItems.filter((item) => item.type === "dynamic_tool");
+      assert.deepEqual(
+        items.slice(0, 3).map((item) => item.status),
+        ["running", "completed", "failed"],
+      );
+      assert.deepEqual(
+        items.slice(0, 3).map((item) => item.title),
+        ["Edit remote document", "Edit remote document", "edit document"],
+      );
+      for (const item of items.slice(0, 3)) {
+        assert.deepEqual(item.toolSource, {
+          key: "mcp:my.server_with_underscores",
+          name: "my.server with underscores",
+          kind: "integration",
+        });
+        assert.deepEqual(item.input, { document: "remote-doc" });
+      }
+      assert.equal(items[3]?.toolName, "ambiguous_server_edit_document");
+      assert.isUndefined(items[3]?.toolSource);
+      assert.equal(statusReads, 1);
+    }).pipe(Effect.provide(IdAllocator.layer), Effect.scoped),
+  );
+
+  it.effect.each(["failure", "timeout"] as const)("retries MCP status after %s", (failure) =>
+    Effect.gen(function* () {
+      const nativeEvents = asyncEventStream();
+      const called = promiseGate<void>();
+      const sessionId = `mcp-status-${failure}`;
+      let statusReads = 0;
+      let signal: AbortSignal | undefined;
+      const harness = yield* makeOpenCodeRuntimeHarness(sessionId, sessionId, {
+        event: { subscribe: async () => ({ stream: nativeEvents.stream }) },
+        session: {
+          create: async () => ({ data: { id: sessionId, time: { created: 1, updated: 1 } } }),
+          promptAsync: async () => ({ data: true }),
+        },
+        mcp: {
+          status: async (_input: unknown, options: { signal?: AbortSignal }) => {
+            statusReads++;
+            if (statusReads === 1) {
+              signal = options?.signal;
+              called.resolve();
+              if (failure === "timeout") return new Promise(() => {});
+              throw new Error("MCP status unavailable");
+            }
+            return { data: { weather: { status: "connected" } } };
+          },
+        },
+      });
+      yield* harness.startTurn();
+      const received = yield* harness.runtime.events.pipe(
+        Stream.takeUntil(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "compaction",
+        ),
+        Stream.runCollect,
+        Effect.forkScoped,
+      );
+      for (const status of ["running", "completed"] as const) {
+        const emitted = yield* Effect.promise(() =>
+          nativeEvents.push({
+            type: "message.part.updated",
+            properties: {
+              sessionID: sessionId,
+              part: {
+                id: "weather-part",
+                sessionID: sessionId,
+                messageID: "weather-message",
+                type: "tool",
+                callID: "weather-call",
+                tool: "weather_edit_document",
+                state: {
+                  status,
+                  input: { document: "remote-doc" },
+                  title: "Edit remote document",
+                  metadata: {},
+                  output: "saved",
+                  time: { start: 1, end: 2 },
+                },
+              },
+            },
+          }),
+        ).pipe(Effect.forkScoped);
+        if (status === "running" && failure === "timeout") {
+          yield* Effect.promise(() => called.promise);
+          yield* TestClock.adjust("1 second");
+        }
+        yield* Fiber.join(emitted);
+      }
+      yield* Effect.promise(() =>
+        nativeEvents.push({ type: "session.compacted", properties: { sessionID: sessionId } }),
+      );
+      const completed = (yield* Fiber.join(received)).find(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "dynamic_tool" &&
+          event.turnItem.status === "completed",
+      );
+      assert.equal(statusReads, 2);
+      assert.equal(
+        completed?.type === "turn_item.updated" && completed.turnItem.title,
+        "Edit remote document",
+      );
+      assert.deepEqual(completed?.type === "turn_item.updated" && completed.turnItem.toolSource, {
+        key: "mcp:weather",
+        name: "weather",
+        kind: "integration",
+      });
+      if (failure === "timeout") assert.isTrue(signal?.aborted);
     }).pipe(Effect.provide(IdAllocator.layer), Effect.scoped),
   );
 
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.testkit.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.testkit.ts
index b18c35b7de8e..0694ec76cc7b 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.testkit.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.testkit.ts
@@ -383,6 +383,7 @@ function makeReplayClient(controller: OpenCodeReplayController): OpencodeClient
       reply: (input: unknown) => request("question.reply", input),
     },
     mcp: {
+      status: () => request("mcp.status", {}),
       add: (input: unknown) => request("mcp.add", input),
     },
   } as unknown as OpencodeClient;
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts
index 11d6da13c7d5..fdae326f9238 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts
@@ -56,6 +56,7 @@ import * as Stream from "effect/Stream";
 
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import * as ServerConfig from "../../config.ts";
+import { mcpToolPresentation } from "../../provider/McpToolPresentation.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import type { EventNdjsonLogger } from "../../provider/Layers/EventNdjsonLogger.ts";
 import * as ProviderEventLoggers from "../../provider/Layers/ProviderEventLoggers.ts";
@@ -286,6 +287,7 @@ interface ActiveOpenCodeTurn {
   readonly parts: Map<string, Exclude<OpenCodePart, ToolPart>>;
   readonly partIdsByMessage: Map<string, Set<string>>;
   readonly toolNamesByCallId: Map<string, string>;
+  mcpServerNames?: ReadonlyArray<string>;
   readonly providerTurn: OrchestrationV2ProviderTurn;
   nextItemOrdinal: number;
   nativeUserMessageId: string | null;
@@ -1593,12 +1595,48 @@ export function makeOpenCodeAdapterV2(
             | "completedAt"
             | "updatedAt"
           >;
-          const turnItem = openCodeToolTurnItem(base, {
-            name: part.tool,
-            input: toolInput(part),
-            output: toolOutput(part),
-            completedMetadata: part.state.status === "completed" ? part.state.metadata : undefined,
-          });
+          const input = toolInput(part);
+          const output = toolOutput(part);
+          const isNativeTool = part.tool === "code_search" || part.tool === "apply_patch";
+          if (!isNativeTool && part.tool.includes("_") && turn.mcpServerNames === undefined) {
+            const serverNames = yield* OpenCodeRuntime.runOpenCodeSdk("mcp.status", (signal) =>
+              client.mcp.status(undefined, { signal, throwOnError: true }),
+            ).pipe(
+              Effect.timeout("1 second"),
+              Effect.map((response) => Object.keys(response.data ?? {})),
+              Effect.catch(() => Effect.succeed(undefined)),
+            );
+            if (serverNames !== undefined) turn.mcpServerNames = serverNames;
+          }
+          const matchingServers = turn.mcpServerNames?.filter(
+            (name) =>
+              !isNativeTool && part.tool.startsWith(`${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_`),
+          );
+          const serverName = matchingServers?.length === 1 ? matchingServers[0] : undefined;
+          const presentation =
+            serverName === undefined
+              ? {}
+              : mcpToolPresentation({
+                  serverName,
+                  toolName: part.tool.slice(serverName.replace(/[^a-zA-Z0-9_-]/g, "_").length + 1),
+                  title: toolTitle(part) === part.tool ? undefined : toolTitle(part),
+                });
+          const turnItem: OrchestrationV2TurnItem = matchingServers?.length
+            ? {
+                ...base,
+                type: "dynamic_tool",
+                ...presentation,
+                toolName: part.tool,
+                input,
+                ...(output === undefined ? {} : { output }),
+              }
+            : openCodeToolTurnItem(base, {
+                name: part.tool,
+                input,
+                output,
+                completedMetadata:
+                  part.state.status === "completed" ? part.state.metadata : undefined,
+              });
           yield* emitProviderEvent({
             type: "node.updated",
             driver: OPENCODE_PROVIDER,
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeToolItems.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeToolItems.ts
index d4d8c86df654..1b01b2b8007c 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCodeToolItems.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeToolItems.ts
@@ -6,6 +6,9 @@
 import type { OrchestrationV2TurnItem } from "@t3tools/contracts";
 import { formatReadToolLabel, formatSearchToolLabel } from "@t3tools/shared/toolActivity";
 
+// Search results stay on the timeline wire, so keep their text a preview.
+const SEARCH_PREVIEW_MAX_CHARS = 8_000;
+
 type ToolItemBase = Omit<
   Extract<OrchestrationV2TurnItem, { type: "dynamic_tool" }>,
   "type" | "toolName" | "input" | "output"
@@ -96,7 +99,10 @@ export function openCodeToolTurnItem(
     case "file_change": {
       const oldStr = recordString(input, "oldString", "oldText");
       const newStr = recordString(input, "newString", "content", "newText");
-      const diffStr = recordString(tool.completedMetadata, "diff", "patch");
+      // A failed edit has no diff; keep its error where the diff would be.
+      const diffStr =
+        recordString(tool.completedMetadata, "diff", "patch") ??
+        (base.status === "failed" && output?.trim() ? output : undefined);
       return {
         ...base,
         type: "file_change",
@@ -108,6 +114,9 @@ export function openCodeToolTurnItem(
     }
     case "file_search": {
       const pattern = recordString(input, "pattern", "query", "path", "filePath");
+      // OpenCode reports matches as plain text, so keep it as one result row
+      // under the searched path, like the ACP search projection.
+      const searchRoot = (recordString(input, "path", "filePath") ?? pattern)?.trim();
       return {
         ...base,
         title:
@@ -115,14 +124,32 @@ export function openCodeToolTurnItem(
           base.title,
         type: "file_search",
         ...(pattern === undefined ? {} : { pattern }),
+        ...(!output?.trim() || searchRoot === undefined
+          ? {}
+          : {
+              results: [
+                { fileName: searchRoot, preview: output.slice(0, SEARCH_PREVIEW_MAX_CHARS) },
+              ],
+            }),
       };
     }
     case "web_search": {
       const pattern = recordString(input, "query", "url", "pattern");
+      const url = recordString(input, "url")?.trim();
       return {
         ...base,
         type: "web_search",
         ...(pattern === undefined ? {} : { patterns: [pattern] }),
+        ...(!output?.trim()
+          ? {}
+          : {
+              results: [
+                {
+                  ...(url === undefined ? {} : { url }),
+                  snippet: output.slice(0, SEARCH_PREVIEW_MAX_CHARS),
+                },
+              ],
+            }),
       };
     }
     case "dynamic_tool": {
diff --git a/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.test.ts
index fb912714f12f..f31e0425cdbc 100644
--- a/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.test.ts
@@ -1063,6 +1063,47 @@ describe("PiAdapterV2", () => {
     }).pipe(Effect.scoped, Effect.provide(testLayer)),
   );
 
+  it.effect("presents explicitly namespaced MCP extension tools", () =>
+    Effect.gen(function* () {
+      const fake = yield* makeFakePi;
+      const { runtime, takeEvent } = yield* openRuntime(fake);
+      const providerThread = yield* runtime.ensureThread({
+        threadId: THREAD_ID,
+        modelSelection: modelSelection("default"),
+        runtimePolicy,
+      });
+      yield* startTurn(runtime, providerThread);
+      yield* fake.takeRequest("prompt");
+      yield* fake.emit({ type: "agent_start" });
+      for (const type of ["tool_execution_start", "tool_execution_end"]) {
+        yield* fake.emit({
+          type,
+          toolCallId: "weather-call",
+          toolName: "mcp__weather__get_weather",
+          args: { city: "Berlin" },
+          result: { content: [{ type: "text", text: "Sunny" }] },
+          isError: false,
+        });
+        const event = yield* takeEvent(
+          (event) => event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool",
+        );
+        if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool")
+          return yield* Effect.die("Expected an MCP tool item");
+        assert.equal(event.turnItem.title, "get weather");
+        assert.equal(
+          event.turnItem.status,
+          type === "tool_execution_start" ? "running" : "completed",
+        );
+        assert.deepEqual(event.turnItem.toolSource, {
+          key: "mcp:weather",
+          name: "weather",
+          kind: "integration",
+        });
+        assert.deepEqual(event.turnItem.input, { city: "Berlin" });
+      }
+    }).pipe(Effect.scoped, Effect.provide(testLayer)),
+  );
+
   it.effect("observes official subagent results without inventing child threads", () =>
     Effect.gen(function* () {
       const fake = yield* makeFakePi;
@@ -1155,6 +1196,102 @@ describe("PiAdapterV2", () => {
     }).pipe(Effect.scoped, Effect.provide(testLayer)),
   );
 
+  it.effect("persists edit patches and write content on file change items", () =>
+    Effect.gen(function* () {
+      const fake = yield* makeFakePi;
+      const { runtime, takeEvent } = yield* openRuntime(fake);
+      const providerThread = yield* runtime.ensureThread({
+        threadId: THREAD_ID,
+        modelSelection: modelSelection("default"),
+        runtimePolicy,
+      });
+      yield* startTurn(runtime, providerThread);
+      yield* fake.takeRequest("prompt");
+      yield* fake.emit({ type: "agent_start" });
+      const patch = "--- a.ts\n+++ a.ts\n@@ -1 +1 @@\n-old\n+new\n";
+      yield* fake.emit({
+        type: "tool_execution_start",
+        toolCallId: "call_edit",
+        toolName: "edit",
+        args: { path: "a.ts", edits: [{ oldText: "old", newText: "new" }] },
+      });
+      yield* fake.emit({
+        type: "tool_execution_end",
+        toolCallId: "call_edit",
+        toolName: "edit",
+        isError: false,
+        result: {
+          content: [{ type: "text", text: "Successfully replaced 1 block(s) in a.ts." }],
+          details: { diff: "-1 old\n+1 new", patch, firstChangedLine: 1 },
+        },
+      });
+      const edit = yield* takeEvent(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "file_change" &&
+          event.turnItem.status === "completed",
+      );
+      assert.isTrue(
+        edit.type === "turn_item.updated" &&
+          edit.turnItem.type === "file_change" &&
+          edit.turnItem.fileName === "a.ts" &&
+          edit.turnItem.diffStr === patch,
+      );
+
+      yield* fake.emit({
+        type: "tool_execution_start",
+        toolCallId: "call_write",
+        toolName: "write",
+        args: { path: "b.ts", content: "export {};\n" },
+      });
+      yield* fake.emit({
+        type: "tool_execution_end",
+        toolCallId: "call_write",
+        toolName: "write",
+        isError: false,
+        result: { content: [{ type: "text", text: "Successfully wrote to b.ts" }] },
+      });
+      const write = yield* takeEvent(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "file_change" &&
+          event.turnItem.status === "completed",
+      );
+      assert.isTrue(
+        write.type === "turn_item.updated" &&
+          write.turnItem.type === "file_change" &&
+          write.turnItem.fileName === "b.ts" &&
+          write.turnItem.newStr === "export {};\n",
+      );
+
+      // A failed edit has no patch, so it keeps the error to show when expanded.
+      yield* fake.emit({
+        type: "tool_execution_start",
+        toolCallId: "call_edit_failed",
+        toolName: "edit",
+        args: { path: "c.ts", edits: [{ oldText: "missing", newText: "new" }] },
+      });
+      yield* fake.emit({
+        type: "tool_execution_end",
+        toolCallId: "call_edit_failed",
+        toolName: "edit",
+        isError: true,
+        result: { content: [{ type: "text", text: "Could not find the text in c.ts." }] },
+      });
+      const failedEdit = yield* takeEvent(
+        (event) =>
+          event.type === "turn_item.updated" &&
+          event.turnItem.type === "file_change" &&
+          event.turnItem.status === "failed",
+      );
+      assert.isTrue(
+        failedEdit.type === "turn_item.updated" &&
+          failedEdit.turnItem.type === "file_change" &&
+          failedEdit.turnItem.diffStr === "Could not find the text in c.ts.",
+      );
+    }).pipe(Effect.scoped, Effect.provide(testLayer)),
+  );
+
   it.effect("settles a command-only prompt from its deferred ack and idle probe", () =>
     Effect.gen(function* () {
       const fake = yield* makeFakePi;
diff --git a/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.ts
index 6f0bcf258acb..80238ee56bcc 100644
--- a/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/PiAdapterV2.ts
@@ -61,6 +61,7 @@ import { ChildProcessSpawner } from "effect/unstable/process";
 
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import * as ServerConfig from "../../config.ts";
+import { mcpToolPresentation } from "../../provider/McpToolPresentation.ts";
 import * as McpProviderSession from "../../mcp/McpProviderSession.ts";
 import {
   expandPiSkillReference,
@@ -988,6 +989,12 @@ export function makePiAdapterV2(
         if (toolName === "edit" || toolName === "write") {
           const fileName = recordString(args, "path") ?? recordString(args, "file_path");
           if (fileName !== undefined) {
+            // edit reports a unified patch in its result details; write only
+            // carries the new content in its args. A failed call keeps its error.
+            const diffStr =
+              recordString(recordField(resultRecord, "details"), "patch") ??
+              (isError && outputText.trim().length > 0 ? outputText : undefined);
+            const newStr = toolName === "write" ? recordString(args, "content") : undefined;
             yield* emit({
               type: "turn_item.updated",
               driver: PI_PROVIDER,
@@ -996,6 +1003,8 @@ export function makePiAdapterV2(
                 title: toolName,
                 type: "file_change",
                 fileName,
+                ...(diffStr === undefined ? {} : { diffStr }),
+                ...(newStr === undefined ? {} : { newStr }),
               },
             });
             return;
@@ -1008,6 +1017,7 @@ export function makePiAdapterV2(
             ...shared,
             title: toolName,
             type: "dynamic_tool",
+            ...mcpToolPresentation({ toolName }),
             toolName,
             input: args ?? {},
             ...(outputText.length > 0 ? { output: outputText } : {}),
diff --git a/apps/server/src/orchestration-v2/BackgroundWorkStop.integration.test.ts b/apps/server/src/orchestration-v2/BackgroundWorkStop.integration.test.ts
index 2b1c529ba177..3c183da6268c 100644
--- a/apps/server/src/orchestration-v2/BackgroundWorkStop.integration.test.ts
+++ b/apps/server/src/orchestration-v2/BackgroundWorkStop.integration.test.ts
@@ -41,7 +41,7 @@ const modelSelection = { instanceId, model: "test-model" };
 // Codex turns leave commands running, then the thread moves to another
 // provider thread (a provider switch). Stop on the newer, settled run must
 // reach both provider threads and end all of the Codex work.
-it.effect("Stop reaches background work an earlier provider thread still runs", () =>
+const stopEarlierBackgroundWork = (failedStart: boolean) =>
   Effect.scoped(
     Effect.gen(function* () {
       const cwd = yield* checkpointWorkspace("background-work-stop");
@@ -233,7 +233,10 @@ it.effect("Stop reaches background work an earlier provider thread still runs",
         const settledRun = (input: {
           readonly ordinal: number;
           readonly providerThreadId: ProviderThreadId;
-          readonly runningItem?: { readonly id: TurnItemId; readonly kind: "command" | "subagent" };
+          readonly runningItem?: {
+            readonly id: TurnItemId;
+            readonly kind: "command" | "subagent";
+          };
         }) => {
           const runId = RunId.make(`run:${input.ordinal}`);
           const attemptId = RunAttemptId.make(`attempt:${input.ordinal}`);
@@ -407,11 +410,41 @@ it.effect("Stop reaches background work an earlier provider thread still runs",
           ],
         });
 
+        const failedRun = settledRun({ ordinal: 5, providerThreadId: otherProviderThreadId });
+        if (failedStart) {
+          yield* sink.write({
+            events: failedRun.events.flatMap((event): Array<OrchestrationV2DomainEvent> => {
+              switch (event.type) {
+                case "provider-turn.updated":
+                  return [];
+                case "run.created":
+                  return [{ ...event, payload: { ...event.payload, status: "failed" } }];
+                case "node.updated":
+                  return [
+                    {
+                      ...event,
+                      payload: { ...event.payload, status: "failed", providerTurnId: null },
+                    },
+                  ];
+                case "run-attempt.created":
+                  return [
+                    {
+                      ...event,
+                      payload: { ...event.payload, status: "failed", providerTurnId: null },
+                    },
+                  ];
+                default:
+                  return [event];
+              }
+            }),
+          });
+        }
+
         yield* orchestrator.dispatch({
           type: "run.interrupt",
           commandId: CommandId.make("stop-background-work"),
           threadId,
-          runId: latestRun.runId,
+          runId: failedStart ? failedRun.runId : latestRun.runId,
         });
         yield* worker.drain();
 
@@ -442,5 +475,13 @@ it.effect("Stop reaches background work an earlier provider thread still runs",
         ),
       );
     }),
-  ),
+  );
+
+it.effect("Stop reaches background work an earlier provider thread still runs", () =>
+  stopEarlierBackgroundWork(false),
+);
+
+it.effect(
+  "Stop reaches earlier background work after the newest run fails before provider start",
+  () => stopEarlierBackgroundWork(true),
 );
diff --git a/apps/server/src/orchestration-v2/CheckpointService.ts b/apps/server/src/orchestration-v2/CheckpointService.ts
index 1471de750357..1338f68328d1 100644
--- a/apps/server/src/orchestration-v2/CheckpointService.ts
+++ b/apps/server/src/orchestration-v2/CheckpointService.ts
@@ -14,10 +14,9 @@ import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as Layer from "effect/Layer";
-import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
-import * as Semaphore from "effect/Semaphore";
 
 import { parseTurnDiffFilesFromNumstat } from "../checkpointing/Diffs.ts";
 import * as CheckpointStore from "../checkpointing/CheckpointStore.ts";
@@ -249,29 +248,9 @@ export const layer: Layer.Layer<
   Effect.gen(function* () {
     const checkpointStore = yield* CheckpointStore.CheckpointStore;
     const idAllocator = yield* IdAllocator.IdAllocatorV2;
-    const workspaceSemaphores = yield* Ref.make(new Map<string, Semaphore.Semaphore>());
-
-    const getWorkspaceSemaphore = (cwd: string) =>
-      Effect.gen(function* () {
-        const existing = (yield* Ref.get(workspaceSemaphores)).get(cwd);
-        if (existing !== undefined) {
-          return existing;
-        }
-
-        const created = yield* Semaphore.make(1);
-        return yield* Ref.modify(workspaceSemaphores, (current) => {
-          const concurrent = current.get(cwd);
-          if (concurrent !== undefined) {
-            return [concurrent, current];
-          }
-          const updated = new Map(current);
-          updated.set(cwd, created);
-          return [created, updated];
-        });
-      });
-
+    const workspaceLocks = yield* KeyedLock.make<string>();
     const withWorkspaceLock = <A, E, R>(cwd: string, effect: Effect.Effect<A, E, R>) =>
-      Effect.flatMap(getWorkspaceSemaphore(cwd), (semaphore) => semaphore.withPermits(1)(effect));
+      workspaceLocks.withLock(cwd, effect);
 
     const isGitCheckpointable = (cwd: string) =>
       checkpointStore.isGitRepository(cwd).pipe(Effect.orElseSucceed(() => false));
diff --git a/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts b/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts
new file mode 100644
index 000000000000..b13a8b5d90c1
--- /dev/null
+++ b/apps/server/src/orchestration-v2/ClaudeAutomaticDelivery.integration.test.ts
@@ -0,0 +1,420 @@
+import type { SDKMessage, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, it } from "@effect/vitest";
+import {
+  ClaudeSettings,
+  CommandId,
+  EventId,
+  MessageId,
+  NodeId,
+  ProjectId,
+  ProviderInstanceId,
+  ScheduledTaskUpsertInput,
+  ThreadId,
+  type OrchestrationV2DomainEvent,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Queue from "effect/Queue";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
+import * as Scheduler from "../scheduling/Scheduler.ts";
+import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
+import * as ClaudeAdapterV2 from "./Adapters/ClaudeAdapterV2.ts";
+import * as EffectWorker from "./EffectWorker.ts";
+import * as EventSink from "./EventSink.ts";
+import * as IdAllocator from "./IdAllocator.ts";
+import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
+import * as Orchestrator from "./Orchestrator.ts";
+import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
+import * as ThreadLaunchService from "./ThreadLaunchService.ts";
+import * as ThreadManagementService from "./ThreadManagementService.ts";
+import { makeOrchestratorV2ReplayLayerWithRegistry } from "./testkit/ProviderReplayHarness.ts";
+import { checkpointWorkspace } from "./testkit/ReplayFixtureWorkspace.ts";
+
+const sessionId = "automatic-delivery-session";
+const settings = Schema.decodeSync(ClaudeSettings)({});
+const decodeScheduledTask = Schema.decodeEffect(ScheduledTaskUpsertInput);
+const refusal =
+  "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
+const statusIds = ["status-1", "status-2", "status-3", "status-4"];
+const modelSelection = {
+  instanceId: ProviderInstanceId.make("claudeAgent"),
+  model: "claude-sonnet-4-6",
+};
+
+// Native frames match the captured Bash/status batch and tool_result_meta shape.
+// The external SDK boundary is replayed; the adapter and durable dispatch are real.
+function frame(value: unknown): SDKMessage {
+  return value as SDKMessage;
+}
+
+const batch = frame({
+  type: "assistant",
+  uuid: "batch",
+  session_id: sessionId,
+  parent_tool_use_id: null,
+  message: {
+    id: "tool-batch",
+    role: "assistant",
+    type: "message",
+    model: modelSelection.model,
+    content: [
+      { type: "tool_use", id: "build", name: "Bash", input: { command: "make" } },
+      ...statusIds.map((id) => ({
+        type: "tool_use",
+        id,
+        name: "mcp__t3-code__task_status",
+        input: { taskId: id },
+      })),
+    ],
+    stop_reason: "tool_use",
+    stop_sequence: null,
+    usage: { input_tokens: 1, output_tokens: 1 },
+  },
+});
+
+const toolResult = (id: string, cancelled: boolean) =>
+  frame({
+    type: "user",
+    uuid: `result-${id}`,
+    session_id: sessionId,
+    parent_tool_use_id: null,
+    message: {
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: id,
+          is_error: cancelled,
+          content: cancelled ? refusal : id === "build" ? "build OK" : "Task completed normally",
+        },
+      ],
+    },
+    ...(cancelled ? { tool_result_meta: [{ id, non_execution_kind: "cancelled" }] } : {}),
+  });
+
+const result = (uuid: string, aborted: boolean) =>
+  frame({
+    type: "result",
+    subtype: "success",
+    uuid,
+    session_id: sessionId,
+    is_error: false,
+    num_turns: 1,
+    result: "",
+    stop_reason: "end_turn",
+    terminal_reason: aborted ? "aborted_tools" : "completed",
+    permission_denials: [],
+    duration_ms: 1,
+    duration_api_ms: 1,
+    total_cost_usd: 0,
+    usage: { input_tokens: 1, output_tokens: 1 },
+    modelUsage: {},
+  });
+
+it.effect.each(["child completion", "scheduled message", "user steering"] as const)(
+  "delivers %s with Claude's native pending-tool cancellation behavior",
+  (delivery) =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const cwd = yield* checkpointWorkspace("claude-automatic-delivery");
+        const sdkMessages = yield* Queue.unbounded<SDKMessage>();
+        const offers: SDKUserMessage[] = [];
+        const nativeQueue: SDKUserMessage[] = [];
+        const batchAbort = new AbortController();
+        const adapter = ClaudeAdapterV2.makeClaudeAdapterV2({
+          instanceId: modelSelection.instanceId,
+          settings,
+          environment: {},
+          attachmentsDir: cwd,
+          fileSystem: yield* FileSystem.FileSystem,
+          path: yield* Path.Path,
+          idAllocator: yield* IdAllocator.IdAllocatorV2,
+          queryRunner: {
+            allocateSessionId: Effect.succeed(sessionId),
+            open: () =>
+              Effect.succeed({
+                messages: Stream.fromQueue(sdkMessages),
+                offer: (message) =>
+                  Effect.sync(() => {
+                    offers.push(message);
+                    nativeQueue.push(message);
+                    // Claude Code 2.1.289's queue watcher aborts when a now-priority
+                    // command arrives, including while Bash blocks pending reads.
+                    if (nativeQueue.some((command) => command.priority === "now")) {
+                      batchAbort.abort({ kind: "interrupt" });
+                    }
+                  }),
+                setModel: () => Effect.void,
+                setPermissionMode: () => Effect.void,
+                interrupt: Effect.die("automatic delivery must never interrupt"),
+                close: Effect.void,
+              }),
+            forkSession: () => Effect.die("unused"),
+            subagentLaunchToolUseId: () => Effect.succeed(null),
+            assertComplete: Effect.void,
+          },
+        });
+        yield* Effect.gen(function* () {
+          const orchestrator = yield* Orchestrator.OrchestratorV2;
+          const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+          const threadId = ThreadId.make("thread:automatic-delivery");
+          const projectId = ProjectId.make("project:automatic-delivery");
+          const watch = (predicate: (event: OrchestrationV2DomainEvent) => boolean) =>
+            orchestrator.streamDomainEvents.pipe(
+              Stream.filter(predicate),
+              Stream.take(1),
+              Stream.runDrain,
+              Effect.forkScoped,
+            );
+          yield* orchestrator.dispatch({
+            type: "thread.create",
+            commandId: CommandId.make("create"),
+            threadId,
+            projectId,
+            title: "Automatic delivery",
+            modelSelection,
+            runtimeMode: "full-access",
+            interactionMode: "default",
+            branch: null,
+            worktreePath: cwd,
+            createdBy: "user",
+            creationSource: "web",
+          });
+          const running = yield* watch(
+            (event) => event.type === "provider-turn.updated" && event.payload.status === "running",
+          );
+          yield* orchestrator.dispatch({
+            type: "message.dispatch",
+            commandId: CommandId.make("first"),
+            threadId,
+            messageId: MessageId.make("first"),
+            text: "Build and check all four tasks.",
+            attachments: [],
+            dispatchMode: { type: "start_immediately" },
+            createdBy: "user",
+            creationSource: "web",
+          });
+          yield* worker.drain();
+          yield* Fiber.join(running);
+          const pending = yield* watch(
+            (event) =>
+              event.type === "turn-item.updated" &&
+              event.payload.nativeItemRef?.nativeId === "status-4",
+          );
+          yield* Queue.offer(sdkMessages, batch);
+          yield* Fiber.join(pending);
+          const before = yield* orchestrator.getThreadProjection(threadId);
+          assert.equal(before.turnItems.filter((item) => item.status === "running").length, 5);
+          const parent = before.runs[0]!;
+          if (parent.rootNodeId === null) return yield* Effect.die("parent has no root node");
+          const messageId = MessageId.make("automatic-notice");
+          if (delivery === "child completion") {
+            const taskId = NodeId.make("completed-child");
+            const now = yield* DateTime.now;
+            const sink = yield* EventSink.EventSinkV2;
+            yield* sink.write({
+              events: [
+                {
+                  id: EventId.make("cohort"),
+                  type: "run.updated",
+                  threadId,
+                  runId: parent.id,
+                  occurredAt: now,
+                  payload: {
+                    ...parent,
+                    delegatedCompletion: {
+                      disposition: "open",
+                      nextGeneration: 2,
+                      delivery: { generation: 1, messageId, taskIds: [taskId] },
+                    },
+                  },
+                },
+                {
+                  id: EventId.make("child"),
+                  type: "subagent.updated",
+                  threadId,
+                  runId: parent.id,
+                  nodeId: taskId,
+                  occurredAt: now,
+                  payload: {
+                    id: taskId,
+                    threadId,
+                    runId: parent.id,
+                    parentNodeId: parent.rootNodeId,
+                    origin: "app_owned",
+                    createdBy: "agent",
+                    driver: ClaudeAdapterV2.CLAUDE_PROVIDER,
+                    providerInstanceId: modelSelection.instanceId,
+                    providerThreadId: null,
+                    childThreadId: null,
+                    nativeTaskRef: null,
+                    prompt: "Background work",
+                    title: "Child",
+                    model: null,
+                    completionWake: "always",
+                    completionDelivery: { state: "claimed", observedByRunId: null },
+                    status: "completed",
+                    result: "done",
+                    startedAt: now,
+                    completedAt: now,
+                    updatedAt: now,
+                  },
+                },
+              ],
+            });
+            const command = {
+              type: "message.dispatch" as const,
+              commandId: CommandId.make("completion"),
+              threadId,
+              messageId,
+              text: "Child completed",
+              attachments: [],
+              dispatchMode: { type: "queue_after_active" as const },
+              createdBy: "agent" as const,
+              creationSource: "server" as const,
+              delegatedCompletion: { parentRunId: parent.id, generation: 1, taskIds: [taskId] },
+            };
+            yield* orchestrator.dispatch(command);
+            yield* orchestrator.dispatch(command);
+            yield* orchestrator.recoverDelegatedTasks;
+          } else if (delivery === "scheduled message") {
+            yield* Effect.gen(function* () {
+              const service = yield* ScheduledTaskService.ScheduledTaskService;
+              const { task } = yield* service.upsert(
+                yield* decodeScheduledTask({
+                  title: "Status check",
+                  prompt: "Check the four tasks.",
+                  enabled: true,
+                  schedule: { type: "interval", everyMs: 60_000 },
+                  projectId,
+                  threadId,
+                  workspaceStrategy: { type: "root" },
+                  modelSelection,
+                  runtimeMode: "full-access",
+                  interactionMode: "default",
+                }),
+              );
+              const ran = yield* service.runNow({ id: task.id });
+              assert.equal(ran.task.lastRunStatus, "succeeded");
+            }).pipe(
+              Effect.provide(
+                ScheduledTaskService.layer.pipe(
+                  Layer.provide(ThreadManagementService.layer),
+                  Layer.provide(
+                    Layer.mock(LegacyV1ThreadImporter.LegacyV1ThreadImporter)({
+                      ensureTranscript: () =>
+                        Effect.succeed({ importedThreadCount: 0, importedMessageCount: 0 }),
+                    }),
+                  ),
+                  Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
+                  Layer.provide(
+                    Layer.mergeAll(NodeCrypto.layer, Scheduler.layer, SqlitePersistenceMemory),
+                  ),
+                ),
+              ),
+            );
+          } else {
+            yield* orchestrator.dispatch({
+              type: "message.dispatch",
+              commandId: CommandId.make("steer"),
+              threadId,
+              messageId,
+              text: "Change direction now.",
+              attachments: [],
+              dispatchMode: { type: "steer_active", targetRunId: parent.id },
+              createdBy: "user",
+              creationSource: "web",
+            });
+          }
+          yield* worker.drain();
+          const explicitSteer = delivery === "user steering";
+          assert.equal(batchAbort.signal.aborted, explicitSteer);
+          assert.equal(offers.length, explicitSteer ? 2 : 1);
+          const finished = yield* watch(
+            (event) =>
+              event.type === "run.updated" &&
+              event.payload.id === parent.id &&
+              event.payload.status === "waiting",
+          );
+          // Bash finishes before the pending status reads, as in the capture.
+          yield* Queue.offer(sdkMessages, toolResult("build", false));
+          for (const id of statusIds)
+            yield* Queue.offer(sdkMessages, toolResult(id, batchAbort.signal.aborted));
+          if (explicitSteer) yield* Queue.offer(sdkMessages, result("aborted", true));
+          yield* Queue.offer(sdkMessages, result("completed", false));
+          yield* Fiber.join(finished);
+          yield* worker.drain();
+          yield* orchestrator.resumeQueuedRuns;
+          yield* worker.drain();
+          if (!explicitSteer) {
+            const queued = (yield* orchestrator.getThreadProjection(threadId)).runs[1]!;
+            const noticeFinished = yield* watch(
+              (event) =>
+                event.type === "run.updated" &&
+                event.payload.id === queued.id &&
+                event.payload.status === "waiting",
+            );
+            const delivered =
+              delivery === "child completion"
+                ? yield* watch(
+                    (event) =>
+                      event.type === "subagent.updated" &&
+                      event.payload.completionDelivery?.state === "delivered",
+                  )
+                : null;
+            yield* Queue.offer(sdkMessages, result("notice-completed", false));
+            yield* Fiber.join(noticeFinished);
+            yield* worker.drain();
+            if (delivered !== null) yield* Fiber.join(delivered);
+          }
+          const after = yield* orchestrator.getThreadProjection(threadId);
+          const reads = after.turnItems.filter((item) =>
+            statusIds.includes(item.nativeItemRef?.nativeId ?? ""),
+          );
+          assert.equal(reads.length, 4);
+          for (const read of reads) {
+            assert.equal(read.status, explicitSteer ? "cancelled" : "completed");
+            assert.equal(read.toolNonExecutionKind, explicitSteer ? "cancelled" : undefined);
+            assert.equal(read.type === "dynamic_tool" && read.output === refusal, explicitSteer);
+          }
+          assert.equal(offers.length, 2);
+          assert.equal(
+            offers.filter((offer) => offer.priority === "now").length,
+            explicitSteer ? 1 : 0,
+          );
+          if (!explicitSteer) {
+            assert.equal(after.runs.length, 2);
+            if (delivery === "child completion") {
+              assert.equal(after.messages.filter((message) => message.id === messageId).length, 1);
+              assert.equal(after.subagents[0]?.completionDelivery?.state, "delivered");
+            } else {
+              assert.equal(
+                after.messages.filter((message) => message.scheduledTaskId !== undefined).length,
+                1,
+              );
+            }
+          }
+          yield* orchestrator.recoverDelegatedTasks;
+          yield* orchestrator.resumeQueuedRuns;
+          yield* worker.drain();
+          assert.equal(offers.length, 2);
+        }).pipe(
+          Effect.provide(
+            makeOrchestratorV2ReplayLayerWithRegistry(
+              { name: "claude-automatic-delivery" },
+              ProviderAdapterRegistry.makeSingleLayer(adapter),
+              { runEffectWorker: false },
+            ),
+          ),
+        );
+      }).pipe(Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer))),
+    ),
+);
diff --git a/apps/server/src/orchestration-v2/KeyedSerialExecutor.test.ts b/apps/server/src/orchestration-v2/KeyedSerialExecutor.test.ts
deleted file mode 100644
index 6f376b9f330e..000000000000
--- a/apps/server/src/orchestration-v2/KeyedSerialExecutor.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { describe, expect, it } from "@effect/vitest";
-
-import * as Deferred from "effect/Deferred";
-import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import * as Queue from "effect/Queue";
-import * as Ref from "effect/Ref";
-
-import { makeKeyedSerialExecutor } from "./KeyedSerialExecutor.ts";
-
-describe("makeKeyedSerialExecutor", () => {
-  it.effect("allows unrelated keys to run concurrently", () =>
-    Effect.gen(function* () {
-      const executor = yield* makeKeyedSerialExecutor<string>();
-      const arrivals = yield* Queue.unbounded<string>();
-      const release = yield* Deferred.make<void>();
-      const run = (key: string) =>
-        executor.withLock(
-          key,
-          Queue.offer(arrivals, key).pipe(Effect.andThen(Deferred.await(release))),
-        );
-
-      const fibers = yield* Effect.forEach(["a", "b"], run, {
-        concurrency: "unbounded",
-        discard: false,
-      }).pipe(Effect.forkChild);
-      const observed = [yield* Queue.take(arrivals), yield* Queue.take(arrivals)];
-      yield* Deferred.succeed(release, undefined);
-      yield* Fiber.join(fibers);
-      expect(new Set(observed)).toEqual(new Set(["a", "b"]));
-    }).pipe(Effect.timeout("1 second")),
-  );
-
-  it.effect("serializes work for the same key", () =>
-    Effect.gen(function* () {
-      const executor = yield* makeKeyedSerialExecutor<string>();
-      const firstEntered = yield* Deferred.make<void>();
-      const releaseFirst = yield* Deferred.make<void>();
-      const events = yield* Ref.make<Array<string>>([]);
-
-      const first = yield* executor
-        .withLock(
-          "thread",
-          Ref.update(events, (current) => [...current, "first:start"]).pipe(
-            Effect.andThen(Deferred.succeed(firstEntered, undefined)),
-            Effect.andThen(Deferred.await(releaseFirst)),
-            Effect.andThen(Ref.update(events, (current) => [...current, "first:end"])),
-          ),
-        )
-        .pipe(Effect.forkChild);
-      yield* Deferred.await(firstEntered);
-      const second = yield* executor
-        .withLock(
-          "thread",
-          Ref.update(events, (current) => [...current, "second:start"]),
-        )
-        .pipe(Effect.forkChild);
-
-      yield* Effect.yieldNow;
-      expect(yield* Ref.get(events)).toEqual(["first:start"]);
-      yield* Deferred.succeed(releaseFirst, undefined);
-      yield* Fiber.join(first);
-      yield* Fiber.join(second);
-      expect(yield* Ref.get(events)).toEqual(["first:start", "first:end", "second:start"]);
-    }).pipe(Effect.timeout("1 second")),
-  );
-});
diff --git a/apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts b/apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts
index ad41ae6ffde6..1a02b71982fe 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts
@@ -534,3 +534,93 @@ it.effect("settles only the stopped run's background work, once", () =>
     ]);
   }).pipe(Effect.provide(testLayer)),
 );
+
+it.effect("keeps delegated child pull-request links independent of the parent", () =>
+  Effect.gen(function* () {
+    const orchestrator = yield* Orchestrator.OrchestratorV2;
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    const parentThreadId = ThreadId.make("thread:parent-pr");
+    const projectId = ProjectId.make("project:parent-pr");
+    const parentPullRequest = {
+      projectId,
+      repository: "pingdotgg/t3code",
+      number: 123,
+      url: "https://github.com/pingdotgg/t3code/pull/123",
+    };
+    yield* orchestrator.dispatch({
+      type: "thread.create",
+      commandId: CommandId.make("create-parent-pr"),
+      threadId: parentThreadId,
+      projectId,
+      title: "Parent with a linked PR",
+      modelSelection,
+      runtimeMode: "full-access",
+      interactionMode: "default",
+      branch: "feature/parent-pr",
+      worktreePath: "/repo-worktree",
+      createdBy: "user",
+      creationSource: "web",
+    });
+    yield* orchestrator.dispatch({
+      type: "thread.metadata.update",
+      commandId: CommandId.make("link-parent-pr"),
+      threadId: parentThreadId,
+      linkedPullRequest: parentPullRequest,
+    });
+    yield* orchestrator.dispatch({
+      type: "message.dispatch",
+      commandId: CommandId.make("start-parent-pr"),
+      threadId: parentThreadId,
+      messageId: MessageId.make("message:parent-pr"),
+      text: "Delegate a review",
+      attachments: [],
+      dispatchMode: { type: "start_immediately" },
+      createdBy: "user",
+      creationSource: "web",
+    });
+    const parent = yield* projections.getThreadProjection(parentThreadId);
+    const parentRun = parent.runs[0]!;
+    yield* orchestrator.dispatch({
+      type: "delegated_task.request",
+      commandId: CommandId.make("delegate-parent-pr"),
+      parentThreadId,
+      parentRunId: parentRun.id,
+      parentNodeId: parentRun.rootNodeId!,
+      task: "Review the changes",
+      modelSelection,
+      runtimeMode: "full-access",
+      interactionMode: "default",
+      createdBy: "agent",
+      creationSource: "mcp",
+    });
+    const updatedParent = yield* projections.getThreadProjection(parentThreadId);
+    const childThreadId = updatedParent.subagents[0]!.childThreadId!;
+    const child = yield* projections.getThreadProjection(childThreadId);
+    assert.isNull(child.thread.linkedPullRequest);
+    assert.deepEqual(child.thread.pullRequests, []);
+    assert.equal(child.thread.branch, parent.thread.branch);
+    assert.equal(child.thread.worktreePath, parent.thread.worktreePath);
+    assert.equal(child.thread.lineage.parentThreadId, parentThreadId);
+
+    const childPullRequest = {
+      ...parentPullRequest,
+      number: 456,
+      url: "https://github.com/pingdotgg/t3code/pull/456",
+    };
+    yield* orchestrator.dispatch({
+      type: "thread.metadata.update",
+      commandId: CommandId.make("link-child-pr"),
+      threadId: childThreadId,
+      linkedPullRequest: childPullRequest,
+    });
+    const linkedChild = yield* projections.getThreadProjection(childThreadId);
+    assert.deepEqual(linkedChild.thread.linkedPullRequest, childPullRequest);
+    assert.deepEqual(
+      linkedChild.thread.pullRequests?.map((link) => link.number),
+      [456],
+    );
+    const parentAfterChildLink = yield* projections.getThreadProjection(parentThreadId);
+    assert.deepEqual(parentAfterChildLink.thread.linkedPullRequest, parentPullRequest);
+    assert.deepEqual(parentAfterChildLink.thread.pullRequests, parent.thread.pullRequests);
+  }).pipe(Effect.provide(testLayer)),
+);
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts
index 42c55371d5f7..fab0276e55ef 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.ts
@@ -49,6 +49,7 @@ import {
   RunId,
   ThreadLinkedPullRequest,
   ThreadId,
+  type TurnItemId,
 } from "@t3tools/contracts";
 import { modelSelectionsEqual } from "@t3tools/shared/model";
 import {
@@ -264,6 +265,10 @@ export interface OrchestratorV2Shape {
     options: ProjectionTimelinePageOptions,
   ) => Effect.Effect<ProjectionTimelinePage, OrchestratorProjectionError>;
   readonly getMessageCount: (threadId: ThreadId) => Effect.Effect<number, OrchestratorV2Error>;
+  readonly getTurnItem: (input: {
+    readonly threadId: ThreadId;
+    readonly itemId: TurnItemId;
+  }) => Effect.Effect<OrchestrationV2TurnItem | null, OrchestratorV2Error>;
   readonly getThreadRecords: <K extends ProjectionRecordField>(
     threadId: ThreadId,
     fields: ReadonlyArray<K>,
@@ -4377,8 +4382,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         const source = projection.runs.find((run) => run.id === command.restartContinuationOfRunId);
         if (
           !source ||
-          (source.status !== "cancelled" &&
-            !isRestartNoteSource(source, projection.providerTurns)) ||
+          source.status !== "cancelled" ||
+          isRestartNoteSource(source, projection.providerTurns) ||
           projection.thread.archivedAt !== null ||
           projection.thread.deletedAt !== null ||
           projection.thread.providerInstanceId !== source.providerInstanceId ||
@@ -4591,7 +4596,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
             .pipe(Effect.orElseSucceed(() => Option.none()));
           if (
             Option.isSome(session) &&
-            session.value.providerSession.capabilities.turns.supportsActiveSteering
+            session.value.providerSession.capabilities.turns.supportsActiveSteering &&
+            session.value.providerSession.capabilities.turns.activeSteeringInterruptsTools !== true
           ) {
             dispatchMode = { type: "steer_active", targetRunId: active.id };
           }
@@ -8035,11 +8041,19 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           activeProviderThreadId: projection.thread.activeProviderThreadId,
           runs: projection.runs,
         }).length > 0;
-      const providerTurn = projection.providerTurns.findLast(
-        (candidate) =>
-          candidate.runAttemptId === run?.activeAttemptId &&
-          (candidate.status === "running" || hasBackgroundWork),
-      );
+      // A failed start has no provider turn. Background work still belongs
+      // to the provider thread, so Stop reaches its latest accepted turn.
+      const providerTurn =
+        projection.providerTurns.findLast(
+          (candidate) =>
+            candidate.runAttemptId === run?.activeAttemptId &&
+            (candidate.status === "running" || hasBackgroundWork),
+        ) ??
+        (hasBackgroundWork
+          ? projection.providerTurns.findLast(
+              (candidate) => candidate.providerThreadId === run?.providerThreadId,
+            )
+          : undefined);
       if (run === undefined || rootNode === undefined || providerThread === undefined) {
         return yield* new OrchestratorDispatchError({
           commandId: command.commandId,
@@ -10067,6 +10081,14 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       projectionStore
         .getMessageCount(threadId)
         .pipe(Effect.mapError((cause) => new OrchestratorProjectionError({ threadId, cause }))),
+    getTurnItem: (input) =>
+      projectionStore
+        .getTurnItem(input)
+        .pipe(
+          Effect.mapError(
+            (cause) => new OrchestratorProjectionError({ threadId: input.threadId, cause }),
+          ),
+        ),
     getThreadRecords: (threadId, fields, filter) =>
       projectionStore
         .getThreadRecords(threadId, fields, filter)
@@ -10188,6 +10210,7 @@ const layerUnavailable: Layer.Layer<OrchestratorV2> = Layer.succeed(
       ),
     getTimelinePage: (threadId) => Effect.fail(new OrchestratorProjectionError({ threadId })),
     getMessageCount: (threadId) => Effect.fail(new OrchestratorProjectionError({ threadId })),
+    getTurnItem: ({ threadId }) => Effect.fail(new OrchestratorProjectionError({ threadId })),
     getThreadRecords: (threadId) => Effect.fail(new OrchestratorProjectionError({ threadId })),
     getThreadProjection: (threadId) =>
       Effect.fail(
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
index 3e979544c87b..3bb7617eef0f 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
@@ -959,6 +959,14 @@ it.layer(TestLayer)("ProjectionStoreV2", (it) => {
       assert.strictEqual(older.projection.turnItems[0]?.ordinal, 850);
       assert.strictEqual(older.projection.turnItems.at(-1)?.ordinal, 925);
 
+      // A single item reads back with its full output, scoped to its thread.
+      const itemId = TurnItemId.make("turn-item:bounded-sql-history:925");
+      const stored = yield* projectionStore.getTurnItem({ threadId, itemId });
+      assert.strictEqual(stored?.type === "command_execution" ? stored.output : undefined, "ok");
+      assert.isNull(
+        yield* projectionStore.getTurnItem({ threadId: ThreadId.make("thread:other"), itemId }),
+      );
+
       const sqlPageLimit = THREAD_HISTORY_PAGE_POLICY.maxItems + 2;
       const initialSnapshot = yield* projectionStore.getThreadSnapshotWindow(threadId, {
         rowLimit: sqlPageLimit,
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 93f1e1e90de2..a6be3079946f 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -318,6 +318,11 @@ export interface ProjectionStoreV2Shape {
   readonly getNextTurnItemOrdinal: (
     threadId: ThreadId,
   ) => Effect.Effect<number, ProjectionStoreV2Error>;
+  /** One persisted turn item, or null when the thread has no such item. */
+  readonly getTurnItem: (input: {
+    readonly threadId: ThreadId;
+    readonly itemId: TurnItemId;
+  }) => Effect.Effect<OrchestrationV2TurnItem | null, ProjectionStoreV2Error>;
   readonly getThreadRecords: <K extends ProjectionRecordField>(
     threadId: ThreadId,
     fields: ReadonlyArray<K>,
@@ -4504,6 +4509,18 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
         Effect.mapError(controlReadError(threadId)),
       );
 
+    const getTurnItem: ProjectionStoreV2Shape["getTurnItem"] = ({ threadId, itemId }) =>
+      sql<{ payload_json: string }>`SELECT payload_json
+        FROM orchestration_v2_projection_turn_items
+        WHERE turn_item_id = ${itemId} AND thread_id = ${threadId}`.pipe(
+        Effect.flatMap((rows) =>
+          rows[0] === undefined
+            ? Effect.succeed(null)
+            : decodeTurnItemPayload(rows[0].payload_json),
+        ),
+        Effect.mapError(controlReadError(threadId)),
+      );
+
     const getThreadAttachmentIds: ProjectionStoreV2Shape["getThreadAttachmentIds"] = (threadId) =>
       sql<{ id: string }>`
       SELECT DISTINCT json_extract(attachment.value, '$.id') AS id
@@ -5539,6 +5556,7 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
       hasUnpairedRunInterruptRequest,
       getMessageCount,
       getNextTurnItemOrdinal,
+      getTurnItem,
       getThreadRecords,
       getRuntimeRequest,
       getPlan,
@@ -5791,6 +5809,13 @@ export const layerMemory: Layer.Layer<ProjectionStoreV2> = Layer.effect(
                 ?.turnItems.reduce((max, item) => Math.max(max, item.ordinal), 0) ?? 0) + 1,
           ),
         ),
+      getTurnItem: ({ threadId, itemId }) =>
+        Ref.get(replayState).pipe(
+          Effect.map(
+            (state) =>
+              state.projections.get(threadId)?.turnItems.find((item) => item.id === itemId) ?? null,
+          ),
+        ),
       getThreadAttachmentIds: (threadId) =>
         service
           .getThreadProjection(threadId)
diff --git a/apps/server/src/orchestration-v2/ProviderAdapter.ts b/apps/server/src/orchestration-v2/ProviderAdapter.ts
index ac300004322e..0db242085c5e 100644
--- a/apps/server/src/orchestration-v2/ProviderAdapter.ts
+++ b/apps/server/src/orchestration-v2/ProviderAdapter.ts
@@ -398,6 +398,8 @@ export interface ProviderAdapterV2TurnInput {
   readonly threadId: ThreadId;
   readonly runId: RunId;
   readonly runOrdinal: number;
+  /** Whether the current native session has an accepted turn; omitted when unknown. */
+  readonly nativeThreadHasTurns?: boolean;
   readonly providerTurnOrdinal: number;
   readonly restartContinuationOfRunId?: RunId;
   readonly attemptId: RunAttemptId;
diff --git a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
index 98287944dee1..6eb0ef12e605 100644
--- a/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
+++ b/apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
@@ -149,33 +149,6 @@ function resolveStaleBackgroundItemProviderInstanceId(
   return projection.providerThreads[0]?.providerInstanceId ?? projection.thread.providerInstanceId;
 }
 
-/**
- * Provider threads with background work reconciliation would cancel and
- * record for their next turn.
- */
-function providerThreadsWithOpenBackgroundWork(
-  projection: ProjectionStore.ProjectionRuntimeRecoveryState,
-): ReadonlySet<ProviderThreadId> {
-  const ids = new Set<ProviderThreadId>();
-  for (const item of projection.turnItems ?? []) {
-    if (
-      !isBackgroundCapableTurnItemType(item.type) ||
-      !isNonterminalTurnItemStatus(item.status) ||
-      isAppOwnedDelegationItem(item)
-    )
-      continue;
-    const providerThreadId =
-      item.providerThreadId ??
-      projection.runs.find((run) => run.id === item.runId)?.providerThreadId;
-    if (providerThreadId != null) ids.add(providerThreadId);
-  }
-  for (const thread of projection.providerThreads ?? []) {
-    if (thread.ownerNodeId === null && providerThreadHasPendingBackgroundTasks(thread))
-      ids.add(thread.id);
-  }
-  return ids;
-}
-
 /**
  * A provider thread's latest started run: the last turn that provider saw.
  * Restart recovery records the thread's cancelled background work on it, and
@@ -668,7 +641,7 @@ export const make = Effect.gen(function* () {
       }
       const continuationRun =
         continueAfterRestart && trigger === "startup"
-          ? restartContinuationRun(projection, new Set(cancelledBackgroundWork.keys()))
+          ? restartContinuationRun(projection)
           : undefined;
       const effects: Array<EffectOutbox.PendingOrchestrationEffectV2> = continuationRun
         ? [
@@ -804,12 +777,7 @@ export const make = Effect.gen(function* () {
             .continueThreadsAfterServerUpdate
         )
           return;
-        // Shutdown reconciliation cancels the background work below, so a
-        // settled thread's continuation must be captured while it is still open.
-        const run = restartContinuationRun(
-          projection,
-          providerThreadsWithOpenBackgroundWork(projection),
-        );
+        const run = restartContinuationRun(projection);
         if (!run) return;
         const commandId = CommandId.make(`command:restart-prepare:${run.id}`);
         yield* eventSink.writeWithEffects({
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
index 696a40d8d176..0d44bac4c054 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
@@ -1082,7 +1082,7 @@ it.effect(
         const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
         assert.isDefined(token);
         const resolved = yield* registry.resolve(token!);
-        assert.equal(resolved?.threadId, threadId);
+        assert.equal(resolved?.thread.threadId, threadId);
         assert.deepEqual(
           resolved?.capabilities,
           new Set(["preview", "orchestration", "worktree", "pull-requests"]),
@@ -1317,7 +1317,7 @@ it.effect("ProviderSessionManagerV2 duplicate detach preserves replacement MCP c
         McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,
         replacement?.providerSessionId,
       );
-      assert.equal((yield* registry.resolve(replacementToken!))?.threadId, threadId);
+      assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
     });
 
     yield* effect.pipe(
@@ -1393,7 +1393,7 @@ it.effect(
           McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,
           replacement?.providerSessionId,
         );
-        assert.equal((yield* registry.resolve(replacementToken!))?.threadId, threadId);
+        assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
       });
 
       yield* effect.pipe(
@@ -1449,7 +1449,7 @@ it.effect(
         // process's MCP client keeps using the credential it was started with.
         yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
         assert.equal(
-          (yield* registry.resolve(originalToken!))?.threadId,
+          (yield* registry.resolve(originalToken!))?.thread.threadId,
           threadId,
           "detach must not revoke the credential the live provider process still holds",
         );
@@ -1468,7 +1468,7 @@ it.effect(
           original?.providerSessionId,
           "re-attach must reuse the existing credential, not rotate it",
         );
-        assert.equal((yield* registry.resolve(originalToken!))?.threadId, threadId);
+        assert.equal((yield* registry.resolve(originalToken!))?.thread.threadId, threadId);
 
         // Releasing the session (provider process gone) still revokes.
         yield* manager.close(providerSessionId);
@@ -1592,7 +1592,7 @@ it.effect(
           "the credential the adapter was configured with must remain current",
         );
         assert.equal(
-          (yield* registry.resolve(originalToken!))?.threadId,
+          (yield* registry.resolve(originalToken!))?.thread.threadId,
           threadId,
           "the predecessor release must not revoke a credential reserved by an in-flight open",
         );
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts
index 20e240e79c58..307bbb708b18 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts
@@ -1,3 +1,4 @@
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 import {
   ModelSelection,
@@ -36,7 +37,6 @@ import * as ServerSettings from "../serverSettings.ts";
 import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
 import * as EventSink from "./EventSink.ts";
 import * as IdAllocator from "./IdAllocator.ts";
-import { makeKeyedSerialExecutor } from "./KeyedSerialExecutor.ts";
 import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
 import {
   ProviderAdapterEventStreamError,
@@ -386,9 +386,9 @@ export const layerWithOptions = (
       // cannot drop cleanup for threads only the earlier session served.
       const releaseRecordRetries = yield* FiberSet.make();
       const nextSubscriberId = yield* Ref.make(0);
-      const sessionOpen = yield* makeKeyedSerialExecutor<ProviderSessionId>();
+      const sessionOpen = yield* KeyedLock.make<ProviderSessionId>();
       // Orders a thread's attach against a detach unloading it on the same session.
-      const threadAttachment = yield* makeKeyedSerialExecutor<string>();
+      const threadAttachment = yield* KeyedLock.make<string>();
       const threadAttachmentKey = (input: {
         readonly providerSessionId: ProviderSessionId;
         readonly threadId: ThreadId;
@@ -427,7 +427,7 @@ export const layerWithOptions = (
       };
       const isMcpCredentialReserved = (threadId: ThreadId, mcpCredentialId: string) =>
         (mcpCredentialReservations.get(mcpReservationKey(threadId, mcpCredentialId)) ?? 0) > 0;
-      const mcpPrepareLock = yield* makeKeyedSerialExecutor<ThreadId>();
+      const mcpPrepareLock = yield* KeyedLock.make<ThreadId>();
       /**
        * Resolves (or mints) the thread's MCP credential and returns it with a
        * reservation held; the caller must drop the reservation exactly once.
@@ -468,8 +468,8 @@ export const layerWithOptions = (
                   const resolved = yield* mcpSessionRegistry.resolve(rawToken);
                   if (
                     resolved !== undefined &&
-                    resolved.threadId === threadId &&
-                    resolved.providerInstanceId === providerInstanceId &&
+                    resolved.thread.threadId === threadId &&
+                    resolved.thread.providerInstanceId === providerInstanceId &&
                     // A flipped browser-access setting must not survive through
                     // credential reuse: rotate so the new scope reflects it.
                     resolved.capabilities.has("preview") === browserToolsAvailable &&
diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
index eba830319aaf..91fe20459ca2 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
@@ -227,6 +227,7 @@ it.effect(
           getTimelinePage: () => Effect.die("Unused timeline read"),
           getMessageCount: () => Effect.die("unused message count"),
           getNextTurnItemOrdinal: () => Effect.die("unused ordinal read"),
+          getTurnItem: () => Effect.die("unused turn item read"),
           getThreadRecords: () => Effect.die("unused record read"),
           getRuntimeRequest: () => Effect.die("unused getRuntimeRequest"),
           getRunningTurnContext: () => Effect.die("unused getRunningTurnContext"),
diff --git a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
index a3e3b122ca45..172b64d8a144 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnStartService.ts
@@ -1231,6 +1231,13 @@ export const layer: Layer.Layer<
               .filter((turn) => turn.providerThreadId === providerThread.id)
               .map((turn) => turn.ordinal),
           ) + 1,
+        // Legacy accepted attempts have no native id. They count only before
+        // a replacement, while no accepted attempt records a native identity.
+        nativeThreadHasTurns:
+          nativeInputRunIds.size > 0 ||
+          (legacyInputRunIds.size > 0 &&
+            sameNativeThread &&
+            !acceptedAttempts.some((source) => source.nativeThreadId !== undefined)),
         shouldStartProviderTurn: runControls.shouldStartProviderTurn,
         shouldFinalizeRun: runControls.shouldFinalizeRun,
         hasUnpairedRunInterruptRequest: runControls.hasUnpairedRunInterruptRequest,
diff --git a/apps/server/src/orchestration-v2/RestartContinuation.test.ts b/apps/server/src/orchestration-v2/RestartContinuation.test.ts
index e7cd4b9476a7..60704e23ec83 100644
--- a/apps/server/src/orchestration-v2/RestartContinuation.test.ts
+++ b/apps/server/src/orchestration-v2/RestartContinuation.test.ts
@@ -32,6 +32,8 @@ const driver = ProviderDriverKind.make("codex");
 const providerThreadId = ProviderThreadId.make("provider-thread:restart");
 const sessionId = ProviderSessionId.make("session:restart");
 const attemptId = RunAttemptId.make("attempt:restart");
+// "No project" threads belong to the environment's Scratch project.
+const scratchProjectId = ProjectId.make("project:scratch");
 
 function makeProjection() {
   return {
@@ -155,76 +157,63 @@ it("recovers an admitted continuation after another crash before provider start"
   assert.equal(restartContinuationRun(starting)?.id, runId);
 });
 
-it("continues a settled root run only when the restart cancelled its background work", () => {
+it("does not continue settled root runs with restart-cancelled background work", () => {
   const projection = makeProjection();
   const settled = {
     ...projection,
-    runs: [{ ...projection.runs[0]!, status: "completed" as const }],
+    runs: [
+      {
+        ...projection.runs[0]!,
+        status: "completed" as const,
+        restartCancelledBackgroundWork: [{ kind: "shell" as const, label: "sleep 25" }],
+      },
+    ],
     providerThreads: [{ ...projection.providerThreads[0]!, status: "idle" as const }],
     providerSessions: [{ ...projection.providerSessions[0]!, status: "stopped" as const }],
     providerTurns: [],
   };
-  const lostWork = new Set([providerThreadId]);
-  assert.isUndefined(restartContinuationRun(settled));
-  assert.equal(restartContinuationRun(settled, lostWork)?.id, runId);
-  // Work an older provider thread launched (before a provider switch) is not
-  // this run's: its provider was never told about it and cannot continue it.
-  assert.isUndefined(
-    restartContinuationRun(settled, new Set([ProviderThreadId.make("provider-thread:claude")])),
-  );
-  for (const invalid of [
-    { ...settled, thread: { ...settled.thread, archivedAt: {} } },
-    { ...settled, thread: { ...settled.thread, deletedAt: {} } },
-    { ...settled, runs: [{ ...settled.runs[0]!, status: "failed" as const }] },
-    {
-      ...settled,
-      providerThreads: [{ ...settled.providerThreads[0]!, nativeThreadRef: null }],
-    },
-  ])
-    assert.isUndefined(
-      restartContinuationRun(invalid as OrchestrationV2ThreadProjection, lostWork),
-    );
+  for (const projectId of [scratchProjectId, projection.thread.projectId])
+    for (const status of ["completed", "waiting"] as const)
+      assert.isUndefined(
+        restartContinuationRun({
+          ...settled,
+          thread: { ...settled.thread, projectId },
+          runs: [{ ...settled.runs[0]!, status }],
+        }),
+      );
 });
 
-it.effect("prompts a settled thread's continuation with the note of its lost work", () =>
-  Effect.gen(function* () {
-    const base = makeProjection();
-    const work = [{ kind: "shell" as const, label: "sleep 25 && echo DONE" }];
-    const projection = {
-      ...base,
-      runs: [{ ...base.runs[0]!, status: "completed", restartCancelledBackgroundWork: work }],
-      providerTurns: [{ ...base.providerTurns[0]!, status: "completed" }],
-    } as unknown as OrchestrationV2ThreadProjection;
-    const commands: Parameters<
-      ThreadManagementService.ThreadManagementService["Service"]["dispatch"]
-    >[0][] = [];
-    yield* continueRestartedRun({ threadId, sourceRunId: runId }).pipe(
-      Effect.provide(
-        Layer.merge(
-          Layer.mock(ThreadManagementService.ThreadManagementService)({
-            getThreadRecords: () => Effect.succeed(projection),
-            recoverDelegatedTask: () => Effect.void,
-            dispatch: (command) => {
-              commands.push(command);
-              return Effect.succeed({} as never);
-            },
-          }),
-          ServerSettings.layerTest({ continueThreadsAfterServerUpdate: true }),
+it.effect.each(["completed", "waiting", "cancelled"] as const)(
+  "ignores a pending restart continuation for a %s run whose provider turn settled",
+  (status) =>
+    Effect.gen(function* () {
+      const base = makeProjection();
+      const work = [{ kind: "shell" as const, label: "sleep 25 && echo DONE" }];
+      const projection = {
+        ...base,
+        runs: [{ ...base.runs[0]!, status, restartCancelledBackgroundWork: work }],
+        providerTurns: [{ ...base.providerTurns[0]!, status: "completed" }],
+      } as unknown as OrchestrationV2ThreadProjection;
+      const commands: Parameters<
+        ThreadManagementService.ThreadManagementService["Service"]["dispatch"]
+      >[0][] = [];
+      yield* continueRestartedRun({ threadId, sourceRunId: runId }).pipe(
+        Effect.provide(
+          Layer.merge(
+            Layer.mock(ThreadManagementService.ThreadManagementService)({
+              getThreadRecords: () => Effect.succeed(projection),
+              recoverDelegatedTask: () => Effect.void,
+              dispatch: (command) => {
+                commands.push(command);
+                return Effect.succeed({} as never);
+              },
+            }),
+            ServerSettings.layerTest({ continueThreadsAfterServerUpdate: true }),
+          ),
         ),
-      ),
-    );
-    assert.lengthOf(commands, 1);
-    const command = commands[0]!;
-    assert.equal(
-      command.type === "message.dispatch" ? command.restartContinuationOfRunId : null,
-      runId,
-    );
-    assert.include(
-      command.type === "message.dispatch" ? command.text : "",
-      "sleep 25 && echo DONE",
-    );
-    assert.notInclude(command.type === "message.dispatch" ? command.text : "", "Continue where");
-  }),
+      );
+      assert.lengthOf(commands, 0);
+    }),
 );
 
 it.effect("does not continue a failed run that lost background work", () =>
@@ -419,7 +408,7 @@ it.effect("prepares no continuation for background work another provider thread
     );
     yield* recovery.prepareForShutdown;
     assert.lengthOf(writes, 0);
-    // The same work on the Codex run's own provider thread is continued.
+    // Work on the settled run's own provider thread must not wake it either.
     const ownWork = {
       ...projection,
       turnItems: [{ ...projection.turnItems[0]!, providerThreadId }],
@@ -446,13 +435,103 @@ it.effect("prepares no continuation for background work another provider thread
       ),
     );
     yield* ownRecovery.prepareForShutdown;
-    assert.deepEqual(
-      writes.map((write) => write.effects[0]?.request),
-      [{ type: "provider-runtime.continue", sourceRunId: runId }],
-    );
+    assert.lengthOf(writes, 0);
   }),
 );
 
+it.effect.each([
+  ["completed", scratchProjectId],
+  ["completed", ProjectId.make("restart-project")],
+  ["waiting", scratchProjectId],
+  ["waiting", ProjectId.make("restart-project")],
+] as const)(
+  "cleans up background work without waking a %s run in project %s",
+  ([status, projectId]) =>
+    Effect.gen(function* () {
+      const base = makeProjection();
+      const projection = {
+        ...base,
+        thread: { ...base.thread, projectId },
+        runs: [{ ...base.runs[0]!, status }],
+        providerTurns: [{ ...base.providerTurns[0]!, status: "completed" }],
+        turnItems: [
+          {
+            id: "turn-item:background-subagent",
+            runId,
+            nodeId: null,
+            providerThreadId,
+            providerInstanceId: instanceId,
+            type: "subagent",
+            subagentId: "subagent:background",
+            title: "Background reviewer",
+            status: "running",
+          },
+        ],
+        subagents: [
+          {
+            id: "subagent:background",
+            runId,
+            driver,
+            providerInstanceId: instanceId,
+            status: "running",
+          },
+        ],
+      } as unknown as OrchestrationV2ThreadProjection;
+      for (const trigger of ["startup", "shutdown"] as const) {
+        const commits: Parameters<EventSink.EventSinkV2["Service"]["commitCommand"]>[0][] = [];
+        const writes: Parameters<EventSink.EventSinkV2["Service"]["writeWithEffects"]>[0][] = [];
+        const recovery = yield* ProviderRuntimeRecovery.make.pipe(
+          Effect.provide(
+            Layer.mergeAll(
+              ServerSettings.layerTest({ continueThreadsAfterServerUpdate: true }),
+              Layer.mock(ProjectionStore.ProjectionStoreV2)({
+                getRecoveryThreadIds: () => Effect.succeed([threadId]),
+                getRuntimeRecoveryProjection: () => Effect.succeed(projection),
+              }),
+              Layer.mock(EventSink.EventSinkV2)({
+                writeWithEffects: (input) =>
+                  Effect.sync(() => {
+                    writes.push(input);
+                    return [];
+                  }),
+                commitCommand: (input) =>
+                  Effect.sync(() => {
+                    commits.push(input);
+                    return { committed: true, cancelledEffectCount: 0 } as never;
+                  }),
+              }),
+              IdAllocator.layer,
+              Layer.mock(EffectWorker.OrchestrationEffectWorkerV2)({
+                runRecoveryOnce: Effect.succeed(false),
+              }),
+              Layer.mock(EffectOutbox.EffectOutboxV2)({
+                listByCommandId: () => Effect.succeed([]),
+                reconcileAfterProcessLoss: Effect.succeed({ requeued: 0, cancelled: 0 }),
+              }),
+            ),
+          ),
+        );
+        if (trigger === "shutdown") yield* recovery.prepareForShutdown;
+        yield* recovery.reconcile(trigger);
+        assert.lengthOf(writes, 0);
+        assert.lengthOf(commits, 1);
+        assert.lengthOf(commits[0]!.effects, 0);
+        const events = commits[0]!.events;
+        for (const type of ["turn-item.updated", "subagent.updated"] as const)
+          assert.isTrue(
+            events.some((event) => event.type === type && event.payload.status === "cancelled"),
+          );
+        const note = events.find((event) => event.type === "run.background-work-cancelled");
+        assert.equal(note?.runId, runId);
+        assert.deepEqual(note?.payload.restartCancelledBackgroundWork, [
+          { kind: "subagent", label: "Background reviewer", id: "turn-item:background-subagent" },
+        ]);
+        if (status === "completed")
+          assert.isFalse(events.some((event) => event.type === "run.updated"));
+      }
+    }),
+);
+
 it.effect("does not cancel or resume a run that completes while shutdown intent commits", () =>
   Effect.gen(function* () {
     let projection = makeProjection();
diff --git a/apps/server/src/orchestration-v2/RestartContinuation.ts b/apps/server/src/orchestration-v2/RestartContinuation.ts
index f91d1a1e5f73..013e7a07fbc4 100644
--- a/apps/server/src/orchestration-v2/RestartContinuation.ts
+++ b/apps/server/src/orchestration-v2/RestartContinuation.ts
@@ -4,7 +4,6 @@ import {
   CommandId,
   MessageId,
   type OrchestrationV2Run,
-  type ProviderThreadId,
   type RunId,
   type ThreadId,
 } from "@t3tools/contracts";
@@ -23,16 +22,14 @@ import {
 const CONTINUE_PROMPT = "Continue where you left off.";
 
 /**
- * The run a restart continuation resumes, if any: an unfinished root run, or a
- * settled one whose own provider thread lost background work in the restart
- * (`cancelledWorkProviderThreadIds`, which recovery records on that thread).
+ * Resume only an unfinished root turn. Leftover background work is cleaned up
+ * separately and reported on the next user turn; it must not wake a settled run.
  */
 export function restartContinuationRun(
   projection: Pick<
     ProjectionRuntimeRecoveryState,
     "thread" | "runs" | "providerThreads" | "providerSessions" | "providerTurns"
   >,
-  cancelledWorkProviderThreadIds: ReadonlySet<ProviderThreadId> = new Set(),
 ): OrchestrationV2Run | undefined {
   if (projection.thread.archivedAt !== null || projection.thread.deletedAt !== null) return;
   // Queued runs never started; recovery holds them behind the cut run.
@@ -46,13 +43,8 @@ export function restartContinuationRun(
   if (!run) return;
   const preparedContinuation =
     run.status === "starting" && run.restartContinuationOfRunId !== undefined;
-  // Background work outlived this settled turn; the provider has no live turn.
-  const settledWithCancelledWork =
-    (run.status === "completed" || run.status === "waiting") &&
-    run.providerThreadId !== null &&
-    cancelledWorkProviderThreadIds.has(run.providerThreadId);
-  if (run.status !== "running" && !preparedContinuation && !settledWithCancelledWork) return;
-  const liveTurnRequired = !preparedContinuation && !settledWithCancelledWork;
+  if (run.status !== "running" && !preparedContinuation) return;
+  const liveTurnRequired = !preparedContinuation;
   if (projection.thread.providerInstanceId !== run.providerInstanceId) return;
   const providerThread = projection.providerThreads.find(
     (thread) => thread.id === run.providerThreadId,
@@ -73,16 +65,13 @@ export function restartContinuationRun(
   const session = projection.providerSessions.find(
     (candidate) => candidate.id === providerThread.providerSessionId,
   );
-  // A settled thread's session may already be stopped and out of the recovery
-  // read; the continuation reopens it from the provider thread's native ref.
   // Most adapters keep a live session "ready" through its turns, so only a
   // stopped or failed session rules out a live turn.
   if (
-    session === undefined
-      ? !settledWithCancelledWork
-      : session.providerInstanceId !== run.providerInstanceId ||
-        session.driver !== providerThread.driver ||
-        (liveTurnRequired && (session.status === "stopped" || session.status === "error"))
+    session === undefined ||
+    session.providerInstanceId !== run.providerInstanceId ||
+    session.driver !== providerThread.driver ||
+    (liveTurnRequired && (session.status === "stopped" || session.status === "error"))
   )
     return;
   if (
@@ -119,10 +108,14 @@ export const continueRestartedRun = Effect.fn("RestartContinuation.continueResta
 
     if (projection.messages.some((message) => message.id === messageId)) return;
     const source = projection.runs.find((run) => run.id === input.sourceRunId);
-    // A settled source prompts with the note of the background work it lost.
-    const noteSource =
-      source !== undefined && isRestartNoteSource(source, projection.providerTurns);
-    if (!source || (source.status !== "cancelled" && !noteSource)) return;
+    // Pending effects from older versions may target settled background work,
+    // including waiting runs that reconciliation subsequently cancelled.
+    if (
+      !source ||
+      source.status !== "cancelled" ||
+      isRestartNoteSource(source, projection.providerTurns)
+    )
+      return;
     // A user submission after reconciliation takes precedence over an automatic
     // prompt. Queued runs never started and stay held behind this one.
     if (
diff --git a/apps/server/src/orchestration-v2/RunExecutionService.ts b/apps/server/src/orchestration-v2/RunExecutionService.ts
index 6aff5da24f1e..7ab2c87cdef4 100644
--- a/apps/server/src/orchestration-v2/RunExecutionService.ts
+++ b/apps/server/src/orchestration-v2/RunExecutionService.ts
@@ -507,6 +507,7 @@ export interface RunExecutionServiceV2StartRootRunInput {
   readonly attempt: OrchestrationV2RunAttempt;
   readonly attemptId: RunAttemptId;
   readonly providerTurnOrdinal: number;
+  readonly nativeThreadHasTurns?: boolean;
   readonly loadInheritedBackgroundTurnItems?: () => Effect.Effect<
     ReadonlyArray<InheritedBackgroundTurnItemRoute>,
     unknown
@@ -1348,6 +1349,9 @@ export const layer: Layer.Layer<
             runId: input.run.id,
             runOrdinal: input.run.ordinal,
             providerTurnOrdinal: input.providerTurnOrdinal,
+            ...(input.nativeThreadHasTurns === undefined
+              ? {}
+              : { nativeThreadHasTurns: input.nativeThreadHasTurns }),
             ...(input.run.restartContinuationOfRunId === undefined
               ? {}
               : {
diff --git a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
index 6a8dded63caa..d72b036316c9 100644
--- a/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
+++ b/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts
@@ -47,6 +47,7 @@ it.effect.each(
           "before dispatch",
           "after delivery",
           "without native steering",
+          "with interrupting native steering",
           "settled only",
         ] as const
       ).map((timing) => ({
@@ -57,7 +58,10 @@ it.effect.each(
     )
     .filter(
       ({ mailbox, timing }) =>
-        mailbox || (timing !== "without native steering" && timing !== "settled only"),
+        mailbox ||
+        (timing !== "without native steering" &&
+          timing !== "with interrupting native steering" &&
+          timing !== "settled only"),
     ),
 )("delivers $label when completion wins $timing", ({ mailbox, timing }) =>
   Effect.scoped(
@@ -73,6 +77,7 @@ it.effect.each(
         turns: {
           ...CodexProviderCapabilitiesV2.turns,
           supportsActiveSteering: timing !== "without native steering",
+          activeSteeringInterruptsTools: timing === "with interrupting native steering",
         },
       };
       const adapter: ProviderAdapterV2Shape = {
diff --git a/apps/server/src/orchestration-v2/SubagentProjection.ts b/apps/server/src/orchestration-v2/SubagentProjection.ts
index fa912dfda0ba..f28dc1aa4be5 100644
--- a/apps/server/src/orchestration-v2/SubagentProjection.ts
+++ b/apps/server/src/orchestration-v2/SubagentProjection.ts
@@ -57,6 +57,8 @@ export function makeSubagentChildThread(input: {
     creationSource: input.creationSource,
     id: input.childThreadId,
     title: input.title,
+    linkedPullRequest: null,
+    pullRequests: [],
     historyOrigin: undefined,
     providerInstanceId: input.providerInstanceId,
     modelSelection: input.modelSelection,
diff --git a/apps/server/src/orchestration-v2/ThreadCommandExecutor.ts b/apps/server/src/orchestration-v2/ThreadCommandExecutor.ts
index c9863776d44a..cec1feb122fc 100644
--- a/apps/server/src/orchestration-v2/ThreadCommandExecutor.ts
+++ b/apps/server/src/orchestration-v2/ThreadCommandExecutor.ts
@@ -1,13 +1,12 @@
 import type { ThreadId } from "@t3tools/contracts";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 
-import { makeKeyedSerialExecutor, type KeyedSerialExecutor } from "./KeyedSerialExecutor.ts";
-
 /** Shared by thread commands and project deletion so both plan against current thread state. */
 export class ThreadCommandExecutor extends Context.Service<
   ThreadCommandExecutor,
-  KeyedSerialExecutor<ThreadId>
+  KeyedLock.KeyedLock<ThreadId>
 >()("t3/orchestration-v2/ThreadCommandExecutor") {}
 
-export const layer = Layer.effect(ThreadCommandExecutor, makeKeyedSerialExecutor<ThreadId>());
+export const layer = Layer.effect(ThreadCommandExecutor, KeyedLock.make<ThreadId>());
diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.ts b/apps/server/src/orchestration-v2/ThreadManagementService.ts
index 37d4bdf3815f..d61973cfe20d 100644
--- a/apps/server/src/orchestration-v2/ThreadManagementService.ts
+++ b/apps/server/src/orchestration-v2/ThreadManagementService.ts
@@ -10,6 +10,7 @@ import {
   type ModelSelection,
   type OrchestrationV2Actor,
   type OrchestrationV2Command,
+  type OrchestrationV2GetTurnItemResult,
   type OrchestrationV2ServerCommand,
   type OrchestrationV2ConversationMessage,
   type OrchestrationV2CreationSource,
@@ -22,6 +23,7 @@ import {
   RunId,
   type ScheduledTaskId,
   ThreadId,
+  type TurnItemId,
 } from "@t3tools/contracts";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
@@ -33,6 +35,7 @@ import * as Schema from "effect/Schema";
 
 import { makeLocalRunRefusal } from "./cloudOnlyHost.ts";
 import * as Orchestrator from "./Orchestrator.ts";
+import { projectTurnItemForDetail } from "./WireProjection.ts";
 import * as LegacyV1ThreadImporter from "./legacy/LegacyV1ThreadImporter.ts";
 
 export type ThreadManagementSendMode = "auto" | "queue" | "steer" | "restart";
@@ -277,6 +280,14 @@ export interface ThreadManagementServiceShape {
   ) => Effect.Effect<Orchestrator.OrchestratorV2DispatchResult, Orchestrator.OrchestratorV2Error>;
   readonly getTimelinePage: Orchestrator.OrchestratorV2["Service"]["getTimelinePage"];
   readonly getMessageCount: Orchestrator.OrchestratorV2["Service"]["getMessageCount"];
+  /**
+   * One turn item with the input and output the thread stream withholds,
+   * bounded for the wire. Clients fetch it when a tool row is expanded.
+   */
+  readonly getTurnItem: (input: {
+    readonly threadId: ThreadId;
+    readonly itemId: TurnItemId;
+  }) => Effect.Effect<OrchestrationV2GetTurnItemResult, Orchestrator.OrchestratorV2Error>;
   readonly getThreadRecords: Orchestrator.OrchestratorV2["Service"]["getThreadRecords"];
   readonly getThreadProjection: (
     threadId: ThreadId,
@@ -727,6 +738,11 @@ const make = Effect.gen(function* () {
       ensureProjectionTranscript(threadId).pipe(
         Effect.andThen(orchestrator.getMessageCount(threadId)),
       ),
+    getTurnItem: (input) =>
+      ensureProjectionTranscript(input.threadId).pipe(
+        Effect.andThen(orchestrator.getTurnItem(input)),
+        Effect.map((item) => ({ item: item === null ? null : projectTurnItemForDetail(item) })),
+      ),
     getThreadRecords: (threadId, fields, filter) =>
       ensureProjectionTranscript(threadId).pipe(
         Effect.andThen(orchestrator.getThreadRecords(threadId, fields, filter)),
diff --git a/apps/server/src/orchestration-v2/WireProjection.test.ts b/apps/server/src/orchestration-v2/WireProjection.test.ts
index 846ed1f1a1f1..48a4881bdfb4 100644
--- a/apps/server/src/orchestration-v2/WireProjection.test.ts
+++ b/apps/server/src/orchestration-v2/WireProjection.test.ts
@@ -17,7 +17,11 @@ import { describe, expect, it } from "@effect/vitest";
 import * as DateTime from "effect/DateTime";
 import * as Schema from "effect/Schema";
 
-import { projectTurnItemForWire, projectDomainEventForWire } from "./WireProjection.ts";
+import {
+  projectTurnItemForWire,
+  projectTurnItemForDetail,
+  projectDomainEventForWire,
+} from "./WireProjection.ts";
 import { threadShellFromProjection } from "./ProjectionStore.ts";
 
 const decodeTurnItem = Schema.decodeUnknownSync(OrchestrationV2TurnItem);
@@ -173,7 +177,7 @@ describe("orchestration V2 wire projection", () => {
 
   it("omits even small dynamic tool results while retaining input", () => {
     const item = { ...base, output: { ok: true } } satisfies OrchestrationV2TurnItem;
-    expect(projectTurnItemForWire(item)).toEqual(base);
+    expect(projectTurnItemForWire(item)).toEqual({ ...base, outputOmitted: true });
     expect(item.output).toEqual({ ok: true });
   });
 
@@ -252,10 +256,24 @@ describe("orchestration V2 wire projection", () => {
       const projected = projectTurnItemForWire(item);
       expect(projected).not.toHaveProperty("output");
       expect(projected).toMatchObject({ input: "test", status: "completed" });
+      // Clients fetch withheld output on demand, so they need to know it exists.
+      expect(projected.type === "command_execution" ? projected.outputOmitted : null).toBe(
+        output ? true : undefined,
+      );
       expect(item.output).toBe(output);
     },
   );
 
+  it.each([
+    ["echo ok", "echo ok"],
+    ["a".repeat(262_143) + "😀", "a".repeat(262_143) + "\n… output truncated for transport"],
+  ])("bounds fetched command input without changing persistence, case %#", (input, expected) => {
+    const item = { ...base, type: "command_execution" as const, input, output: "ok" };
+    const projected = projectTurnItemForDetail(item);
+    expect(projected).toMatchObject({ input: expected, output: "ok" });
+    expect(item.input).toBe(input);
+  });
+
   it("keeps failure evidence without retaining command output", () => {
     const item = {
       ...base,
@@ -290,6 +308,14 @@ describe("orchestration V2 wire projection", () => {
     expect(projected).not.toHaveProperty("newStr");
     expect(projected).toMatchObject({ fileName: "src/main.ts", additions: 3, deletions: 1 });
     expect(item.diffStr).toBe("+new code");
+    // A failed edit keeps the provider's error so expanding the row can show it.
+    const failed = projectTurnItemForWire({
+      ...item,
+      status: "failed",
+      diffStr: "String to replace not found",
+    });
+    expect(failed).toMatchObject({ diffStr: "String to replace not found" });
+    expect(failed).not.toHaveProperty("newStr");
   });
 
   it("retains only result identities and failure metadata in live tool events", () => {
diff --git a/apps/server/src/orchestration-v2/WireProjection.ts b/apps/server/src/orchestration-v2/WireProjection.ts
index b72cd0542457..7c17147d220a 100644
--- a/apps/server/src/orchestration-v2/WireProjection.ts
+++ b/apps/server/src/orchestration-v2/WireProjection.ts
@@ -8,19 +8,22 @@ import { compactDynamicToolOutput, toolOutputIndicatesFailure } from "@t3tools/s
 
 const MAX_DETAIL_STRING_BYTES = 32_768;
 const MAX_DYNAMIC_VALUE_BYTES = 16_384;
+const MAX_ON_DEMAND_BYTES = 256 * 1024;
 
-function truncateDetail(value: string | undefined): string | undefined {
+function truncateDetail(
+  value: string | undefined,
+  maxBytes = MAX_DETAIL_STRING_BYTES,
+): string | undefined {
   if (
     value === undefined ||
-    (value.length <= MAX_DETAIL_STRING_BYTES &&
-      Buffer.byteLength(value, "utf8") <= MAX_DETAIL_STRING_BYTES)
+    (value.length <= maxBytes && Buffer.byteLength(value, "utf8") <= maxBytes)
   ) {
     return value;
   }
   // UTF-8 needs at least one byte per UTF-16 code unit. Only encode the prefix
   // that could fit, rather than allocating a buffer for the complete output.
-  const prefix = Buffer.from(value.slice(0, MAX_DETAIL_STRING_BYTES), "utf8")
-    .subarray(0, MAX_DETAIL_STRING_BYTES)
+  const prefix = Buffer.from(value.slice(0, maxBytes), "utf8")
+    .subarray(0, maxBytes)
     .toString("utf8")
     .replace(/\uFFFD$/u, "");
   return `${prefix}\n… output truncated for transport`;
@@ -80,13 +83,20 @@ export function projectTurnItemForWire(item: OrchestrationV2TurnItem): Orchestra
         (item.exitCode !== undefined && item.exitCode !== 0) ||
         (output !== undefined &&
           toolOutputIndicatesFailure(output.slice(0, MAX_DETAIL_STRING_BYTES)));
-      return failed ? { ...projected, outputIndicatesFailure: true } : projected;
+      return {
+        ...projected,
+        ...(failed ? { outputIndicatesFailure: true } : {}),
+        ...(output?.trim() ? { outputOmitted: true } : {}),
+      };
     }
     case "file_change": {
       // File identity and counts are enough for activity. Full diffs already
       // have a dedicated read path and remain intact in persistence.
-      const { diffStr: _diff, oldStr: _old, newStr: _new, ...projected } = item;
-      return projected;
+      const { diffStr, oldStr: _old, newStr: _new, ...projected } = item;
+      // A failed edit stores the provider's error where the diff would be.
+      return item.status === "failed" && diffStr?.trim()
+        ? { ...projected, diffStr: truncateDetail(diffStr) }
+        : projected;
     }
     case "subagent":
       return {
@@ -102,6 +112,7 @@ export function projectTurnItemForWire(item: OrchestrationV2TurnItem): Orchestra
         ...projected,
         input: summarizeDynamicValue(item.input),
         ...(output === undefined ? {} : { output }),
+        ...(hasDynamicValue(rawOutput) ? { outputOmitted: true } : {}),
       };
     }
     default:
@@ -109,6 +120,62 @@ export function projectTurnItemForWire(item: OrchestrationV2TurnItem): Orchestra
   }
 }
 
+function hasDynamicValue(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value !== "object" || Object.keys(value).length > 0;
+}
+
+function boundDynamicValue(value: unknown): unknown {
+  if (value === undefined) return value;
+  if (typeof value === "string") return truncateDetail(value, MAX_ON_DEMAND_BYTES);
+  let json: string;
+  try {
+    // Compact, so measuring does not inflate the value; clients indent it.
+    json = JSON.stringify(value) ?? String(value);
+  } catch {
+    return "Unserializable tool value";
+  }
+  return Buffer.byteLength(json, "utf8") <= MAX_ON_DEMAND_BYTES
+    ? value
+    : truncateDetail(json, MAX_ON_DEMAND_BYTES);
+}
+
+/**
+ * Projects one item for an on-demand detail read: keeps the input and output
+ * the timeline withholds, bounded so a huge result cannot stall the socket.
+ */
+export function projectTurnItemForDetail(item: OrchestrationV2TurnItem): OrchestrationV2TurnItem {
+  switch (item.type) {
+    case "command_execution":
+      return {
+        ...item,
+        input: truncateDetail(item.input, MAX_ON_DEMAND_BYTES) ?? "",
+        output: truncateDetail(item.output, MAX_ON_DEMAND_BYTES),
+      };
+    case "dynamic_tool":
+      return {
+        ...item,
+        input: boundDynamicValue(item.input),
+        output: boundDynamicValue(item.output),
+      };
+    case "subagent":
+      return {
+        ...item,
+        prompt: truncateDetail(item.prompt, MAX_ON_DEMAND_BYTES) ?? "",
+        progress: truncateDetail(item.progress, MAX_ON_DEMAND_BYTES),
+        result:
+          item.result === null ? null : (truncateDetail(item.result, MAX_ON_DEMAND_BYTES) ?? null),
+      };
+    case "handoff":
+    case "file_change":
+      return projectTurnItemForWire(item);
+    default:
+      return item;
+  }
+}
+
 export function projectContextHandoffForWire(
   handoff: OrchestrationV2ContextHandoff,
 ): OrchestrationV2ContextHandoff {
diff --git a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
index 20988ac44f00..9a87bec48bbb 100644
--- a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
+++ b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts
@@ -21,6 +21,7 @@ import {
   ThreadPullRequestLink,
   TurnItemId,
 } from "@t3tools/contracts";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
@@ -30,7 +31,6 @@ import * as Schema from "effect/Schema";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
 import * as EventSink from "../EventSink.ts";
-import { makeKeyedSerialExecutor } from "../KeyedSerialExecutor.ts";
 import { randomUuidV4 } from "../RandomUuid.ts";
 
 const IMPORT_EVENT_PREFIX = "migration:v1";
@@ -347,7 +347,7 @@ function chunks<A>(items: ReadonlyArray<A>, size: number): Array<ReadonlyArray<A
 const make = Effect.gen(function* () {
   const sql = yield* SqlClient.SqlClient;
   const eventSink = yield* EventSink.EventSinkV2;
-  const transcriptImports = yield* makeKeyedSerialExecutor<ThreadId>();
+  const transcriptImports = yield* KeyedLock.make<ThreadId>();
 
   const listMessages = (threadId: ThreadId) =>
     sql<LegacyMessageRow>`
diff --git a/apps/server/src/orchestration-v2/runtimeLayer.test.ts b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
index 84d6df90160a..c2f0024b0542 100644
--- a/apps/server/src/orchestration-v2/runtimeLayer.test.ts
+++ b/apps/server/src/orchestration-v2/runtimeLayer.test.ts
@@ -2645,84 +2645,86 @@ it.layer(TestLayer)("OrchestrationV2LayerLive lifecycle", (it) => {
       }),
   );
 
-  it.effect("does not admit a restart continuation of a failed run that lost background work", () =>
-    Effect.gen(function* () {
-      const orchestrator = yield* Orchestrator.OrchestratorV2;
-      const eventSink = yield* EventSink.EventSinkV2;
-      const threadId = ThreadId.make("runtime-layer-restart-failed-source");
-      yield* orchestrator.dispatch({
-        type: "thread.create",
-        createdBy: "user",
-        creationSource: "web",
-        commandId: CommandId.make("restart-failed-create"),
-        threadId,
-        projectId: ProjectId.make("restart-project"),
-        title: "Restart",
-        modelSelection,
-        runtimeMode: "full-access",
-        interactionMode: "default",
-        branch: null,
-        worktreePath: "/tmp/runtime-layer-restart-failed",
-      });
-      yield* orchestrator.dispatch({
-        type: "message.dispatch",
-        createdBy: "user",
-        creationSource: "web",
-        commandId: CommandId.make("restart-failed-user-message"),
-        threadId,
-        messageId: MessageId.make("restart-failed-user-message"),
-        text: "Original work",
-        attachments: [],
-        modelSelection,
-        dispatchMode: { type: "start_immediately" },
-      });
-      const original = (yield* orchestrator.getThreadProjection(threadId)).runs[0]!;
-      const now = yield* DateTime.now;
-      yield* eventSink.commitCommand({
-        commandId: CommandId.make("restart-failed-reconcile"),
-        threadId,
-        commandType: "provider-runtime.reconcile",
-        acceptedAt: now,
-        events: [
-          {
-            id: EventId.make("restart-failed-run"),
-            type: "run.updated",
-            threadId,
-            runId: original.id,
-            occurredAt: now,
-            payload: { ...original, status: "failed", completedAt: now },
-          },
-          {
-            id: EventId.make("restart-failed-work"),
-            type: "run.background-work-cancelled",
-            threadId,
-            runId: original.id,
-            occurredAt: now,
-            payload: {
+  it.effect.each(["failed", "completed", "waiting", "cancelled"] as const)(
+    "does not admit a restart continuation of a %s run with only lost background work",
+    (status) =>
+      Effect.gen(function* () {
+        const orchestrator = yield* Orchestrator.OrchestratorV2;
+        const eventSink = yield* EventSink.EventSinkV2;
+        const threadId = ThreadId.make(`runtime-layer-restart-${status}-source`);
+        yield* orchestrator.dispatch({
+          type: "thread.create",
+          createdBy: "user",
+          creationSource: "web",
+          commandId: CommandId.make(`restart-${status}-create`),
+          threadId,
+          projectId: ProjectId.make("restart-project"),
+          title: "Restart",
+          modelSelection,
+          runtimeMode: "full-access",
+          interactionMode: "default",
+          branch: null,
+          worktreePath: "/tmp/runtime-layer-restart-failed",
+        });
+        yield* orchestrator.dispatch({
+          type: "message.dispatch",
+          createdBy: "user",
+          creationSource: "web",
+          commandId: CommandId.make(`restart-${status}-user-message`),
+          threadId,
+          messageId: MessageId.make(`restart-${status}-user-message`),
+          text: "Original work",
+          attachments: [],
+          modelSelection,
+          dispatchMode: { type: "start_immediately" },
+        });
+        const original = (yield* orchestrator.getThreadProjection(threadId)).runs[0]!;
+        const now = yield* DateTime.now;
+        yield* eventSink.commitCommand({
+          commandId: CommandId.make(`restart-${status}-reconcile`),
+          threadId,
+          commandType: "provider-runtime.reconcile",
+          acceptedAt: now,
+          events: [
+            {
+              id: EventId.make(`restart-${status}-run`),
+              type: "run.updated",
+              threadId,
               runId: original.id,
-              restartCancelledBackgroundWork: [{ kind: "shell", label: "sleep 25" }],
+              occurredAt: now,
+              payload: { ...original, status, completedAt: now },
             },
-          },
-        ],
-        effects: [],
-      });
-      yield* orchestrator.dispatch({
-        type: "message.dispatch",
-        createdBy: "agent",
-        creationSource: "server",
-        commandId: CommandId.make("restart-failed-continuation"),
-        threadId,
-        messageId: MessageId.make("restart-failed-continuation"),
-        text: "Note: the T3 server restarted.",
-        attachments: [],
-        modelSelection,
-        dispatchMode: { type: "start_immediately" },
-        restartContinuationOfRunId: original.id,
-      });
-      const projection = yield* orchestrator.getThreadProjection(threadId);
-      assert.lengthOf(projection.runs, 1);
-      assert.equal(projection.runs[0]?.status, "failed");
-    }),
+            {
+              id: EventId.make(`restart-${status}-work`),
+              type: "run.background-work-cancelled",
+              threadId,
+              runId: original.id,
+              occurredAt: now,
+              payload: {
+                runId: original.id,
+                restartCancelledBackgroundWork: [{ kind: "shell", label: "sleep 25" }],
+              },
+            },
+          ],
+          effects: [],
+        });
+        yield* orchestrator.dispatch({
+          type: "message.dispatch",
+          createdBy: "agent",
+          creationSource: "server",
+          commandId: CommandId.make(`restart-${status}-continuation`),
+          threadId,
+          messageId: MessageId.make(`restart-${status}-continuation`),
+          text: "Note: the T3 server restarted.",
+          attachments: [],
+          modelSelection,
+          dispatchMode: { type: "start_immediately" },
+          restartContinuationOfRunId: original.id,
+        });
+        const projection = yield* orchestrator.getThreadProjection(threadId);
+        assert.lengthOf(projection.runs, 1);
+        assert.equal(projection.runs[0]?.status, status);
+      }),
   );
 
   it.effect("rejects settling a thread while a run is active", () =>
diff --git a/apps/server/src/orchestration-v2/testkit/OrchestratorReplayRestartBackgroundNote.integration.test.ts b/apps/server/src/orchestration-v2/testkit/OrchestratorReplayRestartBackgroundNote.integration.test.ts
index fc61c61646bc..d9e6a7f13161 100644
--- a/apps/server/src/orchestration-v2/testkit/OrchestratorReplayRestartBackgroundNote.integration.test.ts
+++ b/apps/server/src/orchestration-v2/testkit/OrchestratorReplayRestartBackgroundNote.integration.test.ts
@@ -11,6 +11,7 @@ import {
   makeClaudeRestartReplayHarness,
 } from "../Adapters/ClaudeAdapterV2.testkit.ts";
 import * as IdAllocator from "../IdAllocator.ts";
+import * as EffectWorker from "../EffectWorker.ts";
 import { makeSqlitePersistenceLive } from "../../persistence/Layers/Sqlite.ts";
 import { provideDeterministicTestRuntime } from "./DeterministicRuntime.ts";
 import { CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT } from "./fixtures/claude_background_subagent_after_root/input.ts";
@@ -19,7 +20,11 @@ import {
   materializeFixtureInput,
   projectionFor,
 } from "./fixtures/shared.ts";
-import { runOrchestratorV2ProviderReplayScenario } from "./ProviderReplayHarness.ts";
+import {
+  makeOrchestratorV2ProviderReplayLayer,
+  runOrchestratorV2ProviderReplayScenario,
+} from "./ProviderReplayHarness.ts";
+import { runOrchestratorV2Scenario } from "./OrchestratorScenario.ts";
 import { checkpointWorkspace } from "./ReplayFixtureWorkspace.ts";
 import { readProviderReplayTranscript } from "./ReplayTranscriptNdjson.ts";
 
@@ -155,21 +160,7 @@ const runRestart = Effect.fn("runRestart")(function* (input: {
   // Phase 1 ends once the root run settles; the subagent is still open.
   const firstIdle = materialized.steps.findIndex((step) => step.type === "await_thread_idle");
   const phase1Steps = materialized.steps.slice(0, firstIdle + 1);
-  const threadId = materialized.projectionThreadIds[0]!;
-  const phase2Steps = [
-    // Let recovery's continuation (run 2) finish before the next user message.
-    ...(input.continueThreadsAfterServerUpdate
-      ? [
-          {
-            type: "await_run_status" as const,
-            threadId,
-            runId: (yield* IdAllocator.IdAllocatorV2).derive.run({ threadId, ordinal: 2 }),
-            status: "completed" as const,
-          },
-        ]
-      : []),
-    ...materialized.steps.slice(firstIdle + 1),
-  ];
+  const phase2Steps = materialized.steps.slice(firstIdle + 1);
   const { harness, assertComplete } = makeClaudeRestartReplayHarness(transcript);
   const databaseLayer = makeSqlitePersistenceLive(path.join(tempDir, "state.sqlite")).pipe(
     Layer.provide(NodeServices.layer),
@@ -192,10 +183,35 @@ const runRestart = Effect.fn("runRestart")(function* (input: {
   assert.equal(settled.runs[0]?.status, "completed");
   assert.equal(settled.subagents[0]?.status, "running");
 
+  // Drain recovery before submitting any user work, which would otherwise
+  // take precedence over an incorrectly queued automatic continuation.
+  const restartScenario = scenario("restarted", []);
+  const restarted = yield* Effect.scoped(
+    Effect.gen(function* () {
+      const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+      yield* worker.drain();
+      return yield* runOrchestratorV2Scenario(restartScenario);
+    }).pipe(
+      Effect.provide(
+        makeOrchestratorV2ProviderReplayLayer(restartScenario, harness, {
+          databaseLayer,
+          recoverOnStartup: true,
+          continueThreadsAfterServerUpdate: input.continueThreadsAfterServerUpdate,
+        }),
+      ),
+    ),
+  );
+  const recovered = projectionFor(restarted, SCENARIO);
+  assert.deepEqual(
+    recovered.runs.map((run) => run.status),
+    ["completed"],
+  );
+  assert.equal(recovered.subagents[0]?.status, "cancelled");
+  assert.equal(recovered.runs[0]?.restartCancelledBackgroundWork?.[0]?.kind, "subagent");
+
   const after = yield* Effect.scoped(
     runOrchestratorV2ProviderReplayScenario(scenario("after-restart", phase2Steps), harness, {
       databaseLayer,
-      recoverOnStartup: true,
       continueThreadsAfterServerUpdate: input.continueThreadsAfterServerUpdate,
     }),
   );
@@ -210,61 +226,37 @@ const userTexts = (projection: ReturnType<typeof projectionFor>) =>
   projection.turnItems.flatMap((item) => (item.type === "user_message" ? [item.text] : []));
 
 describe("restart-cancelled background work", () => {
-  it.effect("tells the next provider turn once that its background subagent died", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const projection = yield* runRestart({
-          // The first turn after the restart carries the note; the second does not.
-          resumedPrompts: [
-            `${NOTE}\n\nUser message:\n${FIRST_AFTER_RESTART}`,
+  it.effect.each([false, true])(
+    "keeps the thread settled and tells the next user turn once when continuation is %s",
+    (continueThreadsAfterServerUpdate) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const projection = yield* runRestart({
+            // The first turn after the restart carries the note; the second does not.
+            resumedPrompts: [
+              `${NOTE}\n\nUser message:\n${FIRST_AFTER_RESTART}`,
+              SECOND_AFTER_RESTART,
+            ],
+            userMessagesAfterRestart: [FIRST_AFTER_RESTART, SECOND_AFTER_RESTART],
+            continueThreadsAfterServerUpdate,
+          });
+          assert.deepEqual(
+            projection.runs.map((run) => run.status),
+            ["completed", "completed", "completed"],
+          );
+          assert.isFalse(
+            projection.runs.some((run) => run.restartContinuationOfRunId !== undefined),
+          );
+          // The note reaches the provider only; the timeline keeps what the user sent.
+          assert.deepEqual(userTexts(projection), [
+            CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT,
+            FIRST_AFTER_RESTART,
             SECOND_AFTER_RESTART,
-          ],
-          userMessagesAfterRestart: [FIRST_AFTER_RESTART, SECOND_AFTER_RESTART],
-          continueThreadsAfterServerUpdate: false,
-        });
-        assert.deepEqual(
-          projection.runs.map((run) => run.status),
-          ["completed", "completed", "completed"],
-        );
-        assert.isFalse(projection.runs.some((run) => run.restartContinuationOfRunId !== undefined));
-        // The note reaches the provider only; the timeline keeps what the user sent.
-        assert.deepEqual(userTexts(projection), [
-          CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT,
-          FIRST_AFTER_RESTART,
-          SECOND_AFTER_RESTART,
-        ]);
-      }).pipe(
-        provideDeterministicTestRuntime,
-        Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer)),
-      ),
-    ),
-  );
-
-  it.effect("continues a settled thread with the note when restart continuation is on", () =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const projection = yield* runRestart({
-          // Recovery's continuation prompts with the note; the user turn after it does not.
-          resumedPrompts: [NOTE, FIRST_AFTER_RESTART],
-          userMessagesAfterRestart: [FIRST_AFTER_RESTART],
-          continueThreadsAfterServerUpdate: true,
-        });
-        const [root, continuation, user] = projection.runs;
-        assert.deepEqual(
-          projection.runs.map((run) => run.status),
-          ["completed", "completed", "completed"],
-        );
-        assert.equal(continuation?.restartContinuationOfRunId, root?.id);
-        assert.isUndefined(user?.restartContinuationOfRunId);
-        assert.deepEqual(userTexts(projection), [
-          CLAUDE_BACKGROUND_SUBAGENT_AFTER_ROOT_PROMPT,
-          NOTE,
-          FIRST_AFTER_RESTART,
-        ]);
-      }).pipe(
-        provideDeterministicTestRuntime,
-        Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer)),
+          ]);
+        }).pipe(
+          provideDeterministicTestRuntime,
+          Effect.provide(Layer.merge(IdAllocator.layer, NodeServices.layer)),
+        ),
       ),
-    ),
   );
 });
diff --git a/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts b/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts
index 9d01f22fe6a0..98ee5d6c8537 100644
--- a/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts
+++ b/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts
@@ -85,6 +85,9 @@ interface CapturedTurn {
   readonly providerThreadId: ProviderThreadId;
   readonly text: string;
   readonly attachments: ReadonlyArray<ChatAttachment>;
+  readonly nativeThreadId?: string | null;
+  readonly providerTurnOrdinal?: number;
+  readonly nativeThreadHasTurns?: boolean;
 }
 
 function unimplemented(driver: ProviderDriverKind, detail: string) {
@@ -232,6 +235,11 @@ function makeTestAdapter(input: {
                   providerThreadId: turnInput.providerThread.id,
                   text: turnInput.message.text,
                   attachments: turnInput.message.attachments,
+                  nativeThreadId: turnInput.providerThread.nativeThreadRef?.nativeId ?? null,
+                  providerTurnOrdinal: turnInput.providerTurnOrdinal,
+                  ...(turnInput.nativeThreadHasTurns === undefined
+                    ? {}
+                    : { nativeThreadHasTurns: turnInput.nativeThreadHasTurns }),
                 },
               ]);
               if (
@@ -1051,6 +1059,135 @@ describe("orchestration v2 provider switching", () => {
       ),
   );
 
+  it.live.each(["native", "legacy"] as const)(
+    "starts a replacement native thread as new after the resume fallback with %s attempts",
+    (attempts) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const cwd = yield* checkpointWorkspace("resume-fallback-native-turns");
+          const capturedTurns = yield* Ref.make<ReadonlyArray<CapturedTurn>>([]);
+          const failResumeOnce = yield* Ref.make(false);
+          const generation = yield* Ref.make(0);
+          const registry = ProviderAdapterRegistry.makeLayer([
+            makeTestAdapter({
+              instanceId: CLAUDE_MODEL_SELECTION.instanceId,
+              driver: CLAUDE_DRIVER,
+              capabilities: ClaudeProviderCapabilitiesV2,
+              modelSelection: CLAUDE_MODEL_SELECTION,
+              responseByRunOrdinal: {},
+              capturedTurns,
+              failResumeOnce,
+              nativeThreadGeneration: generation,
+            }),
+          ]);
+          yield* Effect.gen(function* () {
+            const orchestrator = yield* Orchestrator.OrchestratorV2;
+            const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+            const runToCompletion = Effect.fn("runToCompletion")(function* (ordinal: number) {
+              yield* orchestrator.dispatch({
+                type: "message.dispatch",
+                commandId: CommandId.make(`resume-fallback:${ordinal}`),
+                threadId,
+                messageId: MessageId.make(`resume-fallback:${ordinal}`),
+                createdBy: "user",
+                creationSource: "web",
+                text: `Request ${ordinal}`,
+                attachments: [],
+                modelSelection: CLAUDE_MODEL_SELECTION,
+                dispatchMode: { type: "start_immediately" },
+              });
+              yield* orchestrator.streamStoredEvents.pipe(
+                Stream.filter(
+                  ({ event }) =>
+                    event.type === "run.updated" &&
+                    event.payload.ordinal === ordinal &&
+                    (event.payload.status === "completed" || event.payload.status === "failed"),
+                ),
+                Stream.runHead,
+              );
+              yield* worker.drain();
+              assert.equal(
+                (yield* orchestrator.getThreadProjection(threadId)).runs.at(-1)?.status,
+                "completed",
+              );
+            });
+            yield* orchestrator.dispatch({
+              type: "thread.create",
+              commandId: CommandId.make("resume-fallback:create"),
+              threadId,
+              projectId,
+              createdBy: "user",
+              creationSource: "web",
+              title: "Resume fallback",
+              modelSelection: CLAUDE_MODEL_SELECTION,
+              runtimeMode: "full-access",
+              interactionMode: "default",
+              branch: null,
+              worktreePath: null,
+            });
+            yield* runToCompletion(1);
+            // A detached session resumes on the next turn, as after a restart.
+            const providerThread = (yield* orchestrator.getThreadProjection(
+              threadId,
+            )).providerThreads.at(0);
+            if (providerThread === undefined || providerThread.providerSessionId === null) {
+              return yield* Effect.die("Expected a provider session after the first turn.");
+            }
+            yield* orchestrator.dispatch({
+              type: "provider-session.detach",
+              commandId: CommandId.make("resume-fallback:detach"),
+              threadId,
+              providerSessionId: providerThread.providerSessionId,
+            });
+            yield* worker.drain();
+            if (attempts === "legacy") {
+              // Attempts persisted before native identity existed carry no native id.
+              const existing = yield* orchestrator.getThreadProjection(threadId);
+              yield* (yield* EventSink.EventSinkV2).write({
+                events: existing.attempts.map(
+                  ({ nativeThreadId: _nativeThreadId, ...legacy }, index) => ({
+                    id: EventId.make(`resume-fallback-legacy-attempt:${index}`),
+                    type: "run-attempt.updated" as const,
+                    threadId,
+                    occurredAt: existing.thread.createdAt,
+                    payload: legacy,
+                  }),
+                ),
+              });
+            }
+            yield* Ref.set(failResumeOnce, true);
+            yield* runToCompletion(2);
+            yield* runToCompletion(3);
+
+            const turns = yield* Ref.get(capturedTurns);
+            assert.equal(turns.length, 3);
+            assert.equal(yield* Ref.get(generation), 2);
+            // The fallback binds a new native thread to a provider thread that
+            // already has a turn, so the provider must not resume it.
+            assert.notEqual(turns[1]?.nativeThreadId, turns[0]?.nativeThreadId);
+            assert.isAbove(turns[1]?.providerTurnOrdinal ?? 0, 1);
+            assert.isFalse(turns[1]?.nativeThreadHasTurns);
+            assert.equal(turns[2]?.nativeThreadId, turns[1]?.nativeThreadId);
+            assert.isTrue(turns[2]?.nativeThreadHasTurns);
+          }).pipe(
+            Effect.provide(
+              makeOrchestratorV2ReplayLayerWithRegistry(
+                {
+                  name: "resume-fallback-native-turns",
+                  runtimePolicyOverride: {
+                    cwd,
+                    approvalPolicy: "never",
+                    sandboxPolicy: { type: "readOnly" },
+                  },
+                },
+                registry,
+              ),
+            ),
+          );
+        }),
+      ),
+  );
+
   it.live.each(
     (["failed", "interrupted"] as const).flatMap((status) =>
       [false, true].flatMap((queued) =>
diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/claude_mcp_tool_presentation/output.ts b/apps/server/src/orchestration-v2/testkit/fixtures/claude_mcp_tool_presentation/output.ts
index c68b57d83a8c..b51ca4f52f4a 100644
--- a/apps/server/src/orchestration-v2/testkit/fixtures/claude_mcp_tool_presentation/output.ts
+++ b/apps/server/src/orchestration-v2/testkit/fixtures/claude_mcp_tool_presentation/output.ts
@@ -35,6 +35,7 @@ export function assertClaudeMcpToolPresentationOutput(
 
   assert.equal(scrape?.status, "completed");
   assert.equal(scrape?.title, "Firecrawl scrape");
+  assert.deepEqual(scrape?.toolIcon, scrape?.toolSource?.icon);
   assert.deepEqual(scrape?.toolSource, {
     key: "mcp:firecrawl",
     name: "Firecrawl",
@@ -46,6 +47,10 @@ export function assertClaudeMcpToolPresentationOutput(
   });
 
   assert.equal(map?.status, "completed");
-  assert.isNull(map?.title);
-  assert.notProperty(map, "toolSource");
+  assert.equal(map?.title, "firecrawl map");
+  assert.deepEqual(map?.toolSource, {
+    key: "mcp:firecrawl",
+    name: "Firecrawl",
+    kind: "integration",
+  });
 }
diff --git a/apps/server/src/project/ProjectService.ts b/apps/server/src/project/ProjectService.ts
index 5d0e6b68e626..247ff0aaa925 100644
--- a/apps/server/src/project/ProjectService.ts
+++ b/apps/server/src/project/ProjectService.ts
@@ -8,6 +8,7 @@ import {
   type ProjectSnapshot,
   type ThreadId,
 } from "@t3tools/contracts";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
@@ -18,7 +19,6 @@ import * as Schema from "effect/Schema";
 
 import * as EventSink from "../orchestration-v2/EventSink.ts";
 import * as IdAllocator from "../orchestration-v2/IdAllocator.ts";
-import { makeKeyedSerialExecutor } from "../orchestration-v2/KeyedSerialExecutor.ts";
 import * as LegacyV1ThreadImporter from "../orchestration-v2/legacy/LegacyV1ThreadImporter.ts";
 import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
 import {
@@ -155,8 +155,8 @@ export const make = Effect.gen(function* () {
   const threadCommands = yield* ThreadCommandExecutor.ThreadCommandExecutor;
   // Commands for one project run in order. Commands that claim a workspace root
   // also hold that root, so two projects cannot both claim it.
-  const projectLocks = yield* makeKeyedSerialExecutor<ProjectId>();
-  const workspaceLocks = yield* makeKeyedSerialExecutor<string>();
+  const projectLocks = yield* KeyedLock.make<ProjectId>();
+  const workspaceLocks = yield* KeyedLock.make<string>();
 
   const toProject = (
     row: ProjectStore.ProjectRow,
diff --git a/apps/server/src/provider/CodexToolPresentation.ts b/apps/server/src/provider/CodexToolPresentation.ts
index 6bf7acee05b2..a01390582bda 100644
--- a/apps/server/src/provider/CodexToolPresentation.ts
+++ b/apps/server/src/provider/CodexToolPresentation.ts
@@ -6,25 +6,18 @@ import type {
 } from "@t3tools/contracts";
 import type * as EffectCodexSchema from "effect-codex-app-server/schema";
 
+import {
+  mcpToolPresentation as integrationToolPresentation,
+  normalizeMcpHttpUrl as normalizedHttpUrl,
+  normalizeMcpText as normalizedDisplayName,
+} from "./McpToolPresentation.ts";
+
 type CodexLifecycleItem = EffectCodexSchema.V2ItemCompletedNotification["item"];
 
 function asUnknownRecord(value: unknown): Record<string, unknown> | undefined {
   return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
 }
 
-function normalizedHttpUrl(value: unknown): string | undefined {
-  if (typeof value !== "string" || value.length > 4096) return undefined;
-  try {
-    const url = new URL(value);
-    const href = url.href;
-    return (url.protocol === "http:" || url.protocol === "https:") && href.length <= 4096
-      ? href
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 function normalizedImageUrl(value: unknown): string | undefined {
   if (typeof value !== "string" || value.length > 4096) return undefined;
   try {
@@ -45,12 +38,6 @@ function normalizedAppId(value: unknown): string | undefined {
     : undefined;
 }
 
-function normalizedDisplayName(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const displayName = value.trim().replace(/\s+/gu, " ");
-  return displayName && displayName.length <= 160 ? displayName : undefined;
-}
-
 function normalizedSourceKeyPart(value: string): string {
   return value.trim().toLowerCase();
 }
@@ -130,6 +117,7 @@ function themedLogoIcon(
 }
 
 export interface McpToolPresentation {
+  readonly title?: string;
   readonly toolSurface?: "browser" | "computer";
   readonly toolIcon?: ToolActivityIcon;
   readonly toolSource?: ToolActivitySource;
@@ -227,5 +215,13 @@ export function mcpToolPresentation(
     };
   }
 
-  return {};
+  return integrationToolPresentation({
+    serverName: appContext?.connectorId ?? item.server,
+    toolName: item.tool,
+    title: appContext?.actionName,
+    serverDisplayName: appContext?.appName,
+    source: sourceMetadata,
+    iconUrl: sourceLogo?._tag === "themed-logo" ? sourceLogo.logoUrl : undefined,
+    iconUrlDark: sourceLogo?._tag === "themed-logo" ? sourceLogo.logoUrlDark : undefined,
+  });
 }
diff --git a/apps/server/src/provider/Drivers/ClaudeDriver.ts b/apps/server/src/provider/Drivers/ClaudeDriver.ts
index 1cf47ab74bfc..64107911d6b5 100644
--- a/apps/server/src/provider/Drivers/ClaudeDriver.ts
+++ b/apps/server/src/provider/Drivers/ClaudeDriver.ts
@@ -41,6 +41,7 @@ import {
   checkClaudeProviderStatus,
   makePendingClaudeProvider,
   probeClaudeCapabilities,
+  probeClaudeWorkspaceSnapshot,
 } from "../Layers/ClaudeProvider.ts";
 import { makeClaudeHostProbe } from "./claudeHostProbe.ts";
 import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
@@ -70,7 +71,6 @@ import {
   makeClaudeContinuationGroupKey,
   resolveClaudeHomePath,
 } from "./ClaudeHome.ts";
-import { discoverClaudeSkills } from "./ClaudeSkills.ts";
 const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings);
 
 const DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
@@ -351,16 +351,13 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
         snapshot,
         invalidateCaches: Cache.invalidateAll(capabilitiesProbeCache),
         snapshotForCwd: (cwd: string) =>
-          !effectiveConfig.enabled
-            ? snapshot.getSnapshot
-            : Effect.all([
-                snapshot.getSnapshot,
-                discoverClaudeSkills(effectiveConfig, cwd, processEnv),
-              ]).pipe(
-                Effect.map(([machineSnapshot, skills]) => ({ ...machineSnapshot, skills })),
-                Effect.provideService(FileSystem.FileSystem, fileSystem),
-                Effect.provideService(Path.Path, path),
-              ),
+          snapshot.getSnapshot.pipe(
+            Effect.flatMap((machineSnapshot) =>
+              probeClaudeWorkspaceSnapshot(effectiveConfig, machineSnapshot, cwd, processEnv),
+            ),
+            Effect.provideService(FileSystem.FileSystem, fileSystem),
+            Effect.provideService(Path.Path, path),
+          ),
         orchestrationAdapter,
         textGeneration,
         consumeResetCredit,
diff --git a/apps/server/src/provider/Drivers/ClaudeSkills.test.ts b/apps/server/src/provider/Drivers/ClaudeSkills.test.ts
index d126a15c12b8..c4b328cdc337 100644
--- a/apps/server/src/provider/Drivers/ClaudeSkills.test.ts
+++ b/apps/server/src/provider/Drivers/ClaudeSkills.test.ts
@@ -154,6 +154,48 @@ it.layer(NodeServices.layer)("discoverClaudeSkills", (it) => {
     }),
   );
 
+  it.effect("recovers colon-bearing descriptions with invocation metadata intact", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-skills-" });
+      const configDir = path.join(tempDir, "claude-home");
+
+      for (const [description, comment] of [
+        ["Browser automation + AI test authoring via kane-cli: run browser objectives, ...", ""],
+        ['Read C:\\skills\\guide#tag: continue with "quoted".', " # trailing: comment"],
+      ] as const) {
+        yield* writeSkill(
+          path.join(configDir, "skills"),
+          "kane-cli",
+          [
+            "---",
+            "name: frontmatter-alias",
+            `description: ${description}${comment}`,
+            "allowed-tools: [Read, Write]",
+            "disable-model-invocation: yes",
+            "user-invocable: no",
+            "---",
+          ].join("\n"),
+        );
+
+        const skills = yield* discoverClaudeSkills({ homePath: configDir }, undefined);
+
+        assert.deepEqual(skills, [
+          {
+            name: "kane-cli",
+            path: path.join(configDir, "skills", "kane-cli", "SKILL.md"),
+            enabled: true,
+            scope: "user",
+            description,
+            userInvocationOnly: true,
+            userInvocable: false,
+          },
+        ]);
+      }
+    }),
+  );
+
   it.effect("falls back to the directory name and skips malformed frontmatter", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
@@ -163,7 +205,17 @@ it.layer(NodeServices.layer)("discoverClaudeSkills", (it) => {
       const skillsDir = path.join(configDir, "skills");
 
       yield* writeSkill(skillsDir, "no-frontmatter", "# Just a heading\n");
-      yield* writeSkill(skillsDir, "broken-yaml", "---\nname: [unclosed\n---\n");
+      for (const [directoryName, field] of [
+        ["broken-yaml", "name: [unclosed"],
+        ["broken-tools", "allowed-tools: [Read, Write"],
+        ["broken-quoted", 'name: "unclosed: text'],
+      ] as const) {
+        yield* writeSkill(
+          skillsDir,
+          directoryName,
+          ["---", "description: Run: browser objectives.", field, "---"].join("\n"),
+        );
+      }
       // A stray file (not a directory with SKILL.md) must be skipped.
       yield* fs.makeDirectory(skillsDir, { recursive: true });
       yield* fs.writeFileString(path.join(skillsDir, "README.md"), "not a skill");
diff --git a/apps/server/src/provider/Drivers/ClaudeSkills.ts b/apps/server/src/provider/Drivers/ClaudeSkills.ts
index 259ceeb4b775..8c9c9c669faa 100644
--- a/apps/server/src/provider/Drivers/ClaudeSkills.ts
+++ b/apps/server/src/provider/Drivers/ClaudeSkills.ts
@@ -75,11 +75,28 @@ function parseSkillFrontmatter(contents: string): SkillFrontmatter {
     return { kind: "missing" };
   }
 
+  const frontmatter = match[1] ?? "";
   let parsed: unknown;
   try {
-    parsed = parseYamlDocument(match[1] ?? "");
+    parsed = parseYamlDocument(frontmatter);
   } catch {
-    return { kind: "malformed" };
+    // Claude Code accepts plain scalars containing `: `. Repair only those,
+    // leaving comments and YAML structure for the full-document parser.
+    const repaired = frontmatter.replace(
+      /^([\w-]+:[ \t]*)([^\r\n]*)/gm,
+      (line, prefix: string, value: string) => {
+        const scalar = value.split(/[ \t]+#/)[0] ?? "";
+        if (!/:[ \t]/.test(scalar) || /^(?:["'[\]{}|>&*!#%@`]|[-?:](?:[ \t]|$))/.test(scalar)) {
+          return line;
+        }
+        return `${prefix}${JSON.stringify(scalar)}${value.slice(scalar.length)}`;
+      },
+    );
+    try {
+      parsed = parseYamlDocument(repaired);
+    } catch {
+      return { kind: "malformed" };
+    }
   }
   if (typeof parsed !== "object" || parsed === null) {
     return { kind: "malformed" };
diff --git a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts
index 72534a3a7623..3cb3bebf50cb 100644
--- a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts
+++ b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts
@@ -4,7 +4,12 @@ import { vi } from "vite-plus/test";
 import * as Deferred from "effect/Deferred";
 import * as Fiber from "effect/Fiber";
 import * as TestClock from "effect/testing/TestClock";
-import { ClaudeSettings } from "@t3tools/contracts";
+import {
+  ClaudeSettings,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  type ServerProvider,
+} from "@t3tools/contracts";
 import * as NodeFSP from "node:fs/promises";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, it } from "@effect/vitest";
@@ -17,7 +22,9 @@ import {
   buildClaudeCapabilitiesProbeQueryOptions,
   CLAUDE_CAPABILITIES_PROBE_SETTING_SOURCES,
   probeClaudeCapabilities,
+  probeClaudeWorkspaceSnapshot,
 } from "./ClaudeProvider.ts";
+import { COMPACT_SLASH_COMMAND } from "../providerSnapshot.ts";
 
 vi.mock("@anthropic-ai/claude-agent-sdk", { spy: true });
 
@@ -53,6 +60,182 @@ it("isolates Claude capability probes without dropping workspace setting sources
 });
 
 it.layer(NodeServices.layer)("Claude capability probe SDK boundary", (it) => {
+  it.effect(
+    "discovers commands and skills separately for each cwd without replacing machine metadata",
+    () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-workspaces-" });
+        const configDir = path.join(tempDir, "claude-home");
+        const workspaces = [path.join(tempDir, "one"), path.join(tempDir, "two")];
+        for (const cwd of workspaces) {
+          const skillDir = path.join(cwd, ".claude", "skills", "existing-skill");
+          yield* fs.makeDirectory(skillDir, { recursive: true });
+          yield* fs.writeFileString(
+            path.join(skillDir, "SKILL.md"),
+            "---\nname: existing-skill\ndescription: Existing project skill\n---\nUse this skill.",
+          );
+        }
+        const machineSnapshot = {
+          instanceId: ProviderInstanceId.make("claude"),
+          driver: ProviderDriverKind.make("claudeAgent"),
+          enabled: true,
+          installed: true,
+          status: "ready",
+          auth: { status: "authenticated", email: "machine@example.com" },
+          checkedAt: "2026-03-25T00:00:00.000Z",
+          version: "2.1.288",
+          models: [],
+          slashCommands: [{ name: "server-cwd-only" }],
+          skills: [],
+        } satisfies ServerProvider;
+        let usageCalls = 0;
+        const query = vi.spyOn(ClaudeSdk, "query").mockImplementation(({ options }) => {
+          assert.equal(options?.env?.CLAUDE_CONFIG_DIR, configDir);
+          assert.equal(options?.env?.T3_WORKSPACE_PROBE, "owned-instance");
+          return {
+            initializationResult: async () => ({
+              account: { email: "workspace@example.com" },
+              commands: [
+                {
+                  name: options?.cwd === workspaces[0] ? "start-session" : "other-project",
+                  description: "Project command",
+                  argumentHint: "[topic]",
+                },
+                { name: "nested:review", description: "Review changes", argumentHint: "" },
+                { name: "NESTED:review", description: "", argumentHint: "[path]" },
+                { name: "compact", description: "Provider compact", argumentHint: "" },
+                { name: "user-command", description: "Existing user command", argumentHint: "" },
+              ],
+            }),
+            usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => {
+              usageCalls++;
+              return { rate_limits_available: false, rate_limits: null };
+            },
+          } as ReturnType<typeof ClaudeSdk.query>;
+        });
+        yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore()));
+        for (const [index, cwd] of workspaces.entries()) {
+          const scoped = yield* probeClaudeWorkspaceSnapshot(
+            decodeClaudeSettings({ homePath: configDir }),
+            machineSnapshot,
+            cwd,
+            { ...process.env, T3_WORKSPACE_PROBE: "owned-instance" },
+          );
+          assert.deepEqual(scoped, {
+            ...machineSnapshot,
+            slashCommandsPending: false,
+            slashCommands: [
+              COMPACT_SLASH_COMMAND,
+              {
+                name: index === 0 ? "start-session" : "other-project",
+                description: "Project command",
+                input: { hint: "[topic]" },
+              },
+              { name: "nested:review", description: "Review changes", input: { hint: "[path]" } },
+              { name: "user-command", description: "Existing user command" },
+            ],
+            skills: [
+              {
+                name: "existing-skill",
+                path: path.join(cwd, ".claude", "skills", "existing-skill", "SKILL.md"),
+                enabled: true,
+                scope: "project",
+                description: "Existing project skill",
+              },
+            ],
+          });
+        }
+        assert.deepEqual(
+          query.mock.calls.map(([input]) => input.options?.cwd),
+          workspaces,
+        );
+        assert.equal(usageCalls, 0);
+      }).pipe(Effect.scoped),
+  );
+
+  it.effect("keeps readable skills during failed command discovery and recovers on retry", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const cwd = yield* fs.makeTempDirectoryScoped({ prefix: "t3-claude-workspace-retry-" });
+      const skillDir = path.join(cwd, ".claude", "skills", "existing-skill");
+      yield* fs.makeDirectory(skillDir, { recursive: true });
+      yield* fs.writeFileString(
+        path.join(skillDir, "SKILL.md"),
+        "---\nname: existing-skill\ndescription: Existing project skill\n---\nUse this skill.",
+      );
+      const machineSnapshot = {
+        instanceId: ProviderInstanceId.make("claude"),
+        driver: ProviderDriverKind.make("claudeAgent"),
+        enabled: true,
+        installed: true,
+        status: "ready",
+        auth: { status: "authenticated" },
+        checkedAt: "2026-03-25T00:00:00.000Z",
+        version: "2.1.288",
+        models: [],
+        slashCommands: [{ name: "server-cwd-only" }],
+        skills: [],
+      } satisfies ServerProvider;
+      const query = vi.spyOn(ClaudeSdk, "query").mockImplementation(
+        () =>
+          ({
+            initializationResult: () =>
+              Promise.reject<ClaudeSdk.SDKControlInitializeResponse>(
+                new Error("Initialization failed"),
+              ),
+            usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => ({
+              rate_limits_available: false,
+              rate_limits: null,
+            }),
+          }) as ReturnType<typeof ClaudeSdk.query>,
+      );
+      yield* Effect.addFinalizer(() => Effect.sync(() => query.mockRestore()));
+      const settings = decodeClaudeSettings({ homePath: cwd });
+      const failed = yield* probeClaudeWorkspaceSnapshot(settings, machineSnapshot, cwd);
+      assert.deepEqual(failed, {
+        ...machineSnapshot,
+        slashCommands: [COMPACT_SLASH_COMMAND],
+        slashCommandsPending: true,
+        skills: [
+          {
+            name: "existing-skill",
+            path: path.join(skillDir, "SKILL.md"),
+            enabled: true,
+            scope: "project",
+            description: "Existing project skill",
+          },
+        ],
+      });
+      query.mockImplementation(
+        () =>
+          ({
+            initializationResult: async () => ({
+              commands: [{ name: "recovered", description: "", argumentHint: "" }],
+            }),
+            usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET: async () => ({
+              rate_limits_available: false,
+              rate_limits: null,
+            }),
+          }) as ReturnType<typeof ClaudeSdk.query>,
+      );
+      const recovered = yield* probeClaudeWorkspaceSnapshot(settings, machineSnapshot, cwd);
+      assert.deepEqual(recovered.slashCommands, [COMPACT_SLASH_COMMAND, { name: "recovered" }]);
+      assert.equal(recovered.status, "ready");
+      assert.equal(recovered.slashCommandsPending, false);
+      assert.deepEqual(recovered.skills, failed.skills);
+      const disabled = yield* probeClaudeWorkspaceSnapshot(
+        { ...settings, enabled: false },
+        machineSnapshot,
+        cwd,
+      );
+      assert.equal(disabled, machineSnapshot);
+      assert.equal(query.mock.calls.length, 2);
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("serializes strict no-MCP options and still resolves account capabilities", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
diff --git a/apps/server/src/provider/Layers/ClaudeProvider.ts b/apps/server/src/provider/Layers/ClaudeProvider.ts
index b75999f2511e..84e2fcac30ad 100644
--- a/apps/server/src/provider/Layers/ClaudeProvider.ts
+++ b/apps/server/src/provider/Layers/ClaudeProvider.ts
@@ -1,6 +1,7 @@
 import {
   type ClaudeSettings,
   type ModelCapabilities,
+  type ServerProvider,
   type ServerProviderSlashCommand,
   type ServerProviderResetCredits,
 } from "@t3tools/contracts";
@@ -36,6 +37,7 @@ import {
 import { resolveClaudeSdkExecutablePath } from "../Drivers/ClaudeExecutable.ts";
 import { makeClaudeEnvironment } from "../Drivers/ClaudeHome.ts";
 import { discoverClaudeSkills } from "../Drivers/ClaudeSkills.ts";
+import type { ProviderWorkspaceSnapshot } from "../ProviderDriver.ts";
 import { makeUnavailableUsageLimits } from "../providerUsageLimits.ts";
 import {
   type ClaudeScopedLimitNames,
@@ -334,6 +336,7 @@ const probeClaudeCapabilities = (
   claudeSettings: ClaudeSettings,
   environment?: NodeJS.ProcessEnv,
   cwd?: string,
+  includeUsage = true,
 ) => {
   const abort = new AbortController();
   return Effect.gen(function* () {
@@ -365,15 +368,18 @@ const probeClaudeCapabilities = (
     Effect.flatMap(({ q, init }) =>
       Effect.gen(function* () {
         // Usage has its own deadline so a slow optional request cannot discard initialization.
-        const usageResult = yield* Effect.tryPromise(() =>
-          q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(),
-        ).pipe(Effect.timeout(CLAUDE_USAGE_PROBE_TIMEOUT_MS), Effect.result);
-        const usage = Result.isSuccess(usageResult)
-          ? {
-              rate_limits_available: usageResult.success.rate_limits_available,
-              rate_limits: usageResult.success.rate_limits,
-            }
+        const usageResult = includeUsage
+          ? yield* Effect.tryPromise(() =>
+              q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET(),
+            ).pipe(Effect.timeout(CLAUDE_USAGE_PROBE_TIMEOUT_MS), Effect.result)
           : undefined;
+        const usage =
+          usageResult && Result.isSuccess(usageResult)
+            ? {
+                rate_limits_available: usageResult.success.rate_limits_available,
+                rate_limits: usageResult.success.rate_limits,
+              }
+            : undefined;
         const account = init.account as
           | {
               readonly email?: string;
@@ -418,6 +424,27 @@ export const runClaudeCommand = Effect.fn("runClaudeCommand")(function* (
   return yield* spawnAndCollect(claudeSettings.binaryPath, command);
 });
 
+/** Read commands from the same cwd Claude uses for a workspace session. */
+export const probeClaudeWorkspaceSnapshot = Effect.fn("probeClaudeWorkspaceSnapshot")(function* (
+  claudeSettings: ClaudeSettings,
+  machineSnapshot: ServerProvider,
+  cwd: string,
+  environment?: NodeJS.ProcessEnv,
+): Effect.fn.Return<ProviderWorkspaceSnapshot, never, FileSystem.FileSystem | Path.Path> {
+  if (!claudeSettings.enabled) return machineSnapshot;
+  const skills = yield* discoverClaudeSkills(claudeSettings, cwd, environment);
+  const capabilities = yield* probeClaudeCapabilities(claudeSettings, environment, cwd, false);
+  return {
+    ...machineSnapshot,
+    skills,
+    slashCommands: dedupeSlashCommands([
+      COMPACT_SLASH_COMMAND,
+      ...(capabilities?.slashCommands ?? []),
+    ]),
+    slashCommandsPending: !capabilities,
+  };
+});
+
 export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(function* (
   claudeSettings: ClaudeSettings,
   resolveCapabilities?: (
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.test.ts b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
index 1e9253e8ec03..ddf9428e51b8 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.test.ts
@@ -63,7 +63,7 @@ import {
   writeProviderStatusCache,
 } from "../providerStatusCache.ts";
 import { COMPACT_SLASH_COMMAND } from "../providerSnapshot.ts";
-import type { ProviderInstance } from "../ProviderDriver.ts";
+import type { ProviderInstance, ProviderWorkspaceSnapshot } from "../ProviderDriver.ts";
 import * as ProviderInstanceRegistry from "../Services/ProviderInstanceRegistry.ts";
 import * as ProviderRegistry from "../Services/ProviderRegistry.ts";
 import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";
@@ -641,6 +641,34 @@ it.layer(Layer.mergeAll(TestNodeServices, ServerSettingsModule.layerTest(), Test
             skills: scopedSnapshot.skills,
           },
         ]);
+
+        const pendingSnapshot = {
+          ...scopedSnapshot,
+          slashCommands: [COMPACT_SLASH_COMMAND],
+          slashCommandsPending: true,
+        } satisfies ProviderWorkspaceSnapshot;
+        const partial = upsertProviderWorkspaceSnapshot(result, "/project", pendingSnapshot);
+        assert.deepStrictEqual(partial.workspaceSnapshots?.[0]?.slashCommands, [
+          { name: "project" },
+        ]);
+        assert.strictEqual(partial.workspaceSnapshots?.[0]?.slashCommandsPending, true);
+        const otherProject = upsertProviderWorkspaceSnapshot(
+          partial,
+          "/other-project",
+          pendingSnapshot,
+        );
+        assert.deepStrictEqual(otherProject.workspaceSnapshots?.[1]?.slashCommands, [
+          COMPACT_SLASH_COMMAND,
+        ]);
+        const recovered = upsertProviderWorkspaceSnapshot(partial, "/project", {
+          ...scopedSnapshot,
+          slashCommands: [COMPACT_SLASH_COMMAND, { name: "replacement" }],
+        });
+        assert.deepStrictEqual(recovered.workspaceSnapshots?.[0]?.slashCommands, [
+          COMPACT_SLASH_COMMAND,
+          { name: "replacement" },
+        ]);
+        assert.strictEqual(recovered.workspaceSnapshots?.[0]?.slashCommandsPending, undefined);
       });
 
       it("preserves previously discovered provider models when a refresh returns none", () => {
@@ -1573,7 +1601,12 @@ it.layer(Layer.mergeAll(TestNodeServices, ServerSettingsModule.layerTest(), Test
             slashCommands: [],
           } as const satisfies ServerProvider;
           const snapshotCalls = yield* Ref.make(0);
-          const scopedResult = yield* Ref.make<ServerProvider>(scopedProvider);
+          const scopedResult = yield* Ref.make<ProviderWorkspaceSnapshot>({
+            ...scopedProvider,
+            status: "error",
+            slashCommands: [COMPACT_SLASH_COMMAND],
+            slashCommandsPending: true,
+          });
           const cacheInvalidations = yield* Ref.make(0);
           const scanGate = yield* Ref.make<{
             readonly started: Deferred.Deferred<void>;
@@ -1698,8 +1731,27 @@ it.layer(Layer.mergeAll(TestNodeServices, ServerSettingsModule.layerTest(), Test
               providers[0]?.workspaceSnapshots?.[0]?.skills,
               scopedProvider.skills,
             );
+            assert.deepStrictEqual(providers[0]?.workspaceSnapshots?.[0]?.slashCommands, [
+              COMPACT_SLASH_COMMAND,
+            ]);
+            assert.strictEqual(providers[0]?.workspaceSnapshots?.[0]?.slashCommandsPending, true);
+            yield* Ref.set(scopedResult, {
+              ...scopedProvider,
+              status: "error",
+              slashCommandsPending: false,
+            });
+            yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" });
+            assert.strictEqual(yield* Ref.get(snapshotCalls), 3);
+            assert.deepStrictEqual(
+              (yield* registry.getProviders)[0]?.workspaceSnapshots?.[0]?.slashCommands,
+              scopedProvider.slashCommands,
+            );
+            assert.strictEqual(
+              (yield* registry.getProviders)[0]?.workspaceSnapshots?.[0]?.slashCommandsPending,
+              undefined,
+            );
             yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/workspace" });
-            assert.strictEqual(yield* Ref.get(snapshotCalls), 2);
+            assert.strictEqual(yield* Ref.get(snapshotCalls), 3);
             const newSkills = [
               ...scopedProvider.skills,
               { name: "added", path: "/workspace/added/SKILL.md", enabled: true },
@@ -1710,7 +1762,7 @@ it.layer(Layer.mergeAll(TestNodeServices, ServerSettingsModule.layerTest(), Test
               cwd: "/workspace",
               fresh: true,
             });
-            assert.strictEqual(yield* Ref.get(snapshotCalls), 3);
+            assert.strictEqual(yield* Ref.get(snapshotCalls), 4);
             assert.strictEqual(yield* Ref.get(cacheInvalidations), 1);
             assert.deepStrictEqual(
               (yield* registry.getProviders)[0]?.workspaceSnapshots?.map((s) => s.skills),
diff --git a/apps/server/src/provider/Layers/ProviderRegistry.ts b/apps/server/src/provider/Layers/ProviderRegistry.ts
index de476ca0299a..b9c28c155283 100644
--- a/apps/server/src/provider/Layers/ProviderRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderRegistry.ts
@@ -53,7 +53,7 @@ import {
   resolveProviderStatusCachePath,
   writeProviderStatusCache,
 } from "../providerStatusCache.ts";
-import type { ProviderInstance } from "../ProviderDriver.ts";
+import type { ProviderInstance, ProviderWorkspaceSnapshot } from "../ProviderDriver.ts";
 import { makeManualOnlyProviderMaintenanceCapabilities } from "../providerMaintenance.ts";
 import type { ProviderSnapshotSource } from "../builtInProviderCatalog.ts";
 
@@ -94,12 +94,16 @@ function dropProviderWorkspaceSnapshot(provider: ServerProvider, cwd: string): S
 export function upsertProviderWorkspaceSnapshot(
   provider: ServerProvider,
   cwd: string,
-  scopedSnapshot: ServerProvider,
+  scopedSnapshot: ProviderWorkspaceSnapshot,
 ): ServerProvider {
   const workspaceSnapshot = {
     cwd,
     checkedAt: scopedSnapshot.checkedAt,
-    slashCommands: scopedSnapshot.slashCommands,
+    slashCommands: scopedSnapshot.slashCommandsPending
+      ? (provider.workspaceSnapshots?.find((snapshot) => snapshot.cwd === cwd)?.slashCommands ??
+        scopedSnapshot.slashCommands)
+      : scopedSnapshot.slashCommands,
+    ...(scopedSnapshot.slashCommandsPending ? { slashCommandsPending: true } : {}),
     skills: scopedSnapshot.skills,
   } satisfies NonNullable<ServerProvider["workspaceSnapshots"]>[number];
   return {
@@ -918,7 +922,11 @@ export const ProviderRegistryLive = Layer.effect(
       const workspaceSnapshotOf = (candidate: ServerProvider | undefined) =>
         candidate?.workspaceSnapshots?.find((s) => s.cwd === input.cwd);
       const scannedFrom = workspaceSnapshotOf(provider);
-      if (!provider || !provider.enabled || (!input.fresh && scannedFrom)) {
+      if (
+        !provider ||
+        !provider.enabled ||
+        (!input.fresh && scannedFrom && !scannedFrom.slashCommandsPending)
+      ) {
         return providers;
       }
       const instance = yield* instanceRegistry.getInstance(input.instanceId);
@@ -932,8 +940,7 @@ export const ProviderRegistryLive = Layer.effect(
       });
       // A fresh scan never joins a running one, which may predate the change.
       if (!claimed && !input.fresh) return yield* Ref.get(providersRef);
-      // Fresh scans also re-read the machine snapshot: Claude's plugin
-      // commands come from it, not from the cwd scan.
+      // Fresh scans also re-read the machine snapshot after invalidating caches.
       const refreshMachineSnapshot = input.fresh
         ? (instance.invalidateCaches ?? Effect.void).pipe(
             Effect.andThen(refreshInstance(input.instanceId)),
@@ -942,7 +949,7 @@ export const ProviderRegistryLive = Layer.effect(
       return yield* refreshMachineSnapshot.pipe(
         Effect.andThen(instance.snapshotForCwd(input.cwd)),
         Effect.flatMap((scopedSnapshot) =>
-          scopedSnapshot.status === "error"
+          scopedSnapshot.status === "error" && scopedSnapshot.slashCommandsPending === undefined
             ? Ref.get(providersRef)
             : instanceRegistry.getInstance(input.instanceId).pipe(
                 Effect.flatMap((currentInstance) => {
diff --git a/apps/server/src/provider/McpToolPresentation.test.ts b/apps/server/src/provider/McpToolPresentation.test.ts
new file mode 100644
index 000000000000..5218d05ebeb8
--- /dev/null
+++ b/apps/server/src/provider/McpToolPresentation.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from "@effect/vitest";
+import { mcpToolPresentation } from "./McpToolPresentation.ts";
+
+describe("mcpToolPresentation", () => {
+  it("uses supplied names and logos while retaining the server identity", () => {
+    expect(
+      mcpToolPresentation({
+        serverName: "firecrawl-local",
+        toolName: "firecrawl_scrape",
+        title: "  Scrape\n page  ",
+        serverDisplayName: "Firecrawl",
+        iconUrl: "https://example.com/icon.png",
+        iconUrlDark: "https://example.com/dark.png",
+      }),
+    ).toEqual({
+      title: "Scrape page",
+      toolIcon: {
+        _tag: "themed-logo",
+        logoUrl: "https://example.com/icon.png",
+        logoUrlDark: "https://example.com/dark.png",
+      },
+      toolSource: {
+        key: "mcp:firecrawl-local",
+        name: "Firecrawl",
+        kind: "integration",
+        icon: {
+          _tag: "themed-logo",
+          logoUrl: "https://example.com/icon.png",
+          logoUrlDark: "https://example.com/dark.png",
+        },
+      },
+    });
+  });
+
+  it("uses MCP result source metadata for the tool and its integration", () => {
+    const presentation = mcpToolPresentation({
+      serverName: "firecrawl-local",
+      toolName: "firecrawl_scrape",
+      source: {
+        name: "Firecrawl",
+        logoUrl: "https://example.com/firecrawl.png",
+        logoUrlDark: "https://example.com/firecrawl-dark.png",
+      },
+    });
+    expect(presentation.toolSource?.name).toBe("Firecrawl");
+    expect(presentation.toolIcon).toEqual({
+      _tag: "themed-logo",
+      logoUrl: "https://example.com/firecrawl.png",
+      logoUrlDark: "https://example.com/firecrawl-dark.png",
+    });
+    expect(presentation.toolSource?.icon).toEqual(presentation.toolIcon);
+  });
+
+  it("uses readable fallback names without a guessed logo", () => {
+    expect(mcpToolPresentation({ toolName: "mcp__my_server__get_weather" })).toEqual({
+      title: "get weather",
+      toolSource: { key: "mcp:my_server", name: "my server", kind: "integration" },
+    });
+    expect(mcpToolPresentation({ toolName: "Read" })).toEqual({});
+    expect(mcpToolPresentation({ serverName: "t3-code", toolName: "delegate_task" })).toEqual({});
+  });
+
+  it.each([
+    "javascript:alert(1)",
+    "file:///tmp/logo.png",
+    "not a URL",
+    "https://example.com/" + "x".repeat(4096),
+  ])("ignores an invalid logo %s", (iconUrl) => {
+    expect(
+      mcpToolPresentation({
+        serverName: "weather",
+        toolName: "get_weather",
+        iconUrl,
+        title: "x".repeat(161),
+      }),
+    ).toEqual({
+      title: "get weather",
+      toolSource: { key: "mcp:weather", name: "weather", kind: "integration" },
+    });
+  });
+
+  it("rejects malformed and overlong names", () => {
+    expect(mcpToolPresentation({ serverName: {}, toolName: 1, title: [] })).toEqual({});
+    expect(mcpToolPresentation({ serverName: "x".repeat(161), toolName: "get_weather" })).toEqual(
+      {},
+    );
+    expect(mcpToolPresentation({ title: "Tool title" })).toEqual({ title: "Tool title" });
+  });
+
+  it.each([
+    null,
+    "logo",
+    { logoUrl: "file:///tmp/logo.png" },
+    { logoUrlDark: "https://example.com/dark.png" },
+  ])("ignores source metadata without a valid logo: %j", (source) => {
+    expect(mcpToolPresentation({ serverName: "weather", toolName: "get_weather", source })).toEqual(
+      {
+        title: "get weather",
+        toolSource: { key: "mcp:weather", name: "weather", kind: "integration" },
+      },
+    );
+  });
+});
diff --git a/apps/server/src/provider/McpToolPresentation.ts b/apps/server/src/provider/McpToolPresentation.ts
new file mode 100644
index 000000000000..c8f4dbc0eb11
--- /dev/null
+++ b/apps/server/src/provider/McpToolPresentation.ts
@@ -0,0 +1,70 @@
+import type { ToolActivityIcon, ToolActivitySource } from "@t3tools/contracts";
+import { resolveT3McpToolDefinition } from "@t3tools/shared/t3McpToolPresentation";
+
+export function normalizeMcpText(value: unknown, maxLength = 160): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const text = value.trim().replace(/\s+/gu, " ");
+  return text.length > 0 && text.length <= maxLength ? text : undefined;
+}
+
+export function normalizeMcpHttpUrl(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.length > 4096) return undefined;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "https:" || url.protocol === "http:") && url.href.length <= 4096
+      ? url.href
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function mcpToolPresentation(input: {
+  readonly toolName?: unknown;
+  readonly serverName?: unknown;
+  readonly title?: unknown;
+  readonly serverDisplayName?: unknown;
+  readonly iconUrl?: unknown;
+  readonly iconUrlDark?: unknown;
+  readonly source?: unknown;
+}): {
+  readonly title?: string;
+  readonly toolIcon?: ToolActivityIcon;
+  readonly toolSource?: ToolActivitySource;
+} {
+  const source =
+    typeof input.source === "object" && input.source !== null ? input.source : undefined;
+  const qualified =
+    typeof input.toolName === "string" ? /^mcp__(.+?)__(.+)$/i.exec(input.toolName) : null;
+  const server = normalizeMcpText(input.serverName ?? qualified?.[1] ?? input.serverDisplayName);
+  const tool = normalizeMcpText(qualified?.[2] ?? input.toolName);
+  if (server && tool && resolveT3McpToolDefinition(`${server}.${tool}`)) return {};
+  const title =
+    normalizeMcpText(input.title) ??
+    (server && tool ? normalizeMcpText(tool.replace(/[_-]+/gu, " ")) : undefined);
+  if (!server) return title ? { title } : {};
+  const name =
+    normalizeMcpText(input.serverDisplayName) ??
+    normalizeMcpText(source && Reflect.get(source, "name")) ??
+    normalizeMcpText(server.replace(/[_-]+/gu, " ")) ??
+    server;
+  const logoUrl =
+    normalizeMcpHttpUrl(input.iconUrl) ??
+    normalizeMcpHttpUrl(source && Reflect.get(source, "logoUrl"));
+  const logoUrlDark =
+    normalizeMcpHttpUrl(input.iconUrlDark) ??
+    normalizeMcpHttpUrl(source && Reflect.get(source, "logoUrlDark"));
+  const icon = logoUrl
+    ? { _tag: "themed-logo" as const, logoUrl, ...(logoUrlDark ? { logoUrlDark } : {}) }
+    : undefined;
+  return {
+    ...(title ? { title } : {}),
+    ...(icon ? { toolIcon: icon } : {}),
+    toolSource: {
+      key: `mcp:${server.toLowerCase()}`,
+      name,
+      kind: "integration",
+      ...(icon ? { icon } : {}),
+    },
+  };
+}
diff --git a/apps/server/src/provider/ProviderDriver.ts b/apps/server/src/provider/ProviderDriver.ts
index 4f92df965c8a..cb86075616d1 100644
--- a/apps/server/src/provider/ProviderDriver.ts
+++ b/apps/server/src/provider/ProviderDriver.ts
@@ -31,6 +31,7 @@ import type {
   ProviderInstanceEnvironment,
   ProviderInstanceId,
   ServerProvider,
+  ServerProviderWorkspaceSnapshot,
 } from "@t3tools/contracts";
 import type * as Effect from "effect/Effect";
 import type * as Schema from "effect/Schema";
@@ -59,6 +60,9 @@ export interface ProviderDriverMetadata {
   readonly supportsMultipleInstances?: boolean;
 }
 
+export type ProviderWorkspaceSnapshot = ServerProvider &
+  Pick<ServerProviderWorkspaceSnapshot, "slashCommandsPending">;
+
 /**
  * One materialized provider instance. Held by the registry, looked up by
  * `instanceId`, torn down by closing the scope it was created in.
@@ -76,7 +80,9 @@ export interface ProviderInstance {
   readonly accentColor?: string | undefined;
   readonly enabled: boolean;
   readonly snapshot: ServerProviderShape;
-  readonly snapshotForCwd?: (cwd: string) => Effect.Effect<ServerProvider, ProviderDriverError>;
+  readonly snapshotForCwd?: (
+    cwd: string,
+  ) => Effect.Effect<ProviderWorkspaceSnapshot, ProviderDriverError>;
   readonly refreshModels?: () => Effect.Effect<void, ProviderDriverError>;
   /** Invalidate T3-owned discovery caches before an explicit provider refresh. */
   readonly invalidateCaches?: Effect.Effect<void>;
diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts
index e69c851b258e..f2d999520e02 100644
--- a/apps/server/src/provider/acp/AcpRuntimeModel.test.ts
+++ b/apps/server/src/provider/acp/AcpRuntimeModel.test.ts
@@ -1539,9 +1539,44 @@ describe("extractMcpToolCallIdentity", () => {
     });
   });
 
-  it("does not brand tools whose meta asserts a foreign server", () => {
-    // The foreign assertion vetoes every loose source, including a title
-    // that would otherwise match a T3 convention.
+  it.each([
+    { _meta: { claudeCode: { toolName: "mcp__weather__get_weather" } } },
+    { _meta: { toolName: "mcp::weather::get_weather", serverId: "weather" } },
+  ])("recovers external MCP identity from provider metadata", (metadata) => {
+    const toolCall = toolCallFromUpdate({
+      sessionUpdate: "tool_call",
+      toolCallId: "weather-call",
+      title: "Checking the forecast",
+      status: "in_progress",
+      ...metadata,
+    });
+    expect(extractMcpToolCallIdentity(toolCall)).toEqual({
+      server: "weather",
+      tool: "get_weather",
+    });
+  });
+
+  it.each([
+    { kind: "execute", toolName: "developer__shell", extensionName: "developer" },
+    { kind: "edit", toolName: "developer__edit", extensionName: "developer" },
+    { kind: "other", toolName: "weather__get_weather", extensionName: "weather" },
+  ] as const)(
+    "leaves goose $toolName unclassified so built-ins keep their projection",
+    ({ kind, toolName, extensionName }) => {
+      // goose tags built-in extensions exactly like user MCP servers.
+      const toolCall = toolCallFromUpdate({
+        sessionUpdate: "tool_call",
+        toolCallId: "goose-builtin",
+        kind,
+        title: "developer: shell",
+        status: "in_progress",
+        _meta: { goose: { toolCall: { toolName, extensionName } } },
+      });
+      expect(extractMcpToolCallIdentity(toolCall)).toBeUndefined();
+    },
+  );
+
+  it("uses the asserted server instead of a misleading T3 title", () => {
     const toolCall = toolCallFromUpdate({
       sessionUpdate: "tool_call",
       toolCallId: "foreign-1",
@@ -1551,7 +1586,10 @@ describe("extractMcpToolCallIdentity", () => {
       _meta: { toolName: "delegate_task", serverId: "other-orchestrator" },
     });
 
-    expect(extractMcpToolCallIdentity(toolCall)).toBeUndefined();
+    expect(extractMcpToolCallIdentity(toolCall)).toEqual({
+      server: "other-orchestrator",
+      tool: "delegate_task",
+    });
   });
 
   it("does not brand path-like or unknown-tool titles", () => {
diff --git a/apps/server/src/provider/acp/AcpRuntimeModel.ts b/apps/server/src/provider/acp/AcpRuntimeModel.ts
index 8cb059acb2ec..522d8783dec3 100644
--- a/apps/server/src/provider/acp/AcpRuntimeModel.ts
+++ b/apps/server/src/provider/acp/AcpRuntimeModel.ts
@@ -1134,9 +1134,7 @@ export function extractMcpToolCallIdentity(
   // (goose, qwen, claude-acp) or only through the namespaced function name
   // in the title. The verbatim wire title survives merges even when a later
   // titleless or LLM-enriched update replaces the presentation title, so
-  // match those rather than the summarized state title. Name-derived matches
-  // are gated on the known T3 tool inventory so path-like titles (for
-  // example "t3-code/README.md") never brand.
+  // match those rather than the summarized state title.
   const claudeCode = isRecord(meta?.claudeCode) ? meta.claudeCode : undefined;
   const gooseToolCall = isRecord(meta?.goose)
     ? isRecord(meta.goose.toolCall)
@@ -1160,15 +1158,22 @@ export function extractMcpToolCallIdentity(
       }
     }
   }
-  // A present-but-foreign origin assertion marks the whole call as another
-  // server's MCP call, so no loose name matching (meta or title) may brand it.
   const gooseExtension =
     typeof gooseToolCall?.extensionName === "string" ? gooseToolCall.extensionName.trim() : "";
   const assertsForeignOrigin =
     (metaServerId.length > 0 && !/^t3[-_ ]?code$/i.test(metaServerId)) ||
     (gooseExtension.length > 0 && !/^t3[-_ ]?code$/i.test(gooseExtension));
+  // A foreign origin never brands as T3. qwen's serverId marks a real MCP
+  // server, but goose reports its built-in extensions (developer__shell,
+  // edits) the same way as user MCP servers, so goose stays unclassified and
+  // keeps its command and file-change projections.
   if (assertsForeignOrigin) {
-    return undefined;
+    if (metaServerId.length === 0 || metaToolName.length === 0) return undefined;
+    const prefix = [`mcp__${metaServerId}__`, `mcp::${metaServerId}::`].find((prefix) =>
+      metaToolName.startsWith(prefix),
+    );
+    const tool = prefix === undefined ? metaToolName : metaToolName.slice(prefix.length);
+    return tool ? { server: metaServerId, tool } : undefined;
   }
   const candidates = [
     meta?.toolName,
@@ -1178,6 +1183,9 @@ export function extractMcpToolCallIdentity(
   ].filter((value): value is string => typeof value === "string");
   for (const candidate of candidates) {
     const trimmed = candidate.trim();
+    const qualified = /^mcp__(.+?)__(.+)$/i.exec(trimmed);
+    if (qualified?.[1] && qualified[2] && !/^t3[-_ ]?code$/i.test(qualified[1]))
+      return { server: qualified[1], tool: qualified[2] };
     const match =
       T3_MCP_TITLE_CALL.exec(trimmed) ??
       T3_MCP_TITLE_SUFFIX_CALL.exec(trimmed) ??
diff --git a/apps/server/src/provider/providerMaintenanceCommandCoordinator.ts b/apps/server/src/provider/providerMaintenanceCommandCoordinator.ts
index 7c456c3c484d..f2fc03659be0 100644
--- a/apps/server/src/provider/providerMaintenanceCommandCoordinator.ts
+++ b/apps/server/src/provider/providerMaintenanceCommandCoordinator.ts
@@ -1,6 +1,6 @@
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as Effect from "effect/Effect";
 import * as Ref from "effect/Ref";
-import * as Semaphore from "effect/Semaphore";
 
 export interface ProviderMaintenanceCommandCoordinatorShape<E> {
   readonly withCommandLock: <A, R>(input: {
@@ -15,7 +15,7 @@ export const makeProviderMaintenanceCommandCoordinator = Effect.fn(
   "makeProviderMaintenanceCommandCoordinator",
 )(function* <E>(input: { readonly makeAlreadyRunningError: (targetKey: string) => E }) {
   const runningTargetsRef = yield* Ref.make<ReadonlySet<string>>(new Set());
-  const locksRef = yield* Ref.make<ReadonlyMap<string, Semaphore.Semaphore>>(new Map());
+  const locks = yield* KeyedLock.make<string>();
 
   const acquireTarget = Effect.fn("acquireTarget")(function* (targetKey: string) {
     return yield* Ref.modify(runningTargetsRef, (runningTargets) => {
@@ -35,24 +35,6 @@ export const makeProviderMaintenanceCommandCoordinator = Effect.fn(
       return next;
     });
 
-  const getLock = Effect.fn("getProviderMaintenanceCommandLock")(function* (lockKey: string) {
-    const existing = (yield* Ref.get(locksRef)).get(lockKey);
-    if (existing) {
-      return existing;
-    }
-
-    const lock = yield* Semaphore.make(1);
-    return yield* Ref.modify(locksRef, (locks) => {
-      const current = locks.get(lockKey);
-      if (current) {
-        return [current, locks] as const;
-      }
-      const next = new Map(locks);
-      next.set(lockKey, lock);
-      return [lock, next] as const;
-    });
-  });
-
   const withCommandLock: ProviderMaintenanceCommandCoordinatorShape<E>["withCommandLock"] = ({
     targetKey,
     lockKey,
@@ -65,13 +47,10 @@ export const makeProviderMaintenanceCommandCoordinator = Effect.fn(
         return yield* Effect.fail(input.makeAlreadyRunningError(targetKey));
       }
 
-      return yield* Effect.gen(function* () {
-        const lock = yield* getLock(lockKey);
-        if (onQueued) {
-          yield* onQueued;
-        }
-        return yield* lock.withPermits(1)(run);
-      }).pipe(Effect.ensuring(releaseTarget(targetKey)));
+      return yield* (onQueued ?? Effect.void).pipe(
+        Effect.andThen(locks.withLock(lockKey, run)),
+        Effect.ensuring(releaseTarget(targetKey)),
+      );
     });
 
   return {
diff --git a/apps/server/src/pullRequest/forgejoPullRequestJson.ts b/apps/server/src/pullRequest/forgejoPullRequestJson.ts
index 1d0b5c1d4ccd..cade3b65d9c8 100644
--- a/apps/server/src/pullRequest/forgejoPullRequestJson.ts
+++ b/apps/server/src/pullRequest/forgejoPullRequestJson.ts
@@ -135,8 +135,8 @@ export function forgejoChangeRequest(pr: typeof ForgejoPullRequest.Type) {
     headRepositoryNameWithOwner: pr.head.repo?.full_name ?? null,
     state: pr.merged ? "merged" : pr.state === "closed" ? "closed" : "open",
     isDraft: pr.draft ?? /^(?:\[WIP\]|WIP:)/i.test(pr.title),
-    mergeability:
-      pr.mergeable === undefined ? "unknown" : pr.mergeable ? "mergeable" : "conflicting",
+    // A false value also covers drafts and unfinished or failed conflict checks.
+    mergeability: pr.mergeable === true ? "mergeable" : "unknown",
     additions: pr.additions ?? 0,
     deletions: pr.deletions ?? 0,
     createdAt: toIsoUtc(pr.created_at),
diff --git a/apps/server/src/relay/AgentAwarenessRelay.test.ts b/apps/server/src/relay/AgentAwarenessRelay.test.ts
index 003403fc5c09..4467fd9768ea 100644
--- a/apps/server/src/relay/AgentAwarenessRelay.test.ts
+++ b/apps/server/src/relay/AgentAwarenessRelay.test.ts
@@ -194,6 +194,7 @@ const makeTestRelay = Effect.fnUntraced(function* (
     dispatch: unused,
     getTimelinePage: () => Effect.die("Unused timeline read"),
     getMessageCount: () => Effect.die("unused message count"),
+    getTurnItem: () => Effect.die("unused turn item read"),
     getThreadRecords: () => Effect.die("unused record read"),
     getThreadProjection: unused,
     getCheckpointContext: unused,
diff --git a/apps/server/src/scheduledTasks/ScheduledCloudFire.ts b/apps/server/src/scheduledTasks/ScheduledCloudFire.ts
index 4fffe49339a6..53ffe5a3c472 100644
--- a/apps/server/src/scheduledTasks/ScheduledCloudFire.ts
+++ b/apps/server/src/scheduledTasks/ScheduledCloudFire.ts
@@ -12,6 +12,7 @@ import {
   type ProvisionProvider,
   type ScheduledTask,
 } from "@t3tools/contracts";
+import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
@@ -20,6 +21,7 @@ import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 
 import { EnvironmentControl } from "../environmentControl/EnvironmentControl.ts";
+import type * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
 import * as ProjectService from "../project/ProjectService.ts";
 import { RepositoryIdentityResolver } from "../project/RepositoryIdentityResolver.ts";
 
@@ -98,6 +100,43 @@ export class ScheduledCloudFire extends Context.Reference<{
   }),
 }) {}
 
+/**
+ * Launches one fire of a task: a chat here for a local task, or a fresh machine for a cloud one.
+ * A cloud fire is keyed by its start alone, which its row keeps as `last_run_at`, so a fire
+ * resumed after a restart sends the same request.
+ */
+export const launchFire =
+  (
+    cloudFire: (typeof ScheduledCloudFire)["Service"],
+    threadLaunch: ThreadLaunchService.ThreadLaunchService["Service"],
+  ) =>
+  (
+    task: ScheduledTask,
+    startedAt: DateTime.DateTime,
+    input: Parameters<ThreadLaunchService.ThreadLaunchService["Service"]["launch"]>[0],
+  ): Effect.Effect<unknown, ThreadLaunchService.ThreadLaunchError | ScheduledTaskError> =>
+    task.target === "local"
+      ? threadLaunch.launch(input)
+      : cloudFire.fire({
+          task,
+          provider: task.target,
+          fireKey: `${task.id}:${DateTime.toEpochMillis(startedAt)}`,
+          firedAt: DateTime.toUtc(startedAt),
+        });
+
+/**
+ * Whether a run's end leaves its row 'running'. A cloud fire cut short by shutdown has not
+ * failed: its machine keeps provisioning, and startup resumes the same fire.
+ */
+export const keepsCloudRun = (task: ScheduledTask, cause: Cause.Cause<unknown>): boolean =>
+  task.target !== "local" && Cause.hasInterruptsOnly(cause);
+
+/** The start of a cloud fire its row still marks running, which startup resumes. */
+export const resumableCloudRun = (task: ScheduledTask): Option.Option<DateTime.Utc> =>
+  task.target === "local" || task.lastRunAt === null
+    ? Option.none()
+    : DateTime.make(task.lastRunAt).pipe(Option.map(DateTime.toUtc));
+
 export const layer = Layer.effect(
   ScheduledCloudFire,
   Effect.gen(function* () {
diff --git a/apps/server/src/scheduledTasks/ScheduledTaskService.ts b/apps/server/src/scheduledTasks/ScheduledTaskService.ts
index c3c10960225b..6c6f1aad6482 100644
--- a/apps/server/src/scheduledTasks/ScheduledTaskService.ts
+++ b/apps/server/src/scheduledTasks/ScheduledTaskService.ts
@@ -32,7 +32,12 @@ import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import * as Scheduler from "../scheduling/Scheduler.ts";
-import { ScheduledCloudFire } from "./ScheduledCloudFire.ts";
+import {
+  ScheduledCloudFire,
+  keepsCloudRun,
+  launchFire,
+  resumableCloudRun,
+} from "./ScheduledCloudFire.ts";
 import { isMissedFixedTimeRun, isSameSchedule, nextScheduledRunAt } from "./Schedule.ts";
 
 const decodeTask = Schema.decodeUnknownEffect(ScheduledTask);
@@ -214,7 +219,7 @@ export const layer = Layer.effect(
     const threadLaunch = yield* ThreadLaunchService.ThreadLaunchService;
     const threadManagement = yield* ThreadManagementService.ThreadManagementService;
     const scheduler = yield* Scheduler.Scheduler;
-    const cloudFire = yield* ScheduledCloudFire;
+    const launch = launchFire(yield* ScheduledCloudFire, threadLaunch);
     const cloudRuns = yield* FiberSet.make();
     const activeRuns = yield* Ref.make<ReadonlySet<ScheduledTaskId>>(new Set());
     // Sliding(1) coalesces the dirty-signal: every notification triggers a
@@ -466,213 +471,170 @@ export const layer = Layer.effect(
         ),
       );
 
-    const reserve = (id: ScheduledTaskId) =>
-      Ref.modify(activeRuns, (active) => {
-        if (active.has(id)) return [false, active] as const;
+    const runTask = Effect.fn("ScheduledTaskService.runTask")(function* (
+      task: ScheduledTask,
+      trigger: "scheduled" | "manual" | "resumed",
+      resumedAt?: DateTime.DateTime,
+    ) {
+      const reserved = yield* Ref.modify(activeRuns, (active) => {
+        if (active.has(task.id)) return [false, active] as const;
         const next = new Set(active);
-        next.add(id);
+        next.add(task.id);
         return [true, next] as const;
       });
-    const unreserve = (id: ScheduledTaskId) =>
-      Ref.update(activeRuns, (active) => {
-        const next = new Set(active);
-        next.delete(id);
-        return next;
-      });
-
-    // Checks the fresh row and marks it running, or returns the task a run
-    // must not start for.
-    const beginRun = Effect.fn("ScheduledTaskService.beginRun")(function* (
-      task: ScheduledTask,
-      trigger: "scheduled" | "manual",
-    ) {
-      const startedAt = yield* localNow;
-
-      // The in-memory snapshot may be stale: re-read before touching run
-      // state. The task may have been deleted, paused, or postponed since
-      // the poll loaded it — none of those may fire.
-      const active = yield* findTask(task.id);
-      if (active === null) {
-        // A manual run on a just-deleted task must fail loudly, not report
-        // a successful run that never dispatched.
+      if (!reserved) {
         if (trigger === "manual") {
-          return yield* taskError("Schedule task not found.", { taskId: task.id });
+          return yield* taskError("Schedule task is already running.", { taskId: task.id });
         }
-        return { skipped: task } as const;
-      }
-      // A next_run_at corrupted between the poll read and this re-read must
-      // not defect the poll; an unparseable value is treated as not due.
-      const parsedNextRunAt =
-        active.nextRunAt === null ? Option.none() : DateTime.make(active.nextRunAt);
-      if (
-        trigger === "scheduled" &&
-        (!active.enabled ||
-          Option.isNone(parsedNextRunAt) ||
-          DateTime.toEpochMillis(parsedNextRunAt.value) > DateTime.toEpochMillis(startedAt))
-      ) {
-        return { skipped: active } as const;
+        return task;
       }
 
-      yield* markRunning(active.id, iso(startedAt));
-      yield* notifyChanged;
-      return { active, startedAt } as const;
-    });
+      return yield* Effect.gen(function* () {
+        const startedAt = resumedAt ?? (yield* localNow);
+        const startedAtIso = iso(startedAt);
+
+        // The in-memory snapshot may be stale: re-read before touching run
+        // state. The task may have been deleted, paused, or postponed since
+        // the poll loaded it — none of those may fire.
+        const active = yield* findTask(task.id);
+        if (active === null) {
+          // A manual run on a just-deleted task must fail loudly, not report
+          // a successful run that never dispatched.
+          if (trigger === "manual") {
+            return yield* taskError("Schedule task not found.", { taskId: task.id });
+          }
+          return task;
+        }
+        // A next_run_at corrupted between the poll read and this re-read must
+        // not defect the poll; an unparseable value is treated as not due.
+        const parsedNextRunAt =
+          active.nextRunAt === null ? Option.none() : DateTime.make(active.nextRunAt);
+        if (
+          trigger === "scheduled" &&
+          (!active.enabled ||
+            Option.isNone(parsedNextRunAt) ||
+            DateTime.toEpochMillis(parsedNextRunAt.value) > DateTime.toEpochMillis(startedAt))
+        ) {
+          return active;
+        }
 
-    // Dispatches a run its row already marks running, then records how it
-    // ended. The run is keyed by its start, which the row keeps as
-    // last_run_at, so a cloud fire resumed after a restart sends the same
-    // request.
-    const finishRun = Effect.fn("ScheduledTaskService.finishRun")(function* (
-      active: ScheduledTask,
-      startedAt: DateTime.DateTime,
-    ) {
-      const startedAtIso = iso(startedAt);
-      const fireKey = `${active.id}:${DateTime.toEpochMillis(startedAt)}`;
-      const commandId = CommandId.make(`scheduled-task:${fireKey}`);
-      const messageId = MessageId.make(`scheduled-task-message:${fireKey}`);
-
-      // A cloud task never binds a thread (upsert refuses it), so it always takes the launch
-      // branch, which starts its chat on a fresh machine instead of here.
-      const target = active.target;
-      const launch = (
-        input: Parameters<typeof threadLaunch.launch>[0],
-      ): Effect.Effect<unknown, ThreadLaunchService.ThreadLaunchError | ScheduledTaskError> =>
-        target === "local"
-          ? threadLaunch.launch(input)
-          : cloudFire.fire({
-              task: active,
-              provider: target,
-              fireKey,
-              firedAt: DateTime.toUtc(startedAt),
-            });
-      // Effect.exit (not Effect.result) so defects and interruptions in the
-      // dispatch are also captured and recorded as a failed run instead of
-      // aborting before markCompleted.
-      const result =
-        active.threadId === null
-          ? yield* Effect.exit(
-              launch({
-                commandId,
-                projectId: active.projectId,
-                title: active.title,
-                modelSelection: active.modelSelection,
-                runtimeMode: active.runtimeMode,
-                interactionMode: active.interactionMode,
-                workspaceStrategy: active.workspaceStrategy,
-                initialMessage: {
+        yield* markRunning(active.id, startedAtIso);
+        yield* notifyChanged;
+
+        const fireKey = `${active.id}:${DateTime.toEpochMillis(startedAt)}:${trigger}`;
+        const commandId = CommandId.make(`scheduled-task:${fireKey}`);
+        const messageId = MessageId.make(`scheduled-task-message:${fireKey}`);
+        // Dispatch from the fresh row so prompt/model/binding edits made
+        // after the poll read are honoured.
+        const prompt = active.prompt;
+
+        // Effect.exit (not Effect.result) so defects and interruptions in the
+        // dispatch are also captured and recorded as a failed run instead of
+        // aborting before markCompleted.
+        const result =
+          active.threadId === null
+            ? yield* Effect.exit(
+                launch(active, startedAt, {
+                  commandId,
+                  projectId: active.projectId,
+                  title: active.title,
+                  modelSelection: active.modelSelection,
+                  runtimeMode: active.runtimeMode,
+                  interactionMode: active.interactionMode,
+                  workspaceStrategy: active.workspaceStrategy,
+                  initialMessage: {
+                    messageId,
+                    scheduledTaskId: active.id,
+                    text: prompt,
+                    attachments: [],
+                  },
+                  createdBy: active.createdBy,
+                  creationSource: active.creationSource,
+                }),
+              )
+            : yield* Effect.exit(
+                threadManagement.sendToThread({
+                  projectId: active.projectId,
+                  commandId,
+                  threadId: ThreadId.make(active.threadId),
                   messageId,
                   scheduledTaskId: active.id,
-                  text: active.prompt,
+                  text: prompt,
                   attachments: [],
-                },
-                createdBy: active.createdBy,
-                creationSource: active.creationSource,
-              }),
-            )
-          : yield* Effect.exit(
-              threadManagement.sendToThread({
-                projectId: active.projectId,
-                commandId,
-                threadId: ThreadId.make(active.threadId),
-                messageId,
-                scheduledTaskId: active.id,
-                text: active.prompt,
-                attachments: [],
-                modelSelection: active.modelSelection,
-                mode: "auto",
-                createdBy: active.createdBy,
-                creationSource: active.creationSource,
-              }),
-            );
-
-      const completedAt = yield* localNow;
-      const runSucceeded = result._tag === "Success";
-      const lastRunStatus = runSucceeded ? ("succeeded" as const) : ("failed" as const);
-      const lastRunError = runSucceeded ? null : errorMessage(result.cause);
-      // Re-read the task so the next run is computed from the schedule as it
-      // is *now* (the user may have edited or deleted it while we ran).
-      const current = yield* findTask(active.id);
-      const scheduleSource = current ?? active;
-      const completed: ScheduledTask = {
-        ...scheduleSource,
-        updatedAt: iso(completedAt),
-        lastRunAt: startedAtIso,
-        nextRunAt: nextRunAt(scheduleSource, completedAt),
-        lastRunStatus,
-        lastRunError,
-        runCount: scheduleSource.runCount + 1,
-      };
-      if (current !== null) {
-        // startedAtIso in the guard ensures this writes only to the row this
-        // run marked as running — a task deleted mid-run and recreated with
-        // the same id (idempotent commandId replay) must not be stamped.
-        yield* markCompleted({
-          id: active.id,
-          completedAtIso: completed.updatedAt,
-          nextRunAtIso: completed.nextRunAt,
-          status: lastRunStatus,
-          error: lastRunError,
-          startedAtIso,
-        });
-        yield* notifyChanged;
-      }
-      return completed;
-    });
-
-    // Owns the run's reservation until it ends. A cloud fire cut short by
-    // shutdown is not a failure: its machine keeps provisioning, so the row
-    // stays 'running' and startup resumes the same fire.
-    const settleRun = (active: ScheduledTask, startedAt: DateTime.DateTime) =>
-      finishRun(active, startedAt).pipe(
+                  modelSelection: active.modelSelection,
+                  // Scheduled prompts must not interrupt tools in the bound thread.
+                  mode: "queue",
+                  createdBy: active.createdBy,
+                  creationSource: active.creationSource,
+                }),
+              );
+
+        const completedAt = yield* localNow;
+        const runSucceeded = result._tag === "Success";
+        const lastRunStatus = runSucceeded ? ("succeeded" as const) : ("failed" as const);
+        const lastRunError = runSucceeded ? null : errorMessage(result.cause);
+        // Re-read the task so the next run is computed from the schedule as it
+        // is *now* (the user may have edited or deleted it while we ran).
+        const current = yield* findTask(task.id);
+        const scheduleSource = current ?? task;
+        const completed: ScheduledTask = {
+          ...scheduleSource,
+          updatedAt: iso(completedAt),
+          lastRunAt: startedAtIso,
+          nextRunAt: nextRunAt(scheduleSource, completedAt),
+          lastRunStatus,
+          lastRunError,
+          runCount: scheduleSource.runCount + 1,
+        };
+        if (current !== null) {
+          // startedAtIso in the guard ensures this writes only to the row this
+          // run marked as running — a task deleted mid-run and recreated with
+          // the same id (idempotent commandId replay) must not be stamped.
+          yield* markCompleted({
+            id: task.id,
+            completedAtIso: completed.updatedAt,
+            nextRunAtIso: completed.nextRunAt,
+            status: lastRunStatus,
+            error: lastRunError,
+            startedAtIso,
+          });
+          yield* notifyChanged;
+        }
+        return completed;
+      }).pipe(
         Effect.onError((cause) =>
-          active.target !== "local" && Cause.hasInterruptsOnly(cause)
-            ? Effect.void
-            : releaseStuckRun(active, errorMessage(cause)),
+          keepsCloudRun(task, cause) ? Effect.void : releaseStuckRun(task, errorMessage(cause)),
         ),
-        Effect.ensuring(unreserve(active.id)),
-      );
-
-    // A cloud fire waits minutes for its machine, so once its checks pass it
-    // runs beside the poll loop and the caller rather than holding them; its
-    // row reads 'running' until the machine is ready.
-    const runCloud = (active: ScheduledTask, startedAt: DateTime.DateTime) =>
-      FiberSet.run(
-        cloudRuns,
-        settleRun(active, startedAt).pipe(
-          Effect.catch((cause) =>
-            Effect.logWarning("Cloud scheduled task run failed", { taskId: active.id, cause }),
-          ),
+        Effect.ensuring(
+          Ref.update(activeRuns, (active) => {
+            const next = new Set(active);
+            next.delete(task.id);
+            return next;
+          }),
         ),
       );
+    });
 
+    // A cloud fire waits minutes for its machine, so it runs beside the poll
+    // loop and the caller, its row reading 'running' until the machine is ready.
     const startRun = Effect.fn("ScheduledTaskService.startRun")(function* (
       task: ScheduledTask,
-      trigger: "scheduled" | "manual",
+      trigger: "scheduled" | "manual" | "resumed",
+      resumedAt?: DateTime.DateTime,
     ) {
-      if (!(yield* reserve(task.id))) {
-        if (trigger === "manual") {
-          return yield* taskError("Schedule task is already running.", { taskId: task.id });
-        }
-        return task;
+      if (task.target === "local") return yield* runTask(task, trigger, resumedAt);
+      if (trigger === "manual" && (yield* Ref.get(activeRuns)).has(task.id)) {
+        return yield* taskError("Schedule task is already running.", { taskId: task.id });
       }
-      // Uninterruptible between the checks and the hand-off, so the
-      // reservation always ends up with exactly one owner.
-      return yield* Effect.uninterruptibleMask((restore) =>
-        Effect.gen(function* () {
-          const begun = yield* restore(beginRun(task, trigger)).pipe(
-            Effect.onError(() => unreserve(task.id)),
-          );
-          if ("skipped" in begun) {
-            yield* unreserve(task.id);
-            return begun.skipped;
-          }
-          if (begun.active.target === "local") {
-            return yield* restore(settleRun(begun.active, begun.startedAt));
-          }
-          yield* runCloud(begun.active, begun.startedAt);
-          return begun.active;
-        }),
+      yield* FiberSet.run(
+        cloudRuns,
+        runTask(task, trigger, resumedAt).pipe(
+          Effect.catch((cause) =>
+            Effect.logWarning("Cloud scheduled task run failed", { taskId: task.id, cause }),
+          ),
+        ),
       );
+      return task;
     });
 
     // A due fixed-time run that is long past its slot (server was off or
@@ -742,15 +704,11 @@ export const layer = Layer.effect(
         (row) =>
           Effect.gen(function* () {
             const decoded = yield* Effect.result(decodeRow(row));
-            const cloudStartedAt =
-              Result.isSuccess(decoded) && decoded.success.target !== "local"
-                ? Option.flatMap(Option.fromNullishOr(decoded.success.lastRunAt), (at) =>
-                    DateTime.make(at),
-                  )
-                : Option.none();
-            if (Result.isSuccess(decoded) && Option.isSome(cloudStartedAt)) {
-              yield* reserve(decoded.success.id);
-              yield* runCloud(decoded.success, cloudStartedAt.value);
+            const resumedAt = Result.isSuccess(decoded)
+              ? resumableCloudRun(decoded.success)
+              : Option.none();
+            if (Result.isSuccess(decoded) && Option.isSome(resumedAt)) {
+              yield* startRun(decoded.success, "resumed", resumedAt.value);
               return;
             }
             if (Result.isSuccess(decoded)) {
@@ -831,9 +789,8 @@ export const layer = Layer.effect(
         // keep their run history, and so real load failures propagate instead
         // of silently resetting an existing row.
         const existingTask = yield* findTask(id);
-        const threadId = input.threadId ?? null;
         const target = input.target ?? existingTask?.target ?? "local";
-        if (target !== "local" && threadId !== null) {
+        if (target !== "local" && (input.threadId ?? null) !== null) {
           return yield* taskError("A task that runs on a cloud machine must start a new chat.", {
             taskId: id,
           });
@@ -852,7 +809,7 @@ export const layer = Layer.effect(
           enabled: input.enabled,
           schedule: input.schedule,
           projectId: input.projectId,
-          threadId,
+          threadId: input.threadId ?? null,
           target,
           workspaceStrategy: input.workspaceStrategy,
           modelSelection: input.modelSelection,
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 01385136f832..5124f898cfa6 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -118,6 +118,7 @@ import { ObservabilityLive } from "./observability/Layers/Observability.ts";
 import * as HeapSnapshot from "./observability/HeapSnapshot.ts";
 import * as EventLoopMonitor from "./observability/EventLoopMonitor.ts";
 import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
+import * as DirectEndpoints from "./environment/DirectEndpoints.ts";
 import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts";
 import { authHttpApiLayer, environmentAuthenticatedAuthLayer } from "./auth/http.ts";
 import * as ReplayMarkers from "./auth/replayMarkers.ts";
@@ -630,6 +631,7 @@ const RuntimeDependenciesLive = RuntimeCoreDependenciesLive.pipe(
   Layer.provideMerge(AnalyticsService.layer),
   Layer.provideMerge(ExternalLauncher.layer),
   Layer.provideMerge(RemoteOpenTargets.layer),
+  Layer.provideMerge(DirectEndpoints.layer),
   Layer.provideMerge(ServerLifecycleEvents.layer),
   Layer.provide(NetService.layer),
 );
diff --git a/apps/server/src/sourceControl/SourceControlDiscovery.test.ts b/apps/server/src/sourceControl/SourceControlDiscovery.test.ts
index 15a6d454172a..1f5a8138b252 100644
--- a/apps/server/src/sourceControl/SourceControlDiscovery.test.ts
+++ b/apps/server/src/sourceControl/SourceControlDiscovery.test.ts
@@ -199,6 +199,87 @@ it.effect("reads Forgejo checks without repository or viewer requests", () => {
   );
 });
 
+it.effect.each([
+  ["Ready", false, true, false, "mergeable"],
+  ["Draft", true, false, true, "unknown"],
+  ["Blocked", false, false, false, "unknown"],
+  ["Unchecked", false, undefined, false, "unknown"],
+  ["WIP: Legacy draft", undefined, false, true, "unknown"],
+  ["[WIP] Legacy draft", undefined, false, true, "unknown"],
+  ["WIP: Explicitly ready", false, false, false, "unknown"],
+] as const)(
+  "reads Forgejo mergeability for %s (draft=%s, mergeable=%s) across list, summary and detail",
+  ([title, draft, mergeable, isDraft, mergeability]) => {
+    const pr = {
+      number: 42,
+      title,
+      body: "",
+      html_url: "https://forgejo.test/maria/project/pulls/42",
+      user: { login: "maria" },
+      state: "open",
+      merged: false,
+      ...(draft === undefined ? {} : { draft }),
+      ...(mergeable === undefined ? {} : { mergeable }),
+      head: { ref: "feature", sha: "head", repo: null },
+      base: { ref: "main", sha: "base", repo: null },
+      created_at: "2026-09-16T00:00:00Z",
+      updated_at: "2026-09-16T00:00:00Z",
+      closed_at: null,
+      merged_at: null,
+      labels: [],
+    };
+    return Effect.gen(function* () {
+      const provider = yield* ForgejoPullRequestProvider.make;
+      const readSummary = provider.getChangeRequestSummary;
+      if (readSummary === undefined) return yield* Effect.die("summary read missing");
+      const input = { cwd: "/repo", repository: "maria/project", host: "forgejo.test", number: 42 };
+      const list = yield* provider.listChangeRequests({
+        ...input,
+        state: "open",
+        involvement: "all",
+        viewer: "maria",
+        limit: 10,
+      });
+      const summary = yield* readSummary(input);
+      const detail = yield* provider.getChangeRequest(input);
+      assert.strictEqual(list.items.length, 1);
+      for (const result of [list.items[0]!, summary, detail]) {
+        assert.strictEqual(result.mergeability, mergeability);
+        assert.strictEqual(result.isDraft, isDraft);
+      }
+    }).pipe(
+      Effect.provide(
+        Layer.mock(ForgejoCli.ForgejoCli)({
+          api: (input) => {
+            const [path, query] = input.path.split("?");
+            let response: unknown;
+            switch (path) {
+              case "repos/maria/project/pulls":
+                response = new URLSearchParams(query).get("page") === "1" ? [pr] : [];
+                break;
+              case "repos/maria/project/pulls/42":
+                response = pr;
+                break;
+              case "repos/maria/project":
+                response = { full_name: "maria/project", permissions: { push: true, admin: true } };
+                break;
+              case "user":
+                response = pr.user;
+                break;
+              case "repos/maria/project/statuses/head":
+                response = [];
+                break;
+              default:
+                return Effect.die(`Unexpected Forgejo request: ${input.path}`);
+            }
+            return encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
+          },
+        }),
+      ),
+    );
+  },
+);
+
 it.effect("loads Forgejo pull request references from files and commits views", () =>
   Effect.gen(function* () {
     const provider = yield* ForgejoSourceControlProvider.make;
diff --git a/apps/server/src/terminal/Manager.ts b/apps/server/src/terminal/Manager.ts
index 6122c8606f0b..8766255b7226 100644
--- a/apps/server/src/terminal/Manager.ts
+++ b/apps/server/src/terminal/Manager.ts
@@ -40,6 +40,7 @@ import {
   ProviderInstanceId,
 } from "@t3tools/contracts";
 import { makeKeyedCoalescingWorker } from "@t3tools/shared/KeyedCoalescingWorker";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import { HostProcessArchitecture, HostProcessPlatform } from "@t3tools/shared/hostProcess";
 import { mergePathEntries } from "@t3tools/shared/shell";
 
@@ -58,7 +59,6 @@ import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
-import * as Semaphore from "effect/Semaphore";
 import * as SynchronizedRef from "effect/SynchronizedRef";
 
 import * as ServerConfig from "../config.ts";
@@ -1569,7 +1569,7 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
     sessions: new Map(),
     killFibers: new Map(),
   });
-  const threadLocksRef = yield* SynchronizedRef.make(new Map<string, Semaphore.Semaphore>());
+  const threadLocks = yield* KeyedLock.make<string>();
   const terminalEventListeners = new Set<(event: TerminalEvent) => Effect.Effect<void>>();
   const workerScope = yield* Scope.make("sequential");
   yield* Effect.addFinalizer(() => Scope.close(workerScope, Exit.void));
@@ -1598,29 +1598,10 @@ export const makeWithOptions = Effect.fn("TerminalManager.makeWithOptions")(func
     f: (state: TerminalManagerState) => readonly [A, TerminalManagerState],
   ) => SynchronizedRef.modify(managerStateRef, f);
 
-  const getThreadSemaphore = (threadId: string) =>
-    SynchronizedRef.modifyEffect(threadLocksRef, (current) => {
-      const existing: Option.Option<Semaphore.Semaphore> = Option.fromNullishOr(
-        current.get(threadId),
-      );
-      return Option.match(existing, {
-        onNone: () =>
-          Semaphore.make(1).pipe(
-            Effect.map((semaphore) => {
-              const next = new Map(current);
-              next.set(threadId, semaphore);
-              return [semaphore, next] as const;
-            }),
-          ),
-        onSome: (semaphore) => Effect.succeed([semaphore, current] as const),
-      });
-    });
-
   const withThreadLock = <A, E, R>(
     threadId: string,
     effect: Effect.Effect<A, E, R>,
-  ): Effect.Effect<A, E, R> =>
-    Effect.flatMap(getThreadSemaphore(threadId), (semaphore) => semaphore.withPermit(effect));
+  ): Effect.Effect<A, E, R> => threadLocks.withLock(threadId, effect);
 
   const clearKillFiber = Effect.fn("terminal.clearKillFiber")(function* (
     process: PtyAdapter.PtyProcess | null,
diff --git a/apps/server/src/vcs/GitVcsDriver.ts b/apps/server/src/vcs/GitVcsDriver.ts
index 99220a8bf78f..8e9147669433 100644
--- a/apps/server/src/vcs/GitVcsDriver.ts
+++ b/apps/server/src/vcs/GitVcsDriver.ts
@@ -174,6 +174,8 @@ export interface GitCommitProgress {
 export interface GitCommitOptions {
   readonly timeoutMs?: number;
   readonly progress?: GitCommitProgress;
+  /** Stage the current working tree immediately before committing. */
+  readonly stage?: { readonly filePaths?: readonly string[] };
 }
 
 export interface GitDeleteLocalBranchInput {
diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts
index c720a2e4958a..17ae6e309fee 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.test.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts
@@ -3052,7 +3052,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
   });
 
   describe("commit context", () => {
-    it.effect("stages selected files and commits only those files", () =>
+    it.effect("prepares selected files without staging and commits only those files", () =>
       Effect.gen(function* () {
         const cwd = yield* makeTmpDir();
         yield* initRepoWithCommit(cwd);
@@ -3064,8 +3064,9 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
         const context = yield* driver.prepareCommitContext(cwd, ["a.txt"]);
         assert.include(context?.stagedSummary ?? "", "a.txt");
         assert.notInclude(context?.stagedSummary ?? "", "b.txt");
+        assert.equal(yield* git(cwd, ["diff", "--cached", "--name-only"]), "");
 
-        const commit = yield* driver.commit(cwd, "Add a", "");
+        const commit = yield* driver.commit(cwd, "Add a", "", { stage: { filePaths: ["a.txt"] } });
         assert.match(commit.commitSha, /^[a-f0-9]{40}$/);
         assert.equal(yield* git(cwd, ["log", "-1", "--pretty=%s"]), "Add a");
 
@@ -3084,14 +3085,96 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
         yield* writeTextFile(cwd, "selected[1].txt", "literal\n");
         yield* writeTextFile(cwd, "selected1.txt", "pattern match\n");
 
-        yield* driver.prepareCommitContext(cwd, ["selected[1].txt"]);
+        const context = yield* driver.prepareCommitContext(cwd, ["selected[1].txt"]);
 
-        assert.equal(yield* git(cwd, ["diff", "--cached", "--name-only"]), "selected[1].txt");
+        assert.include(context?.stagedSummary ?? "", "selected[1].txt");
+        assert.notInclude(context?.stagedSummary ?? "", "selected1.txt");
+        assert.equal(yield* git(cwd, ["diff", "--cached", "--name-only"]), "");
+        yield* driver.commit(cwd, "Add literal path", "", {
+          stage: { filePaths: ["selected[1].txt"] },
+        });
+        assert.equal(
+          yield* git(cwd, ["show", "--pretty=", "--name-only", "HEAD"]),
+          "selected[1].txt",
+        );
 
         const status = yield* git(cwd, ["status", "--porcelain"]);
         assert.include(status, "?? selected1.txt");
       }),
     );
+
+    it.effect.each([false, true])(
+      "preserves partial staging and split-index files (split: %s)",
+      (split) =>
+        Effect.gen(function* () {
+          const cwd = yield* makeTmpDir();
+          yield* initRepoWithCommit(cwd);
+          if (split) yield* git(cwd, ["config", "core.splitIndex", "true"]);
+          yield* writeTextFile(cwd, "README.md", "# test\nstaged\n");
+          yield* git(cwd, ["add", "README.md"]);
+          yield* writeTextFile(cwd, "README.md", "# test\nstaged\nunstaged\n");
+          yield* writeTextFile(cwd, "untracked.txt", "untracked\n");
+          yield* writeTextFile(cwd, ".gitignore", "ignored.txt\n");
+          yield* writeTextFile(cwd, "ignored.txt", "ignored\n");
+          const before = NodeFS.readFileSync(`${cwd}/.git/index`);
+          const shared = NodeFS.readdirSync(`${cwd}/.git`).filter((name) =>
+            name.startsWith("sharedindex."),
+          );
+          const driver = yield* GitVcsDriver.GitVcsDriver;
+          for (const paths of [undefined, ["README.md"]]) {
+            const context = yield* driver.prepareCommitContext(cwd, paths);
+            assert.include(context?.stagedPatch ?? "", "unstaged");
+            assert.notInclude(context?.stagedSummary ?? "", "ignored.txt");
+            assert.deepEqual(NodeFS.readFileSync(`${cwd}/.git/index`), before);
+            assert.deepEqual(
+              NodeFS.readdirSync(`${cwd}/.git`).filter((name) => name.startsWith("sharedindex.")),
+              shared,
+            );
+          }
+        }),
+    );
+
+    it.effect("prepares an unborn repository without creating a real index", () =>
+      Effect.gen(function* () {
+        const cwd = yield* makeTmpDir();
+        const driver = yield* GitVcsDriver.GitVcsDriver;
+        yield* driver.initRepo({ cwd });
+        yield* git(cwd, ["config", "user.email", "test@test.com"]);
+        yield* git(cwd, ["config", "user.name", "Test"]);
+        yield* writeTextFile(cwd, "initial.txt", "initial\n");
+        for (const paths of [undefined, ["initial.txt"]]) {
+          const context = yield* driver.prepareCommitContext(cwd, paths);
+          assert.include(context?.stagedSummary ?? "", "initial.txt");
+          assert.isFalse(NodeFS.existsSync(`${cwd}/.git/index`));
+        }
+        yield* driver.commit(cwd, "Initial", "", { stage: { filePaths: ["initial.txt"] } });
+        assert.equal(yield* git(cwd, ["show", "HEAD:initial.txt"]), "initial");
+      }),
+    );
+
+    it.effect("preserves merge metadata while preparing selected and all files", () =>
+      Effect.gen(function* () {
+        const cwd = yield* makeTmpDir();
+        const { initialBranch } = yield* initRepoWithCommit(cwd);
+        yield* git(cwd, ["checkout", "-b", "feature"]);
+        yield* writeTextFile(cwd, "feature.txt", "feature\n");
+        yield* git(cwd, ["add", "."]);
+        yield* git(cwd, ["commit", "-m", "Feature"]);
+        yield* git(cwd, ["checkout", initialBranch]);
+        yield* git(cwd, ["merge", "--no-commit", "--no-ff", "feature"]);
+        yield* writeTextFile(cwd, "README.md", "# test\nmerge edit\n");
+        const names = ["index", "MERGE_HEAD", "MERGE_MSG", "ORIG_HEAD"];
+        const before = names.map((name) => NodeFS.readFileSync(`${cwd}/.git/${name}`));
+        const driver = yield* GitVcsDriver.GitVcsDriver;
+        for (const paths of [undefined, ["README.md"]]) {
+          yield* driver.prepareCommitContext(cwd, paths);
+          assert.deepEqual(
+            names.map((name) => NodeFS.readFileSync(`${cwd}/.git/${name}`)),
+            before,
+          );
+        }
+      }),
+    );
   });
 
   describe("remote operations", () => {
@@ -3271,7 +3354,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
           refName: "feature/push",
         });
         yield* writeTextFile(cwd, "feature.txt", "feature\n");
-        yield* (yield* GitVcsDriver.GitVcsDriver).prepareCommitContext(cwd);
+        yield* git(cwd, ["add", "-A"]);
         yield* (yield* GitVcsDriver.GitVcsDriver).commit(cwd, "Add feature", "");
 
         const pushed = yield* (yield* GitVcsDriver.GitVcsDriver).pushCurrentBranch(cwd, null);
@@ -3343,7 +3426,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
           yield* git(cwd, ["remote", "add", "origin", remote]);
           yield* git(cwd, ["push", "-u", "origin", "main"]);
           yield* writeTextFile(cwd, "upstream.txt", "upstream\n");
-          yield* driver.prepareCommitContext(cwd);
+          yield* git(cwd, ["add", "-A"]);
           yield* driver.commit(cwd, "Add upstream update", "");
 
           const pushed = yield* driver.pushCurrentBranch(cwd, null);
@@ -3384,7 +3467,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
         const devSha = yield* git(cwd, ["rev-parse", "HEAD"]);
         yield* git(cwd, ["checkout", "-b", "feature/x", "origin/dev"]);
         yield* writeTextFile(cwd, "feature.txt", "feature\n");
-        yield* driver.prepareCommitContext(cwd);
+        yield* git(cwd, ["add", "-A"]);
         yield* driver.commit(cwd, "Add feature", "");
 
         const pushed = yield* driver.pushCurrentBranch(cwd, null);
@@ -3418,7 +3501,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
         yield* git(cwd, ["checkout", "-b", "feature/y", "origin/main"]);
         yield* git(cwd, ["config", "branch.feature/y.gh-merge-base", "release/v2"]);
         yield* writeTextFile(cwd, "feature.txt", "feature\n");
-        yield* driver.prepareCommitContext(cwd);
+        yield* git(cwd, ["add", "-A"]);
         yield* driver.commit(cwd, "Add feature", "");
 
         const pushed = yield* driver.pushCurrentBranch(cwd, null);
@@ -3456,7 +3539,7 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => {
           "upstream/effect-atom",
         );
         yield* writeTextFile(cwd, "alias.txt", "alias\n");
-        yield* driver.prepareCommitContext(cwd);
+        yield* git(cwd, ["add", "-A"]);
         yield* driver.commit(cwd, "Add alias update", "");
 
         const pushed = yield* driver.pushCurrentBranch(cwd, null);
diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts
index 971d0e7a9a95..935fb3d24a72 100644
--- a/apps/server/src/vcs/GitVcsDriverCore.ts
+++ b/apps/server/src/vcs/GitVcsDriverCore.ts
@@ -2025,48 +2025,132 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
       })),
     );
 
-  const prepareCommitContext: GitVcsDriver.GitVcsDriver["Service"]["prepareCommitContext"] =
-    Effect.fn("prepareCommitContext")(function* (cwd, filePaths) {
-      if (filePaths && filePaths.length > 0) {
-        yield* runGit("GitVcsDriver.prepareCommitContext.reset", cwd, ["reset"]).pipe(
-          Effect.catchTags({
-            GitCommandError: () => Effect.void,
-          }),
+  const stageCommitChanges = Effect.fnUntraced(function* (
+    cwd: string,
+    filePaths?: readonly string[],
+    env?: NodeJS.ProcessEnv,
+  ) {
+    const config = env
+      ? ["-c", "core.splitIndex=false", "-c", "splitIndex.sharedIndexExpire=never"]
+      : [];
+    if (filePaths && filePaths.length > 0) {
+      if (env) {
+        const head = yield* executeGit(
+          "GitVcsDriver.prepareCommitContext.head",
+          cwd,
+          ["rev-parse", "--verify", "--quiet", "HEAD"],
+          { allowNonZeroExit: true },
+        );
+        // Even with GIT_INDEX_FILE, reset clears the repository's merge state.
+        yield* runGit(
+          "GitVcsDriver.prepareCommitContext.readTree",
+          cwd,
+          [...config, "read-tree", ...(head.exitCode === 0 ? ["HEAD"] : ["--empty"])],
+          { env },
         );
-        yield* runGit("GitVcsDriver.prepareCommitContext.addSelected", cwd, [
-          "--literal-pathspecs",
-          "add",
-          "-A",
-          "--",
-          ...filePaths,
-        ]);
       } else {
-        yield* runGit("GitVcsDriver.prepareCommitContext.addAll", cwd, ["add", "-A"]);
+        yield* runGit("GitVcsDriver.commit.reset", cwd, ["reset"]).pipe(
+          Effect.catchTags({ GitCommandError: () => Effect.void }),
+        );
       }
-
-      const stagedSummary = yield* runGitStdout(
-        "GitVcsDriver.prepareCommitContext.stagedSummary",
+      yield* runGit(
+        "GitVcsDriver.commit.addSelected",
         cwd,
-        ["diff", "--cached", "--name-status"],
-      ).pipe(Effect.map((stdout) => stdout.trim()));
-      if (stagedSummary.length === 0) {
-        return null;
-      }
-
-      const stagedPatch = yield* runGitStdoutWithOptions(
-        "GitVcsDriver.prepareCommitContext.stagedPatch",
+        [...config, "--literal-pathspecs", "add", "-A", "--", ...filePaths],
+        env ? { env } : {},
+      );
+    } else {
+      yield* runGit(
+        "GitVcsDriver.commit.addAll",
         cwd,
-        ["diff", "--no-ext-diff", "--cached", "--patch", "--minimal"],
-        {
-          maxOutputBytes: PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES,
-          appendTruncationMarker: true,
-        },
+        [...config, "add", "-A"],
+        env ? { env } : {},
       );
+    }
+  });
 
-      return {
-        stagedSummary,
-        stagedPatch,
-      };
+  const prepareCommitContext: GitVcsDriver.GitVcsDriver["Service"]["prepareCommitContext"] =
+    Effect.fn("prepareCommitContext")(function* (cwd, filePaths) {
+      return yield* Effect.scoped(
+        Effect.gen(function* () {
+          const indexValue = yield* runGitStdout(
+            "GitVcsDriver.prepareCommitContext.indexPath",
+            cwd,
+            ["rev-parse", "--git-path", "index"],
+          );
+          const indexPath = path.resolve(cwd, indexValue.trim());
+          const directory = yield* fileSystem.makeTempDirectoryScoped({
+            prefix: "t3code-commit-index-",
+          });
+          const tempIndexPath = path.join(directory, "index");
+          const env = { GIT_INDEX_FILE: tempIndexPath } satisfies NodeJS.ProcessEnv;
+          const config = [
+            "-c",
+            "core.splitIndex=false",
+            "-c",
+            "splitIndex.sharedIndexExpire=never",
+          ];
+          if (yield* fileSystem.exists(indexPath)) {
+            const { mtime } = yield* fileSystem.stat(indexPath);
+            yield* fileSystem.copyFile(indexPath, tempIndexPath);
+            const indexTime = Option.isSome(mtime)
+              ? Math.max(0, Math.floor(mtime.value.getTime() / 1000))
+              : 0;
+            yield* fileSystem.utimes(tempIndexPath, indexTime, indexTime);
+            yield* runGit(
+              "GitVcsDriver.prepareCommitContext.expandSplitIndex",
+              cwd,
+              [...config, "update-index", "--no-split-index"],
+              { env },
+            );
+          } else {
+            yield* runGit(
+              "GitVcsDriver.prepareCommitContext.emptyIndex",
+              cwd,
+              [...config, "read-tree", "--empty"],
+              { env },
+            );
+          }
+          yield* stageCommitChanges(cwd, filePaths, env);
+
+          const stagedSummary = yield* runGitStdoutWithOptions(
+            "GitVcsDriver.prepareCommitContext.stagedSummary",
+            cwd,
+            ["diff", "--cached", "--name-status"],
+            { env },
+          ).pipe(Effect.map((stdout) => stdout.trim()));
+          if (stagedSummary.length === 0) {
+            return null;
+          }
+
+          const stagedPatch = yield* runGitStdoutWithOptions(
+            "GitVcsDriver.prepareCommitContext.stagedPatch",
+            cwd,
+            ["diff", "--no-ext-diff", "--cached", "--patch", "--minimal"],
+            {
+              env,
+              maxOutputBytes: PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES,
+              appendTruncationMarker: true,
+            },
+          );
+
+          return {
+            stagedSummary,
+            stagedPatch,
+          };
+        }),
+      ).pipe(
+        Effect.catchTags({
+          PlatformError: (cause) =>
+            new GitCommandError({
+              operation: "GitVcsDriver.prepareCommitContext",
+              command: "git",
+              cwd,
+              detail: "Failed to prepare the temporary commit index.",
+              cause,
+            }),
+        }),
+      );
     });
 
   const commit: GitVcsDriver.GitVcsDriver["Service"]["commit"] = Effect.fn("commit")(function* (
@@ -2075,6 +2159,9 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
     body,
     options?: GitVcsDriver.GitCommitOptions,
   ) {
+    if (options?.stage !== undefined) {
+      yield* stageCommitChanges(cwd, options.stage.filePaths);
+    }
     const args = ["commit", "-m", subject];
     const trimmedBody = body.trim();
     if (trimmedBody.length > 0) {
diff --git a/apps/server/src/vcs/VcsStatusBroadcaster.ts b/apps/server/src/vcs/VcsStatusBroadcaster.ts
index 118e2bd29807..a009bbdb63ae 100644
--- a/apps/server/src/vcs/VcsStatusBroadcaster.ts
+++ b/apps/server/src/vcs/VcsStatusBroadcaster.ts
@@ -10,7 +10,6 @@ import * as PubSub from "effect/PubSub";
 import * as Ref from "effect/Ref";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
-import * as Semaphore from "effect/Semaphore";
 import * as Stream from "effect/Stream";
 import * as SynchronizedRef from "effect/SynchronizedRef";
 import type {
@@ -22,6 +21,7 @@ import type {
   VcsStatusStreamEvent,
 } from "@t3tools/contracts";
 import { mergeGitStatusParts } from "@t3tools/shared/git";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 
 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
@@ -234,15 +234,9 @@ export const make = Effect.gen(function* () {
   // One permit per cwd for remote reads that write the cache. Without it a
   // periodic poll that started before `gh pr create` can finish after the
   // turn-end refresh and overwrite the fresh PR with its stale `pr: null`.
-  const remoteWriteLocks = new Map<string, Semaphore.Semaphore>();
-  const withRemoteWriteLock = <A, E, R>(cwd: string, effect: Effect.Effect<A, E, R>) => {
-    let lock = remoteWriteLocks.get(cwd);
-    if (lock === undefined) {
-      lock = Semaphore.makeUnsafe(1);
-      remoteWriteLocks.set(cwd, lock);
-    }
-    return lock.withPermits(1)(effect);
-  };
+  const remoteWriteLocks = yield* KeyedLock.make<string>();
+  const withRemoteWriteLock = <A, E, R>(cwd: string, effect: Effect.Effect<A, E, R>) =>
+    remoteWriteLocks.withLock(cwd, effect);
   const pollersRef = yield* SynchronizedRef.make(new Map<string, ActiveRemotePoller>());
 
   const getCachedStatus = Effect.fn("VcsStatusBroadcaster.getCachedStatus")(function* (
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 6de35f46a7c2..e1128c05ee2f 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -209,6 +209,7 @@ import * as ProjectCloneTracker from "./project/ProjectCloneTracker.ts";
 import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts";
 import * as WorktreeSetupTracker from "./project/WorktreeSetupTracker.ts";
 import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
+import * as DirectEndpoints from "./environment/DirectEndpoints.ts";
 import * as RemoteOpenTargets from "./environment/RemoteOpenTargets.ts";
 import * as BackgroundPolicy from "./background/BackgroundPolicy.ts";
 import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
@@ -1255,6 +1256,7 @@ const makeWsRpcLayer = (
       const environmentTheme = yield* EnvironmentTheme.EnvironmentThemeService;
       const externalLauncher = yield* ExternalLauncher.ExternalLauncher;
       const remoteOpenTargets = yield* RemoteOpenTargets.RemoteOpenTargets;
+      const directEndpoints = yield* DirectEndpoints.DirectEndpoints;
       const gitWorkflow = yield* GitWorkflowService.GitWorkflowService;
       const review = yield* ReviewService.ReviewService;
       const vcsProvisioning = yield* VcsProvisioningService.VcsProvisioningService;
@@ -1699,6 +1701,7 @@ const makeWsRpcLayer = (
             remoteOpenTargets: yield* resolveAvailableEditorsForConfig(
               remoteOpenTargets.resolveTargets(),
             ),
+            directEndpoints: yield* resolveAvailableEditorsForConfig(directEndpoints.resolve()),
             observability: {
               logsDirectoryPath: config.logsDir,
               localTracingEnabled: true,
@@ -1857,6 +1860,21 @@ const makeWsRpcLayer = (
             readWorkflowScript({ scriptPath: input.scriptPath }),
             { "rpc.aggregate": "orchestration" },
           ),
+        [ORCHESTRATION_V2_WS_METHODS.getTurnItem]: (input) =>
+          observeRpcEffect(
+            ORCHESTRATION_V2_WS_METHODS.getTurnItem,
+            threadManagement.getTurnItem(input).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new OrchestrationV2GetThreadProjectionError({
+                    threadId: input.threadId,
+                    message: "Failed to load turn item",
+                    cause,
+                  }),
+              ),
+            ),
+            { "rpc.aggregate": "orchestration" },
+          ),
         [ORCHESTRATION_V2_WS_METHODS.getTurnDiff]: (input) =>
           observeRpcEffect(
             ORCHESTRATION_V2_WS_METHODS.getTurnDiff,
diff --git a/apps/web/package.json b/apps/web/package.json
index ffccf206f910..53c53c1c7cf9 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -60,6 +60,7 @@
     "remark-breaks": "^4.0.0",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.4.0",
+    "unbash": "^5.0.0",
     "zustand": "^5.0.11"
   },
   "devDependencies": {
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 5358e253af4f..26b97c24719d 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -161,6 +161,7 @@ import {
   shouldOpenMarkdownFileLinkInEditor,
   type MarkdownFileLinkMeta,
 } from "../markdown-links";
+import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
 import { readLocalApi } from "../localApi";
 import { useAssetUrlRefresh, useAssetUrlState } from "../assets/assetUrls";
 import { cn } from "../lib/utils";
@@ -3022,6 +3023,7 @@ const CHAT_MARKDOWN_COMPONENTS = {
       updateThreadPullRequestLink,
       fileLinkChip,
       renderContextReference,
+      text,
     } = use(ChatMarkdownRendererContext);
     const citation = href ? parseAssistantCitationHref(href) : null;
     if (citation) return <AssistantCitationChip citation={citation} />;
@@ -3233,10 +3235,21 @@ const CHAT_MARKDOWN_COMPONENTS = {
       );
     }
 
-    return fileLinkChip(
-      fileLinkMeta,
-      `[${fileLinkMeta.basename}](${normalizedHref})`,
-      normalizedHref,
+    const label = nodeToPlainText(children);
+    const start = node?.position?.start.offset;
+    const end = node?.position?.end.offset;
+    const source = start !== undefined && end !== undefined ? text.slice(start, end) : "";
+    const copyMarkdown =
+      source.startsWith("[") && source.includes("](")
+        ? source
+        : `[${(label || fileLinkMeta.basename).replace(/[\\[\]]/g, "\\$&")}](${normalizedHref})`;
+    const chip = fileLinkChip(fileLinkMeta, copyMarkdown, normalizedHref);
+    return isMarkdownFileLinkLabel(label, normalizedHref) ? (
+      chip
+    ) : (
+      <span data-markdown-copy={copyMarkdown}>
+        {children} {chip}
+      </span>
     );
   },
   code: function MarkdownCode({ node, children, className, ...props }) {
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 17e4c7772cb7..02769b4a3bb0 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -253,7 +253,8 @@ import {
   setActivePreviewTab,
   useThreadPreviewState,
 } from "../previewStateStore";
-import { BrowserSettingsReadError } from "../browser/openFileInPreview";
+import { BrowserSettingsReadError, openUrlInPreview } from "../browser/openFileInPreview";
+import { resolveDiscoveredServerUrl } from "../browser/browserTargetResolver";
 import { previewRuntimeTabId } from "../browser/previewRuntimeTabId";
 import { addBrowserSurface } from "./preview/addBrowserSurface";
 import { closePreviewSession } from "./preview/closePreviewSession";
@@ -3005,6 +3006,7 @@ export default function ChatView(props: ChatViewProps) {
   }, [setDismissedVersionMismatchKey, versionMismatchDismissKey]);
   const serverUpdateEnvironmentId = activeThread?.environmentId ?? null;
   const versionMismatchSelfUpdate = resolveServerSelfUpdateCapability(serverConfig);
+  const versionMismatchInstallation = serverConfig?.environment.capabilities.serverInstallation;
   const versionMismatchDesktopAppUpdate = supportsDesktopAppUpdate(serverConfig);
   const versionMismatchThreadContinuation = supportsServerUpdateThreadContinuation(serverConfig);
   const serverUpdateState = useAtomValue(
@@ -3127,6 +3129,7 @@ export default function ChatView(props: ChatViewProps) {
             environmentId={serverUpdateEnvironmentId}
             serverLabel={versionMismatchServerLabel}
             selfUpdate={versionMismatchSelfUpdate}
+            installation={versionMismatchInstallation}
             desktopAppUpdate={versionMismatchDesktopAppUpdate}
             threadContinuation={versionMismatchThreadContinuation}
             targetVersion={versionMismatch.clientVersion}
@@ -3168,6 +3171,7 @@ export default function ChatView(props: ChatViewProps) {
     versionMismatchDismissKey,
     serverUpdateEnvironmentId,
     versionMismatchSelfUpdate,
+    versionMismatchInstallation,
     versionMismatchDesktopAppUpdate,
     versionMismatchThreadContinuation,
     versionMismatchServerLabel,
@@ -4944,12 +4948,32 @@ export default function ChatView(props: ChatViewProps) {
           data: `${script.command}\r`,
         },
       });
-      if (writeResult._tag === "Failure" && !isAtomCommandInterrupted(writeResult)) {
-        const error = squashAtomCommandFailure(writeResult);
-        setThreadError(
-          activeThreadId,
-          error instanceof Error ? error.message : `Failed to run script "${script.name}".`,
-        );
+      if (writeResult._tag === "Failure") {
+        if (!isAtomCommandInterrupted(writeResult)) {
+          const error = squashAtomCommandFailure(writeResult);
+          setThreadError(
+            activeThreadId,
+            error instanceof Error ? error.message : `Failed to run script "${script.name}".`,
+          );
+        }
+        return;
+      }
+      if (script.autoOpenPreview && script.previewUrl && isPreviewSupportedInRuntime()) {
+        const previewResult = await openUrlInPreview({
+          threadRef: activeThreadRef,
+          url: resolveDiscoveredServerUrl(activeThreadRef.environmentId, script.previewUrl),
+          openPreview,
+        });
+        if (previewResult._tag === "Failure" && !isAtomCommandInterrupted(previewResult)) {
+          const error = squashAtomCommandFailure(previewResult);
+          toastManager.add(
+            stackedThreadToast({
+              type: "error",
+              title: "Could not open preview",
+              description: error instanceof Error ? error.message : "An unexpected error occurred.",
+            }),
+          );
+        }
       }
     },
     [
@@ -4965,6 +4989,7 @@ export default function ChatView(props: ChatViewProps) {
       setLastInvokedScriptByProjectId,
       environmentId,
       openTerminal,
+      openPreview,
       activeKnownTerminalIds,
       allocatableActiveTerminalIds,
       runningTerminalIds,
@@ -8929,18 +8954,7 @@ export default function ChatView(props: ChatViewProps) {
     );
     const messageIdForSend = heldCloudSend?.message.id ?? newMessageId();
     const messageCreatedAt = heldCloudSend?.message.createdAt ?? new Date().toISOString();
-    // Sending past the resume banner compacts first so the turn does not resend the stale
-    // history. The message queues behind the /compact run; steering into it is rejected,
-    // and a held queue would strand it.
-    const compactBeforeSend =
-      resumeCompactionBannerItem !== null &&
-      !compactDisabled &&
-      !hasHeldQueuedRuns &&
-      multipleModelSelections === null &&
-      messageTextForSend.toLowerCase() !== "/compact";
-    const turnDispatchMode = compactBeforeSend ? "queue" : dispatchMode;
-    const shouldQueueBehindActiveRun =
-      compactBeforeSend || (phase === "running" && dispatchMode === "queue");
+    const shouldQueueBehindActiveRun = phase === "running" && dispatchMode === "queue";
     const outgoingMessageText = formatOutgoingPrompt({
       provider: ctxSelectedProvider,
       model: ctxSelectedModel,
@@ -9508,22 +9522,6 @@ export default function ChatView(props: ChatViewProps) {
       failure = turnAttachmentsResult;
     }
 
-    if (failure === null && compactBeforeSend) {
-      const compactResult = await startThreadTurn({
-        environmentId,
-        input: {
-          threadId: threadIdForSend,
-          message: { messageId: newMessageId(), role: "user", text: "/compact", attachments: [] },
-          modelSelection: ctxSelectedModelSelection,
-          runtimeMode,
-          interactionMode: sendInteractionMode,
-        },
-      });
-      if (compactResult._tag === "Failure") {
-        failure = compactResult;
-      }
-    }
-
     let backgroundDraftOpened = false;
     let turnStartSucceeded = false;
     if (failure === null && turnAttachmentsResult._tag === "Success") {
@@ -9605,7 +9603,7 @@ export default function ChatView(props: ChatViewProps) {
           titleSeed: title,
           runtimeMode,
           interactionMode: sendInteractionMode,
-          dispatchMode: turnDispatchMode,
+          dispatchMode,
           ...(bootstrap ? { bootstrap } : {}),
           createdAt: messageCreatedAt,
         },
diff --git a/apps/web/src/components/DiffPanelShell.tsx b/apps/web/src/components/DiffPanelShell.tsx
index 6f7f6e5c8f1f..456f70516b23 100644
--- a/apps/web/src/components/DiffPanelShell.tsx
+++ b/apps/web/src/components/DiffPanelShell.tsx
@@ -13,7 +13,7 @@ function getDiffPanelHeaderRowClassName(mode: DiffPanelMode) {
     "flex items-center justify-between gap-2",
     mode === "embedded" ? "px-2" : "px-4",
     shouldUseDragRegion
-      ? "drag-region h-[var(--workspace-topbar-height)] border-b border-border wco:h-[env(titlebar-area-height)] wco:pr-(--workspace-native-controls-inset)"
+      ? "drag-region h-[var(--workspace-topbar-height)] border-b border-border wco:pr-(--workspace-native-controls-inset)"
       : "flex h-10 min-h-10 shrink-0 items-center border-b border-border/60 bg-background in-data-[preview-panel-mode=inline]:mb-3 in-data-[preview-panel-mode=inline]:h-7 in-data-[preview-panel-mode=inline]:min-h-7 in-data-[preview-panel-mode=inline]:border-b-transparent",
   );
 }
diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsx
index a940d2ae90fb..4c62f5f385ef 100644
--- a/apps/web/src/components/Icons.tsx
+++ b/apps/web/src/components/Icons.tsx
@@ -158,70 +158,166 @@ export const GitLabIcon = ({
   </svg>
 );
 
+// Microsoft Azure DevOps mark via selfhst/icons (CC BY 4.0): https://github.com/selfhst/icons/blob/main/svg/azure-devops.svg
 export const AzureDevOpsIcon: Icon = (props) => {
   const id = useId().replaceAll(":", "");
-  const gradientA = `${id}-azure-a`;
-  const gradientB = `${id}-azure-b`;
-  const gradientC = `${id}-azure-c`;
+  const gradientId = `${id}-azure`;
 
   return (
-    <svg {...props} viewBox="0 0 96 96">
+    <svg {...props} viewBox="0 0 512 512">
       <defs>
         <linearGradient
-          id={gradientA}
-          x1="-1032.17"
-          x2="-1059.21"
-          y1="145.31"
-          y2="65.43"
-          gradientTransform="matrix(1 0 0 -1 1075 158)"
+          id={`${gradientId}-a`}
+          x1="58.027"
+          x2="58.027"
+          y1="356.668"
+          y2="100.668"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
           gradientUnits="userSpaceOnUse"
         >
-          <stop offset="0" stopColor="#114a8b" />
-          <stop offset="1" stopColor="#0669bc" />
+          <stop offset="0" stopColor="#163697" />
+          <stop offset=".276" stopColor="#2052cb" />
+          <stop offset=".518" stopColor="#2764e7" />
+          <stop offset=".879" stopColor="#367af2" />
         </linearGradient>
         <linearGradient
-          id={gradientB}
-          x1="-1023.73"
-          x2="-1029.98"
-          y1="108.08"
-          y2="105.97"
-          gradientTransform="matrix(1 0 0 -1 1075 158)"
+          id={`${gradientId}-b`}
+          x1="58.027"
+          x2="58.027"
+          y1="351.334"
+          y2="292.668"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
           gradientUnits="userSpaceOnUse"
         >
-          <stop offset="0" stopOpacity=".3" />
-          <stop offset=".07" stopOpacity=".2" />
-          <stop offset=".32" stopOpacity=".1" />
-          <stop offset=".62" stopOpacity=".05" />
-          <stop offset="1" stopOpacity="0" />
+          <stop offset="0" stopColor="#102784" />
+          <stop offset="1" stopColor="#2052cb" stopOpacity="0" />
         </linearGradient>
         <linearGradient
-          id={gradientC}
-          x1="-1027.16"
-          x2="-997.48"
-          y1="147.64"
-          y2="68.56"
-          gradientTransform="matrix(1 0 0 -1 1075 158)"
+          id={`${gradientId}-c`}
+          x1="389.98"
+          x2="107.314"
+          y1="57.935"
+          y2="193.935"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
           gradientUnits="userSpaceOnUse"
         >
-          <stop offset="0" stopColor="#3ccbf4" />
-          <stop offset="1" stopColor="#2892df" />
+          <stop offset="0" stopColor="#163697" />
+          <stop offset=".301" stopColor="#2052cb" />
+          <stop offset=".626" stopColor="#2764e7" />
+          <stop offset=".926" stopColor="#367af2" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-d`}
+          x1="391.996"
+          x2="341.385"
+          y1="76.552"
+          y2="78.224"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset="0" stopColor="#102784" />
+          <stop offset="1" stopColor="#2052cb" stopOpacity="0" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-e`}
+          x1="442.24"
+          x2="442.24"
+          y1="54.769"
+          y2="419.38"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset=".043" stopColor="#2052cb" />
+          <stop offset=".489" stopColor="#367af2" />
+          <stop offset=".943" stopColor="#16bbda" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-f`}
+          x1="435.596"
+          x2="425.732"
+          y1="270.413"
+          y2="385.266"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset=".134" stopColor="#16bbda" stopOpacity="0" />
+          <stop offset=".932" stopColor="#6be7a0" stopOpacity=".8629" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-g`}
+          x1="437.081"
+          x2="507.893"
+          y1="204.362"
+          y2="119.081"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset="0" stopColor="#2c68e0" stopOpacity="0" />
+          <stop offset=".898" stopColor="#66c0ff" stopOpacity=".5" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-h`}
+          x1="99.399"
+          x2="352.75"
+          y1="279.26"
+          y2="498.676"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset=".005" stopColor="#367af2" />
+          <stop offset=".507" stopColor="#0fafff" />
+          <stop offset="1" stopColor="#26cfe8" />
+        </linearGradient>
+        <linearGradient
+          id={`${gradientId}-i`}
+          x1="184.342"
+          x2="338.581"
+          y1="356.795"
+          y2="480.642"
+          gradientTransform="matrix(1 0 0 -1 0 514)"
+          gradientUnits="userSpaceOnUse"
+        >
+          <stop offset=".443" stopColor="#26cfe8" stopOpacity="0" />
+          <stop offset=".897" stopColor="#6be7a0" stopOpacity=".8629" />
         </linearGradient>
       </defs>
       <path
-        fill={`url(#${gradientA})`}
-        d="M33.34 6.54h26.04l-27.03 80.1a4.15 4.15 0 0 1-3.94 2.81H8.15a4.14 4.14 0 0 1-3.93-5.47L29.4 9.38a4.15 4.15 0 0 1 3.94-2.83z"
+        d="M116.1 73.4c-5.8 5.8-13.7 13.8-13.7 22.6v216.4c0 8.9-3.3 17.3-9 23.4s-13.3 9.2-21.1 8.5l-42.7-3.1c-7.9-.5-15-3.9-20.3-9.3-5.7-5.7-9.3-13.7-9.3-22.6V202.7c0-8.9 3.6-16.9 9.4-22.6l2-1.9z"
+        fill={`url(#${gradientId}-a)`}
+      />
+      <path
+        d="M116.1 73.4c-5.8 5.8-13.7 13.8-13.7 22.6v216.4c0 8.9-3.3 17.3-9 23.4s-13.3 9.2-21.1 8.5l-42.7-3.1c-7.9-.5-15-3.9-20.3-9.3-5.7-5.7-9.3-13.7-9.3-22.6V202.7c0-8.9 3.6-16.9 9.4-22.6l2-1.9z"
+        fill={`url(#${gradientId}-b)`}
+      />
+      <path
+        d="m500.5 366-128 106.7c-5.5 4.6-12.7 7.4-20.5 7.4q-2.4 0-4.8-.3l-112.5-16.9v27.8c0 11.7-9.6 21.3-21.3 21.3-7.3 0-13.5-3.6-17.5-9.1l-36.2-51.4-5.4-7.6-36.6-51.9-7-10c-2.6-3.5-3.9-7.8-3.9-12.3 0-6 2.5-11.6 6.8-15.7 3.8-3.7 9.1-5.8 14.5-5.8.4 0 1 .1 1.5.1l105.2 7.5L384 366.5l93.7 6.7c.7.1 1.6.1 2.3.1 7.8 0 14.9-2.7 20.5-7.3"
+        fill={`url(#${gradientId}-c)`}
+      />
+      <path
+        d="m500.5 366-128 106.7c-5.5 4.6-12.7 7.4-20.5 7.4q-2.4 0-4.8-.3l-112.5-16.9v27.8c0 11.7-9.6 21.3-21.3 21.3-7.3 0-13.5-3.6-17.5-9.1l-36.2-51.4-5.4-7.6-36.6-51.9-7-10c-2.6-3.5-3.9-7.8-3.9-12.3 0-6 2.5-11.6 6.8-15.7 3.8-3.7 9.1-5.8 14.5-5.8.4 0 1 .1 1.5.1l105.2 7.5L384 366.5l93.7 6.7c.7.1 1.6.1 2.3.1 7.8 0 14.9-2.7 20.5-7.3"
+        fill={`url(#${gradientId}-d)`}
+      />
+      <path
+        d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+        fill={`url(#${gradientId}-e)`}
+      />
+      <path
+        d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+        fill={`url(#${gradientId}-f)`}
+        fillOpacity=".7"
       />
       <path
-        fill="#0078d4"
-        d="M71.17 60.26H29.88a1.91 1.91 0 0 0-1.3 3.31l26.53 24.76a4.17 4.17 0 0 0 2.85 1.13h23.38z"
+        d="M512 170.7v170.7c0 9.9-4.5 18.8-11.5 24.6l-128 106.7c7-5.9 11.5-14.7 11.5-24.6V175.3c0-16.7 13-30.7 29.8-31.9l63.9-4.6c.7-.1 1.6-.1 2.3-.1 7.8 0 14.9 2.8 20.5 7.4 7 5.8 11.5 14.6 11.5 24.6"
+        fill={`url(#${gradientId}-g)`}
       />
       <path
-        fill={`url(#${gradientB})`}
-        d="M33.34 6.54a4.12 4.12 0 0 0-3.95 2.88L4.25 83.92a4.14 4.14 0 0 0 3.91 5.54h20.79a4.44 4.44 0 0 0 3.4-2.9l5.02-14.78 17.91 16.7a4.24 4.24 0 0 0 2.67.97h23.29L71.02 60.26H41.24L59.47 6.55z"
+        d="M384 125.5c0 11.2-8.6 20.5-19.8 21.3-.5 0-1.1.1-1.6.1l-127.9 9.2-132.3 9.1-72.7 5.5c-6.9.4-13.2 3.1-18.2 7.4L116.1 73.4c4.7-4.7 10.9-8 17.8-9.1l100.8-15.1V21.3C234.7 9.6 244.3 0 256 0c5.8 0 11.1 2.3 14.9 6.1l33.4 32.6 16.9 16.5 40.3 39.3 16.1 15.8c4.1 3.9 6.4 9.4 6.4 15.2"
+        fill={`url(#${gradientId}-h)`}
       />
       <path
-        fill={`url(#${gradientC})`}
-        d="M66.6 9.36a4.14 4.14 0 0 0-3.93-2.82H33.65a4.15 4.15 0 0 1 3.93 2.82l25.18 74.62a4.15 4.15 0 0 1-3.93 5.48h29.02a4.15 4.15 0 0 0 3.93-5.48z"
+        d="M384 125.5c0 11.2-8.6 20.5-19.8 21.3-.5 0-1.1.1-1.6.1l-127.9 9.2-132.3 9.1-72.7 5.5c-6.9.4-13.2 3.1-18.2 7.4L116.1 73.4c4.7-4.7 10.9-8 17.8-9.1l100.8-15.1V21.3C234.7 9.6 244.3 0 256 0c5.8 0 11.1 2.3 14.9 6.1l33.4 32.6 16.9 16.5 40.3 39.3 16.1 15.8c4.1 3.9 6.4 9.4 6.4 15.2"
+        fill={`url(#${gradientId}-i)`}
+        fillOpacity=".5"
       />
     </svg>
   );
diff --git a/apps/web/src/components/RightPanelSheet.tsx b/apps/web/src/components/RightPanelSheet.tsx
index 044369ed0f76..0cad2af5009d 100644
--- a/apps/web/src/components/RightPanelSheet.tsx
+++ b/apps/web/src/components/RightPanelSheet.tsx
@@ -22,7 +22,7 @@ export function RightPanelSheet(props: {
         side="right"
         showCloseButton={false}
         keepMounted
-        className="w-[min(42vw,28rem)] min-w-80 max-w-[28rem] max-[760px]:w-[min(88vw,24rem)] max-[760px]:min-w-0 wco:mt-[env(titlebar-area-height)] wco:h-[calc(100%-env(titlebar-area-height))] wco:max-h-[calc(100%-env(titlebar-area-height))]"
+        className="w-[min(42vw,28rem)] min-w-80 max-w-[28rem] max-[760px]:w-[min(88vw,24rem)] max-[760px]:min-w-0 wco:mt-(--workspace-topbar-height) wco:h-[calc(100%-var(--workspace-topbar-height))] wco:max-h-[calc(100%-var(--workspace-topbar-height))]"
       >
         {props.children}
       </SheetPopup>
diff --git a/apps/web/src/components/ServerUpdateAction.test.tsx b/apps/web/src/components/ServerUpdateAction.test.tsx
index 6c388bca4f98..116b7fdd21bb 100644
--- a/apps/web/src/components/ServerUpdateAction.test.tsx
+++ b/apps/web/src/components/ServerUpdateAction.test.tsx
@@ -1,7 +1,7 @@
 import { act, type ReactElement } from "react";
 import { create, type ReactTestRenderer } from "react-test-renderer";
 import { renderToStaticMarkup } from "react-dom/server";
-import type { EnvironmentId } from "@t3tools/contracts";
+import type { EnvironmentId, ServerInstallation } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
 import { AsyncResult } from "effect/unstable/reactivity";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
@@ -9,11 +9,17 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"
 const testState = vi.hoisted(() => ({
   updateServer: vi.fn(),
   toast: vi.fn(),
+  clipboard: vi.fn(),
   continueThreadsAfterServerUpdate: false,
 }));
 
 vi.mock("~/hooks/useCopyToClipboard", () => ({
-  useCopyToClipboard: () => ({ copyToClipboard: vi.fn() }),
+  useCopyToClipboard: (options: { onCopy: (context: { command: string }) => void }) => ({
+    copyToClipboard: (command: string, context: { command: string }) => {
+      testState.clipboard(command);
+      options.onCopy(context);
+    },
+  }),
 }));
 vi.mock("~/hooks/useSettings", () => ({
   useEnvironmentSettings: (
@@ -66,9 +72,51 @@ describe("ServerUpdateAction", () => {
   beforeEach(() => {
     testState.updateServer.mockReset();
     testState.toast.mockReset();
+    testState.clipboard.mockReset();
     testState.continueThreadsAfterServerUpdate = false;
   });
 
+  it.each([
+    [
+      { kind: "npm-global", prefix: "/opt/node" },
+      "npm install --global --prefix '/opt/node' t3@0.0.45",
+      "Update command copied",
+      "then restart t3",
+    ],
+    [
+      { kind: "npx" },
+      "npx t3@0.0.45",
+      "Relaunch command copied",
+      "This does not update an installed t3 command.",
+    ],
+    [
+      undefined,
+      "npx t3@0.0.45",
+      "Relaunch command copied",
+      "This does not update an installed t3 command.",
+    ],
+  ] satisfies ReadonlyArray<readonly [ServerInstallation | undefined, string, string, string]>)(
+    "copies an honest manual command for %j without invoking remote update",
+    (installation, command, title, guidance) => {
+      const action = ServerUpdateAction({
+        environmentId: "env-test" as EnvironmentId,
+        serverLabel: "Test server",
+        selfUpdate: null,
+        installation,
+        targetVersion: "0.0.45",
+      }) as ActionElement;
+      action.props.onClick?.();
+      expect(testState.clipboard).toHaveBeenCalledWith(command);
+      expect(testState.toast).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title,
+          description: expect.stringContaining(guidance),
+        }),
+      );
+      expect(testState.updateServer).not.toHaveBeenCalled();
+    },
+  );
+
   it("reports success only after the shared update flow reconnects", async () => {
     testState.updateServer.mockResolvedValue(
       AsyncResult.success({ targetVersion: "0.0.31", method: "boot-service" as const }),
diff --git a/apps/web/src/components/ServerUpdateAction.tsx b/apps/web/src/components/ServerUpdateAction.tsx
index 00c37f683b54..638d66264ae0 100644
--- a/apps/web/src/components/ServerUpdateAction.tsx
+++ b/apps/web/src/components/ServerUpdateAction.tsx
@@ -1,4 +1,8 @@
-import type { EnvironmentId, ServerSelfUpdateCapability } from "@t3tools/contracts";
+import type {
+  EnvironmentId,
+  ServerInstallation,
+  ServerSelfUpdateCapability,
+} from "@t3tools/contracts";
 import type { ServerUpdateStage, ServerUpdateState } from "@t3tools/client-runtime/state/server";
 import {
   isAtomCommandInterrupted,
@@ -44,6 +48,7 @@ export interface ServerUpdateTarget {
   readonly environmentId: EnvironmentId;
   readonly serverLabel: string;
   readonly selfUpdate: ServerSelfUpdateCapability | null;
+  readonly installation?: ServerInstallation | undefined;
   readonly desktopAppUpdate?: boolean;
   readonly threadContinuation?: boolean;
   readonly targetVersion: string;
@@ -192,6 +197,7 @@ export function ServerUpdateAction({
   environmentId,
   serverLabel,
   selfUpdate,
+  installation,
   desktopAppUpdate = false,
   threadContinuation = false,
   targetVersion,
@@ -208,12 +214,16 @@ export function ServerUpdateAction({
   );
   const update = useServerUpdate();
   const { copyToClipboard } = useCopyToClipboard<{ command: string }>({
-    target: "update command",
+    target: installation?.kind === "npm-global" ? "update command" : "relaunch command",
     onCopy: ({ command }) => {
       toastManager.add({
         type: "success",
-        title: "Update command copied",
-        description: `Run \`${command}\` on ${serverLabel} to update it.`,
+        title:
+          installation?.kind === "npm-global" ? "Update command copied" : "Relaunch command copied",
+        description:
+          installation?.kind === "npm-global"
+            ? `Run \`${command}\` on ${serverLabel}, then restart t3 with your usual options.`
+            : `Stop t3 on ${serverLabel}, then relaunch with \`${command}\` using the same subcommand and options. This does not update an installed t3 command.`,
       });
     },
     onError: (error) => {
@@ -262,8 +272,15 @@ export function ServerUpdateAction({
 
   const guestLabel = guestServerUpdateLabel(environmentId, selfUpdate);
   const manualCommand =
-    selfUpdate === null && guestLabel === null ? manualServerUpdateCommand(targetVersion) : null;
-  const actionLabel = manualCommand !== null ? "Copy update command" : (guestLabel ?? label);
+    selfUpdate === null && guestLabel === null
+      ? manualServerUpdateCommand(targetVersion, installation)
+      : null;
+  const actionLabel =
+    manualCommand !== null
+      ? installation?.kind === "npm-global"
+        ? "Copy update command"
+        : "Copy relaunch command"
+      : (guestLabel ?? label);
   const onClick =
     manualCommand !== null
       ? () => copyToClipboard(manualCommand, { command: manualCommand })
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index 6331ad40773f..f3efb10ddf03 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -1830,7 +1830,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                 <span
                   className={cn(
                     "inline-flex justify-end tabular-nums text-secondary-label transition-opacity",
-                    !isWoke && "group-hover/sidebar-row:opacity-0",
+                    !isWoke && "group-any-hover/sidebar-row:opacity-0",
                   )}
                 >
                   {variantAction === "unsnooze" && props.snoozeWakeLabelText !== null ? (
@@ -1874,8 +1874,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                       onClick={handleUnsnoozeClick}
                       onPointerDown={handleActionPointerDown}
                       className={cn(
-                        "pointer-events-none absolute inset-y-0 right-0 -mr-1 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-1.5 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-hover/sidebar-row:pointer-events-auto group-hover/sidebar-row:opacity-100",
-                        isWoke && "group-hover/sidebar-row:static",
+                        "pointer-events-none absolute inset-y-0 right-0 -mr-1 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-1.5 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-any-hover/sidebar-row:pointer-events-auto group-any-hover/sidebar-row:opacity-100",
+                        isWoke && "group-any-hover/sidebar-row:static",
                       )}
                     >
                       <AlarmClockOffIcon className="mb-px size-3" />
@@ -1891,8 +1891,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                           onClick={handleUnsettleClick}
                           onPointerDown={handleActionPointerDown}
                           className={cn(
-                            "pointer-events-none absolute inset-y-0 right-0 -mr-1 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-1.5 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-hover/sidebar-row:pointer-events-auto group-hover/sidebar-row:opacity-100",
-                            isWoke && "group-hover/sidebar-row:static",
+                            "pointer-events-none absolute inset-y-0 right-0 -mr-1 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-1.5 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-any-hover/sidebar-row:pointer-events-auto group-any-hover/sidebar-row:opacity-100",
+                            isWoke && "group-any-hover/sidebar-row:static",
                           )}
                         />
                       }
@@ -1908,8 +1908,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                     onClick={handleSettleClick}
                     onPointerDown={handleActionPointerDown}
                     className={cn(
-                      "pointer-events-none absolute inset-y-0 right-0 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-2 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-hover/sidebar-row:pointer-events-auto group-hover/sidebar-row:opacity-100",
-                      isWoke && "group-hover/sidebar-row:static",
+                      "pointer-events-none absolute inset-y-0 right-0 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-2 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:pointer-events-auto focus-visible:opacity-100 group-any-hover/sidebar-row:pointer-events-auto group-any-hover/sidebar-row:opacity-100",
+                      isWoke && "group-any-hover/sidebar-row:static",
                     )}
                   >
                     <CheckIcon className="size-3" />
@@ -1998,7 +1998,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                     className={cn(
                       isWokeStatus
                         ? "pointer-events-auto"
-                        : "pointer-events-none group-has-[:focus-visible]/sidebar-status-slot:absolute group-has-[:focus-visible]/sidebar-status-slot:right-0 group-has-[:focus-visible]/sidebar-status-slot:opacity-0 group-hover/sidebar-row:absolute group-hover/sidebar-row:right-0 group-hover/sidebar-row:opacity-0",
+                        : "pointer-events-none group-has-[:focus-visible]/sidebar-status-slot:absolute group-has-[:focus-visible]/sidebar-status-slot:right-0 group-has-[:focus-visible]/sidebar-status-slot:opacity-0 group-any-hover/sidebar-row:absolute group-any-hover/sidebar-row:right-0 group-any-hover/sidebar-row:opacity-0",
                       "flex items-center self-center justify-self-end tabular-nums text-secondary-label transition-opacity",
                       snoozeMenuOpen && "pointer-events-none absolute right-0 opacity-0",
                     )}
@@ -2065,7 +2065,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
                         // would keep the controls pinned over the status label
                         // once the pointer moves away (e.g. after a failed
                         // settle) instead of cross-fading back.
-                        "pointer-events-none absolute inset-y-0 right-0 flex items-stretch opacity-0 transition-opacity has-[:focus-visible]:pointer-events-auto has-[:focus-visible]:static has-[:focus-visible]:opacity-100 group-hover/sidebar-row:pointer-events-auto group-hover/sidebar-row:static group-hover/sidebar-row:opacity-100",
+                        "pointer-events-none absolute inset-y-0 right-0 flex items-stretch opacity-0 transition-opacity has-[:focus-visible]:pointer-events-auto has-[:focus-visible]:static has-[:focus-visible]:opacity-100 group-any-hover/sidebar-row:pointer-events-auto group-any-hover/sidebar-row:static group-any-hover/sidebar-row:opacity-100",
                         snoozeMenuOpen && "pointer-events-auto static opacity-100",
                       )}
                     >
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index a34ca29ec5a2..7b7715a251ee 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -1123,6 +1123,7 @@ import {
   formatProviderSkillDisplayName,
   getProviderSlashCommandsForSlashMenu,
   getProviderSkillsForSlashMenu,
+  hasCompleteProviderWorkspaceSnapshot,
   resolveProviderSkillsForCwd,
   resolveProviderSlashCommandsForCwd,
 } from "@t3tools/client-runtime/providerSkills";
@@ -2190,41 +2191,68 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     reportFailure: false,
   });
   const workspaceRefreshKeyRef = useRef<string | null>(null);
-  const workspaceRefreshRetryRef = useRef<{ key: string; notBefore: number } | null>(null);
+  const [workspaceRefreshRetry, setWorkspaceRefreshRetry] = useState<{
+    key: string;
+    notBefore: number;
+  } | null>(null);
+  const workspaceRefreshScopeKey =
+    gitCwd && selectedProviderEntry
+      ? `${environmentId}:${selectedProviderEntry.instanceId}:${gitCwd}`
+      : null;
+  const workspaceSlashCommandsPending =
+    selectedProviderStatus?.workspaceSnapshots?.some(
+      (snapshot) => snapshot.cwd === gitCwd && snapshot.slashCommandsPending === true,
+    ) ?? false;
+  useEffect(() => {
+    if (
+      !workspaceSlashCommandsPending ||
+      !workspaceRefreshRetry ||
+      workspaceRefreshRetry.key !== workspaceRefreshScopeKey
+    )
+      return;
+    const timeout = setTimeout(
+      () => {
+        setWorkspaceRefreshRetry((current) => (current === workspaceRefreshRetry ? null : current));
+      },
+      Math.max(0, workspaceRefreshRetry.notBefore - Date.now()),
+    );
+    return () => clearTimeout(timeout);
+  }, [workspaceRefreshRetry, workspaceRefreshScopeKey, workspaceSlashCommandsPending]);
   const hadWorkspaceSnapshotRef = useRef(false);
   useEffect(() => {
-    const hasWorkspaceSnapshot = Boolean(
-      gitCwd &&
-      selectedProviderStatus?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === gitCwd),
+    const hasWorkspaceSnapshot = hasCompleteProviderWorkspaceSnapshot(
+      selectedProviderStatus,
+      gitCwd,
     );
     if (hadWorkspaceSnapshotRef.current && !hasWorkspaceSnapshot) {
       workspaceRefreshKeyRef.current = null;
-      workspaceRefreshRetryRef.current = null;
+      setWorkspaceRefreshRetry(null);
     }
     hadWorkspaceSnapshotRef.current = hasWorkspaceSnapshot;
   }, [gitCwd, selectedProviderStatus]);
   useEffect(() => {
     if (!gitCwd || !selectedProviderEntry) return;
     const key = `${environmentId}:${selectedProviderEntry.instanceId}:${gitCwd}`;
-    const hasWorkspaceSnapshot = selectedProviderStatus?.workspaceSnapshots?.some(
-      (snapshot) => snapshot.cwd === gitCwd,
+    const hasWorkspaceSnapshot = hasCompleteProviderWorkspaceSnapshot(
+      selectedProviderStatus,
+      gitCwd,
     );
     if (workspaceRefreshKeyRef.current === key) return;
     if (hasWorkspaceSnapshot) {
       workspaceRefreshKeyRef.current = key;
-      workspaceRefreshRetryRef.current = null;
+      setWorkspaceRefreshRetry(null);
       return;
     }
-    const retry = workspaceRefreshRetryRef.current;
+    const retry = workspaceRefreshRetry;
     if (retry?.key === key && Date.now() < retry.notBefore) return;
     workspaceRefreshKeyRef.current = key;
     const retryLater = () => {
       if (workspaceRefreshKeyRef.current !== key) return;
       workspaceRefreshKeyRef.current = null;
-      workspaceRefreshRetryRef.current = {
+      setWorkspaceRefreshRetry({
         key,
         notBefore: Date.now() + WORKSPACE_SNAPSHOT_RETRY_COOLDOWN_MS,
-      };
+      });
     };
     void refreshProviders({
       environmentId,
@@ -2232,14 +2260,24 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     }).then((result) => {
       const hasWorkspaceSnapshot =
         result._tag === "Success" &&
-        result.value.providers
-          .find((provider) => provider.instanceId === selectedProviderEntry.instanceId)
-          ?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === gitCwd);
+        hasCompleteProviderWorkspaceSnapshot(
+          result.value.providers.find(
+            (provider) => provider.instanceId === selectedProviderEntry.instanceId,
+          ),
+          gitCwd,
+        );
       if (!hasWorkspaceSnapshot && workspaceRefreshKeyRef.current === key) {
         retryLater();
       }
     }, retryLater);
-  }, [environmentId, gitCwd, prompt, refreshProviders, selectedProviderEntry]);
+  }, [
+    environmentId,
+    gitCwd,
+    prompt,
+    refreshProviders,
+    selectedProviderEntry,
+    workspaceRefreshRetry,
+  ]);
   const selectedProviderModels = useMemo<ReadonlyArray<ServerProvider["models"][number]>>(
     () => selectedProviderEntry?.models ?? [],
     [selectedProviderEntry],
diff --git a/apps/web/src/components/chat/HighlightedTokens.test.ts b/apps/web/src/components/chat/HighlightedTokens.test.ts
new file mode 100644
index 000000000000..ef4bf456585f
--- /dev/null
+++ b/apps/web/src/components/chat/HighlightedTokens.test.ts
@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { embeddedScripts } from "../../lib/embeddedScripts";
+import { keyedLines, withEmbeddedScripts, wordsOf } from "./HighlightedTokens";
+
+function tokensOf(...contents: string[]) {
+  let offset = 0;
+  return contents.map((content) => {
+    const token = { content, offset };
+    offset += content.length;
+    return token;
+  });
+}
+
+function shape(parts: ReturnType<typeof wordsOf>) {
+  return parts.map((part) =>
+    typeof part === "string" ? part : part.pieces.map((piece) => piece.text).join(""),
+  );
+}
+
+describe("wordsOf", () => {
+  it.each([
+    // Shiki splits these shell words into several tokens.
+    [["echo", " ", '"', "$HOME", "/${", "PATH", "%%:*", '}"'], 'echo "$HOME/${PATH%%:*}"'],
+    [["rsync", " ", "-a", " ", "--exclude", " ", "build"], "rsync -a --exclude build"],
+    // A token can carry whitespace on either side or inside a string.
+    [["git", " && ", "echo", " ", '"two  words"', "; "], 'git && echo "two  words"; '],
+    [["  ", "indented"], "  indented"],
+    [[], ""],
+  ])("wraps the same words as the plain-text fallback: %j", (contents, line) => {
+    expect(shape(wordsOf(tokensOf(...contents)))).toEqual(
+      line.split(/(\s+)/u).filter((part) => part !== ""),
+    );
+  });
+
+  it("keeps each piece's own token so colors survive regrouping", () => {
+    const [word] = wordsOf(tokensOf('"', "$HOME", '"'));
+    expect(
+      typeof word === "string" ? null : word?.pieces.map((piece) => piece.token.content),
+    ).toEqual(['"', "$HOME", '"']);
+  });
+});
+
+describe("keyedLines", () => {
+  it.each([
+    "git status\ngit diff",
+    "Get-ChildItem\r\nWrite-Output done\r\n",
+    "mixed\r\nendings\n\nlone \r stays",
+  ])("renders the same text as the source: %j", (code) => {
+    // Shiki splits lines on \r?\n and drops the ending from the tokens.
+    const lines = code.split(/\r?\n/u).map((line) => tokensOf(line));
+    const rendered = keyedLines(code, lines)
+      .map(({ tokens, ending }) => tokens.map((token) => token.content).join("") + ending)
+      .join("");
+    expect(rendered).toBe(code);
+  });
+
+  it("keys empty lines apart", () => {
+    const code = "a\r\n\r\n\r\nb";
+    const keys = keyedLines(
+      code,
+      code.split(/\r?\n/u).map((line) => tokensOf(line)),
+    ).map((line) => line.key);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+});
+
+describe("withEmbeddedScripts", () => {
+  // A stand-in grammar: each word is one token colored with the language name,
+  // and lines split the way Shiki splits them.
+  function tokenize(text: string, language: string) {
+    if (language === "unknown") throw new Error("Language not found");
+    let lineStart = 0;
+    return text.split(/\r?\n/u).map((line) => {
+      const tokens = [...line.matchAll(/\S+|\s+/gu)].map((match) => ({
+        content: match[0],
+        offset: lineStart + match.index,
+        color: language,
+      }));
+      lineStart +=
+        line.length + (text.slice(lineStart + line.length).match(/^\r?\n/u)?.[0].length ?? 0);
+      return tokens;
+    });
+  }
+
+  function colorsOf(code: string, scripts = embeddedScripts(code)) {
+    const lines = withEmbeddedScripts(code, tokenize(code, "shellscript"), scripts, tokenize);
+    expect(lines.map((line) => line.map((token) => token.content).join("")).join("\n")).toBe(
+      code.replaceAll("\r\n", "\n"),
+    );
+    return lines.flat().map((token) => [token.content, token.color]);
+  }
+
+  it("colors each nested script with its own grammar, keeping the text", () => {
+    expect(colorsOf(`bash -lc "python3 -c 'print(1)'"`)).toEqual([
+      [`bash -lc "python3 -c '`, "shellscript"],
+      ["print(1)", "python"],
+      [`'"`, "shellscript"],
+    ]);
+  });
+
+  it("colors an escape sequence like the character it spells", () => {
+    expect(colorsOf(`bash -c "python3 -c 'print(\\"x\\")'"`)).toContainEqual([
+      `print(\\"x\\")`,
+      "python",
+    ]);
+  });
+
+  it("keeps the surrounding colors where a grammar is missing", () => {
+    const code = "cat > x.ts <<'EOF'\r\nbody\r\nEOF";
+    const [script] = embeddedScripts(code);
+    // Compare per character: untouched lines keep their grammar's token boundaries.
+    const characterColors = (scripts: ReturnType<typeof embeddedScripts>) =>
+      colorsOf(code, scripts).flatMap(([content, color]) => [...content!].map(() => color));
+    expect(characterColors([{ ...script!, language: "unknown" }])).toEqual(characterColors([]));
+  });
+});
diff --git a/apps/web/src/components/chat/HighlightedTokens.tsx b/apps/web/src/components/chat/HighlightedTokens.tsx
new file mode 100644
index 000000000000..1d7f1522383f
--- /dev/null
+++ b/apps/web/src/components/chat/HighlightedTokens.tsx
@@ -0,0 +1,204 @@
+import { use, useMemo, type CSSProperties } from "react";
+
+import { resolveDiffThemeName } from "../../lib/diffRendering";
+import type { EmbeddedScript } from "../../lib/embeddedScripts";
+import { getSyntaxHighlighterPromise } from "../../lib/syntaxHighlighting";
+
+interface SyntaxToken {
+  readonly content: string;
+  readonly offset: number;
+  readonly color?: string;
+  readonly fontStyle?: number;
+}
+
+type TokenLines = ReadonlyArray<ReadonlyArray<SyntaxToken>>;
+
+const NO_EMBEDDED_SCRIPTS: ReadonlyArray<EmbeddedScript> = [];
+
+function syntaxTokenStyle(token: SyntaxToken): CSSProperties {
+  const fontStyle = token.fontStyle ?? 0;
+  return {
+    ...(token.color ? { color: token.color } : {}),
+    ...(fontStyle & 1 ? { fontStyle: "italic" } : {}),
+    ...(fontStyle & 2 ? { fontWeight: 700 } : {}),
+    ...(fontStyle & 4 ? { textDecoration: "underline" } : {}),
+  };
+}
+
+/**
+ * Colors `code` inside the caller's `<pre>` without changing its text, so
+ * selection and copy match the plain version. Suspends while the grammar
+ * loads; wrap it in Suspense with the plain text as the fallback.
+ * `wordClassName` goes on each whitespace-separated word. `embedded`
+ * scripts are colored with their own grammar inside `code`.
+ */
+export function HighlightedTokens({
+  code,
+  language,
+  embedded = NO_EMBEDDED_SCRIPTS,
+  theme,
+  wordClassName,
+}: {
+  code: string;
+  language: string;
+  embedded?: ReadonlyArray<EmbeddedScript>;
+  theme: "light" | "dark";
+  wordClassName?: string;
+}) {
+  const highlighter = use(getSyntaxHighlighterPromise(language));
+  // Every grammar loads into the same shared highlighter.
+  for (const script of embedded) use(getSyntaxHighlighterPromise(script.language));
+  const lines = useMemo(() => {
+    const themeName = resolveDiffThemeName(theme);
+    const tokenize = (text: string, lang: string) =>
+      highlighter.codeToTokens(text, { lang, theme: themeName }).tokens;
+    return keyedLines(
+      code,
+      withEmbeddedScripts(code, tokenize(code, language), embedded, tokenize),
+    );
+  }, [code, embedded, highlighter, language, theme]);
+
+  return lines.map(({ key, tokens, ending }) => (
+    <span key={key}>
+      {wordClassName
+        ? wordsOf(tokens).map((part) =>
+            typeof part === "string" ? (
+              part
+            ) : (
+              <span key={part.key} className={wordClassName}>
+                {part.pieces.map((piece) => (
+                  <span key={piece.key} style={syntaxTokenStyle(piece.token)}>
+                    {piece.text}
+                  </span>
+                ))}
+              </span>
+            ),
+          )
+        : tokens.map((token) => (
+            <span key={`${token.offset}:${token.content}`} style={syntaxTokenStyle(token)}>
+              {token.content}
+            </span>
+          ))}
+      {ending}
+    </span>
+  ));
+}
+
+/**
+ * Recolors each embedded script's span of `code` with its own grammar,
+ * outermost first so nested scripts win. A script whose grammar is missing
+ * keeps the colors around it.
+ */
+export function withEmbeddedScripts(
+  code: string,
+  lines: TokenLines,
+  embedded: ReadonlyArray<EmbeddedScript>,
+  tokenize: (text: string, language: string) => TokenLines,
+): TokenLines {
+  if (embedded.length === 0) return lines;
+  const styles = Array.from<SyntaxToken | undefined>({ length: code.length });
+  for (const token of lines.flat()) {
+    styles.fill(token, token.offset, token.offset + token.content.length);
+  }
+  for (const script of embedded) {
+    let scriptLines: TokenLines;
+    try {
+      scriptLines = tokenize(script.text, script.language);
+    } catch {
+      continue;
+    }
+    for (const token of scriptLines.flat()) {
+      if (token.content === "") continue;
+      const last = token.offset + token.content.length - 1;
+      styles.fill(token, script.starts[token.offset], script.ends[last]);
+    }
+  }
+  return restyledLines(code, styles);
+}
+
+/** Splits `code` into lines of tokens, one per run of characters sharing a style. */
+function restyledLines(
+  code: string,
+  styles: ReadonlyArray<SyntaxToken | undefined>,
+): SyntaxToken[][] {
+  const lines: SyntaxToken[][] = [];
+  let start = 0;
+  for (const lineBreak of [...code.matchAll(/\r?\n/gu), undefined]) {
+    const end = lineBreak?.index ?? code.length;
+    const tokens: SyntaxToken[] = [];
+    for (let index = start; index < end;) {
+      const style = styles[index];
+      let next = index + 1;
+      while (
+        next < end &&
+        styles[next]?.color === style?.color &&
+        styles[next]?.fontStyle === style?.fontStyle
+      ) {
+        next += 1;
+      }
+      tokens.push({
+        content: code.slice(index, next),
+        offset: index,
+        ...(style?.color ? { color: style.color } : {}),
+        ...(style?.fontStyle ? { fontStyle: style.fontStyle } : {}),
+      });
+      index = next;
+    }
+    lines.push(tokens);
+    if (lineBreak) start = lineBreak.index + lineBreak[0].length;
+  }
+  return lines;
+}
+
+/**
+ * Keys each line by its start offset, which stays unique when several lines
+ * are empty, and pairs it with the line ending `code` has after it. Shiki drops
+ * `\n` and `\r\n` from tokens alike, so CRLF has to come back from the source.
+ */
+export function keyedLines<Token extends SyntaxToken>(
+  code: string,
+  lines: ReadonlyArray<ReadonlyArray<Token>>,
+) {
+  const endings = code.match(/\r?\n/gu) ?? [];
+  let lineStart = 0;
+  return lines.map((tokens, index) => {
+    const text = tokens.map((token) => token.content).join("");
+    const key = `${lineStart}:${text}`;
+    const ending = endings[index] ?? "";
+    lineStart += text.length + ending.length;
+    return { key, tokens, ending };
+  });
+}
+
+interface Word {
+  readonly key: string;
+  readonly pieces: Array<{ key: string; text: string; token: SyntaxToken }>;
+}
+
+/**
+ * Regroups a line's tokens into whitespace runs and whole words, matching
+ * `text.split(/(\s+)/)`, so a word made of several tokens (`"$HOME/x"`) wraps
+ * exactly like its plain-text fallback.
+ */
+export function wordsOf(tokens: ReadonlyArray<SyntaxToken>): Array<string | Word> {
+  const parts: Array<string | Word> = [];
+  let word: Word | null = null;
+  for (const token of tokens) {
+    let offset = token.offset;
+    for (const text of token.content.split(/(\s+)/u)) {
+      if (text === "") continue;
+      if (/^\s/u.test(text)) {
+        parts.push(text);
+        word = null;
+      } else {
+        if (!word) {
+          word = { key: String(offset), pieces: [] };
+          parts.push(word);
+        }
+        word.pieces.push({ key: String(offset), text, token });
+      }
+      offset += text.length;
+    }
+  }
+  return parts;
+}
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 280cc3672103..81b4af628630 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -121,7 +121,7 @@ export function workEntryDisplayLabel(entry: WorkLogEntry, workspaceRoot: string
   }
   const toolPresentation = resolveWorkEntryToolPresentation(entry);
   if (toolPresentation) return toolPresentation.displayName;
-  if (entry.command) return commandDisplayText(entry.command);
+  if (entry.command?.trim()) return commandDisplayText(entry.command);
   const action = toolGroupAction(entry);
   if (action === "code-search" || action === "search") {
     // Adapters title file searches with their target; the item keeps only the pattern.
diff --git a/apps/web/src/components/chat/MessagesTimeline.test.tsx b/apps/web/src/components/chat/MessagesTimeline.test.tsx
index 5b805d7f5649..f7aeb679a87b 100644
--- a/apps/web/src/components/chat/MessagesTimeline.test.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.test.tsx
@@ -1,8 +1,11 @@
+// @vitest-environment jsdom
+
 import {
   ApprovalRequestId,
   CheckpointRef,
   EnvironmentId,
   MessageId,
+  ProjectId,
   RunId,
   ThreadId,
 } from "@t3tools/contracts";
@@ -15,6 +18,7 @@ import {
   type ReactElement,
 } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
+import { createRoot } from "react-dom/client";
 import { create, type ReactTestRenderer } from "react-test-renderer";
 import { shouldUseRestingComposerLayout } from "../composerFooterLayout";
 import { useComposerFocusState } from "./useComposerFocusState";
@@ -227,6 +231,7 @@ function stubDomGlobals() {
   };
 
   vi.stubGlobal("Element", ElementStub);
+  vi.stubGlobal("getComputedStyle", undefined);
   vi.stubGlobal("localStorage", {
     getItem: () => null,
     setItem: () => {},
@@ -256,13 +261,131 @@ function stubDomGlobals() {
 
 beforeEach(stubDomGlobals);
 beforeAll(async () => {
-  stubDomGlobals();
+  Object.defineProperty(window, "matchMedia", { value: matchMedia, configurable: true });
   ({ MessagesTimeline, resolvePreviewAnnotationImage } = await import("./MessagesTimeline"));
 }, 30_000);
 
 const ACTIVE_THREAD_ENVIRONMENT_ID = EnvironmentId.make("environment-local");
 const MESSAGE_CREATED_AT = "2026-03-17T19:12:28.000Z";
 
+describe("timeline tooltip scroll dismissal", () => {
+  it.each([
+    "hover",
+    "delayed hover",
+    "focus",
+    "hover then focus",
+    "outside timeline",
+    "wheel without scroll",
+    "pr hover",
+    "pr delayed hover",
+    "pr focus",
+    "pr hover then focus",
+  ])("handles %s through the real tooltip interactions", async (scenario) => {
+    const isPullRequest = scenario.startsWith("pr ");
+    const interaction = isPullRequest ? scenario.slice(3) : scenario;
+    vi.unstubAllGlobals();
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    vi.useFakeTimers();
+    const { Tooltip, TooltipTrigger, TooltipPopup, TooltipScrollDismissArea } =
+      await vi.importActual<typeof import("../ui/tooltip")>("../ui/tooltip");
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+    const onMouseEnter = vi.fn();
+    const query = await import("~/state/query");
+    const querySpy = isPullRequest
+      ? vi.spyOn(query, "useEnvironmentQuery").mockReturnValue({
+          data: null,
+          dataUpdatedAt: 0,
+          error: "Pull request not found",
+          failure: null,
+          isPending: false,
+          isSuccess: false,
+          refresh: vi.fn(),
+        })
+      : null;
+    const { PullRequestLinkPreview } = await import("../pullRequest/PullRequestLinkPreview");
+    const tooltip = isPullRequest ? (
+      <PullRequestLinkPreview
+        link={<button onMouseEnter={onMouseEnter}>message link</button>}
+        originalUrl="https://example.com"
+        target={{
+          environmentId: ACTIVE_THREAD_ENVIRONMENT_ID,
+          input: {
+            projectId: ProjectId.make("project-1"),
+            repository: "pingdotgg/t3code",
+            number: 1,
+          },
+        }}
+      />
+    ) : (
+      <Tooltip>
+        <TooltipTrigger delay={50} onMouseEnter={onMouseEnter}>
+          message link
+        </TooltipTrigger>
+        <TooltipPopup>https://example.com</TooltipPopup>
+      </Tooltip>
+    );
+    try {
+      await act(async () => {
+        root.render(
+          <>
+            <TooltipScrollDismissArea>
+              <div data-testid="scrollable">
+                {interaction === "outside timeline" ? null : tooltip}
+              </div>
+            </TooltipScrollDismissArea>
+            {interaction === "outside timeline" ? tooltip : null}
+          </>,
+        );
+      });
+      const trigger = container.querySelector<HTMLButtonElement>("button")!;
+      const scrollable = container.querySelector<HTMLElement>('[data-testid="scrollable"]')!;
+      await act(async () => {
+        if (interaction !== "focus") {
+          trigger.dispatchEvent(new MouseEvent("mouseover", { bubbles: true }));
+          trigger.dispatchEvent(new MouseEvent("mouseenter"));
+          trigger.dispatchEvent(new MouseEvent("mousemove", { bubbles: true }));
+        }
+        if (interaction === "focus" || interaction === "hover then focus") {
+          document.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab" }));
+          trigger.focus();
+        }
+        if (interaction !== "delayed hover") {
+          await vi.advanceTimersByTimeAsync(isPullRequest ? 400 : 60);
+        }
+      });
+      expect(onMouseEnter).toHaveBeenCalledTimes(interaction === "focus" ? 0 : 1);
+      expect(
+        document.querySelector('[data-slot="tooltip-popup"][data-open]')?.textContent ?? null,
+      ).toBe(interaction === "delayed hover" ? null : "https://example.com");
+
+      await act(async () => {
+        scrollable.dispatchEvent(
+          interaction === "wheel without scroll"
+            ? new WheelEvent("wheel", { bubbles: true, deltaY: 100 })
+            : new Event("scroll"),
+        );
+        await vi.advanceTimersByTimeAsync(isPullRequest ? 1000 : 100);
+      });
+      expect(
+        document.querySelector('[data-slot="tooltip-popup"][data-open]')?.textContent ?? null,
+      ).toBe(
+        interaction === "hover" || interaction === "delayed hover" ? null : "https://example.com",
+      );
+      if (interaction === "focus" || interaction === "hover then focus") {
+        expect(document.activeElement).toBe(trigger);
+      }
+    } finally {
+      await act(async () => root.unmount());
+      querySpy?.mockRestore();
+      container.remove();
+      vi.useRealTimers();
+      vi.unstubAllGlobals();
+    }
+  });
+});
+
 function buildProps() {
   return {
     isWorking: false,
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 224cb58f78c3..1f267bcfd730 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -45,6 +45,10 @@ import {
   workEntryViewedImagePath,
 } from "@t3tools/client-runtime/work-log/presentation";
 import { resolveWorkGroupScrollAnchor } from "@t3tools/client-runtime/work-log/scroll-anchor";
+import {
+  turnItemHasDetail,
+  turnItemNeedsDetailFetch,
+} from "@t3tools/client-runtime/work-log/item-detail";
 import { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
 import {
   subagentGroupSummary,
@@ -216,7 +220,7 @@ import {
 import { TerminalContextInlineChip } from "./TerminalContextInlineChip";
 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
 import { Spinner } from "../ui/spinner";
-import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+import { Tooltip, TooltipPopup, TooltipTrigger, TooltipScrollDismissArea } from "../ui/tooltip";
 import { WorktreeSetupCard } from "./WorktreeSetupCard";
 import {
   ContextChipPopover as UserMessageContextPopover,
@@ -260,7 +264,7 @@ import {
   formatDayAwareTimestamp,
   formatUpcomingTimestamp,
 } from "../../timestampFormat";
-import { V2ItemInspector } from "./V2ItemInspector";
+import { FetchedToolOutput, V2ItemInspector } from "./V2ItemInspector";
 import { useV2ItemSupport } from "../../state/v2ItemSupport";
 import { Collapsible, CollapsibleTrigger, CollapsiblePanel } from "../ui/collapsible";
 import {
@@ -1329,7 +1333,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   return (
     <TimelineRowCtx value={sharedState}>
       <TimelineRowActivityCtx value={activityState}>
-        <div
+        <TooltipScrollDismissArea
           ref={setTimelineViewportElement}
           className="relative h-full min-h-0"
           data-assistant-citation-viewport="true"
@@ -1398,7 +1402,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
               });
             }}
           />
-        </div>
+        </TooltipScrollDismissArea>
       </TimelineRowActivityCtx>
     </TimelineRowCtx>
   );
@@ -5159,10 +5163,25 @@ function WorkEntryLogRow(props: WorkEntryRowProps) {
             viewedImage ? viewedImagePath : null,
           )
       : null;
+  // Projected rows expand to the item inspector, so only offer a disclosure
+  // when it has something to show, even if that output still has to load.
+  // Reads and skills still fetch the output the timeline withheld.
+  const plainOutputFetches =
+    plainOutput !== undefined &&
+    workEntry.projectedItem !== undefined &&
+    turnItemNeedsDetailFetch(workEntry.projectedItem.item);
   const canExpandProjectedItem =
     plainOutput !== undefined
-      ? Boolean(plainOutput || viewedImage || workEntry.questionAnswer)
-      : canExpand || workEntry.projectedItem !== undefined;
+      ? Boolean(plainOutput || viewedImage || workEntry.questionAnswer || plainOutputFetches)
+      : workEntry.projectedItem === undefined
+        ? canExpand
+        : isReasoning
+          ? Boolean(workEntry.detail?.trim())
+          : Boolean(
+              viewedImage ||
+              workEntry.questionAnswer ||
+              turnItemHasDetail(workEntry.projectedItem.item),
+            );
   // Reserve destructive row styling for severe failures, not routine tool errors.
   const iconWrapperClass = cn(
     "flex size-4 items-center justify-center",
@@ -5333,7 +5352,9 @@ function WorkEntryLogRow(props: WorkEntryRowProps) {
       !isReasoning &&
       !workEntry.questionAnswer &&
       canExpandProjectedItem &&
-      (expandedBody || (workEntry.projectedItem && plainOutput === undefined)) ? (
+      (expandedBody ||
+        plainOutputFetches ||
+        (workEntry.projectedItem && plainOutput === undefined)) ? (
         <WorkLogDetails kind="panel">
           {workEntry.projectedItem && plainOutput === undefined ? (
             <V2ItemInspector
@@ -5345,9 +5366,19 @@ function WorkEntryLogRow(props: WorkEntryRowProps) {
               onOpenTurnDiff={ctx.onOpenTurnDiff}
               onRollbackCheckpoint={ctx.onRollbackCheckpoint}
             />
-          ) : expandedBody ? (
-            <pre className={toolCallExpandedBodyClassName}>{expandedBody}</pre>
-          ) : null}
+          ) : (
+            <>
+              {expandedBody ? (
+                <pre className={toolCallExpandedBodyClassName}>{expandedBody}</pre>
+              ) : null}
+              {plainOutputFetches && workEntry.projectedItem ? (
+                <FetchedToolOutput
+                  projectedItem={workEntry.projectedItem}
+                  environmentId={ctx.activeThreadEnvironmentId}
+                />
+              ) : null}
+            </>
+          )}
         </WorkLogDetails>
       ) : null}
     </WorkLogRow>
diff --git a/apps/web/src/components/chat/ShellCommandBlock.tsx b/apps/web/src/components/chat/ShellCommandBlock.tsx
new file mode 100644
index 000000000000..cd264eaaa903
--- /dev/null
+++ b/apps/web/src/components/chat/ShellCommandBlock.tsx
@@ -0,0 +1,76 @@
+import {
+  commandHighlightLanguage,
+  withVisibleControlCharacters,
+} from "@t3tools/client-runtime/work-log/command-label";
+import { Suspense, use, useMemo } from "react";
+
+import { useTheme } from "../../hooks/useTheme";
+import { RenderErrorBoundary } from "../RenderErrorBoundary";
+import { HighlightedTokens } from "./HighlightedTokens";
+
+// Shell words wrap as a unit, so `--exclude` or a quoted string is not split
+// at a hyphen; a word longer than the line still breaks anywhere.
+const WORD_CLASS_NAME = "inline-block max-w-full [overflow-wrap:anywhere]";
+
+// The shell parser loads with the first expanded command, not with the timeline.
+let embeddedScriptsModule: Promise<typeof import("../../lib/embeddedScripts")> | undefined;
+function loadEmbeddedScripts() {
+  embeddedScriptsModule ??= import("../../lib/embeddedScripts");
+  return embeddedScriptsModule;
+}
+
+/** Same layout as the highlighted version, so the grammar arriving never reflows the block. */
+function PlainWords({ code }: { code: string }) {
+  // split with a capture group alternates words (even) and whitespace (odd).
+  return code.split(/(\s+)/u).map((part, index) =>
+    index % 2 === 1 || part === "" ? (
+      part
+    ) : (
+      // Positions are stable for a given string, which is all this renders.
+      // oxlint-disable-next-line react/no-array-index-key
+      <span key={index} className={WORD_CLASS_NAME}>
+        {part}
+      </span>
+    ),
+  );
+}
+
+function HighlightedCommand({ code, theme }: { code: string; theme: "light" | "dark" }) {
+  const { embeddedScripts } = use(loadEmbeddedScripts());
+  const language = commandHighlightLanguage(code);
+  // Only shell syntax nests scripts; PowerShell's own grammar colors its strings.
+  const embedded = useMemo(
+    () => (language === "shellscript" ? embeddedScripts(code) : []),
+    [code, embeddedScripts, language],
+  );
+  return (
+    <HighlightedTokens
+      code={code}
+      language={language}
+      embedded={embedded}
+      theme={theme}
+      wordClassName={WORD_CLASS_NAME}
+    />
+  );
+}
+
+/**
+ * The command a command_execution item ran, syntax highlighted. Scripts inside
+ * it, such as a `bash -lc` script or a Python heredoc, get their own grammar.
+ */
+export function ShellCommandBlock({ command }: { command: string }) {
+  const { resolvedTheme } = useTheme();
+  const code = withVisibleControlCharacters(command.trim());
+  if (!code) return null;
+  const plain = <PlainWords code={code} />;
+  return (
+    // The tool body sets the monospace, pre-wrapped text this sits in.
+    <div className="text-foreground/85">
+      <RenderErrorBoundary fallback={plain} resetKeys={[code]}>
+        <Suspense fallback={plain}>
+          <HighlightedCommand code={code} theme={resolvedTheme} />
+        </Suspense>
+      </RenderErrorBoundary>
+    </div>
+  );
+}
diff --git a/apps/web/src/components/chat/SnapShotAttachmentDetails.tsx b/apps/web/src/components/chat/SnapShotAttachmentDetails.tsx
index 793da952c6ef..ca6e366fe829 100644
--- a/apps/web/src/components/chat/SnapShotAttachmentDetails.tsx
+++ b/apps/web/src/components/chat/SnapShotAttachmentDetails.tsx
@@ -1,15 +1,14 @@
 import type { SnapShotSource } from "@t3tools/contracts";
 import { ImageIcon, TextIcon } from "lucide-react";
-import { Suspense, use, useMemo, type CSSProperties } from "react";
+import { Suspense } from "react";
 
 import { useTheme } from "../../hooks/useTheme";
-import { resolveDiffThemeName } from "../../lib/diffRendering";
-import { getSyntaxHighlighterPromise } from "../../lib/syntaxHighlighting";
 import { cn } from "../../lib/utils";
 import { RenderErrorBoundary } from "../RenderErrorBoundary";
 import { Button } from "../ui/button";
 import { Popover, PopoverPopup, PopoverTitle, PopoverTrigger } from "../ui/popover";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+import { HighlightedTokens } from "./HighlightedTokens";
 
 export const SNAP_SHOT_ATTACHMENT_FRAME_CLASS =
   "relative h-28 w-52 max-w-full overflow-hidden rounded-lg border border-border/80";
@@ -19,59 +18,6 @@ export interface SnapShotAccessibilityDetails {
   format: "json" | "text";
 }
 
-interface SyntaxToken {
-  readonly content: string;
-  readonly offset: number;
-  readonly color?: string;
-  readonly fontStyle?: number;
-}
-
-function syntaxTokenStyle(token: SyntaxToken): CSSProperties {
-  const fontStyle = token.fontStyle ?? 0;
-  return {
-    ...(token.color ? { color: token.color } : {}),
-    ...(fontStyle & 1 ? { fontStyle: "italic" } : {}),
-    ...(fontStyle & 2 ? { fontWeight: 700 } : {}),
-    ...(fontStyle & 4 ? { textDecoration: "underline" } : {}),
-  };
-}
-
-function HighlightedAccessibilityJson({
-  content,
-  theme,
-}: {
-  content: string;
-  theme: "light" | "dark";
-}) {
-  const highlighter = use(getSyntaxHighlighterPromise("json"));
-  const lines = useMemo(
-    () =>
-      highlighter.codeToTokens(content, {
-        lang: "json",
-        theme: resolveDiffThemeName(theme),
-      }).tokens,
-    [content, highlighter, theme],
-  );
-
-  let lineOffset = 0;
-  return lines.map((line) => {
-    const lineContent = line.map((token) => token.content).join("");
-    const lineKey = `${lineOffset}:${lineContent}`;
-    const hasNextLine = lineOffset + lineContent.length < content.length;
-    lineOffset += lineContent.length + 1;
-    return (
-      <span key={lineKey}>
-        {line.map((token) => (
-          <span key={`${token.offset}:${token.content}`} style={syntaxTokenStyle(token)}>
-            {token.content}
-          </span>
-        ))}
-        {hasNextLine ? "\n" : null}
-      </span>
-    );
-  });
-}
-
 export function SnapShotAccessibilityData({
   details,
   className,
@@ -84,7 +30,7 @@ export function SnapShotAccessibilityData({
     details.format === "json" ? (
       <RenderErrorBoundary fallback={details.content}>
         <Suspense fallback={details.content}>
-          <HighlightedAccessibilityJson content={details.content} theme={resolvedTheme} />
+          <HighlightedTokens code={details.content} language="json" theme={resolvedTheme} />
         </Suspense>
       </RenderErrorBoundary>
     ) : (
diff --git a/apps/web/src/components/chat/V2ItemInspector.tsx b/apps/web/src/components/chat/V2ItemInspector.tsx
index b2f0f6b9e762..7dc48a9e00a4 100644
--- a/apps/web/src/components/chat/V2ItemInspector.tsx
+++ b/apps/web/src/components/chat/V2ItemInspector.tsx
@@ -4,18 +4,27 @@ import type {
   RunId,
   ThreadId,
 } from "@t3tools/contracts";
+import {
+  toolCallLines,
+  turnItemDetailRevision,
+  turnItemNeedsDetailFetch,
+  turnItemOutputText,
+} from "@t3tools/client-runtime/work-log/item-detail";
 import { ExternalLinkIcon, GitBranchIcon, RotateCcwIcon } from "lucide-react";
 import { memo, Suspense, use, useMemo } from "react";
 
 import { useTheme } from "../../hooks/useTheme";
+import { cn } from "../../lib/utils";
 import { resolveDiffThemeName } from "../../lib/diffRendering";
 import { getSyntaxHighlighterPromise } from "../../lib/syntaxHighlighting";
+import { useTurnItemDetail } from "../../state/queries";
 import { useV2ItemSupport } from "../../state/v2ItemSupport";
 import { formatWorkspaceRelativePath } from "../../filePathDisplay";
 import { Button } from "../ui/button";
 import ChatMarkdown from "../ChatMarkdown";
 import { RenderErrorBoundary } from "../RenderErrorBoundary";
 import { resolveExternalWebLinkHref } from "./externalLinkContextMenu";
+import { ShellCommandBlock } from "./ShellCommandBlock";
 
 interface V2ItemInspectorProps {
   readonly projectedItem: OrchestrationV2ProjectedTurnItem;
@@ -48,6 +57,9 @@ function JsonTokens({ text }: { readonly text: string }) {
   ]);
 }
 
+const monoClassName =
+  "font-mono text-(length:--font-size-code,var(--text-2xs)) leading-relaxed whitespace-pre-wrap break-words select-text";
+
 function StructuredValue({
   value,
   highlightJson = false,
@@ -67,7 +79,7 @@ function StructuredValue({
   }, [highlightJson, text]);
   if (!text) return null;
   return (
-    <pre className="max-h-80 overflow-auto whitespace-pre-wrap break-words rounded-md border border-border/50 bg-background/60 p-2 font-mono text-2xs leading-relaxed text-muted-foreground select-text">
+    <pre className={cn("max-h-80 overflow-auto text-muted-foreground", monoClassName)}>
       {isJson ? (
         <RenderErrorBoundary fallback={text}>
           <Suspense fallback={text}>
@@ -81,8 +93,111 @@ function StructuredValue({
   );
 }
 
+/**
+ * The item behind a projected row, with the output the timeline withheld
+ * fetched while the row is open.
+ */
+function useFetchedTurnItem(
+  projectedItem: OrchestrationV2ProjectedTurnItem,
+  environmentId: EnvironmentId,
+) {
+  const wireItem = projectedItem.item;
+  const fetches = turnItemNeedsDetailFetch(wireItem);
+  const detail = useTurnItemDetail(
+    fetches
+      ? {
+          environmentId,
+          threadId: projectedItem.sourceThreadId,
+          itemId: projectedItem.sourceItemId,
+          revision: turnItemDetailRevision(wireItem),
+        }
+      : null,
+  );
+  const fetchedItem = detail.data?.item;
+  const item = fetchedItem?.type === wireItem.type ? fetchedItem : wireItem;
+  return {
+    item,
+    output: {
+      output: turnItemOutputText(item),
+      pending: item === wireItem && detail.isPending,
+      error:
+        item !== wireItem
+          ? null
+          : detail.data?.item === null
+            ? "Output is no longer available."
+            : detail.error,
+      empty: fetches && item !== wireItem,
+    },
+  };
+}
+
+interface ToolOutputState {
+  readonly output: string | null;
+  readonly pending: boolean;
+  readonly error: string | null;
+  readonly empty: boolean;
+}
+
+function ToolOutput(props: ToolOutputState) {
+  return props.output ? (
+    <div className="max-h-80 overflow-auto text-muted-foreground">{props.output}</div>
+  ) : props.pending ? (
+    <div className="text-muted-foreground italic">Loading output…</div>
+  ) : props.error ? (
+    <div className="text-destructive">Couldn&apos;t load output: {props.error}</div>
+  ) : props.empty ? (
+    <div className="text-muted-foreground italic">No output.</div>
+  ) : null;
+}
+
+/** Fetched output for rows that show their own plain text instead of the inspector. */
+export function FetchedToolOutput(props: {
+  readonly projectedItem: OrchestrationV2ProjectedTurnItem;
+  readonly environmentId: EnvironmentId;
+}) {
+  const { output } = useFetchedTurnItem(props.projectedItem, props.environmentId);
+  return (
+    <div className={cn("mt-1.5", monoClassName)}>
+      <ToolOutput {...output} />
+    </div>
+  );
+}
+
+/** A tool call's body: the call itself in the foreground, its result muted below. */
+function ToolCallBody(
+  props: ToolOutputState & {
+    readonly command?: string;
+    readonly args?: unknown;
+    readonly exitCode?: number | undefined;
+  },
+) {
+  const call = toolCallLines({ command: props.command, args: props.args });
+  return (
+    <div className={cn("space-y-1.5", monoClassName)}>
+      {call.command ? <ShellCommandBlock command={call.command} /> : null}
+      {call.args ? (
+        <div className="text-foreground/85">
+          {call.args.map(([key, value]) => (
+            <div key={key}>
+              <span className="text-muted-foreground">{key} </span>
+              {value}
+            </div>
+          ))}
+        </div>
+      ) : null}
+      {call.argsText ? <StructuredValue value={call.argsText} highlightJson /> : null}
+      <ToolOutput {...props} />
+      {props.exitCode !== undefined && props.exitCode !== 0 ? (
+        <div className="text-destructive">exit {props.exitCode}</div>
+      ) : null}
+    </div>
+  );
+}
+
 export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspectorProps) {
-  const { item } = props.projectedItem;
+  const fetched = useFetchedTurnItem(props.projectedItem, props.environmentId);
+  const item = fetched.item;
+  const outputState = fetched.output;
   const support = useV2ItemSupport({
     environmentId: props.environmentId,
     sourceThreadId: props.projectedItem.sourceThreadId,
@@ -105,14 +220,7 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
       ) : null}
 
       {item.type === "command_execution" ? (
-        <div className="space-y-2">
-          <StructuredValue value={item.input} highlightJson />
-          {item.exitCode !== undefined ? (
-            <p className={item.exitCode === 0 ? "text-success" : "text-destructive"}>
-              Process exited with code {item.exitCode}
-            </p>
-          ) : null}
-        </div>
+        <ToolCallBody command={item.input} exitCode={item.exitCode} {...outputState} />
       ) : null}
 
       {item.type === "file_change" ? (
@@ -137,6 +245,9 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
               </Button>
             ) : null}
           </div>
+          {item.status === "failed" && item.diffStr?.trim() ? (
+            <StructuredValue value={item.diffStr} />
+          ) : null}
           {item.changes !== undefined && item.changes.length > 0 ? (
             <ul className="space-y-1 font-mono text-muted-foreground">
               {item.changes.map((change, index) => (
@@ -153,8 +264,16 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
         </div>
       ) : null}
 
-      {item.type === "file_search" && item.results ? (
-        <ul className="space-y-1 rounded-md border border-border/45 p-2">
+      {item.type === "file_search" && item.pattern?.trim() ? (
+        <div className={cn("text-foreground/85", monoClassName)}>{item.pattern}</div>
+      ) : null}
+
+      {item.type === "web_search" && item.patterns?.length ? (
+        <div className={cn("text-foreground/85", monoClassName)}>{item.patterns.join("\n")}</div>
+      ) : null}
+
+      {item.type === "file_search" && item.results?.length ? (
+        <ul className="space-y-1">
           {item.results.map((result) => (
             <li key={JSON.stringify(result)}>
               <span className="font-mono text-foreground/80">
@@ -170,8 +289,8 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
         </ul>
       ) : null}
 
-      {item.type === "web_search" && item.results ? (
-        <ul className="space-y-1.5 rounded-md border border-border/45 p-2">
+      {item.type === "web_search" && item.results?.length ? (
+        <ul className="space-y-1.5">
           {item.results.map((result) => {
             const safeHref = resolveExternalWebLinkHref(result.url);
             return (
@@ -198,14 +317,7 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
         </ul>
       ) : null}
 
-      {item.type === "dynamic_tool" ? (
-        <div>
-          <p className="mb-1 text-3xs font-medium tracking-wide uppercase text-muted-foreground">
-            Input
-          </p>
-          <StructuredValue value={item.input} highlightJson />
-        </div>
-      ) : null}
+      {item.type === "dynamic_tool" ? <ToolCallBody args={item.input} {...outputState} /> : null}
 
       {item.type === "approval_request" ? <StructuredValue value={item.prompt} /> : null}
       {item.type === "user_input_request" ? (
@@ -213,6 +325,7 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
       ) : null}
       {item.type === "notification" ? <StructuredValue value={item.detail} /> : null}
       {item.type === "system_notice" ? <StructuredValue value={item.message} /> : null}
+      {item.type === "error" ? <StructuredValue value={item.failure.message} /> : null}
       {item.type === "proposed_plan" ? <StructuredValue value={item.markdown} /> : null}
       {item.type === "todo_list" ? (
         <StructuredValue
@@ -259,7 +372,7 @@ export const V2ItemInspector = memo(function V2ItemInspector(props: V2ItemInspec
       ) : null}
 
       {item.type === "handoff" ? (
-        <div className="space-y-1 rounded-md border border-border/45 p-2 text-muted-foreground">
+        <div className="space-y-1 text-muted-foreground">
           <p>
             {item.fromProviderInstanceIds.join(", ")} → {item.toProviderInstanceId}
           </p>
diff --git a/apps/web/src/components/chat/WorkLog.tsx b/apps/web/src/components/chat/WorkLog.tsx
index 5a0efd3550c3..4358f30f4de3 100644
--- a/apps/web/src/components/chat/WorkLog.tsx
+++ b/apps/web/src/components/chat/WorkLog.tsx
@@ -123,7 +123,7 @@ export function WorkLogDetails({
         kind === "text"
           ? "ms-7 flex max-h-96 flex-col gap-3 overflow-auto px-0.5 py-1 select-text"
           : kind === "panel"
-            ? "mt-1 rounded-md bg-muted/40 px-3 py-2"
+            ? "mt-0.5 mb-1.5"
             : "mt-1",
       )}
       onClick={(event) => event.stopPropagation()}
diff --git a/apps/web/src/components/chat/threadDetailsPanelStyles.ts b/apps/web/src/components/chat/threadDetailsPanelStyles.ts
index 523a97f3acac..d3f81e8ddddd 100644
--- a/apps/web/src/components/chat/threadDetailsPanelStyles.ts
+++ b/apps/web/src/components/chat/threadDetailsPanelStyles.ts
@@ -38,7 +38,7 @@ export const THREAD_DETAILS_PANEL_ICON_CLASS = "size-4 shrink-0 text-muted-foreg
 
 export const THREAD_DETAILS_PANEL_CHEVRON_CLASS = "size-4 shrink-0 text-muted-foreground";
 
-export const THREAD_DETAILS_PANEL_ICON_ACTION_CLASS = `size-6 rounded-md border-transparent bg-transparent p-0 sm:size-6 ${THREAD_DETAILS_PANEL_ROW_SURFACE_CLASS}`;
+export const THREAD_DETAILS_PANEL_ICON_ACTION_CLASS = `size-6 justify-center rounded-md border-transparent bg-transparent p-0 sm:size-6 ${THREAD_DETAILS_PANEL_ROW_SURFACE_CLASS}`;
 
 export const THREAD_DETAILS_PANEL_SPLIT_GROUP_CLASS = `group/thread-details-action flex w-full items-center rounded-lg ${THREAD_DETAILS_PANEL_SPLIT_GROUP_SURFACE_CLASS}`;
 
diff --git a/apps/web/src/components/chat/useAutoBalanceUpdateBanner.tsx b/apps/web/src/components/chat/useAutoBalanceUpdateBanner.tsx
index 13e14b031ec9..51fa6274bc13 100644
--- a/apps/web/src/components/chat/useAutoBalanceUpdateBanner.tsx
+++ b/apps/web/src/components/chat/useAutoBalanceUpdateBanner.tsx
@@ -65,6 +65,7 @@ export function useAutoBalanceUpdateBanner(
         environmentId: environment.environmentId,
         serverLabel: environment.label,
         selfUpdate,
+        installation: environment.serverConfig?.environment.capabilities.serverInstallation,
         desktopAppUpdate,
         threadContinuation: supportsServerUpdateThreadContinuation(environment.serverConfig),
         continueThreadsAfterServerUpdate:
diff --git a/apps/web/src/components/cloud/CloudEnvironmentConnectList.test.tsx b/apps/web/src/components/cloud/CloudEnvironmentConnectList.test.tsx
index 157861f1eaa6..d7f2e030cb58 100644
--- a/apps/web/src/components/cloud/CloudEnvironmentConnectList.test.tsx
+++ b/apps/web/src/components/cloud/CloudEnvironmentConnectList.test.tsx
@@ -327,6 +327,7 @@ describe("cloud onboarding discovery", () => {
             {
               environmentId: newMachineId,
               connection: { phase: "connected", error: null, traceId: null },
+              relayManaged: true,
             },
           ]}
           showSavedEnvironments
diff --git a/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx b/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx
index 5022031e98e6..fe5eb7836239 100644
--- a/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx
+++ b/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx
@@ -48,6 +48,8 @@ function discoveredCompatibilityError(
 export interface SavedCloudEnvironmentConnection {
   readonly environmentId: EnvironmentId;
   readonly connection: EnvironmentConnectionPresentation;
+  /** False for a machine saved over another route (LAN, Tailscale, SSH) only. */
+  readonly relayManaged: boolean;
   /** Present once connected; carries the user's icon override. */
   readonly serverConfig?: ServerConfig | null;
 }
@@ -121,7 +123,15 @@ export function CloudEnvironmentConnectRows({
     ReadonlySet<EnvironmentId>
   >(new Set());
   const savedById = new Map(
-    savedEnvironments.map((environment) => [environment.environmentId, environment]),
+    savedEnvironments
+      .filter((environment) => environment.relayManaged)
+      .map((environment) => [environment.environmentId, environment]),
+  );
+  // Saved over another route only: T3 Connect would be an added fallback.
+  const savedWithoutRelay = new Set(
+    savedEnvironments
+      .filter((environment) => !environment.relayManaged)
+      .map((environment) => environment.environmentId),
   );
 
   useEffect(() => {
@@ -153,8 +163,12 @@ export function CloudEnvironmentConnectRows({
     if (result._tag === "Success") {
       toastManager.add({
         type: "success",
-        title: "Environment added",
-        description: `Connecting to ${environment.label} through T3 Connect.`,
+        title: savedWithoutRelay.has(environment.environmentId)
+          ? "T3 Connect route added"
+          : "Environment added",
+        description: savedWithoutRelay.has(environment.environmentId)
+          ? `${environment.label} falls back to T3 Connect when its other routes are unreachable.`
+          : `Connecting to ${environment.label} through T3 Connect.`,
       });
       return true;
     }
@@ -182,10 +196,14 @@ export function CloudEnvironmentConnectRows({
     return false;
   };
 
+  // During onboarding selection a machine saved over another route already
+  // has its own row elsewhere, and selecting it must not add a T3 Connect
+  // route as a side effect, so it is left out here.
   const visibleEnvironments = [...environmentsState.environments.values()].filter(
     ({ environment }) =>
       environment.environmentId !== primaryEnvironmentId &&
-      (showSavedEnvironments || !savedById.has(environment.environmentId)),
+      (showSavedEnvironments || !savedById.has(environment.environmentId)) &&
+      !(selection && savedWithoutRelay.has(environment.environmentId)),
   );
   const selectNewComputers = useEffectEvent(() => {
     const seen = selection?.autoSelectedComputers;
@@ -337,19 +355,22 @@ export function CloudEnvironmentConnectRows({
           : availability === "checking"
             ? "bg-warning"
             : "bg-muted-foreground/35";
+    const notAdded = savedWithoutRelay.has(environment.environmentId)
+      ? "Saved without T3 Connect"
+      : "Not added";
     const statusText =
       unsupported && !savedEnvironment
-        ? "T3 Connect · Not added · Client not supported"
+        ? `T3 Connect · ${notAdded} · Client not supported`
         : savedConnection
           ? savedConnection.statusText
           : availability === "online"
-            ? "T3 Connect · Not added · Relay online"
+            ? `T3 Connect · ${notAdded} · Relay online`
             : availability === "offline"
-              ? "T3 Connect · Not added · Relay offline"
+              ? `T3 Connect · ${notAdded} · Relay offline`
               : availability === "checking"
-                ? "T3 Connect · Not added · Checking relay status…"
+                ? `T3 Connect · ${notAdded} · Checking relay status…`
                 : (Option.getOrNull(error)?.message ??
-                  "T3 Connect · Not added · Relay status unavailable");
+                  `T3 Connect · ${notAdded} · Relay status unavailable`);
     if (selection) {
       return (
         <label
@@ -464,7 +485,11 @@ export function CloudEnvironmentConnectRows({
               disabled={connectingEnvironmentIds.size > 0}
               onClick={() => void connectEnvironment(environment)}
             >
-              {connectingEnvironmentIds.has(environment.environmentId) ? "Adding…" : "Add"}
+              {connectingEnvironmentIds.has(environment.environmentId)
+                ? "Adding…"
+                : savedWithoutRelay.has(environment.environmentId)
+                  ? "Add route"
+                  : "Add"}
             </Button>
           )}
         </div>
diff --git a/apps/web/src/components/device/DeviceSetup.tsx b/apps/web/src/components/device/DeviceSetup.tsx
index f7869bcd6aff..d4ebfe89f903 100644
--- a/apps/web/src/components/device/DeviceSetup.tsx
+++ b/apps/web/src/components/device/DeviceSetup.tsx
@@ -63,6 +63,9 @@ export function DeviceSetup(props: {
   const [step, setStep] = useState(0);
   const enabled = props.state.hostStatus !== "disabled";
   const busy = props.state.hostStatus === "installing" || props.state.hostStatus === "starting";
+  const localPlatformsUnavailable = props.state.hosts.some(
+    (host) => host.kind === "local" && !host.platforms.some((platform) => platform.available),
+  );
 
   const update = async (
     kind: NonNullable<typeof pending>,
@@ -117,8 +120,8 @@ export function DeviceSetup(props: {
           </section>
         ) : null}
 
-        {step === 1 ? (
-          <section className="space-y-3 text-sm">
+        {step === 1 || (step === 0 && enabled && localPlatformsUnavailable) ? (
+          <section className={cn("space-y-3 text-sm", step === 0 && "mt-4")}>
             <h3 className="font-medium">Check simulator support</h3>
             <DevicePlatformSetup
               state={props.state}
diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.test.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.test.tsx
index 884bef0bf0b8..a39e144ca382 100644
--- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.test.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.test.tsx
@@ -32,6 +32,7 @@ vi.mock("~/state/environments", () => ({
   usePrimaryEnvironmentId: () => EnvironmentId.make("env-1"),
 }));
 vi.mock("~/hooks/useSettings", () => ({
+  useEnvironmentSettings: () => undefined,
   useClientSettings: (select: (settings: typeof DEFAULT_CLIENT_SETTINGS) => unknown) =>
     select(DEFAULT_CLIENT_SETTINGS),
 }));
diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
index bf5bd62de91c..53dc7642d9be 100644
--- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx
@@ -6,7 +6,6 @@ import { scopedThreadKey, scopeProjectRef } from "@t3tools/client-runtime/enviro
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import {
   type EnvironmentId,
-  DEFAULT_SERVER_SETTINGS,
   type PullRequestAction,
   type PullRequestMergeMethod,
   type PullRequestListEntry,
@@ -15,7 +14,6 @@ import {
   resolveEnvironmentMachineKind,
   type ScopedThreadRef,
 } from "@t3tools/contracts";
-import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
 import {
   ArrowDownUpIcon,
   ArrowLeftIcon,
@@ -63,20 +61,14 @@ import {
   type ShortcutMatchContext,
 } from "~/keybindings";
 import { primaryServerKeybindingsAtom } from "~/state/server";
-import { useClientSettings } from "~/hooks/useSettings";
-import {
-  deriveLogicalProjectKeyFromSettings,
-  derivePhysicalProjectKey,
-  selectProjectGroupingSettings,
-} from "~/logicalProject";
+import { usePullRequestDefaultMergeMethodResolver } from "./usePullRequestActions";
 import { changeRequestRepositoryUrl, gitHubPullRequestBrowserUrl } from "~/lib/openPullRequestLink";
 import { usePreparePullRequestThreadAction } from "~/lib/sourceControlActions";
 import { cn } from "~/lib/utils";
 import { readLocalApi } from "~/localApi";
 import type { ReviewCommentContext } from "~/reviewCommentContext";
-import { buildPhysicalToLogicalProjectKeyMap } from "~/sidebarProjectGrouping";
 import { useProjects, useServerConfigs } from "~/state/entities";
-import { useEnvironments, usePrimaryEnvironmentId } from "~/state/environments";
+import { useEnvironments } from "~/state/environments";
 import { useEnvironmentQuery } from "~/state/query";
 import { useLiveRefresh } from "~/hooks/useLiveRefresh";
 import {
@@ -563,19 +555,14 @@ export function PullRequestDetailPanel({
   }, [condensed]);
   const lastSelectedMergeMethod = useUiStateStore((state) => state.pullRequestMergeMethod);
   const setLastSelectedMergeMethod = useUiStateStore((state) => state.setPullRequestMergeMethod);
-  // Server-side and per project, like every other project setting. The
-  // client-local per-project map from before still answers when the server
-  // has no value, so a choice made on an older release keeps applying until
-  // it is set (or reset) in Settings.
-  const legacyMergeMethodOverrides = useClientSettings(
-    (settings) => settings.pullRequestMergeMethodOverrides,
+  const resolveProjectDefaultMergeMethod = usePullRequestDefaultMergeMethodResolver(
+    environmentId,
+    reference.projectId,
+  );
+  const projectDefaultMergeMethod = useMemo(
+    () => resolveProjectDefaultMergeMethod(),
+    [resolveProjectDefaultMergeMethod],
   );
-  const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings);
-  const projectDefaultMergeMethod =
-    resolveProjectSettings(
-      environmentConfigs.get(environmentId)?.settings ?? DEFAULT_SERVER_SETTINGS,
-      reference.projectId,
-    ).settings.pullRequestMergeMethod ?? undefined;
   const [mergeMethodSelection, setMergeMethodSelection] = useState<{
     readonly pullRequestKey: string;
     readonly method: PullRequestMergeMethod;
@@ -887,39 +874,12 @@ export function PullRequestDetailPanel({
   const [titleSaving, setTitleSaving] = useState(false);
   const newThread = useNewThreadHandler();
   const { environments } = useEnvironments();
-  const primaryEnvironmentId = usePrimaryEnvironmentId();
   const unavailableGitHubUrl = useMemo(() => {
     const identity = projects.find(
       (project) => project.id === reference.projectId && project.environmentId === environmentId,
     )?.repositoryIdentity;
     return gitHubPullRequestBrowserUrl(identity, reference.repository, reference.number);
   }, [environmentId, projects, reference.number, reference.projectId, reference.repository]);
-  // Project settings stored the override under the sidebar group's key, which a duplicate row
-  // borrows from its siblings, so the project alone does not always name the same key.
-  const legacyProjectDefaultMergeMethod = useMemo(() => {
-    if (projectDefaultMergeMethod !== undefined) return undefined;
-    const project = projects.find(
-      (candidate) =>
-        candidate.environmentId === environmentId && candidate.id === reference.projectId,
-    );
-    if (!project) return undefined;
-    const projectKey =
-      buildPhysicalToLogicalProjectKeyMap({
-        projects,
-        settings: projectGroupingSettings,
-        primaryEnvironmentId,
-      }).get(derivePhysicalProjectKey(project)) ??
-      deriveLogicalProjectKeyFromSettings(project, projectGroupingSettings);
-    return legacyMergeMethodOverrides[projectKey];
-  }, [
-    environmentId,
-    legacyMergeMethodOverrides,
-    primaryEnvironmentId,
-    projectDefaultMergeMethod,
-    projectGroupingSettings,
-    projects,
-    reference.projectId,
-  ]);
   // Beside a thread there is nothing to pick: the hand-offs land in that thread's composer, and
   // the thread is already on one server's copy of the branch.
   const pickableEnvironments = useMemo(
@@ -1421,7 +1381,7 @@ export function PullRequestDetailPanel({
   const selectedMergeMethod = resolvePullRequestMergeMethod(
     allowedMergeMethods,
     currentMergeMethod,
-    projectDefaultMergeMethod ?? legacyProjectDefaultMergeMethod,
+    projectDefaultMergeMethod,
     lastSelectedMergeMethod,
   );
   const selectedMergeMethodLabel = PULL_REQUEST_MERGE_METHOD_LABELS[selectedMergeMethod];
diff --git a/apps/web/src/components/pullRequest/PullRequestLinkPreview.tsx b/apps/web/src/components/pullRequest/PullRequestLinkPreview.tsx
index 3f183b264b2b..de87d9a5f1f5 100644
--- a/apps/web/src/components/pullRequest/PullRequestLinkPreview.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestLinkPreview.tsx
@@ -1,7 +1,9 @@
+import type { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card";
 import { isAtomCommandInterrupted } from "@t3tools/client-runtime/state/runtime";
 import type { EnvironmentId, PullRequestRef } from "@t3tools/contracts";
 import {
   cloneElement,
+  useRef,
   useState,
   type ComponentPropsWithoutRef,
   type MouseEvent,
@@ -45,6 +47,7 @@ export function PullRequestLinkPreview({
   fallback?: ReactNode;
 }) {
   const [open, setOpen] = useState(false);
+  const previewActionsRef = useRef<PreviewCardPrimitive.Root.Actions | null>(null);
   const [resolvingClick, setResolvingClick] = useState(false);
   const detailQuery = useEnvironmentQuery(
     open
@@ -96,8 +99,14 @@ export function PullRequestLinkPreview({
         : (detail?.author.login ?? null);
 
   return (
-    <PreviewCard open={open} onOpenChange={setOpen}>
-      <Tooltip open={showUrlTooltip}>
+    <PreviewCard open={open} onOpenChange={setOpen} actionsRef={previewActionsRef}>
+      <Tooltip
+        open={showUrlTooltip}
+        onOpenChange={(nextOpen) => {
+          // Cancel the card's delayed hover too, without changing its content preview.
+          if (!nextOpen && !showCard) previewActionsRef.current?.close();
+        }}
+      >
         <PreviewCardTrigger
           render={<TooltipTrigger render={trigger} />}
           delay={350}
diff --git a/apps/web/src/components/pullRequest/PullRequestRow.tsx b/apps/web/src/components/pullRequest/PullRequestRow.tsx
index 04008281f5e7..1f4de90f55b8 100644
--- a/apps/web/src/components/pullRequest/PullRequestRow.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestRow.tsx
@@ -1,5 +1,9 @@
 import { SearchIcon } from "lucide-react";
 import { PullRequestStackPopover } from "./PullRequestStackPopover";
+import {
+  PullRequestSpeedActions,
+  type PullRequestSpeedActionResult,
+} from "./PullRequestSpeedActions";
 import { memo, type RefCallback } from "react";
 
 import { cn } from "~/lib/utils";
@@ -66,10 +70,9 @@ function PullRequestRowLabels({ labels }: { labels: EnvironmentPullRequestEntry[
 
 /**
  * The page row keeps a little more room around the shared lines than the panel, which sits in
- * a narrow column. The intrinsic size is the content box a skipped row reserves, which is the
- * two lines without the padding: a 56px row less 20px of `py-2.5`.
+ * a narrow column. Its outer wrapper reserves the full row height when offscreen.
  */
-const PAGE_ROW_CLASS = "px-3 py-2.5 [contain-intrinsic-block-size:36.5px]";
+const PAGE_ROW_CLASS = "px-3 py-2.5";
 
 export type PullRequestRowTarget = Pick<
   EnvironmentPullRequestEntry,
@@ -86,6 +89,8 @@ function PullRequestRowImpl({
   statsKey,
   statsRef,
   onSelect,
+  speedMode,
+  onActed,
 }: {
   entry: EnvironmentPullRequestEntry;
   selected: boolean;
@@ -101,144 +106,152 @@ function PullRequestRowImpl({
   matchedElsewhere?: boolean;
   /** Used by the list's shared visibility observer to defer optional line-count reads. */
   statsKey?: string;
-  statsRef?: RefCallback<HTMLButtonElement>;
+  statsRef?: RefCallback<HTMLDivElement>;
   onSelect: (entry: PullRequestRowTarget) => void;
+  speedMode: boolean;
+  onActed: (result: PullRequestSpeedActionResult) => void;
 }) {
   const { Icon, providerName } = getSourceControlPresentationForKind(entry.provider);
   return (
-    <button
+    <div
       ref={statsRef}
       data-pull-request-stats-key={statsKey}
-      type="button"
-      aria-current={selected ? "true" : undefined}
-      onClick={() => onSelect(entry)}
       className={cn(
-        PULL_REQUEST_ROW_CLASS,
-        PAGE_ROW_CLASS,
-        "cursor-pointer transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
-        // Offscreen rows are skipped for style, layout and paint: a long list costs what the
-        // viewport shows, not what the pages have loaded. The intrinsic size keeps the
-        // scrollbar honest while a row is skipped.
-        "[content-visibility:auto]",
+        // Keep the action buttons inside the same skipped row, but outside its selection button.
+        "flex items-center rounded-md [content-visibility:auto] [contain-intrinsic-block-size:56.5px]",
         selected ? "bg-accent" : "hover:bg-accent/60",
       )}
     >
-      <PullRequestRowGlyph
-        state={entry.state}
-        isDraft={entry.isDraft}
-        mergeability={entry.mergeability}
-        baseBranch={entry.baseBranch}
-        // On the title line rather than between the lines, as main aligns it.
-        className="mt-0.75 self-start"
-      />
-      <PullRequestRowLines
-        number={
-          // The number carries the link, here as much as on the detail: a right-click on it
-          // copies the pull request's own address rather than opening the editing menu.
-          <span
-            className={PULL_REQUEST_ROW_NUMBER_CLASS}
-            onContextMenu={(event) => {
-              event.preventDefault();
-              event.stopPropagation();
-              void showPullRequestLinkContextMenu({
-                url: entry.url,
-                openLabel: openOnHostLabel(entry.provider),
-                position: { x: event.clientX, y: event.clientY },
-              });
-            }}
-          >
-            #{entry.number}
-          </span>
-        }
-        title={entry.title}
-        signals={
-          <>
-            {entry.checksState === undefined ? null : (
-              <PullRequestChecksPopover
-                checksState={entry.checksState}
-                environmentId={entry.environmentId}
-                reference={{
-                  projectId: entry.projectId,
-                  repository: entry.repository,
-                  number: entry.number,
-                }}
-              />
-            )}
-            {/* Only a verdict the host actually reports: an approval, a request for changes,
+      <button
+        type="button"
+        aria-current={selected ? "true" : undefined}
+        onClick={() => onSelect(entry)}
+        className={cn(
+          PULL_REQUEST_ROW_CLASS,
+          PAGE_ROW_CLASS,
+          "min-w-0 flex-1 cursor-pointer transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
+        )}
+      >
+        <PullRequestRowGlyph
+          state={entry.state}
+          isDraft={entry.isDraft}
+          mergeability={entry.mergeability}
+          baseBranch={entry.baseBranch}
+          // On the title line rather than between the lines, as main aligns it.
+          className="mt-0.75 self-start"
+        />
+        <PullRequestRowLines
+          number={
+            // The number carries the link, here as much as on the detail: a right-click on it
+            // copies the pull request's own address rather than opening the editing menu.
+            <span
+              className={PULL_REQUEST_ROW_NUMBER_CLASS}
+              onContextMenu={(event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                void showPullRequestLinkContextMenu({
+                  url: entry.url,
+                  openLabel: openOnHostLabel(entry.provider),
+                  position: { x: event.clientX, y: event.clientY },
+                });
+              }}
+            >
+              #{entry.number}
+            </span>
+          }
+          title={entry.title}
+          signals={
+            <>
+              {entry.checksState === undefined ? null : (
+                <PullRequestChecksPopover
+                  checksState={entry.checksState}
+                  environmentId={entry.environmentId}
+                  reference={{
+                    projectId: entry.projectId,
+                    repository: entry.repository,
+                    number: entry.number,
+                  }}
+                />
+              )}
+              {/* Only a verdict the host actually reports: an approval, a request for changes,
                 or a review the branch rules still require. No glyph on the common case of a
                 pull request nobody has reviewed, so a row only wears a person when the person
                 has said something. */}
-            {entry.reviewDecision === undefined ? null : (
-              <PullRequestReviewDecisionGlyph decision={entry.reviewDecision} />
-            )}
-          </>
-        }
-        status={
-          <>
-            {entry.stack ? (
-              <PullRequestStackPopover
-                environmentId={entry.environmentId}
-                reference={{
-                  projectId: entry.projectId,
-                  host: entry.host,
-                  repository: entry.repository,
-                  number: entry.number,
-                }}
-                membership={entry.stack}
-                onSelect={(target) =>
-                  onSelect({ ...target, host: entry.host, environmentId: entry.environmentId })
-                }
-              />
-            ) : null}
-            <PullRequestDiffStat
-              additions={entry.additions}
-              deletions={entry.deletions}
-              className="font-mono"
-            />
-          </>
-        }
-        metaClassName="@container/pr-row-meta"
-        meta={
-          <>
-            {matchedElsewhere ? (
-              <Tooltip>
-                <TooltipTrigger
-                  render={
-                    <span className="flex min-w-6 items-center gap-1 overflow-hidden rounded-full border border-border/60 px-1 text-3xs" />
+              {entry.reviewDecision === undefined ? null : (
+                <PullRequestReviewDecisionGlyph decision={entry.reviewDecision} />
+              )}
+            </>
+          }
+          status={
+            <>
+              {entry.stack ? (
+                <PullRequestStackPopover
+                  environmentId={entry.environmentId}
+                  reference={{
+                    projectId: entry.projectId,
+                    host: entry.host,
+                    repository: entry.repository,
+                    number: entry.number,
+                  }}
+                  membership={entry.stack}
+                  onSelect={(target) =>
+                    onSelect({ ...target, host: entry.host, environmentId: entry.environmentId })
                   }
-                >
-                  <span className="sr-only">matched in the description</span>
-                  <SearchIcon aria-hidden className="size-3 shrink-0" />
-                  <span aria-hidden className="hidden truncate @xs/pr-row-meta:block">
-                    matched in the description
-                  </span>
-                </TooltipTrigger>
-                <TooltipPopup side="top">Matched in the description</TooltipPopup>
-              </Tooltip>
-            ) : null}
-            {showProvider ? (
-              <Tooltip>
-                <TooltipTrigger render={<span className="inline-flex shrink-0" />}>
-                  <Icon aria-label={providerName} className="size-3" />
-                </TooltipTrigger>
-                <TooltipPopup>{providerName}</TooltipPopup>
-              </Tooltip>
-            ) : null}
-            <PullRequestRowAuthor
-              actor={entry.author}
-              className="min-w-3.5 max-w-40"
-              labelClassName="sr-only @xs/pr-row-meta:not-sr-only @xs/pr-row-meta:truncate"
-            />
-            {showProjectTitle ? <span className="truncate">{entry.repository}</span> : null}
-            {environmentLabel ? (
-              <span className="min-w-0 max-w-32 truncate">{environmentLabel}</span>
-            ) : null}
-            {entry.labels.length > 0 ? <PullRequestRowLabels labels={entry.labels} /> : null}
-          </>
-        }
-        updatedAt={entry.updatedAt}
-      />
-    </button>
+                />
+              ) : null}
+              <PullRequestDiffStat
+                additions={entry.additions}
+                deletions={entry.deletions}
+                className="font-mono"
+              />
+            </>
+          }
+          metaClassName="@container/pr-row-meta"
+          meta={
+            <>
+              {matchedElsewhere ? (
+                <Tooltip>
+                  <TooltipTrigger
+                    render={
+                      <span className="flex min-w-6 items-center gap-1 overflow-hidden rounded-full border border-border/60 px-1 text-3xs" />
+                    }
+                  >
+                    <span className="sr-only">matched in the description</span>
+                    <SearchIcon aria-hidden className="size-3 shrink-0" />
+                    <span aria-hidden className="hidden truncate @xs/pr-row-meta:block">
+                      matched in the description
+                    </span>
+                  </TooltipTrigger>
+                  <TooltipPopup side="top">Matched in the description</TooltipPopup>
+                </Tooltip>
+              ) : null}
+              {showProvider ? (
+                <Tooltip>
+                  <TooltipTrigger render={<span className="inline-flex shrink-0" />}>
+                    <Icon aria-label={providerName} className="size-3" />
+                  </TooltipTrigger>
+                  <TooltipPopup>{providerName}</TooltipPopup>
+                </Tooltip>
+              ) : null}
+              <PullRequestRowAuthor
+                actor={entry.author}
+                className="min-w-3.5 max-w-40"
+                labelClassName="sr-only @xs/pr-row-meta:not-sr-only @xs/pr-row-meta:truncate"
+              />
+              {showProjectTitle ? <span className="truncate">{entry.repository}</span> : null}
+              {environmentLabel ? (
+                <span className="min-w-0 max-w-32 truncate">{environmentLabel}</span>
+              ) : null}
+              {entry.labels.length > 0 ? <PullRequestRowLabels labels={entry.labels} /> : null}
+            </>
+          }
+          updatedAt={entry.updatedAt}
+        />
+      </button>
+      {entry.state !== "merged" && entry.provider === "github" ? (
+        <PullRequestSpeedActions entry={entry} visible={speedMode} onActed={onActed} />
+      ) : null}
+    </div>
   );
 }
 
diff --git a/apps/web/src/components/pullRequest/PullRequestSpeedActions.tsx b/apps/web/src/components/pullRequest/PullRequestSpeedActions.tsx
new file mode 100644
index 000000000000..613928733d37
--- /dev/null
+++ b/apps/web/src/components/pullRequest/PullRequestSpeedActions.tsx
@@ -0,0 +1,135 @@
+import type { PullRequestAction } from "@t3tools/contracts";
+import { Effect } from "effect";
+import { AtomRegistry } from "effect/unstable/reactivity";
+import { appAtomRegistry } from "~/rpc/atomRegistry";
+import { pullRequestEnvironment, pullRequestStackAtom } from "~/state/pullRequests";
+import { useUiStateStore } from "~/uiStateStore";
+import { Button } from "../ui/button";
+import { Spinner } from "../ui/spinner";
+import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+import { resolvePullRequestMergeMethod } from "./pullRequestDetail.logic";
+import { PullRequestGlyph } from "./pullRequestIcons";
+import type { EnvironmentPullRequestEntry } from "./pullRequestList.logic";
+import {
+  usePullRequestActionRunner,
+  usePullRequestDefaultMergeMethodResolver,
+} from "./usePullRequestActions";
+
+export interface PullRequestSpeedActionResult {
+  readonly entry: EnvironmentPullRequestEntry;
+  readonly action: PullRequestAction;
+}
+
+/** No detail or stack reads until a merge is clicked, even on a long list. */
+export function PullRequestSpeedActions({
+  entry,
+  visible,
+  onActed,
+}: {
+  entry: EnvironmentPullRequestEntry;
+  visible: boolean;
+  onActed: (result: PullRequestSpeedActionResult) => void;
+}) {
+  const resolveProjectDefault = usePullRequestDefaultMergeMethodResolver(
+    entry.environmentId,
+    entry.projectId,
+  );
+  const reference = {
+    projectId: entry.projectId,
+    host: entry.host,
+    repository: entry.repository,
+    number: entry.number,
+  };
+  const { actionPending, perform } = usePullRequestActionRunner({
+    environmentId: entry.environmentId,
+    reference,
+    onSuccess: (action) => onActed({ entry, action }),
+    resolveMergeMethod: async () => {
+      const target = { environmentId: entry.environmentId, input: reference };
+      const detailAtom = pullRequestEnvironment.detail({
+        ...target,
+        input: { ...reference, allowStale: false },
+      });
+      appAtomRegistry.refresh(detailAtom);
+      const detail = await Effect.runPromise(
+        AtomRegistry.getResult(appAtomRegistry, detailAtom, { suspendOnWaiting: true }),
+      );
+      if (
+        detail.state !== "open" ||
+        detail.isDraft ||
+        !detail.capabilities.actions.includes("merge") ||
+        !detail.viewerPermissions.actions.includes("merge")
+      ) {
+        throw new Error("This pull request cannot be merged.");
+      }
+      if (detail.capabilities.stackActions) {
+        const stackAtom = pullRequestStackAtom(target);
+        appAtomRegistry.refresh(stackAtom);
+        const stack = await Effect.runPromise(
+          AtomRegistry.getResult(appAtomRegistry, stackAtom, { suspendOnWaiting: true }),
+        );
+        if (stack !== null) throw new Error("Open this pull request to merge its stack.");
+      }
+      const allowed = detail.capabilities.mergeMethods.filter(
+        (method) => detail.mergeCapabilities[method],
+      );
+      if (allowed.length === 0)
+        throw new Error("No merge method is available for this repository.");
+      return resolvePullRequestMergeMethod(
+        allowed,
+        null,
+        resolveProjectDefault(),
+        useUiStateStore.getState().pullRequestMergeMethod,
+      );
+    },
+  });
+  const actions =
+    entry.state === "closed"
+      ? (["reopen"] as const)
+      : entry.isDraft
+        ? (["close", "ready"] as const)
+        : (["close", "merge"] as const);
+  return (
+    <div
+      className="shrink-0 items-center gap-1 pr-3"
+      style={{ display: visible || actionPending ? "flex" : "none" }}
+      role="group"
+      aria-label={`Quick actions for pull request #${entry.number}`}
+    >
+      {actions.map((action) => {
+        const label = ACTIONS[action].label;
+        const Icon = ACTIONS[action].Icon;
+        return (
+          <Tooltip key={action}>
+            <TooltipTrigger
+              render={
+                <Button
+                  variant={action === "close" ? "destructive-outline" : "outline"}
+                  size="xs"
+                  disabled={actionPending || (action === "merge" && entry.stack !== undefined)}
+                  aria-label={`${label} #${entry.number}`}
+                  onClick={() => void perform(action)}
+                />
+              }
+            >
+              {actionPending ? <Spinner size="xs" /> : <Icon aria-hidden className="size-3" />}
+              {label}
+            </TooltipTrigger>
+            <TooltipPopup>
+              {action === "merge" && entry.stack
+                ? "Open this pull request to merge its stack"
+                : `${label} immediately`}
+            </TooltipPopup>
+          </Tooltip>
+        );
+      })}
+    </div>
+  );
+}
+
+const ACTIONS = {
+  close: { label: "Close", Icon: PullRequestGlyph.closed },
+  merge: { label: "Merge", Icon: PullRequestGlyph.merged },
+  ready: { label: "Ready for review", Icon: PullRequestGlyph.pullRequest },
+  reopen: { label: "Reopen", Icon: PullRequestGlyph.reopen },
+} as const;
diff --git a/apps/web/src/components/pullRequest/PullRequestThreadLinks.tsx b/apps/web/src/components/pullRequest/PullRequestThreadLinks.tsx
index ed692a81370e..0b168afc9867 100644
--- a/apps/web/src/components/pullRequest/PullRequestThreadLinks.tsx
+++ b/apps/web/src/components/pullRequest/PullRequestThreadLinks.tsx
@@ -50,8 +50,8 @@ function EnabledPullRequestThreadLinks({
   onPickerOpenChange,
 }: PullRequestThreadLinksProps) {
   const parsed = parseChangeRequestUrl(url);
-  const currentThreadRef = threadRef?.environmentId === environmentId ? threadRef : null;
-  const thread = useThreadShell(currentThreadRef);
+  const thread = useThreadShell(threadRef?.environmentId === environmentId ? threadRef : null);
+  const currentThreadRef = thread === null ? null : threadRef;
   const linking = usePullRequestLinking(environmentId);
   const linkedHere = linking.isLinked(thread, url);
   const relations = useEnvironmentQuery(
diff --git a/apps/web/src/components/pullRequest/pullRequestChecks.test.tsx b/apps/web/src/components/pullRequest/pullRequestChecks.test.tsx
index 48a371a7a9c0..b0e8c69517bc 100644
--- a/apps/web/src/components/pullRequest/pullRequestChecks.test.tsx
+++ b/apps/web/src/components/pullRequest/pullRequestChecks.test.tsx
@@ -102,6 +102,8 @@ function row(overrides: Partial<EnvironmentPullRequestEntry>): ReactNode {
     showProjectTitle: false,
     showProvider: false,
     onSelect: () => {},
+    speedMode: false,
+    onActed: () => {},
   });
 }
 
diff --git a/apps/web/src/components/pullRequest/usePullRequestActions.ts b/apps/web/src/components/pullRequest/usePullRequestActions.ts
index 3ba3b60bd90e..01c2789e8209 100644
--- a/apps/web/src/components/pullRequest/usePullRequestActions.ts
+++ b/apps/web/src/components/pullRequest/usePullRequestActions.ts
@@ -8,12 +8,23 @@ import { scopeProjectRef } from "@t3tools/client-runtime/environment";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import type {
   EnvironmentId,
+  ProjectId,
   PullRequestAction,
   PullRequestDetail,
   PullRequestMergeMethod,
   PullRequestRef,
 } from "@t3tools/contracts";
-import { useState } from "react";
+import { useCallback, useRef, useState } from "react";
+import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
+import { useClientSettings, useEnvironmentSettings } from "~/hooks/useSettings";
+import {
+  deriveLogicalProjectKeyFromSettings,
+  derivePhysicalProjectKey,
+  selectProjectGroupingSettings,
+} from "~/logicalProject";
+import { buildPhysicalToLogicalProjectKeyMap } from "~/sidebarProjectGrouping";
+import { useProjects } from "~/state/entities";
+import { usePrimaryEnvironmentId } from "~/state/environments";
 
 import { type DraftId, useComposerDraftStore } from "~/composerDraftStore";
 import { useNewThreadHandler } from "~/hooks/useHandleNewThread";
@@ -25,8 +36,48 @@ import { useAtomCommand } from "~/state/use-atom-command";
 import { toastManager } from "../ui/toast";
 import { handoffPrompt, handoffReviewComments, readableFailure } from "./pullRequestDetail.logic";
 
+/** Resolve on demand so hidden quick actions do not rebuild the legacy project grouping. */
+export function usePullRequestDefaultMergeMethodResolver(
+  environmentId: EnvironmentId,
+  projectId: ProjectId,
+) {
+  const projectDefault = useEnvironmentSettings(
+    environmentId,
+    (settings) => resolveProjectSettings(settings, projectId).settings.pullRequestMergeMethod,
+  );
+  const legacyOverrides = useClientSettings((settings) => settings.pullRequestMergeMethodOverrides);
+  const grouping = useClientSettings(selectProjectGroupingSettings);
+  const projects = useProjects();
+  const primaryEnvironmentId = usePrimaryEnvironmentId();
+  return useCallback(() => {
+    if (projectDefault != null) return projectDefault;
+    if (Object.keys(legacyOverrides).length === 0) return undefined;
+    const project = projects.find(
+      (candidate) => candidate.environmentId === environmentId && candidate.id === projectId,
+    );
+    if (!project) return undefined;
+    // Duplicate sidebar rows borrow their logical group key from their siblings.
+    const key =
+      buildPhysicalToLogicalProjectKeyMap({
+        projects,
+        settings: grouping,
+        primaryEnvironmentId,
+      }).get(derivePhysicalProjectKey(project)) ??
+      deriveLogicalProjectKeyFromSettings(project, grouping);
+    return legacyOverrides[key];
+  }, [
+    projectDefault,
+    projects,
+    environmentId,
+    projectId,
+    grouping,
+    primaryEnvironmentId,
+    legacyOverrides,
+  ]);
+}
+
 const ACTION_SUCCESS_LABELS: Record<PullRequestAction, string> = {
-  merge: "Pull request merged",
+  merge: "Merge requested",
   ready: "Marked ready for review",
   draft: "Converted to draft",
   close: "Pull request closed",
@@ -80,37 +131,41 @@ export function usePullRequestActionRunner({
   environmentId,
   reference,
   onSuccess,
+  resolveMergeMethod,
 }: {
   environmentId: EnvironmentId;
   reference: PullRequestRef | null;
   onSuccess?: (action: PullRequestAction) => void;
+  /** Small surfaces resolve repository settings on the click, not for every visible row. */
+  resolveMergeMethod?: () => Promise<PullRequestMergeMethod>;
 }) {
   const runAction = useAtomCommand(pullRequestEnvironment.runAction, { reportFailure: false });
   const [actionPending, setActionPending] = useState(false);
+  const pendingRef = useRef(false);
 
   const perform = async (action: PullRequestAction, method?: PullRequestMergeMethod) => {
-    if (actionPending || reference === null) return;
+    if (pendingRef.current || reference === null) return;
+    pendingRef.current = true;
     setActionPending(true);
-    const result = await runAction({
-      environmentId,
-      input: { ...reference, action, ...(method ? { mergeMethod: method } : {}) },
-    });
-    setActionPending(false);
-    if (result._tag === "Failure") {
-      // The host's own sentence, because it is the only thing that says why. A merge strategy a
-      // branch policy forbids is refused at completion and nowhere earlier — Azure DevOps
-      // publishes no per-strategy availability to hide the control with — so "action failed"
-      // would leave the reader pressing the same button again.
-      const failure = squashAtomCommandFailure(result);
+    try {
+      const mergeMethod = method ?? (action === "merge" ? await resolveMergeMethod?.() : undefined);
+      const result = await runAction({
+        environmentId,
+        input: { ...reference, action, ...(mergeMethod ? { mergeMethod } : {}) },
+      });
+      if (result._tag === "Failure") throw squashAtomCommandFailure(result);
+      toastManager.add({ type: "success", title: ACTION_SUCCESS_LABELS[action] });
+      onSuccess?.(action);
+    } catch (failure) {
       toastManager.add({
         type: "error",
         title: ACTION_FAILURE_LABELS[action],
         description: readableFailure(failure, ACTION_FAILURE_HINTS[action]),
       });
-      return;
+    } finally {
+      pendingRef.current = false;
+      setActionPending(false);
     }
-    toastManager.add({ type: "success", title: ACTION_SUCCESS_LABELS[action] });
-    onSuccess?.(action);
   };
 
   return { actionPending, perform };
diff --git a/apps/web/src/components/settings/ConnectionsSettings.tsx b/apps/web/src/components/settings/ConnectionsSettings.tsx
index e89ab5534659..29f4c39238d2 100644
--- a/apps/web/src/components/settings/ConnectionsSettings.tsx
+++ b/apps/web/src/components/settings/ConnectionsSettings.tsx
@@ -1,8 +1,10 @@
 import {
+  ChevronRightIcon,
   ChevronsLeftRightEllipsisIcon,
   EllipsisIcon,
   PlusIcon,
   QrCodeIcon,
+  RouteIcon,
   TerminalIcon,
 } from "lucide-react";
 import { useAtomValue } from "@effect/atom-react";
@@ -41,7 +43,12 @@ import {
   type EnvironmentId,
   resolveEnvironmentMachineKind,
 } from "@t3tools/contracts";
-import { connectionStatusText } from "@t3tools/client-runtime/connection";
+import {
+  RelayConnectionRegistration,
+  RelayConnectionTarget,
+  connectionRoutes,
+  connectionStatusText,
+} from "@t3tools/client-runtime/connection";
 import {
   isAtomCommandInterrupted,
   squashAtomCommandFailure,
@@ -69,6 +76,8 @@ import {
 import { LocalEnvironmentSetting } from "./LocalEnvironmentSetting";
 import { searchableSetting } from "./settingsSearch";
 import { EnvironmentIconMenu } from "./EnvironmentIconPicker";
+import { EnvironmentRoutesList } from "./EnvironmentRoutesList";
+import { usePreparedConnection } from "~/state/session";
 import {
   EnvironmentRow,
   environmentTransportLabel,
@@ -1436,6 +1445,7 @@ type SavedBackendListRowProps = {
   removingEnvironmentId: EnvironmentId | null;
   onSetEnabled: (environmentId: EnvironmentId, enabled: boolean) => void;
   onRemove: (environment: EnvironmentPresentation) => void;
+  onAddRoute: (environment: EnvironmentPresentation) => void;
 };
 
 /**
@@ -1487,7 +1497,9 @@ function SavedBackendListRow({
   removingEnvironmentId,
   onSetEnabled,
   onRemove,
+  onAddRoute,
 }: SavedBackendListRowProps) {
+  const [routesOpen, setRoutesOpen] = useState(false);
   const environmentId = environment.environmentId;
   const unsupported = environment.connection.phase === "unsupported";
   const enabled = environment.entry.enabled && !unsupported;
@@ -1542,8 +1554,13 @@ function SavedBackendListRow({
     environment.serverConfig ??
       (lastDescriptor === undefined ? null : { environment: lastDescriptor }),
   );
+  const prepared = usePreparedConnection(environmentId);
+  const routeCount = connectionRoutes(environment.entry).length;
   const subtitleText = [
-    environmentTransportLabel(environment),
+    environmentTransportLabel(
+      environment,
+      isConnected && prepared._tag === "Some" ? prepared.value.target : null,
+    ),
     resumingServerUpdate ? "Restarting" : status.text,
     enabled && versionMismatch ? serverVersion : null,
   ]
@@ -1576,26 +1593,49 @@ function SavedBackendListRow({
       label={environment.label}
       dimmed={!enabled}
       subtitle={
-        <Tooltip>
-          {/* The status can change while the tooltip is open, and base-ui only
-              re-measures the popup when the trigger's payload changes. */}
-          <TooltipTrigger
-            payload={statusTooltip}
-            render={
-              <span
-                className={cn(
-                  "block truncate",
-                  enabled && status.tone === "error" && !resumingServerUpdate && "text-destructive",
-                )}
-              />
-            }
+        <span className="flex min-w-0 items-center gap-1">
+          <Tooltip>
+            {/* The status can change while the tooltip is open, and base-ui only
+                re-measures the popup when the trigger's payload changes. */}
+            <TooltipTrigger
+              payload={statusTooltip}
+              render={
+                <span
+                  className={cn(
+                    "min-w-0 truncate",
+                    enabled &&
+                      status.tone === "error" &&
+                      !resumingServerUpdate &&
+                      "text-destructive",
+                  )}
+                />
+              }
+            >
+              {subtitleText}
+            </TooltipTrigger>
+            <TooltipPopup side="top" className="whitespace-pre-wrap">
+              {statusTooltip}
+            </TooltipPopup>
+          </Tooltip>
+          <span aria-hidden className="shrink-0">
+            ·
+          </span>
+          <button
+            type="button"
+            aria-expanded={routesOpen}
+            onClick={() => setRoutesOpen((open) => !open)}
+            className="inline-flex shrink-0 items-center gap-0.5 rounded-sm text-muted-foreground outline-none hover:text-foreground focus-visible:ring-1 focus-visible:ring-ring"
           >
-            {subtitleText}
-          </TooltipTrigger>
-          <TooltipPopup side="top" className="whitespace-pre-wrap">
-            {statusTooltip}
-          </TooltipPopup>
-        </Tooltip>
+            {routeCount === 1 ? "Routes" : `${routeCount} routes`}
+            <ChevronRightIcon
+              aria-hidden
+              className={cn(
+                "size-3 shrink-0 transition-transform duration-150 motion-reduce:transition-none",
+                routesOpen && "rotate-90",
+              )}
+            />
+          </button>
+        </span>
       }
       below={
         serverUpdateState.status !== "idle" ? (
@@ -1604,6 +1644,14 @@ function SavedBackendListRow({
           </div>
         ) : null
       }
+      detail={
+        routesOpen ? (
+          <EnvironmentRoutesList
+            environment={environment}
+            onAddRoute={() => onAddRoute(environment)}
+          />
+        ) : null
+      }
     >
       {unsupported &&
       environment.entry.serverUpdateRequired === true &&
@@ -1621,6 +1669,7 @@ function SavedBackendListRow({
           environmentId={environmentId}
           serverLabel={`${environment.label} server`}
           selfUpdate={resolveServerSelfUpdateCapability(environment.serverConfig)}
+          installation={environment.serverConfig?.environment.capabilities.serverInstallation}
           desktopAppUpdate={supportsDesktopAppUpdate(environment.serverConfig)}
           threadContinuation={supportsServerUpdateThreadContinuation(environment.serverConfig)}
           targetVersion={versionMismatch.clientVersion}
@@ -1663,6 +1712,10 @@ function SavedBackendListRow({
             environmentId={environmentId}
             serverConfig={environment.serverConfig}
           />
+          <MenuItem onClick={() => setRoutesOpen((open) => !open)}>
+            <RouteIcon />
+            {routesOpen ? "Hide routes" : "Routes"}
+          </MenuItem>
           {errorTraceId ? (
             <MenuItem onClick={() => copyTraceId(errorTraceId)}>Copy trace ID</MenuItem>
           ) : null}
@@ -1852,6 +1905,10 @@ export function ConnectionsSettings() {
     reportFailure: false,
   });
   const removeEnvironment = useAtomCommand(environmentCatalog.remove, { reportFailure: false });
+  const registerEnvironment = useAtomCommand(environmentCatalog.register, {
+    reportFailure: false,
+  });
+  const relayDiscoveryState = useRelayEnvironmentDiscovery();
   const setEnvironmentEnabled = useAtomCommand(environmentCatalog.setEnabled, {
     reportFailure: false,
   });
@@ -1921,6 +1978,7 @@ export function ConnectionsSettings() {
             environmentId: environment.environmentId,
             serverLabel: environment.label,
             selfUpdate,
+            installation: environment.serverConfig?.environment.capabilities.serverInstallation,
             desktopAppUpdate,
             threadContinuation: supportsServerUpdateThreadContinuation(environment.serverConfig),
             continueThreadsAfterServerUpdate:
@@ -1981,6 +2039,8 @@ export function ConnectionsSettings() {
   >(null);
   const [isRevokingOtherDesktopClients, setIsRevokingOtherDesktopClients] = useState(false);
   const [addBackendDialogOpen, setAddBackendDialogOpen] = useState(false);
+  // Set when the dialog adds a route to a saved machine instead of a new one.
+  const [routeTarget, setRouteTarget] = useState<EnvironmentPresentation | null>(null);
   const [savedBackendMode, setSavedBackendMode] = useState<"remote" | "ssh">("remote");
   const [savedBackendHost, setSavedBackendHost] = useState("");
   const [savedBackendPairingCode, setSavedBackendPairingCode] = useState("");
@@ -2323,7 +2383,11 @@ export function ConnectionsSettings() {
     async (target: DesktopSshEnvironmentTarget) => {
       setIsAddingSavedBackend(true);
       setSavedBackendError(null);
-      const result = await connectSshEnvironment({ target, label: "" });
+      const result = await connectSshEnvironment({
+        target,
+        label: "",
+        ...(routeTarget ? { expectedEnvironmentId: routeTarget.environmentId } : {}),
+      });
       if (result._tag === "Failure") {
         if (!isAtomCommandInterrupted(result)) {
           setSavedBackendError(formatDesktopSshConnectionError(squashAtomCommandFailure(result)));
@@ -2340,12 +2404,14 @@ export function ConnectionsSettings() {
       setAddBackendDialogOpen(false);
       toastManager.add({
         type: "success",
-        title: "Environment connected",
-        description: `${target.alias} is ready over an SSH-managed tunnel.`,
+        title: routeTarget ? "Route added" : "Environment connected",
+        description: routeTarget
+          ? `${routeTarget.label} can now be reached over SSH ${target.alias}.`
+          : `${target.alias} is ready over an SSH-managed tunnel.`,
       });
       setIsAddingSavedBackend(false);
     },
-    [connectSshEnvironment],
+    [connectSshEnvironment, routeTarget],
   );
 
   const handleAddSavedBackend = useCallback(async () => {
@@ -2388,7 +2454,10 @@ export function ConnectionsSettings() {
       return;
     }
 
-    const result = await connectPairing(remotePairingInput);
+    const result = await connectPairing({
+      ...remotePairingInput,
+      ...(routeTarget ? { expectedEnvironmentId: routeTarget.environmentId } : {}),
+    });
     if (result._tag === "Failure") {
       if (!isAtomCommandInterrupted(result)) {
         const error = squashAtomCommandFailure(result);
@@ -2412,13 +2481,22 @@ export function ConnectionsSettings() {
     setSavedBackendSshUsername("");
     setSavedBackendSshPort("");
     setAddBackendDialogOpen(false);
-    toastManager.add({
-      type: "success",
-      title: "Backend added",
-      description: "The environment is saved and will reconnect on app startup.",
-    });
+    toastManager.add(
+      routeTarget
+        ? {
+            type: "success",
+            title: "Route added",
+            description: `${routeTarget.label} now has another way to connect.`,
+          }
+        : {
+            type: "success",
+            title: "Backend added",
+            description: "The environment is saved and will reconnect on app startup.",
+          },
+    );
     setIsAddingSavedBackend(false);
   }, [
+    routeTarget,
     connectPairing,
     connectSavedBackendSshTarget,
     savedBackendHost,
@@ -2710,8 +2788,57 @@ export function ConnectionsSettings() {
       </div>
     </div>
   );
+  // T3 Connect is offered as a route when this account can reach the machine
+  // through it and it is not one of the machine's routes yet.
+  const relayRouteOffer =
+    routeTarget !== null &&
+    !routeTarget.relayManaged &&
+    relayDiscoveryState.environments.has(routeTarget.environmentId)
+      ? relayDiscoveryState.environments.get(routeTarget.environmentId)!.environment
+      : null;
+  const addRelayRoute = async () => {
+    if (relayRouteOffer === null || routeTarget === null) return;
+    setIsAddingSavedBackend(true);
+    const result = await registerEnvironment(
+      new RelayConnectionRegistration({
+        target: new RelayConnectionTarget({
+          environmentId: relayRouteOffer.environmentId,
+          label: routeTarget.label,
+        }),
+      }),
+    );
+    setIsAddingSavedBackend(false);
+    if (result._tag === "Failure") {
+      if (!isAtomCommandInterrupted(result)) {
+        const error = squashAtomCommandFailure(result);
+        setSavedBackendError(error instanceof Error ? error.message : "Could not add the route.");
+      }
+      return;
+    }
+    setAddBackendDialogOpen(false);
+    toastManager.add({
+      type: "success",
+      title: "Route added",
+      description: `${routeTarget.label} falls back to T3 Connect when its other routes are unreachable.`,
+    });
+  };
   const renderRemoteModeBody = () => (
     <div className="space-y-4">
+      {relayRouteOffer !== null ? (
+        <div className="flex items-center justify-between gap-3 rounded-md border border-border px-3 py-2">
+          <p className="text-xs text-muted-foreground">
+            This machine is on your T3 Connect account. Use it as a fallback route.
+          </p>
+          <Button
+            size="xs"
+            variant="outline"
+            disabled={isAddingSavedBackend}
+            onClick={() => void addRelayRoute()}
+          >
+            Add T3 Connect
+          </Button>
+        </div>
+      ) : null}
       {renderRemoteFields()}
       {savedBackendError ? <p className="text-xs text-destructive">{savedBackendError}</p> : null}
       <Button
@@ -2721,7 +2848,7 @@ export function ConnectionsSettings() {
         onClick={() => void handleAddSavedBackend()}
       >
         <PlusIcon className="size-3.5" />
-        {isAddingSavedBackend ? "Adding…" : "Add environment"}
+        {isAddingSavedBackend ? "Adding…" : routeTarget ? "Add route" : "Add environment"}
       </Button>
     </div>
   );
@@ -2842,7 +2969,7 @@ export function ConnectionsSettings() {
           onClick={() => void handleAddSavedBackend()}
         >
           <PlusIcon className="size-3.5" />
-          {isAddingSavedBackend ? "Adding…" : "Add environment"}
+          {isAddingSavedBackend ? "Adding…" : routeTarget ? "Add route" : "Add environment"}
         </Button>
       </div>
     </div>
@@ -3375,6 +3502,9 @@ export function ConnectionsSettings() {
                         primaryEnvironment ? `${primaryEnvironment.label} server` : "server"
                       }
                       selfUpdate={resolveServerSelfUpdateCapability(primaryServerConfig)}
+                      installation={
+                        primaryServerConfig?.environment.capabilities.serverInstallation
+                      }
                       desktopAppUpdate={supportsDesktopAppUpdate(primaryServerConfig)}
                       threadContinuation={supportsServerUpdateThreadContinuation(
                         primaryServerConfig,
@@ -3730,7 +3860,9 @@ export function ConnectionsSettings() {
               open={addBackendDialogOpen}
               onOpenChange={(open) => {
                 setAddBackendDialogOpen(open);
-                if (!open) {
+                if (open) {
+                  setRouteTarget(null);
+                } else {
                   setSavedBackendError(null);
                 }
               }}
@@ -3752,8 +3884,14 @@ export function ConnectionsSettings() {
               </Tooltip>
               <DialogPopup className="max-h-[80dvh] sm:max-w-3xl">
                 <DialogHeader>
-                  <DialogTitle>Add Environment</DialogTitle>
-                  <DialogDescription>Pair another environment to this client.</DialogDescription>
+                  <DialogTitle>
+                    {routeTarget ? `Add a route to ${routeTarget.label}` : "Add Environment"}
+                  </DialogTitle>
+                  <DialogDescription>
+                    {routeTarget
+                      ? "Pair this machine again over another address, such as its Tailscale name. It joins the existing routes instead of adding a second machine."
+                      : "Pair another environment to this client."}
+                  </DialogDescription>
                 </DialogHeader>
                 <DialogPanel>
                   <div className="space-y-4">
@@ -3791,6 +3929,11 @@ export function ConnectionsSettings() {
             removingEnvironmentId={removingSavedEnvironmentId}
             onSetEnabled={handleSetSavedBackendEnabled}
             onRemove={handleRemoveSavedBackend}
+            onAddRoute={(target) => {
+              setRouteTarget(target);
+              setSavedBackendError(null);
+              setAddBackendDialogOpen(true);
+            }}
           />
         ))}
         <CloudRemoteEnvironmentRows
diff --git a/apps/web/src/components/settings/EnvironmentRoutesList.tsx b/apps/web/src/components/settings/EnvironmentRoutesList.tsx
new file mode 100644
index 000000000000..9bf096688006
--- /dev/null
+++ b/apps/web/src/components/settings/EnvironmentRoutesList.tsx
@@ -0,0 +1,222 @@
+import {
+  DndContext,
+  type DragEndEvent,
+  KeyboardSensor,
+  PointerSensor,
+  closestCenter,
+  useSensor,
+  useSensors,
+} from "@dnd-kit/core";
+import { restrictToParentElement, restrictToVerticalAxis } from "@dnd-kit/modifiers";
+import {
+  SortableContext,
+  arrayMove,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy,
+} from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import {
+  type ConnectionRoute,
+  connectionRouteAddress,
+  connectionRouteId,
+  connectionRouteLabel,
+  connectionRoutes,
+  isLearned,
+} from "@t3tools/client-runtime/connection";
+import { GripVerticalIcon, PlusIcon, XIcon } from "lucide-react";
+import { useState } from "react";
+
+import { requestConfirmDialog } from "~/confirmDialog";
+import { environmentCatalog } from "~/connection/catalog";
+import { cn } from "~/lib/utils";
+import type { EnvironmentPresentation } from "~/state/environments";
+import { usePreparedConnection } from "~/state/session";
+import { useAtomCommand } from "~/state/use-atom-command";
+import { Button } from "../ui/button";
+import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
+
+/**
+ * The ways this client reaches one saved machine, preferred first. Drag to
+ * reorder; the first route that answers is used and the connection moves back
+ * up when a better one is reachable again. Shown under the machine's row.
+ */
+export function EnvironmentRoutesList({
+  environment,
+  onAddRoute,
+}: {
+  readonly environment: EnvironmentPresentation;
+  readonly onAddRoute: () => void;
+}) {
+  const saved = connectionRoutes(environment.entry);
+  const savedIds = saved.map((route) => connectionRouteId(route.target));
+  // A dropped order shows until the catalog matches it, so the row does not
+  // jump back while the reorder is being saved.
+  const [pending, setPending] = useState<ReadonlyArray<string> | null>(null);
+  const order: Array<string> =
+    pending !== null &&
+    pending.length === savedIds.length &&
+    pending.some((id, index) => id !== savedIds[index])
+      ? [...pending]
+      : savedIds;
+  const byId = new Map(saved.map((route) => [connectionRouteId(route.target), route]));
+  const routes = order.flatMap((id) => byId.get(id) ?? []);
+
+  const prepared = usePreparedConnection(environment.environmentId);
+  const activeRouteId =
+    prepared._tag === "Some" && environment.connection.phase === "connected"
+      ? connectionRouteId(prepared.value.target)
+      : null;
+  const reorder = useAtomCommand(environmentCatalog.reorderRoutes, "Reorder routes");
+  const removeRoute = useAtomCommand(environmentCatalog.removeRoute, "Remove route");
+  const sensors = useSensors(
+    useSensor(PointerSensor, { activationConstraint: { distance: 4 } }),
+    useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
+  );
+
+  // Removing a paired route forgets its credential, so it asks first, like
+  // on mobile. No mounted confirm host means no removal.
+  const confirmRemove = async (route: ConnectionRoute) => {
+    const address = connectionRouteAddress(route);
+    const confirmed = await requestConfirmDialog(
+      `Remove ${connectionRouteLabel(route)} route?${address === null ? "" : `\n${address}`}`,
+      { variant: "destructive" },
+    );
+    if (confirmed !== true) return;
+    await removeRoute({
+      environmentId: environment.environmentId,
+      routeId: connectionRouteId(route.target),
+    });
+  };
+
+  const handleDragEnd = (event: DragEndEvent) => {
+    if (event.over === null || event.active.id === event.over.id) return;
+    const next = arrayMove(
+      order,
+      order.indexOf(String(event.active.id)),
+      order.indexOf(String(event.over.id)),
+    );
+    setPending(next);
+    void reorder({ environmentId: environment.environmentId, routeIds: next }).then((result) => {
+      if (result._tag === "Failure") setPending(null);
+    });
+  };
+
+  return (
+    <div className="mt-2 rounded-md border border-border/70">
+      <DndContext
+        sensors={sensors}
+        collisionDetection={closestCenter}
+        modifiers={[restrictToVerticalAxis, restrictToParentElement]}
+        onDragEnd={handleDragEnd}
+      >
+        <SortableContext items={order} strategy={verticalListSortingStrategy}>
+          <ol aria-label={`Routes to ${environment.label}, preferred first`}>
+            {routes.map((route, index) => (
+              <SortableRouteRow
+                key={connectionRouteId(route.target)}
+                route={route}
+                position={index + 1}
+                inUse={connectionRouteId(route.target) === activeRouteId}
+                // The last route goes with the machine; that is "Remove from
+                // this device", not a route action. A learned route would be
+                // learned again, so it is only reordered.
+                removable={routes.length > 1 && !isLearned(route)}
+                onRemove={() => void confirmRemove(route)}
+              />
+            ))}
+          </ol>
+        </SortableContext>
+      </DndContext>
+      <div className="border-t border-border/70 px-1 py-1">
+        <Button size="xs" variant="ghost-muted" onClick={onAddRoute}>
+          <PlusIcon className="size-3" />
+          Add route
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+function SortableRouteRow({
+  route,
+  position,
+  inUse,
+  removable,
+  onRemove,
+}: {
+  readonly route: ConnectionRoute;
+  readonly position: number;
+  readonly inUse: boolean;
+  readonly removable: boolean;
+  readonly onRemove: () => void;
+}) {
+  const id = connectionRouteId(route.target);
+  const label = connectionRouteLabel(route);
+  const address = connectionRouteAddress(route);
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    setActivatorNodeRef,
+    transform,
+    transition,
+    isDragging,
+  } = useSortable({ id });
+
+  return (
+    <li
+      ref={setNodeRef}
+      style={{ transform: CSS.Translate.toString(transform), transition }}
+      className={cn(
+        "flex items-center gap-2 border-b border-border/70 px-1 py-1.5 last:border-b-0",
+        isDragging && "relative z-10 rounded-md bg-background shadow-md",
+      )}
+    >
+      <button
+        type="button"
+        ref={setActivatorNodeRef}
+        {...attributes}
+        {...listeners}
+        aria-label={`Reorder ${label}, position ${position}`}
+        className="flex size-6 shrink-0 cursor-grab touch-none items-center justify-center rounded text-muted-foreground/70 outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring active:cursor-grabbing"
+      >
+        <GripVerticalIcon className="size-3.5" />
+      </button>
+      <div className="min-w-0 flex-1">
+        <p className="flex items-center gap-1.5 text-xs font-medium text-foreground">
+          {label}
+          {inUse ? (
+            <span className="rounded-sm bg-success/12 px-1 text-2xs font-normal text-success-foreground">
+              In use
+            </span>
+          ) : null}
+        </p>
+        {address !== null ? (
+          <p className="truncate text-2xs text-muted-foreground">
+            {address}
+            {isLearned(route) ? " · found automatically" : ""}
+          </p>
+        ) : null}
+      </div>
+      {removable ? (
+        <Tooltip>
+          <TooltipTrigger
+            render={
+              <Button
+                type="button"
+                variant="ghost-muted"
+                size="icon-xs"
+                aria-label={`Remove ${label} route`}
+                onClick={onRemove}
+              />
+            }
+          >
+            <XIcon className="size-3" />
+          </TooltipTrigger>
+          <TooltipPopup side="top">Remove route</TooltipPopup>
+        </Tooltip>
+      ) : null}
+    </li>
+  );
+}
diff --git a/apps/web/src/components/settings/EnvironmentRow.tsx b/apps/web/src/components/settings/EnvironmentRow.tsx
index 5f3dae7e47c1..a855c9aadf70 100644
--- a/apps/web/src/components/settings/EnvironmentRow.tsx
+++ b/apps/web/src/components/settings/EnvironmentRow.tsx
@@ -1,3 +1,9 @@
+import {
+  type ConnectionTarget,
+  connectionRouteId,
+  connectionRouteLabel,
+  connectionRoutes,
+} from "@t3tools/client-runtime/connection";
 import type { DesktopSshEnvironmentTarget, EnvironmentMachineKind } from "@t3tools/contracts";
 import * as Option from "effect/Option";
 import type { ReactNode } from "react";
@@ -15,10 +21,26 @@ export function formatDesktopSshTarget(target: DesktopSshEnvironmentTarget): str
 /**
  * How this client reaches a machine, printed first in every environment row so
  * T3 Connect, SSH, WSL, and plain remote links are told apart without a legend.
+ * A machine with several routes names the one in use, or how many it has.
  */
-export function environmentTransportLabel(environment: EnvironmentPresentation): string {
+export function environmentTransportLabel(
+  environment: EnvironmentPresentation,
+  activeTarget: ConnectionTarget | null = null,
+): string {
   const { entry } = environment;
   if (entry.target._tag === "PrimaryConnectionTarget") return "This machine";
+  const routes = connectionRoutes(entry);
+  if (routes.length > 1) {
+    const active =
+      activeTarget === null
+        ? undefined
+        : routes.find(
+            (route) => connectionRouteId(route.target) === connectionRouteId(activeTarget),
+          );
+    return active === undefined
+      ? connectionRouteLabel(routes[0]!)
+      : `via ${connectionRouteLabel(active)}`;
+  }
   if (environment.relayManaged) return "T3 Connect";
   if (isDesktopLocalConnectionTarget(entry.target)) return "WSL";
   if (
@@ -41,6 +63,7 @@ export function EnvironmentRow({
   label,
   subtitle,
   below,
+  detail,
   dimmed = false,
   className,
   children,
@@ -50,6 +73,8 @@ export function EnvironmentRow({
   readonly subtitle: ReactNode;
   /** Extra content under the subtitle, such as update progress. */
   readonly below?: ReactNode;
+  /** Expanded content under the whole row, aligned with the label, such as its routes. */
+  readonly detail?: ReactNode;
   readonly dimmed?: boolean;
   readonly className?: string;
   readonly children?: ReactNode;
@@ -69,6 +94,7 @@ export function EnvironmentRow({
         {below}
       </div>
       <div className="flex shrink-0 items-center gap-1">{children}</div>
+      {detail ? <div className="col-span-2 col-start-2 min-w-0">{detail}</div> : null}
     </div>
   );
 }
diff --git a/apps/web/src/components/settings/FontFamilyPicker.tsx b/apps/web/src/components/settings/FontFamilyPicker.tsx
index b7e43eef8209..086de86e3aa9 100644
--- a/apps/web/src/components/settings/FontFamilyPicker.tsx
+++ b/apps/web/src/components/settings/FontFamilyPicker.tsx
@@ -12,6 +12,7 @@ import {
   ComboboxTrigger,
 } from "../ui/combobox";
 import { SelectButton } from "../ui/select";
+import { stackedThreadToast, toastManager } from "../ui/toast";
 
 const DEFAULT_FONT_VALUE = "__default__";
 
@@ -141,8 +142,8 @@ export function FontFamilyPicker({
 
   const families = useMemo(() => {
     if (enumeration.status !== "granted") return [];
-    return requireMonospace ? enumeration.families.filter(isMonospaceFamily) : enumeration.families;
-  }, [enumeration, requireMonospace]);
+    return enumeration.families;
+  }, [enumeration]);
 
   const items = useMemo(() => {
     const trimmedQuery = query.trim().toLowerCase();
@@ -160,6 +161,16 @@ export function FontFamilyPicker({
 
   const handlePick = (value: string) => {
     setOpen(false);
+    if (value !== DEFAULT_FONT_VALUE && requireMonospace && !isMonospaceFamily(value)) {
+      toastManager.add(
+        stackedThreadToast({
+          type: "error",
+          title: `"${value}" isn't monospace`,
+          description: "Code and terminal need a fixed-width font, so the current font was kept.",
+        }),
+      );
+      return;
+    }
     onSelect(value === DEFAULT_FONT_VALUE ? "" : value);
   };
 
diff --git a/apps/web/src/components/settings/IntegrationsSettings.tsx b/apps/web/src/components/settings/IntegrationsSettings.tsx
index f77cfcc25768..f9dfb47c5f9b 100644
--- a/apps/web/src/components/settings/IntegrationsSettings.tsx
+++ b/apps/web/src/components/settings/IntegrationsSettings.tsx
@@ -646,10 +646,18 @@ function DeviceIntegrationControls({
     "hub" | "check" | "agent" | "update-hub" | "update-agent" | null
   >(null);
   const busy = state.hostStatus === "installing" || state.hostStatus === "starting";
+  const localPlatformsUnavailable = state.hosts.some(
+    (host) => host.kind === "local" && !host.platforms.some((platform) => platform.available),
+  );
   const [platformsRevealed, setPlatformsRevealed] = useState(false);
   // Keep diagnostics visible through subsequent agent setup and refresh phases.
   if (platformsRevealed && !enabled) setPlatformsRevealed(false);
-  if (enabled && !platformsRevealed && state.hostStatus === "ready" && pending !== "hub") {
+  if (
+    enabled &&
+    !platformsRevealed &&
+    (state.hostStatus === "ready" || localPlatformsUnavailable) &&
+    pending !== "hub"
+  ) {
     setPlatformsRevealed(true);
   }
 
diff --git a/apps/web/src/components/settings/ProviderInstanceCard.tsx b/apps/web/src/components/settings/ProviderInstanceCard.tsx
index 226043c7ce1f..415ebb97c029 100644
--- a/apps/web/src/components/settings/ProviderInstanceCard.tsx
+++ b/apps/web/src/components/settings/ProviderInstanceCard.tsx
@@ -593,7 +593,11 @@ export function ProviderInstanceCard({
     compatibility.status !== "supported" &&
     compatibility.status !== "unknown";
   const VersionAdvisoryIcon = hasCompatibilityWarning ? AlertTriangleIcon : ArrowUpCircleIcon;
-  const onRunVersionAction = versionAdvisory?.targetVersion ? onInstallRecommended : onRunUpdate;
+  const onRunVersionAction = readOnly
+    ? undefined
+    : versionAdvisory?.targetVersion
+      ? onInstallRecommended
+      : onRunUpdate;
   const urlAuthAction = liveProvider?.auth.action;
   const displayName =
     instance.displayName?.trim() || driverOption?.label || String(instance.driver);
@@ -765,6 +769,101 @@ export function ProviderInstanceCard({
         ) : null}
       </>
     );
+  const versionAdvisoryNode = versionAdvisory ? (
+    <Popover>
+      <Tooltip>
+        <TooltipTrigger
+          render={
+            <PopoverTrigger
+              render={
+                <Button
+                  type="button"
+                  size={mode === "list" ? "icon-micro" : "icon-xs"}
+                  variant="ghost-muted"
+                  className={mode === "list" ? "pointer-events-auto relative shrink-0" : undefined}
+                  aria-label={`${versionAdvisory.title} — view details`}
+                >
+                  <VersionAdvisoryIcon
+                    className={cn(
+                      mode === "list" && "size-3.5",
+                      hasCompatibilityWarning && "text-warning",
+                    )}
+                  />
+                </Button>
+              }
+            />
+          }
+        />
+        <TooltipPopup side="top">{versionAdvisory.title}</TooltipPopup>
+      </Tooltip>
+      <PopoverPopup side="bottom" align="end" width="md" aria-label={versionAdvisory.title}>
+        <div className="grid min-w-0 gap-3">
+          <div className="grid gap-0.5">
+            <p className="text-sm font-semibold leading-tight text-foreground">
+              {versionAdvisory.title}
+            </p>
+            <p
+              className={cn(
+                "text-xs leading-snug",
+                versionAdvisory.emphasis === "strong" ? "text-warning" : "text-muted-foreground",
+              )}
+            >
+              {versionAdvisory.detail}
+            </p>
+          </div>
+          {onRunVersionAction ? (
+            <Button
+              type="button"
+              size="xs"
+              variant="outline"
+              className="w-full"
+              disabled={isUpdating}
+              onClick={onRunVersionAction}
+            >
+              {isUpdating ? <Spinner /> : <DownloadIcon />}
+              {isUpdating
+                ? "Updating"
+                : versionAdvisory.targetVersion
+                  ? `Install ${getProviderVersionLabel(versionAdvisory.targetVersion)}`
+                  : "Update now"}
+            </Button>
+          ) : null}
+          {onRunVersionAction && updateCommand ? (
+            <div className="flex items-center gap-2 text-3xs font-medium uppercase tracking-wider text-muted-foreground">
+              <span aria-hidden className="h-px flex-1 bg-border" />
+              or, update manually using
+              <span aria-hidden className="h-px flex-1 bg-border" />
+            </div>
+          ) : null}
+          {updateCommand ? (
+            <div className="flex min-w-0 items-center gap-1 rounded-md border border-border/70 bg-muted/40 py-0.5 pr-0.5 pl-2">
+              <code className="min-w-0 flex-1 truncate font-mono text-2xs text-foreground">
+                {updateCommand}
+              </code>
+              <Tooltip>
+                <TooltipTrigger
+                  render={
+                    <Button
+                      type="button"
+                      size="icon-xs"
+                      variant="ghost-muted"
+                      className="shrink-0"
+                      onClick={() => copyToClipboard(updateCommand, { providerName: displayName })}
+                      aria-label="Copy update command"
+                    >
+                      <CopyIcon className="size-3" />
+                    </Button>
+                  }
+                />
+                <TooltipPopup side="top">Copy command</TooltipPopup>
+              </Tooltip>
+            </div>
+          ) : null}
+        </div>
+      </PopoverPopup>
+    </Popover>
+  ) : null;
+
   if (mode === "list") {
     return (
       <div
@@ -796,49 +895,7 @@ export function ProviderInstanceCard({
                   {versionLabel}
                 </code>
               ) : null}
-              {versionAdvisory ? (
-                hasCompatibilityWarning ? (
-                  <Tooltip>
-                    <TooltipTrigger
-                      render={
-                        <span
-                          tabIndex={0}
-                          role="img"
-                          aria-label={versionAdvisory.title}
-                          className="pointer-events-auto relative inline-flex shrink-0 text-warning"
-                        >
-                          <VersionAdvisoryIcon className="size-3.5" />
-                        </span>
-                      }
-                    />
-                    <TooltipPopup side="top">{versionAdvisory.detail}</TooltipPopup>
-                  </Tooltip>
-                ) : updateCommand ? (
-                  <Tooltip>
-                    <TooltipTrigger
-                      render={
-                        <Button
-                          type="button"
-                          size="icon-micro"
-                          variant="ghost-muted"
-                          className="pointer-events-auto relative shrink-0"
-                          aria-label={`Copy ${displayName} update command`}
-                          onClick={() =>
-                            copyToClipboard(updateCommand, { providerName: displayName })
-                          }
-                        >
-                          <ArrowUpCircleIcon className="size-3.5" />
-                        </Button>
-                      }
-                    />
-                    <TooltipPopup side="top">Copy update command</TooltipPopup>
-                  </Tooltip>
-                ) : (
-                  <span role="img" aria-label="Update available" className="inline-flex shrink-0">
-                    <ArrowUpCircleIcon className="size-3.5 text-muted-foreground" />
-                  </span>
-                )
-              ) : null}
+              {versionAdvisoryNode}
             </span>
             <span className="mt-0.5 flex items-start gap-1.5 text-xs leading-normal text-muted-foreground/80">
               {statusDotNode ? (
@@ -876,105 +933,12 @@ export function ProviderInstanceCard({
         </Badge>
       ) : null}
       {versionCodeNode}
+      {versionAdvisoryNode}
       <span
         inert={readOnly}
         aria-disabled={readOnly || undefined}
         className={cn("inline-flex items-center gap-1", readOnly && "opacity-50")}
       >
-        {versionAdvisory ? (
-          <Popover>
-            <Tooltip>
-              <TooltipTrigger
-                render={
-                  <PopoverTrigger
-                    render={
-                      <Button
-                        type="button"
-                        size="icon-xs"
-                        variant="ghost-muted"
-                        aria-label={`${versionAdvisory.title} — view details`}
-                      >
-                        <VersionAdvisoryIcon
-                          className={cn(hasCompatibilityWarning && "text-warning")}
-                        />
-                      </Button>
-                    }
-                  />
-                }
-              />
-              <TooltipPopup side="top">{versionAdvisory.title}</TooltipPopup>
-            </Tooltip>
-            <PopoverPopup side="bottom" align="end" width="md">
-              <div className="grid min-w-0 gap-3">
-                <div className="grid gap-0.5">
-                  <p className="text-sm font-semibold leading-tight text-foreground">
-                    {versionAdvisory.title}
-                  </p>
-                  <p
-                    className={cn(
-                      "text-xs leading-snug",
-                      versionAdvisory.emphasis === "strong"
-                        ? "text-warning"
-                        : "text-muted-foreground",
-                    )}
-                  >
-                    {versionAdvisory.detail}
-                  </p>
-                </div>
-                {onRunVersionAction ? (
-                  <Button
-                    type="button"
-                    size="xs"
-                    variant="outline"
-                    className="w-full"
-                    disabled={isUpdating}
-                    onClick={onRunVersionAction}
-                  >
-                    {isUpdating ? <Spinner /> : <DownloadIcon />}
-                    {isUpdating
-                      ? "Updating"
-                      : versionAdvisory.targetVersion
-                        ? `Install ${getProviderVersionLabel(versionAdvisory.targetVersion)}`
-                        : "Update now"}
-                  </Button>
-                ) : null}
-                {onRunVersionAction && updateCommand ? (
-                  <div className="flex items-center gap-2 text-3xs font-medium uppercase tracking-wider text-muted-foreground">
-                    <span aria-hidden className="h-px flex-1 bg-border" />
-                    or, update manually using
-                    <span aria-hidden className="h-px flex-1 bg-border" />
-                  </div>
-                ) : null}
-                {updateCommand ? (
-                  <div className="flex min-w-0 items-center gap-1 rounded-md border border-border/70 bg-muted/40 py-0.5 pr-0.5 pl-2">
-                    <code className="min-w-0 flex-1 truncate font-mono text-2xs text-foreground">
-                      {updateCommand}
-                    </code>
-                    <Tooltip>
-                      <TooltipTrigger
-                        render={
-                          <Button
-                            type="button"
-                            size="icon-xs"
-                            variant="ghost-muted"
-                            className="shrink-0"
-                            onClick={() =>
-                              copyToClipboard(updateCommand, { providerName: displayName })
-                            }
-                            aria-label="Copy update command"
-                          >
-                            <CopyIcon className="size-3" />
-                          </Button>
-                        }
-                      />
-                      <TooltipPopup side="top">Copy command</TooltipPopup>
-                    </Tooltip>
-                  </div>
-                ) : null}
-              </div>
-            </PopoverPopup>
-          </Popover>
-        ) : null}
         {titleTailNode}
         {onDelete ? (
           <Button
diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.tsx
index 0f0f8a337290..41fd9efb5da4 100644
--- a/apps/web/src/components/settings/ProviderSettingsPanel.tsx
+++ b/apps/web/src/components/settings/ProviderSettingsPanel.tsx
@@ -1164,7 +1164,7 @@ export function EnvironmentProviderSettings({
           })
         }
         onInstallRecommended={
-          mode === "editor" &&
+          !readOnly &&
           liveProvider?.compatibilityAdvisory?.message &&
           liveProvider.compatibilityAdvisory.recommendedVersion &&
           liveProvider.versionAdvisory?.canInstallVersion
@@ -1177,13 +1177,13 @@ export function EnvironmentProviderSettings({
             : undefined
         }
         onRunUpdate={
-          mode === "editor" && showInlineUpdateButton && updateCandidate
+          !readOnly && showInlineUpdateButton && updateCandidate
             ? () => {
                 if (canRunInlineUpdate) void runProviderUpdate(updateCandidate);
               }
             : undefined
         }
-        isUpdating={mode === "editor" ? isInstanceUpdateRunning : undefined}
+        isUpdating={isInstanceUpdateRunning}
       />
     );
   };
diff --git a/apps/web/src/components/ui/tooltip.tsx b/apps/web/src/components/ui/tooltip.tsx
index 7ba9e4c238c4..1017a787931f 100644
--- a/apps/web/src/components/ui/tooltip.tsx
+++ b/apps/web/src/components/ui/tooltip.tsx
@@ -1,13 +1,83 @@
 import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+import { createContext, use, useEffect, useRef, type ComponentProps, type RefObject } from "react";
 
 import { cn } from "~/lib/utils";
 
 const TooltipProvider = TooltipPrimitive.Provider;
 
-const Tooltip = TooltipPrimitive.Root;
+type TooltipActionsRef = RefObject<TooltipPrimitive.Root.Actions | null>;
+const TooltipHoverContext = createContext<TooltipActionsRef | null>(null);
+const TooltipScrollContext = createContext<RefObject<{
+  trigger: HTMLElement;
+  actionsRef: TooltipActionsRef;
+} | null> | null>(null);
+
+/** Dismisses hovered descendants on real scroll events without rerendering the timeline. */
+function TooltipScrollDismissArea({ onScrollCapture, ...props }: ComponentProps<"div">) {
+  const hovered = useRef<{ trigger: HTMLElement; actionsRef: TooltipActionsRef } | null>(null);
+  return (
+    <TooltipScrollContext value={hovered}>
+      <div
+        {...props}
+        onScrollCapture={(event) => {
+          onScrollCapture?.(event);
+          const tooltip = hovered.current;
+          if (!tooltip || tooltip.trigger.contains(tooltip.trigger.ownerDocument.activeElement)) {
+            return;
+          }
+          hovered.current = null;
+          // Base UI also cancels delayed hover opens through this action.
+          tooltip.actionsRef.current?.close();
+        }}
+      />
+    </TooltipScrollContext>
+  );
+}
+
+function Tooltip<Payload>(props: TooltipPrimitive.Root.Props<Payload>) {
+  const hovered = use(TooltipScrollContext);
+  const localActionsRef = useRef<TooltipPrimitive.Root.Actions | null>(null);
+  const actionsRef = props.actionsRef ?? localActionsRef;
+  useEffect(
+    () => () => {
+      if (hovered?.current?.actionsRef === actionsRef) hovered.current = null;
+    },
+    [actionsRef, hovered],
+  );
+
+  if (!hovered) return <TooltipPrimitive.Root {...props} />;
+  return (
+    <TooltipHoverContext value={actionsRef}>
+      <TooltipPrimitive.Root
+        {...props}
+        actionsRef={actionsRef}
+        onOpenChange={(open, details) => {
+          props.onOpenChange?.(open, details);
+          if (!open && !details.isCanceled && hovered.current?.actionsRef === actionsRef) {
+            hovered.current = null;
+          }
+        }}
+      />
+    </TooltipHoverContext>
+  );
+}
 
 function TooltipTrigger(props: TooltipPrimitive.Trigger.Props) {
-  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+  const hovered = use(TooltipScrollContext);
+  const actionsRef = use(TooltipHoverContext);
+  if (!hovered || !actionsRef) {
+    return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />;
+  }
+  return (
+    <TooltipPrimitive.Trigger
+      data-slot="tooltip-trigger"
+      {...props}
+      onMouseEnter={(event) => {
+        props.onMouseEnter?.(event);
+        hovered.current = { trigger: event.currentTarget, actionsRef };
+      }}
+    />
+  );
 }
 
 function TooltipPopup({
@@ -64,4 +134,4 @@ function TooltipPopup({
   );
 }
 
-export { TooltipProvider, Tooltip, TooltipTrigger, TooltipPopup };
+export { TooltipProvider, Tooltip, TooltipTrigger, TooltipPopup, TooltipScrollDismissArea };
diff --git a/apps/web/src/connection/onboarding.ts b/apps/web/src/connection/onboarding.ts
index 5fcce05a9d07..c4368b0b77e9 100644
--- a/apps/web/src/connection/onboarding.ts
+++ b/apps/web/src/connection/onboarding.ts
@@ -30,7 +30,7 @@ export const connectSshEnvironment = createRuntimeCommand(connectionAtomRuntime,
     mode: "serial",
     key: (input: { readonly target: DesktopSshEnvironmentTarget }) => JSON.stringify(input.target),
   },
-  execute: (input: { readonly target: DesktopSshEnvironmentTarget; readonly label?: string }) =>
+  execute: (input: ConnectionOnboarding.SshConnectionInput) =>
     ConnectionOnboarding.ConnectionOnboarding.pipe(
       Effect.flatMap((onboarding) => onboarding.registerSsh(input)),
     ),
diff --git a/apps/web/src/connection/platform.test.ts b/apps/web/src/connection/platform.test.ts
index b31634705368..ee45e2932e39 100644
--- a/apps/web/src/connection/platform.test.ts
+++ b/apps/web/src/connection/platform.test.ts
@@ -83,6 +83,21 @@ describe("desktop SSH pairing", () => {
     }),
   );
 
+  it.effect("does not consume the credential when adding a route to a different machine", () =>
+    Effect.gen(function* () {
+      const calls: string[] = [];
+
+      const error = yield* provisionDesktopSshEnvironment(
+        makeBridge(calls),
+        TARGET,
+        EnvironmentId.make("some-other-machine"),
+      ).pipe(Effect.flip);
+
+      expect(error).toMatchObject({ reason: "configuration" });
+      expect(calls).toEqual(["ensure", "descriptor"]);
+    }),
+  );
+
   it.effect("does not consume the credential when descriptor discovery fails", () =>
     Effect.gen(function* () {
       const calls: string[] = [];
diff --git a/apps/web/src/connection/platform.ts b/apps/web/src/connection/platform.ts
index 7355283876a2..4b5ce7fb4bd9 100644
--- a/apps/web/src/connection/platform.ts
+++ b/apps/web/src/connection/platform.ts
@@ -27,6 +27,7 @@ import {
   type DesktopBridge,
   type DesktopEnvironmentBootstrap,
   type DesktopSshEnvironmentTarget,
+  type EnvironmentId,
   PRIMARY_LOCAL_ENVIRONMENT_ID,
 } from "@t3tools/contracts";
 import * as Clock from "effect/Clock";
@@ -88,28 +89,68 @@ const connectivityLayer = Connectivity.layer({
   ),
 });
 
+interface NetworkInformationLike extends EventTarget {
+  readonly type?: string;
+}
+
+/**
+ * Wakes connections when the browser reports a different network type, such
+ * as a laptop moving from Wi-Fi to a phone hotspot. `change` also fires for
+ * bandwidth and latency estimates on the same network, so only a type change
+ * counts. Browsers without `navigator.connection.type` rely on the periodic
+ * route check instead.
+ */
+const networkPathChanges = Stream.callback<"network-changed">((queue) =>
+  Effect.acquireRelease(
+    Effect.sync(() => {
+      const connection =
+        typeof navigator === "undefined"
+          ? undefined
+          : (navigator as Navigator & { readonly connection?: NetworkInformationLike }).connection;
+      if (connection?.type === undefined) return undefined;
+      let previous = connection.type;
+      const listener = () => {
+        const type = connection.type;
+        if (type === undefined || type === previous) return;
+        previous = type;
+        Queue.offerUnsafe(queue, "network-changed");
+      };
+      connection.addEventListener("change", listener);
+      return { connection, listener };
+    }),
+    (subscription) =>
+      Effect.sync(() =>
+        subscription?.connection.removeEventListener("change", subscription.listener),
+      ),
+  ).pipe(Effect.asVoid),
+);
+
 const wakeupsLayer = Wakeups.layer({
-  changes: Stream.merge(
-    Stream.callback<"application-active">((queue) =>
-      Effect.acquireRelease(
-        Effect.sync(() => {
-          const listener = () => {
-            if (document.visibilityState === "visible") {
-              Queue.offerUnsafe(queue, "application-active");
-            }
-          };
-          document.addEventListener("visibilitychange", listener);
-          return listener;
-        }),
-        (listener) =>
+  changes: Stream.mergeAll(
+    [
+      Stream.callback<"application-active">((queue) =>
+        Effect.acquireRelease(
           Effect.sync(() => {
-            document.removeEventListener("visibilitychange", listener);
+            const listener = () => {
+              if (document.visibilityState === "visible") {
+                Queue.offerUnsafe(queue, "application-active");
+              }
+            };
+            document.addEventListener("visibilitychange", listener);
+            return listener;
           }),
-      ).pipe(Effect.asVoid),
-    ),
-    managedRelayAccountChanges(appAtomRegistry).pipe(
-      Stream.map(() => "credentials-changed" as const),
-    ),
+          (listener) =>
+            Effect.sync(() => {
+              document.removeEventListener("visibilitychange", listener);
+            }),
+        ).pipe(Effect.asVoid),
+      ),
+      managedRelayAccountChanges(appAtomRegistry).pipe(
+        Stream.map(() => "credentials-changed" as const),
+      ),
+      networkPathChanges,
+    ],
+    { concurrency: "unbounded" },
   ),
 });
 
@@ -142,7 +183,11 @@ function sshPreparationError(cause: unknown) {
 
 export const provisionDesktopSshEnvironment = Effect.fn(
   "web.connectionPlatform.ssh.provisionDesktop",
-)(function* (bridge: DesktopBridge, target: DesktopSshEnvironmentTarget) {
+)(function* (
+  bridge: DesktopBridge,
+  target: DesktopSshEnvironmentTarget,
+  expectedEnvironmentId?: EnvironmentId,
+) {
   const bootstrap = yield* Effect.tryPromise({
     try: () =>
       bridge.ensureSshEnvironment(target, {
@@ -161,6 +206,12 @@ export const provisionDesktopSshEnvironment = Effect.fn(
     try: () => bridge.fetchSshEnvironmentDescriptor(bootstrap.httpBaseUrl),
     catch: sshPreparationError,
   });
+  if (expectedEnvironmentId !== undefined && descriptor.environmentId !== expectedEnvironmentId) {
+    return yield* new ConnectionBlockedError({
+      reason: "configuration",
+      detail: `That host reaches ${descriptor.label}, a different machine. Add it as its own environment instead.`,
+    });
+  }
   const access = yield* Effect.tryPromise({
     try: () => bridge.bootstrapSshBearerSession(bootstrap.httpBaseUrl, pairingToken),
     catch: sshPreparationError,
@@ -223,16 +274,18 @@ const capabilitiesLayer = Layer.effectContext(
       }).pipe(Effect.map(Option.fromNullishOr)),
     });
     const ssh = ClientCapabilities.SshEnvironmentGateway.of({
-      provision: Effect.fn("web.connectionPlatform.ssh.provision")(function* (target) {
-        const bridge = window.desktopBridge;
-        if (bridge === undefined) {
-          return yield* new ConnectionBlockedError({
-            reason: "unsupported",
-            detail: "SSH environments are only available in the desktop app.",
-          });
-        }
-        return yield* provisionDesktopSshEnvironment(bridge, target);
-      }),
+      provision: Effect.fn("web.connectionPlatform.ssh.provision")(
+        function* (target, expectedEnvironmentId) {
+          const bridge = window.desktopBridge;
+          if (bridge === undefined) {
+            return yield* new ConnectionBlockedError({
+              reason: "unsupported",
+              detail: "SSH environments are only available in the desktop app.",
+            });
+          }
+          return yield* provisionDesktopSshEnvironment(bridge, target, expectedEnvironmentId);
+        },
+      ),
       prepare: Effect.fn("web.connectionPlatform.ssh.prepare")(function* (input) {
         const bridge = window.desktopBridge;
         if (bridge === undefined) {
diff --git a/apps/web/src/connection/storage.ts b/apps/web/src/connection/storage.ts
index 7e909d02c7d6..9306b847d5d5 100644
--- a/apps/web/src/connection/storage.ts
+++ b/apps/web/src/connection/storage.ts
@@ -11,6 +11,7 @@ import {
   removeCatalogValue,
   removeConnectionFromCatalog,
   setConnectionEnabledInCatalog,
+  setRoutesInCatalog,
   replaceCatalogValue,
   Persistence,
 } from "@t3tools/client-runtime/platform";
@@ -86,6 +87,7 @@ function persistenceError(
     | "list-targets"
     | "list-disabled-targets"
     | "register-connection"
+    | "set-connection-routes"
     | "remove-connection"
     | "set-connection-enabled"
     | "load-shell"
@@ -474,13 +476,17 @@ export const connectionStorageLayer = Layer.effectContext(
       ),
     });
     const registrationStore = Persistence.ConnectionRegistrationStore.of({
-      register: (registration) =>
+      register: (registration, routes) =>
         catalog
-          .update((document) => registerConnectionInCatalog(document, registration))
+          .update((document) => registerConnectionInCatalog(document, registration, routes))
           .pipe(Effect.mapError((cause) => persistenceError("register-connection", cause))),
-      remove: (target) =>
+      setRoutes: (environmentId, routes) =>
         catalog
-          .update((document) => removeConnectionFromCatalog(document, target))
+          .update((document) => setRoutesInCatalog(document, environmentId, routes))
+          .pipe(Effect.mapError((cause) => persistenceError("set-connection-routes", cause))),
+      remove: (environmentId) =>
+        catalog
+          .update((document) => removeConnectionFromCatalog(document, environmentId))
           .pipe(Effect.mapError((cause) => persistenceError("remove-connection", cause))),
       setEnabled: (environmentId, enabled) =>
         catalog
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index 65e2cef9c5d1..46b57325a3ff 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -5,6 +5,15 @@
 /* Window Controls Overlay: active when Electron exposes native titlebar control geometry. */
 @custom-variant wco (&:is(.wco, .wco *));
 
+/* Secondary hovering pointers reveal sidebar actions on touch-primary devices. */
+@custom-variant any-hover {
+  @media (any-hover: hover) {
+    &:hover {
+      @slot;
+    }
+  }
+}
+
 /* On mobile, morph the expanded hero composer into the compact docked
    composer while it moves; the rest of the app remains visually stationary. */
 html[data-mobile-composer-route-transition="true"]::view-transition-old(root),
@@ -140,7 +149,7 @@ html[data-mobile-composer-route-transition="true"]::view-transition-old(t3-mobil
 }
 
 .wco {
-  --workspace-topbar-height: env(titlebar-area-height, 52px);
+  --workspace-topbar-height: max(40px, env(titlebar-area-height, 52px));
   --workspace-controls-top: env(titlebar-area-y, 0px);
   --workspace-controls-left: calc(env(titlebar-area-x, 0px) + 0.75rem);
   --workspace-controls-right: calc(
diff --git a/apps/web/src/lib/embeddedScripts.test.ts b/apps/web/src/lib/embeddedScripts.test.ts
new file mode 100644
index 000000000000..d99263b6479a
--- /dev/null
+++ b/apps/web/src/lib/embeddedScripts.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { embeddedScripts } from "./embeddedScripts";
+
+/** Each script's language, its text, and the part of the command that spells it. */
+function scriptsOf(command: string) {
+  return embeddedScripts(command).map((script) => {
+    // Every character maps inside the command, in order.
+    script.starts.forEach((start, index) => {
+      expect(start).toBeLessThan(script.ends[index]!);
+      if (index > 0) expect(start).toBeGreaterThanOrEqual(script.ends[index - 1]!);
+    });
+    return [
+      script.language,
+      script.text,
+      command.slice(script.starts[0], script.ends.at(-1)),
+    ] as const;
+  });
+}
+
+const pythonScript = `from pathlib import Path
+import json
+
+# print every package.json name and version
+for p in sorted(Path('.').glob('**/package.json')):
+    data = json.loads(p.read_text())
+    print(f"{data['name']:16} {data.get('version', '?')}")
+`;
+
+describe("embeddedScripts", () => {
+  it("finds the script inside a Codex login-shell wrapper and the script inside that", () => {
+    // Recorded in the turn_interrupt_mid_tool Codex transcript
+    // (apps/server/src/orchestration-v2/testkit/fixtures).
+    const inner = `console.log('interrupt fixture tool started'); setTimeout(() => {}, 30000)`;
+    const command = `/bin/bash -lc "node -e \\"${inner}\\""`;
+    expect(scriptsOf(command)).toEqual([
+      ["shellscript", `node -e "${inner}"`, `node -e \\"${inner}\\"`],
+      ["javascript", inner, inner],
+    ]);
+  });
+
+  it("highlights a heredoc fed to an interpreter in that interpreter's language", () => {
+    const command = `python3 - <<'PY'\n${pythonScript}PY`;
+    expect(scriptsOf(command)).toEqual([["python", pythonScript, pythonScript]]);
+  });
+
+  it("maps escaped characters back to both source characters", () => {
+    const command = `/bin/zsh -lc "python3 - <<'PY'\nprint(\\"\\$HOME\\")\nPY"`;
+    const [shell, python] = scriptsOf(command);
+    expect(shell?.[1]).toBe(`python3 - <<'PY'\nprint("$HOME")\nPY`);
+    expect(python).toEqual(["python", `print("$HOME")\n`, `print(\\"\\$HOME\\")\n`]);
+  });
+
+  it.each([
+    [`python3 -c 'print(1)'`, "python", "print(1)"],
+    [`python3 -X dev -c 'print(1)'`, "python", "print(1)"],
+    [`py -3 -c 'print(1)'`, "python", "print(1)"],
+    [`C:\\Python312\\python.exe -c 'print(1)'`, "python", "print(1)"],
+    [`"C:\\Program Files\\Python312\\python.exe" -c 'print(1)'`, "python", "print(1)"],
+    [`node --eval "process.exit(0)"`, "javascript", "process.exit(0)"],
+    [`bun -e 'console.log(Bun.version)'`, "typescript", "console.log(Bun.version)"],
+    [`deno eval 'console.log(1)'`, "typescript", "console.log(1)"],
+    [`deno eval --config deno.json 'console.log(1)'`, "typescript", "console.log(1)"],
+    [`deno eval --env-file 'console.log(1)'`, "typescript", "console.log(1)"],
+    [`psql -f schema.sql -c 'select 1'`, "sql", "select 1"],
+    [`node -C development -e 'console.log(1)'`, "javascript", "console.log(1)"],
+    [`ruby -e 'puts 1'`, "ruby", "puts 1"],
+    [`ruby -I lib -e 'puts 1'`, "ruby", "puts 1"],
+    [`perl -E 'say 1'`, "perl", "say 1"],
+    [`sqlite3 app.db "select * from users"`, "sql", "select * from users"],
+    [`psql -d app -c 'select 1'`, "sql", "select 1"],
+    [`pwsh -NoProfile -Command "Get-ChildItem"`, "powershell", "Get-ChildItem"],
+    [`env FOO=1 sudo -u bob python3 -c 'print(1)'`, "python", "print(1)"],
+    [`env -- FOO=1 python3 -c 'print(1)'`, "python", "print(1)"],
+    [`node --eval="process.exit(0)"`, "javascript", "process.exit(0)"],
+    [`psql --command='select 1'`, "sql", "select 1"],
+    [`mysql -c -e 'select 1'`, "sql", "select 1"],
+    [`mysql -f app <<'EOF'\nselect 1;\nEOF`, "sql", "select 1;\n"],
+    [`psql app <<'EOF'\nselect 1;\nEOF`, "sql", "select 1;\n"],
+    [`echo "$(node -e 'console.log(1)')"`, "javascript", "console.log(1)"],
+    [`python3 <<< 'print(1)'`, "python", "print(1)"],
+  ])("finds the inline script in %s", (command, language, script) => {
+    expect(scriptsOf(command)).toEqual([[language, script, expect.any(String)]]);
+  });
+
+  it.each([[`psql -c 'select 1' -c 'select 2'`], [`sqlite3 app.db "select 1" "select 2"`]])(
+    "finds every statement a SQL shell runs: %s",
+    (command) => {
+      expect(scriptsOf(command).map(([language, text]) => [language, text])).toEqual([
+        ["sql", "select 1"],
+        ["sql", "select 2"],
+      ]);
+    },
+  );
+
+  it.each([
+    ["the file `cat` writes", `cat > src/app.ts <<'EOF'\nconst a = 1;\nEOF`, "typescript"],
+    ["the file `tee` writes", `tee -a config.json <<EOF\n{}\nEOF`, "json"],
+    ["its delimiter", `kubectl apply -f - <<'YAML'\nkind: Pod\nYAML`, "yaml"],
+    ["the shell reading it", `bash <<'EOF'\necho hi\nEOF`, "shellscript"],
+  ])("takes a heredoc's language from %s", (_source, command, language) => {
+    expect(scriptsOf(command).map(([lang]) => lang)).toEqual([language]);
+  });
+
+  it.each([
+    ["a script file", `python3 build.py <<EOF\ndata\nEOF`],
+    ["a module", `python3 -m json.tool <<EOF\n{}\nEOF`],
+    ["a SQL file", `psql -f migrate.sql <<EOF\ny\nEOF`],
+    ["a SQL file given with =", `psql --file=migrate.sql <<EOF\ny\nEOF`],
+    ["plain commands", `rg -n "foo" src && git status`],
+    ["an unnamed heredoc into a plain command", `git commit -F - <<'EOF'\nfix: x\nEOF`],
+    ["an empty script", `bash -lc '   '`],
+    ["a heredoc `cat` sends to stdout while stderr goes to a file", `cat 2>log.ts <<'EOF'\nx\nEOF`],
+  ])("finds nothing for %s", (_case, command) => {
+    expect(scriptsOf(command)).toEqual([]);
+  });
+
+  it("trusts nothing in a command whose quoting does not parse", () => {
+    // Codex's secret redaction dropped the backslash of an escaped quote, so
+    // the -lc argument ends early and the rest no longer balances.
+    const command = `/bin/zsh -lc "python3 -c 'token=[REDACTED_SECRET]"apiToken\\"]; print(token)'"`;
+    expect(scriptsOf(command)).toEqual([]);
+  });
+});
diff --git a/apps/web/src/lib/embeddedScripts.ts b/apps/web/src/lib/embeddedScripts.ts
new file mode 100644
index 000000000000..809481b6973f
--- /dev/null
+++ b/apps/web/src/lib/embeddedScripts.ts
@@ -0,0 +1,544 @@
+import { getFiletypeFromFileName } from "@pierre/diffs";
+import {
+  parse,
+  type Command,
+  type DoubleQuotedChild,
+  type HereDoc,
+  type Word,
+  type WordPart,
+} from "unbash";
+
+/**
+ * Code in another language inside a shell command: a `bash -lc "…"` script, a
+ * `python3 -c '…'` argument, or a heredoc fed to an interpreter or written to
+ * a file. `starts[i]` and `ends[i]` are the span of the original command that
+ * spells `text[i]`, so a quoted `\"` maps back to both of its characters.
+ */
+export interface EmbeddedScript {
+  readonly language: string;
+  readonly text: string;
+  readonly starts: ReadonlyArray<number>;
+  readonly ends: ReadonlyArray<number>;
+}
+
+interface MappedText {
+  readonly text: string;
+  readonly starts: ReadonlyArray<number>;
+  readonly ends: ReadonlyArray<number>;
+}
+
+interface Interpreter {
+  readonly language: string;
+  /** Flags whose next argument is the script. */
+  readonly inline: (flag: string) => boolean;
+  /** Options that consume the next argument. */
+  readonly valueOptions?: ReadonlySet<string>;
+  /** Options after which the script comes from a file or module instead. */
+  readonly scriptFileOptions?: ReadonlySet<string>;
+  /** "always" for SQL shells, which read statements from stdin next to their database argument. */
+  readonly stdin: "always" | "without-script-file" | "never";
+  /** The first positional argument holding a script, as in `sqlite3 app.db "select 1"`. */
+  readonly positionalScript?: number;
+  /** SQL shells run every `-c` and every statement argument, in order. */
+  readonly repeatable?: boolean;
+  readonly subcommand?: string;
+  /** PowerShell matches parameters case-insensitively; the lists above are lowercase. */
+  readonly ignoreCase?: boolean;
+}
+
+const MAX_DEPTH = 4;
+
+const flagIn =
+  (...flags: string[]) =>
+  (flag: string) =>
+    flags.includes(flag);
+
+const SHELL: Interpreter = {
+  language: "shellscript",
+  inline: (flag) => /^-[a-z]*c[a-z]*$/u.test(flag),
+  valueOptions: new Set(["-o", "-O", "--rcfile", "--init-file"]),
+  stdin: "without-script-file",
+};
+
+const PYTHON: Interpreter = {
+  language: "python",
+  inline: flagIn("-c"),
+  valueOptions: new Set(["-W", "-X"]),
+  scriptFileOptions: new Set(["-m"]),
+  stdin: "without-script-file",
+};
+
+// Shared by SQL clients; each names its own script flags, since `-c` and `-f`
+// mean different things to psql and mysql.
+const SQL_SHELL = {
+  language: "sql",
+  valueOptions: new Set([
+    "-d",
+    "-h",
+    "-u",
+    "-U",
+    "--dbname",
+    "--host",
+    "--user",
+    "--username",
+    "-separator",
+    "-nullvalue",
+    "-init",
+  ]),
+  stdin: "always",
+  repeatable: true,
+} satisfies Omit<Interpreter, "inline">;
+
+const INTERPRETERS: Record<string, Interpreter> = {
+  sh: SHELL,
+  bash: SHELL,
+  zsh: SHELL,
+  dash: SHELL,
+  ash: SHELL,
+  ksh: SHELL,
+  fish: { language: "fish", inline: flagIn("-c", "--command"), stdin: "without-script-file" },
+  node: {
+    language: "javascript",
+    inline: flagIn("-e", "--eval", "-p", "--print"),
+    valueOptions: new Set(["-r", "--require", "--import", "--loader", "-C", "--conditions"]),
+    stdin: "without-script-file",
+  },
+  bun: { language: "typescript", inline: flagIn("-e", "--eval", "-p", "--print"), stdin: "never" },
+  deno: {
+    language: "typescript",
+    inline: () => false,
+    // `--env-file` takes its optional path only as `--env-file=path`.
+    valueOptions: new Set(["-c", "--config", "--import-map", "--ext"]),
+    stdin: "never",
+    subcommand: "eval",
+  },
+  ruby: {
+    language: "ruby",
+    inline: flagIn("-e"),
+    valueOptions: new Set(["-r", "-I", "-C"]),
+    stdin: "without-script-file",
+  },
+  perl: { language: "perl", inline: flagIn("-e", "-E"), stdin: "without-script-file" },
+  osascript: {
+    language: "applescript",
+    inline: flagIn("-e"),
+    valueOptions: new Set(["-l", "-s"]),
+    stdin: "without-script-file",
+  },
+  pwsh: {
+    language: "powershell",
+    inline: flagIn("-c", "-command"),
+    valueOptions: new Set(["-executionpolicy", "-workingdirectory", "-windowstyle"]),
+    scriptFileOptions: new Set(["-f", "-file", "-encodedcommand"]),
+    stdin: "never",
+    ignoreCase: true,
+  },
+  psql: {
+    ...SQL_SHELL,
+    inline: flagIn("-c", "--command"),
+    scriptFileOptions: new Set(["-f", "--file"]),
+  },
+  mysql: { ...SQL_SHELL, inline: flagIn("-e", "--execute") },
+  sqlite3: { ...SQL_SHELL, inline: flagIn("-cmd"), positionalScript: 1 },
+  duckdb: {
+    ...SQL_SHELL,
+    inline: flagIn("-c", "-cmd"),
+    scriptFileOptions: new Set(["-f"]),
+    positionalScript: 1,
+  },
+};
+INTERPRETERS.powershell = INTERPRETERS.pwsh!;
+INTERPRETERS.mariadb = INTERPRETERS.mysql!;
+
+// Commands that run the next word as the program, with the options that consume a value.
+const PROGRAM_WRAPPERS: Record<string, ReadonlySet<string>> = {
+  env: new Set(["-u", "--unset", "-C", "--chdir"]),
+  sudo: new Set(["-u", "--user", "-g", "--group", "-C", "-D", "--chdir"]),
+  nice: new Set(["-n", "--adjustment"]),
+  nohup: new Set(),
+  exec: new Set(["-a"]),
+  command: new Set(),
+  builtin: new Set(),
+};
+
+// Heredoc delimiters that name their language, as in `<<'SQL'`.
+const DELIMITER_LANGUAGES: Record<string, string> = {
+  py: "python",
+  python: "python",
+  js: "javascript",
+  javascript: "javascript",
+  ts: "typescript",
+  typescript: "typescript",
+  sql: "sql",
+  json: "json",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  sh: "shellscript",
+  bash: "shellscript",
+  shell: "shellscript",
+  rb: "ruby",
+  ruby: "ruby",
+  html: "html",
+  css: "css",
+  md: "markdown",
+  markdown: "markdown",
+  xml: "xml",
+  diff: "diff",
+  patch: "diff",
+};
+
+/**
+ * The scripts embedded in a shell command, outermost first, so a highlighter
+ * painting them in order lets a nested script override the one containing it.
+ * Returns nothing for a command that does not parse cleanly; where a broken
+ * quote ends cannot be trusted.
+ */
+export function embeddedScripts(command: string): EmbeddedScript[] {
+  const identity = Array.from({ length: command.length }, (_, index) => index);
+  return scriptsIn(
+    { text: command, starts: identity, ends: identity.map((index) => index + 1) },
+    0,
+  );
+}
+
+function scriptsIn(source: MappedText, depth: number): EmbeddedScript[] {
+  const script = parse(source.text);
+  if (script.errors?.length) return [];
+  const found: EmbeddedScript[] = [];
+  forEachCommand(script.commands, (command) => {
+    for (const { language, mapped } of commandScripts(command, source.text)) {
+      if (mapped.text.trim() === "") continue;
+      const embedded: EmbeddedScript = {
+        language,
+        text: mapped.text,
+        starts: mapped.starts.map((start) => source.starts[start]!),
+        ends: mapped.ends.map((end) => source.ends[end - 1]!),
+      };
+      found.push(embedded);
+      if (language === "shellscript" && depth + 1 < MAX_DEPTH) {
+        found.push(...scriptsIn(embedded, depth + 1));
+      }
+    }
+  });
+  return found;
+}
+
+function isNode(value: unknown): value is { readonly type: string } {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+
+/** Visits every simple command, including those inside `$(…)`, loops and subshells. */
+function forEachCommand(
+  node: unknown,
+  visit: (command: Command) => void,
+  seen = new WeakSet<object>(),
+): void {
+  if (Array.isArray(node)) {
+    for (const child of node) forEachCommand(child, visit, seen);
+    return;
+  }
+  if (!isNode(node) || seen.has(node)) return;
+  seen.add(node);
+  switch (node.type) {
+    case "Command":
+      visit(node as Command);
+      break;
+    case "CommandExpansion":
+    case "ProcessSubstitution": {
+      const { script } = node as Extract<WordPart, { type: "CommandExpansion" }>;
+      // Escaped-backtick scripts own a decoded source their positions index.
+      if (script && !script.errors?.length && script.source === undefined) {
+        forEachCommand(script.commands, visit, seen);
+      }
+      return;
+    }
+  }
+  // Word parts are lazy getters, which Object.values skips.
+  if ("parts" in node) forEachCommand(node.parts, visit, seen);
+  for (const value of Object.values(node)) {
+    if (typeof value === "object") forEachCommand(value, visit, seen);
+  }
+}
+
+function programName(word: Word): string {
+  // Bash reads `C:\Python312\python.exe` unquoted as escapes; Windows meant a path.
+  const path = /\\/u.test(word.text) ? word.text.replace(/^["']|["']$/gu, "") : word.value;
+  return (path.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.exe$/u, "");
+}
+
+function interpreterFor(name: string): Interpreter | undefined {
+  // `py` is the Windows Python launcher, as in `py -3 -c '…'`.
+  if (/^python(?:\d+(?:\.\d+)?)?$|^pypy3?$|^py$/u.test(name)) return PYTHON;
+  return Object.hasOwn(INTERPRETERS, name) ? INTERPRETERS[name] : undefined;
+}
+
+/** Skips `env FOO=1`, `sudo -u bob` and similar to the word naming the real program. */
+function programIndex(words: ReadonlyArray<Word>): number {
+  let index = 0;
+  while (index < words.length) {
+    const name = programName(words[index]!);
+    if (!Object.hasOwn(PROGRAM_WRAPPERS, name)) return index;
+    const valueOptions = PROGRAM_WRAPPERS[name]!;
+    index += 1;
+    let optionsEnded = false;
+    while (index < words.length) {
+      const value = words[index]!.value;
+      const isOption = !optionsEnded && value.startsWith("-");
+      if (isOption && value === "--") optionsEnded = true;
+      // `env -- FOO=1 cmd` still takes assignments after the options end.
+      if (isOption || /^[A-Za-z_]\w*=/u.test(value)) {
+        index += isOption && valueOptions.has(value) ? 2 : 1;
+      } else {
+        break;
+      }
+    }
+  }
+  return index;
+}
+
+function commandScripts(
+  command: Command,
+  source: string,
+): Array<{ language: string; mapped: MappedText }> {
+  if (!command.name) return [];
+  const words = [command.name, ...command.args.filter((arg): arg is Word => arg.type === "Word")];
+  const index = programIndex(words);
+  const program = words[index];
+  if (!program) return [];
+  const name = programName(program);
+  const interpreter = interpreterFor(name);
+  const args = words.slice(index + 1);
+  const scripts: Array<{ language: string; mapped: MappedText }> = [];
+
+  let readsStdinScript = false;
+  if (interpreter) {
+    const found = interpreterArgs(interpreter, args);
+    for (const script of found.scripts) {
+      const mapped = wordText(script.word, source);
+      if (!mapped) continue;
+      const start = script.inValue ? mapped.text.indexOf("=") + 1 : 0;
+      scripts.push({ language: interpreter.language, mapped: sliceMapped(mapped, start) });
+    }
+    readsStdinScript =
+      interpreter.stdin !== "never" && found.scripts.length === 0 && !found.scriptFromFile;
+  }
+
+  const stdinLanguage = readsStdinScript ? interpreter?.language : undefined;
+  const writtenLanguage = writtenFileLanguage(name, command, args);
+  for (const redirect of command.redirects) {
+    const toStdin = isDescriptor(redirect.descriptor, 0);
+    if (redirect.type === "HereString" && toStdin && stdinLanguage && redirect.target) {
+      const mapped = wordText(redirect.target, source);
+      if (mapped) scripts.push({ language: stdinLanguage, mapped });
+    }
+    if (redirect.type === "HereDoc") {
+      const language =
+        (toStdin ? (stdinLanguage ?? writtenLanguage) : undefined) ?? delimiterLanguage(redirect);
+      if (language) scripts.push({ language, mapped: hereDocText(redirect, source) });
+    }
+  }
+  return scripts;
+}
+
+/** Whether a redirection without a descriptor, or with `fd`, targets file descriptor `fd`. */
+function isDescriptor(descriptor: HereDoc["descriptor"], fd: number): boolean {
+  return (
+    descriptor === undefined || (descriptor.type === "FileDescriptor" && descriptor.value === fd)
+  );
+}
+
+interface ScriptArgument {
+  readonly word: Word;
+  /** The script follows the `=` of `--eval=…` rather than filling the word. */
+  readonly inValue: boolean;
+}
+
+/** The script arguments, and whether the script comes from a file instead. */
+function interpreterArgs(
+  interpreter: Interpreter,
+  args: ReadonlyArray<Word>,
+): { scripts: ScriptArgument[]; scriptFromFile: boolean } {
+  const positionals: Word[] = [];
+  const scripts: ScriptArgument[] = [];
+  const whole = (word: Word): ScriptArgument => ({ word, inValue: false });
+  let optionsEnded = false;
+  let scriptFromFile = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]!;
+    const flag = interpreter.ignoreCase ? arg.value.toLowerCase() : arg.value;
+    if (!optionsEnded && flag === "--") {
+      optionsEnded = true;
+      continue;
+    }
+    if (!optionsEnded && flag.startsWith("-") && flag !== "-") {
+      // `--eval=code` and `--file=path` carry their value in the same word.
+      const [name = flag, value] = flag.startsWith("--") ? flag.split(/=(.*)/su) : [flag];
+      if (interpreter.scriptFileOptions?.has(name)) {
+        if (!interpreter.repeatable) return { scripts, scriptFromFile: true };
+        // SQL shells run `-f` files and `-c` statements alike, in order.
+        scriptFromFile = true;
+        if (value === undefined) index += 1;
+        continue;
+      }
+      if (interpreter.inline(name)) {
+        const next = args[index + 1];
+        if (value !== undefined) scripts.push({ word: arg, inValue: true });
+        else if (next) scripts.push(whole(next));
+        if (!interpreter.repeatable) return { scripts, scriptFromFile: false };
+        if (value === undefined) index += 1;
+        continue;
+      }
+      if (value === undefined && interpreter.valueOptions?.has(flag)) index += 1;
+      continue;
+    }
+    positionals.push(arg);
+    // An interpreter stops reading its own options at the script file.
+    if (interpreter.stdin === "without-script-file" && !interpreter.subcommand) break;
+  }
+
+  if (interpreter.subcommand) {
+    if (positionals[0]?.value !== interpreter.subcommand) return { scripts, scriptFromFile: true };
+    return { scripts: positionals.slice(1, 2).map(whole), scriptFromFile: false };
+  }
+  if (interpreter.positionalScript !== undefined) {
+    scripts.push(...positionals.slice(interpreter.positionalScript).map(whole));
+  }
+  // SQL shells take databases as positional arguments, not script files.
+  if (interpreter.stdin === "always") return { scripts, scriptFromFile };
+  const first = positionals[0];
+  return { scripts, scriptFromFile: first !== undefined && first.value !== "-" };
+}
+
+function sliceMapped(mapped: MappedText, start: number): MappedText {
+  if (start === 0) return mapped;
+  return {
+    text: mapped.text.slice(start),
+    starts: mapped.starts.slice(start),
+    ends: mapped.ends.slice(start),
+  };
+}
+
+/** The language of the file `cat > file` or `tee file` writes its stdin to. */
+function writtenFileLanguage(
+  name: string,
+  command: Command,
+  args: ReadonlyArray<Word>,
+): string | undefined {
+  let path: string | undefined;
+  if (name === "cat") {
+    for (const redirect of command.redirects) {
+      if (
+        redirect.type === "Redirect" &&
+        [">", ">>", ">|", "&>", "&>>"].includes(redirect.operator) &&
+        isDescriptor(redirect.descriptor, 1)
+      ) {
+        path = redirect.target?.value;
+      }
+    }
+  } else if (name === "tee") {
+    path = args.find((arg) => !arg.value.startsWith("-"))?.value;
+  }
+  if (!path) return undefined;
+  const language = getFiletypeFromFileName(path);
+  return language === "text" ? undefined : language;
+}
+
+function delimiterLanguage(hereDoc: HereDoc): string | undefined {
+  const name = hereDoc.delimiter?.value.toLowerCase();
+  return name && Object.hasOwn(DELIMITER_LANGUAGES, name) ? DELIMITER_LANGUAGES[name] : undefined;
+}
+
+/** A heredoc body as written; the interpreter reads its characters one to one. */
+function hereDocText(hereDoc: HereDoc, source: string): MappedText {
+  const { pos, end } = hereDoc.body;
+  const starts = Array.from({ length: end - pos }, (_, index) => pos + index);
+  return {
+    text: source.slice(pos, end),
+    starts,
+    ends: starts.map((start) => start + 1),
+  };
+}
+
+/**
+ * A word's value with the source span of each character: quotes removed and
+ * escapes resolved, the way the program receives it. Expansions such as
+ * `$HOME` stay as written. Returns undefined for spellings it cannot map.
+ */
+function wordText(word: Word, source: string): MappedText | undefined {
+  const builder = new MappedTextBuilder();
+  const parts: ReadonlyArray<WordPart> = word.parts ?? [
+    { type: "Literal", pos: word.pos, end: word.end, text: word.text, value: word.value },
+  ];
+  for (const part of parts) {
+    switch (part.type) {
+      case "Literal":
+        if (!builder.addEscaped(part, false)) return undefined;
+        break;
+      case "SingleQuoted":
+        builder.addRaw(part.value, part.pos + 1);
+        break;
+      case "DoubleQuoted":
+      case "LocaleString":
+        for (const child of part.parts) {
+          if (!builder.addDoubleQuotedChild(child)) return undefined;
+        }
+        break;
+      case "AnsiCQuoted":
+        // $'…' escapes such as \x41 do not map character for character.
+        if (part.value !== part.text.slice(2, -1)) return undefined;
+        builder.addRaw(part.value, part.pos + 2);
+        break;
+      default:
+        builder.addRaw(source.slice(part.pos, part.end), part.pos);
+    }
+  }
+  return builder.build();
+}
+
+class MappedTextBuilder {
+  private text = "";
+  private readonly starts: number[] = [];
+  private readonly ends: number[] = [];
+
+  addRaw(text: string, pos: number) {
+    for (let index = 0; index < text.length; index += 1) this.push(text[index]!, pos + index, 1);
+  }
+
+  addDoubleQuotedChild(child: DoubleQuotedChild): boolean {
+    if (child.type === "Literal") return this.addEscaped(child, true);
+    this.addRaw(child.text, child.pos);
+    return true;
+  }
+
+  /** Adds a literal, resolving backslash escapes; false when the result disagrees with the parser. */
+  addEscaped(literal: { pos: number; text: string; value: string }, doubleQuoted: boolean) {
+    const before = this.text.length;
+    const { text, pos } = literal;
+    for (let index = 0; index < text.length; index += 1) {
+      const next = text[index + 1];
+      if (
+        text[index] === "\\" &&
+        next !== undefined &&
+        (!doubleQuoted || '$`"\\\n'.includes(next))
+      ) {
+        // A backslash-newline joins lines and spells nothing.
+        if (next !== "\n") this.push(next, pos + index, 2);
+        index += 1;
+      } else {
+        this.push(text[index]!, pos + index, 1);
+      }
+    }
+    return this.text.slice(before) === literal.value;
+  }
+
+  build(): MappedText {
+    return { text: this.text, starts: this.starts, ends: this.ends };
+  }
+
+  private push(character: string, start: number, length: number) {
+    this.text += character;
+    this.starts.push(start);
+    this.ends.push(start + length);
+  }
+}
diff --git a/apps/web/src/onboarding/targetEnvironment.logic.ts b/apps/web/src/onboarding/targetEnvironment.logic.ts
index 6045b8c441e2..665590ec990d 100644
--- a/apps/web/src/onboarding/targetEnvironment.logic.ts
+++ b/apps/web/src/onboarding/targetEnvironment.logic.ts
@@ -1,16 +1,16 @@
-import type { ConnectionTarget } from "@t3tools/client-runtime/connection";
+import { type ConnectionCatalogEntry, hasRelayRoute } from "@t3tools/client-runtime/connection";
 import type { EnvironmentId } from "@t3tools/contracts";
 
 interface OnboardingEnvironment {
   readonly environmentId: EnvironmentId;
   readonly connection: { readonly phase: string };
-  readonly entry: { readonly target: ConnectionTarget };
+  readonly entry: Pick<ConnectionCatalogEntry, "target" | "alternateRoutes">;
 }
 
 export function isOnboardingRelayEnvironment(
   environment: Pick<OnboardingEnvironment, "entry">,
 ): boolean {
-  return environment.entry.target._tag === "RelayConnectionTarget";
+  return hasRelayRoute(environment.entry);
 }
 
 /** Keep a directly paired machine pinned while its initial connection completes. */
diff --git a/apps/web/src/routes/_chat.pull-requests.tsx b/apps/web/src/routes/_chat.pull-requests.tsx
index 8f75fcb66cac..b67f79234813 100644
--- a/apps/web/src/routes/_chat.pull-requests.tsx
+++ b/apps/web/src/routes/_chat.pull-requests.tsx
@@ -1,5 +1,7 @@
 import { RefreshIcon } from "~/components/ui/refresh-icon";
 import { Spinner } from "~/components/ui/spinner";
+import { useShortcutModifierState } from "~/shortcutModifierState";
+import type { PullRequestSpeedActionResult } from "~/components/pullRequest/PullRequestSpeedActions";
 import { pullRequestHostOf, resolveEnvironmentMachineKind } from "@t3tools/contracts";
 import type {
   EnvironmentId,
@@ -342,6 +344,9 @@ export const Route = createFileRoute("/_chat/pull-requests")({
 
 function PullRequestsRouteView() {
   useEscapeToGoBack();
+  const modifiers = useShortcutModifierState(true);
+  const speedMode =
+    modifiers.shiftKey && !modifiers.metaKey && !modifiers.ctrlKey && !modifiers.altKey;
   const search = Route.useSearch();
   const sort = search.sort ?? "ready";
   const statsPolicy: PullRequestStatsPolicy =
@@ -952,6 +957,16 @@ function PullRequestsRouteView() {
   };
   /** The detail panel's own writes, by row, so its failure takes back its own note. */
   const detailOverrideTokens = useRef(new Map<string, number | null>());
+  const speedActionRef = useRef<(result: PullRequestSpeedActionResult) => void>(() => {});
+  speedActionRef.current = ({ entry, action }) => {
+    // Some hosts accept a merge before it completes. Let the next host read declare it merged.
+    if (action !== "merge") overrideEntry(entry, action);
+    setDetailRefreshToken((token) => token + 1);
+    refreshListAndStats(undefined, entry.environmentId);
+  };
+  const onSpeedAction = useCallback((result: PullRequestSpeedActionResult) => {
+    speedActionRef.current(result);
+  }, []);
   // A reload recreates the registry the queries live in, so with nothing held the page would
   // cold-start into skeletons even though almost every row is unchanged. The last answer for
   // this set of environments is kept across reloads and hydrated here as the carried rows: they
@@ -1395,11 +1410,11 @@ function PullRequestsRouteView() {
     [statsBatches],
   );
   const statsObserver = useRef<IntersectionObserver | null>(null);
-  const statsRows = useRef(new Set<HTMLButtonElement>());
+  const statsRows = useRef(new Set<HTMLDivElement>());
   const statsPending = useRef(true);
   const statsPolicyRef = useRef(statsPolicy);
   statsPolicyRef.current = statsPolicy;
-  const registerStatsRow = useCallback((node: HTMLButtonElement | null) => {
+  const registerStatsRow = useCallback((node: HTMLDivElement | null) => {
     if (node === null || typeof IntersectionObserver === "undefined") return;
     statsRows.current.add(node);
     statsObserver.current?.observe(node);
@@ -1817,6 +1832,8 @@ function PullRequestsRouteView() {
                       selected.number === entry.number
                     }
                     onSelect={selectEntry}
+                    speedMode={speedMode}
+                    onActed={onSpeedAction}
                   />
                 );
               })}
diff --git a/apps/web/src/shortcutModifierState.ts b/apps/web/src/shortcutModifierState.ts
index 15d6e0a1bcae..20091622158e 100644
--- a/apps/web/src/shortcutModifierState.ts
+++ b/apps/web/src/shortcutModifierState.ts
@@ -1,4 +1,5 @@
 import { useEffect, useRef, useState } from "react";
+import { isEditableFocused } from "./lib/editableFocus";
 
 export interface ShortcutModifierState {
   metaKey: boolean;
@@ -26,7 +27,7 @@ export function areShortcutModifierStatesEqual(
   );
 }
 
-export function useShortcutModifierState(): ShortcutModifierState {
+export function useShortcutModifierState(ignoreEditable = false): ShortcutModifierState {
   const [state, setState] = useState(EMPTY_SHORTCUT_MODIFIER_STATE);
   const stateRef = useRef(EMPTY_SHORTCUT_MODIFIER_STATE);
 
@@ -39,7 +40,11 @@ export function useShortcutModifierState(): ShortcutModifierState {
       setState(next);
     };
     const onKeyboardEvent = (event: KeyboardEvent) => {
-      updateState(shortcutModifierStateAfterKeyboardEvent(stateRef.current, event));
+      updateState(
+        ignoreEditable && isEditableFocused(event.target)
+          ? EMPTY_SHORTCUT_MODIFIER_STATE
+          : shortcutModifierStateAfterKeyboardEvent(stateRef.current, event),
+      );
     };
     // Dictation tools (Wispr Flow) paste with a synthetic ⌘V whose Meta keyup
     // never reaches the page, so the tracked state stays "⌘ held" forever and
@@ -50,17 +55,22 @@ export function useShortcutModifierState(): ShortcutModifierState {
       updateState(EMPTY_SHORTCUT_MODIFIER_STATE);
     };
 
+    const onFocus = (event: FocusEvent) => {
+      if (ignoreEditable && isEditableFocused(event.target)) onResetEvent();
+    };
+    window.addEventListener("focusin", onFocus);
     window.addEventListener("keydown", onKeyboardEvent, true);
     window.addEventListener("keyup", onKeyboardEvent, true);
     window.addEventListener("paste", onResetEvent, true);
     window.addEventListener("blur", onResetEvent);
     return () => {
+      window.removeEventListener("focusin", onFocus);
       window.removeEventListener("keydown", onKeyboardEvent, true);
       window.removeEventListener("keyup", onKeyboardEvent, true);
       window.removeEventListener("paste", onResetEvent, true);
       window.removeEventListener("blur", onResetEvent);
     };
-  }, []);
+  }, [ignoreEditable]);
 
   return state;
 }
diff --git a/apps/web/src/state/environments.ts b/apps/web/src/state/environments.ts
index c429e02afeea..b7105c2adf9c 100644
--- a/apps/web/src/state/environments.ts
+++ b/apps/web/src/state/environments.ts
@@ -1,6 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
 import {
   connectionCatalogDisplayUrl,
+  hasRelayRoute,
   type EnvironmentPresentation as BaseEnvironmentPresentation,
 } from "@t3tools/client-runtime/connection";
 import { Discovery } from "@t3tools/client-runtime/relay";
@@ -34,7 +35,7 @@ function projectEnvironmentPresentation(
     environmentId,
     label: presentation.entry.target.label,
     displayUrl: connectionCatalogDisplayUrl(presentation.entry),
-    relayManaged: presentation.entry.target._tag === "RelayConnectionTarget",
+    relayManaged: hasRelayRoute(presentation.entry),
   };
 }
 
diff --git a/apps/web/src/state/queries.ts b/apps/web/src/state/queries.ts
index 01bfa8864bb7..839c4b657606 100644
--- a/apps/web/src/state/queries.ts
+++ b/apps/web/src/state/queries.ts
@@ -13,6 +13,8 @@ import type {
   EnvironmentId,
   ProjectContentMatch,
   ProjectEntryKind,
+  ThreadId,
+  TurnItemId,
   VcsListRefsResult,
   VcsRef,
 } from "@t3tools/contracts";
@@ -351,3 +353,22 @@ export function useCheckpointDiff(
   );
   return fullThreadTarget === null ? turn : fullThread;
 }
+
+/** Full input and output of one timeline item, fetched only while its row is open. */
+export function useTurnItemDetail(
+  target: {
+    readonly environmentId: EnvironmentId;
+    readonly threadId: ThreadId;
+    readonly itemId: TurnItemId;
+    readonly revision: string;
+  } | null,
+) {
+  return useEnvironmentQuery(
+    target === null
+      ? null
+      : orchestrationEnvironment.turnItem({
+          environmentId: target.environmentId,
+          input: { threadId: target.threadId, itemId: target.itemId, revision: target.revision },
+        }),
+  );
+}
diff --git a/apps/web/src/versionSkew.test.ts b/apps/web/src/versionSkew.test.ts
index de7e98bc3531..89e19e83319b 100644
--- a/apps/web/src/versionSkew.test.ts
+++ b/apps/web/src/versionSkew.test.ts
@@ -15,6 +15,7 @@ import {
   dismissVersionMismatch,
   isServerUpdateFailureDismissed,
   isVersionMismatchDismissed,
+  manualServerUpdateCommand,
   resolveServerConfigVersionMismatch,
   resolveServerSelfUpdateCapability,
   resolveVersionMismatch,
@@ -26,6 +27,21 @@ const MISMATCH_HINT =
   "Version mismatch. Try syncing the client and server to the same T3 Code version.";
 
 describe("versionSkew", () => {
+  it("updates only the proven npm prefix and safely quotes its path", () => {
+    expect(manualServerUpdateCommand("0.0.45", { kind: "npm-global", prefix: "/opt/node" })).toBe(
+      "npm install --global --prefix '/opt/node' t3@0.0.45",
+    );
+    expect(
+      manualServerUpdateCommand("0.0.45", { kind: "npm-global", prefix: "/opt/maria's node" }),
+    ).toBe("npm install --global --prefix '/opt/maria'\\''s node' t3@0.0.45");
+  });
+
+  it("keeps runner and unknown commands as relaunches", () => {
+    expect(manualServerUpdateCommand("0.0.45")).toBe("npx t3@0.0.45");
+    expect(manualServerUpdateCommand("0.0.45", { kind: "npx" })).toBe("npx t3@0.0.45");
+    expect(manualServerUpdateCommand("0.0.45", { kind: "pnpm-dlx" })).toBe("pnpm dlx t3@0.0.45");
+    expect(manualServerUpdateCommand("0.0.45", { kind: "bunx" })).toBe("bunx t3@0.0.45");
+  });
   beforeEach(() => {
     branding.APP_VERSION = "0.0.34";
   });
diff --git a/apps/web/src/versionSkew.ts b/apps/web/src/versionSkew.ts
index 2cb4c6b387cc..ca8891a84a39 100644
--- a/apps/web/src/versionSkew.ts
+++ b/apps/web/src/versionSkew.ts
@@ -1,4 +1,9 @@
-import type { EnvironmentId, ServerConfig, ServerSelfUpdateCapability } from "@t3tools/contracts";
+import type {
+  EnvironmentId,
+  ServerConfig,
+  ServerInstallation,
+  ServerSelfUpdateCapability,
+} from "@t3tools/contracts";
 import type { ServerUpdateState } from "@t3tools/client-runtime/state/server";
 import { compareSemverVersions, parseSemver } from "@t3tools/shared/semver";
 import * as Schema from "effect/Schema";
@@ -115,8 +120,17 @@ export function supportsServerUpdateThreadContinuation(
 }
 
 /** The command to hand users whose server cannot update itself. */
-export function manualServerUpdateCommand(targetVersion: string): string {
-  return `npx t3@${targetVersion}`;
+export function manualServerUpdateCommand(
+  targetVersion: string,
+  installation?: ServerInstallation,
+): string {
+  if (installation?.kind === "npm-global") {
+    const prefix = `'${installation.prefix.replaceAll("'", "'\\''")}'`;
+    return `npm install --global --prefix ${prefix} t3@${targetVersion}`;
+  }
+  const runner =
+    installation?.kind === "pnpm-dlx" ? "pnpm dlx" : installation?.kind === "bunx" ? "bunx" : "npx";
+  return `${runner} t3@${targetVersion}`;
 }
 
 export function serverUpdateGuidance(capability: ServerSelfUpdateCapability): string {
diff --git a/docs/internals/mobile-development.md b/docs/internals/mobile-development.md
index 9f0cb9d2e2fb..d1d375584bb0 100644
--- a/docs/internals/mobile-development.md
+++ b/docs/internals/mobile-development.md
@@ -17,12 +17,11 @@ shutdown, but a supervisor created after its cleanup runs would escape it. A clo
 parent scope also closes late arrivals, preventing interrupted startup or runtime
 replacement from leaving a WebSocket alive outside the new registry.
 
-The [Uniwind patch](../../patches/uniwind@1.11.0.patch) still compiles CSS on Metro
-updates so newly used classes are discovered. It skips global style invalidation
-only when the generated stylesheet and theme list are unchanged. Skipping compilation
-would lose new classes; invalidating every consumer for unchanged output makes an
-ordinary component edit refresh the whole app. The fingerprint is recorded only
-after initialization succeeds.
+Uniwind compiles CSS on Metro updates so newly used classes are discovered. It
+skips global style invalidation only when the generated stylesheet and theme list
+are unchanged. Skipping compilation would lose new classes; invalidating every
+consumer for unchanged output makes an ordinary component edit refresh the whole
+app. The fingerprint is recorded only after initialization succeeds.
 
 The [expo-notifications patch](../../patches/expo-notifications@57.0.15.patch) protects
 `NotificationCenterManager`'s delegates and pending responses with a lock. React runtimes can
diff --git a/docs/internals/remote.md b/docs/internals/remote.md
index 43d96f862e3b..04d5a8f9dd88 100644
--- a/docs/internals/remote.md
+++ b/docs/internals/remote.md
@@ -24,6 +24,33 @@ prove that a route works. In particular, a host's loopback address refers to a
 different machine when another device opens it. Endpoint selection must not
 silently fall back to loopback when a shareable endpoint is unavailable.
 
+A saved environment holds an ordered list of routes, and the
+[driver](../../packages/client-runtime/src/connection/driver.ts) connects over
+the first that works. Each direct route is first checked with the public
+descriptor, so a saved LAN address that a different machine answers on another
+network receives no credential. That check is not proof of a working route:
+when every route stays silent, each is still tried. A route that fails to
+connect, including a blocked one such as a signed-out T3 Connect, moves on to
+the next; only an incompatible server stops the walk, because it is the same
+server on every route. While connected over a later route the
+[supervisor](../../packages/client-runtime/src/connection/supervisor.ts)
+preflights the earlier ones and replaces the session when one would connect.
+Preflight includes authorization so a route that answers but rejects this
+client never costs a working session; a route that still fails afterwards is
+held back for a cooldown so a flaky network cannot bounce the connection.
+
+A connected server reports the LAN and tailnet addresses it is bound to, and the
+client saves them as learned routes. A learned route reuses the credential of
+the route it was learned over: the T3 Connect access token, which is not bound
+to an origin because each DPoP proof names the URL it signs, or the paired
+bearer token. Learned routes the server stops reporting are dropped, which is
+how a changed LAN address replaces the old one; routes the user saved are never
+touched. The reported addresses are hints like any advertised endpoint, so a
+learned route still has to answer as this environment before it is used.
+
+GitHub routing trust covers the whole route list. Adding or changing a route
+revokes it; reordering does not, because the same addresses remain trusted.
+
 ## Hosted web is a client
 
 The hosted web app stores its connection catalog in the browser and connects
diff --git a/docs/user/install.md b/docs/user/install.md
index 372d8e6e5607..980837199e9b 100644
--- a/docs/user/install.md
+++ b/docs/user/install.md
@@ -33,7 +33,13 @@ line to add. Set `T3CODE_CHANNEL=nightly` to install the nightly train, or
 | Move to the newest release                       | `t3 update`                                               |
 | Remove it again                                  | `t3 uninstall`                                            |
 
-Run `t3 --help` for the full reference.
+Run `t3 help` or `t3 --help` for the full reference. To start in a new working
+directory, use an explicit path such as `t3 ./my-project`. A bare directory name
+is accepted only if it already exists.
+
+If `t3` or `t3 start` reports an already running server, connect to that server
+instead. Stop it before starting a replacement, or use a different `--base-dir`
+for an independent server.
 
 To try T3 Code once without installing it, run `npx t3@latest` instead (needs
 Node.js for `npx`).
diff --git a/docs/user/remote-access.md b/docs/user/remote-access.md
index f12b66c7e9dc..6e3697902f57 100644
--- a/docs/user/remote-access.md
+++ b/docs/user/remote-access.md
@@ -81,6 +81,35 @@ created in Settings can only be copied from the client that created them while
 its Connections page stays open. If you leave or reload that page, create
 another link to share.
 
+### Reach one machine several ways
+
+A machine can have more than one route: LAN, Tailscale, a public URL, SSH, or
+T3 Connect. To add one, choose **Add route** in the machine's route list, or
+next to it in the T3 Connect list. Pairing the same machine again over another
+address also adds a route instead of a second machine. A new route is placed by
+speed, in that order, and you can reorder routes at any time.
+
+While connected through T3 Connect or a paired address, T3 Code also learns the
+machine's current LAN and Tailscale addresses and adds them as routes, so
+pairing once through T3 Connect is enough to use the LAN at home. When the
+machine's LAN address changes, for example after it joins another Wi-Fi network,
+the learned route follows it. The machine must allow network access for its LAN
+address to be learned. You can reorder a learned route, but not remove it; it
+goes away with the route it was learned through, or when the machine stops
+reporting that address.
+
+T3 Code connects over the first route that answers. Away from home, a LAN
+address that does not answer is checked briefly and skipped. It is only tried
+again, after the other routes, if none of them connect. While connected over a
+later route, T3 Code checks the earlier ones when your network changes, when you
+return to the app, and every minute, and moves back as soon as one works.
+
+On web and desktop, select the route count under the machine's name in
+**Settings → Connections** to see its routes. Drag a route to change the order,
+or remove it. On mobile, open the machine under **Settings → Environments** and
+choose **Edit**. Signing out of T3 Connect removes only that route; a machine
+you can still reach another way stays saved.
+
 ### Balance new threads across machines
 
 Auto balance is off by default. On web and desktop, enable it in
diff --git a/docs/user/thread-migration.md b/docs/user/thread-migration.md
index f01488e1a56e..51f4b87ec9f0 100644
--- a/docs/user/thread-migration.md
+++ b/docs/user/thread-migration.md
@@ -10,7 +10,9 @@ and changes in either version do not sync to the other. Settings, attachments, a
 remain shared.
 
 The V2 desktop app uses a separate browser profile, so browser cookies and caches do not carry
-over from V1. You may need to sign in again to websites opened inside the app.
+over from V1. You may need to sign in again to websites opened inside the app. On its first launch,
+the V2 desktop app copies stashed prompts, unsent drafts, layout, and theme from V1. Anything you
+change in V2 afterwards stays in V2.
 
 The migrated thread keeps its title, project, provider and model selection, permission and
 interaction modes, branch or worktree, archive state, settlement state, snooze and pin state, and
diff --git a/docs/user/updating.md b/docs/user/updating.md
index c0f05fc89351..3461dae9844c 100644
--- a/docs/user/updating.md
+++ b/docs/user/updating.md
@@ -44,7 +44,8 @@ The offered action depends on how the server runs:
 | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **Update server**          | Keep the client open while it installs and reconnects. Supported background services update remotely. For a desktop-hosted server, this also closes and relaunches the desktop app on the host. |
 | **Update the desktop app** | Update the desktop app on the machine running the server, then reopen it if needed.                                                                                                             |
-| **Copy update command**    | Stop the command-line server on its host and relaunch with the copied command, keeping your usual startup options.                                                                              |
+| **Copy update command**    | Run the command on the named host to update the detected global npm install, then restart the server with your usual options.                                                                   |
+| **Copy relaunch command**  | Stop the command-line server on its host and relaunch with the copied command, keeping your usual subcommand and options. This does not update an installed `t3` command.                       |
 
 On the host, run:
 
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index f8a285887dba..965db74b7997 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -319,6 +319,10 @@
       "types": "./src/work-log/userInput.ts",
       "default": "./src/work-log/userInput.ts"
     },
+    "./work-log/item-detail": {
+      "types": "./src/work-log/itemDetail.ts",
+      "default": "./src/work-log/itemDetail.ts"
+    },
     "./work-log/presentation": {
       "types": "./src/work-log/presentation.ts",
       "default": "./src/work-log/presentation.ts"
diff --git a/packages/client-runtime/src/authorization/layer.test.ts b/packages/client-runtime/src/authorization/layer.test.ts
index d31f37db2eb7..3f8dd1a926e5 100644
--- a/packages/client-runtime/src/authorization/layer.test.ts
+++ b/packages/client-runtime/src/authorization/layer.test.ts
@@ -340,6 +340,117 @@ describe("RemoteEnvironmentAuthorization", () => {
     }),
   );
 
+  it.effect("uses the T3 Connect token on a learned direct address without the relay", () =>
+    Effect.gen(function* () {
+      const cached = new TokenStore.RemoteDpopAccessToken({
+        environmentId: ENVIRONMENT_ID,
+        accountId: "account-1",
+        label: DESCRIPTOR.label,
+        endpoint: ENDPOINT,
+        accessToken: "cached-access-token",
+        expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
+        dpopThumbprint: "thumbprint-1",
+      });
+      const harness = yield* makeHarness({
+        initialToken: cached,
+        responses: [Response.json(DESCRIPTOR), websocketTicket("lan-ticket")],
+      });
+
+      const authorized = yield* Effect.gen(function* () {
+        const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
+        return yield* remote.authorizeDpop({
+          expectedEnvironmentId: ENVIRONMENT_ID,
+          directEndpoint: {
+            httpBaseUrl: "http://192.168.1.10:3773/",
+            wsBaseUrl: "ws://192.168.1.10:3773/",
+          },
+        });
+      }).pipe(Effect.provide(harness.layer));
+
+      expect(authorized.httpBaseUrl).toBe("http://192.168.1.10:3773/");
+      expect(authorized.socketUrl).toMatch(/^ws:\/\/192\.168\.1\.10:3773\/ws\?/);
+      expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
+      expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
+        "http://192.168.1.10:3773/.well-known/t3/environment",
+        "http://192.168.1.10:3773/api/auth/websocket-ticket",
+      ]);
+    }),
+  );
+
+  it.effect("sends no token to a direct address that answers as another machine", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        initialToken: persistedToken({ accessToken: "cached-access-token" }),
+        responses: [
+          Response.json({ ...DESCRIPTOR, environmentId: EnvironmentId.make("someone-else") }),
+        ],
+      });
+
+      const error = yield* Effect.gen(function* () {
+        const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
+        return yield* remote
+          .authorizeDpop({
+            expectedEnvironmentId: ENVIRONMENT_ID,
+            directEndpoint: {
+              httpBaseUrl: "http://192.168.1.10:3773/",
+              wsBaseUrl: "ws://192.168.1.10:3773/",
+            },
+          })
+          .pipe(Effect.flip);
+      }).pipe(Effect.provide(harness.layer));
+
+      expect(error).toMatchObject({ _tag: "ConnectionBlockedError", reason: "configuration" });
+      expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
+        "http://192.168.1.10:3773/.well-known/t3/environment",
+      ]);
+      // The token stays saved for the T3 Connect route.
+      expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
+        "cached-access-token",
+      );
+    }),
+  );
+
+  it.effect("replaces a token a learned direct address rejects", () =>
+    Effect.gen(function* () {
+      const cached = new TokenStore.RemoteDpopAccessToken({
+        environmentId: ENVIRONMENT_ID,
+        accountId: "account-1",
+        label: DESCRIPTOR.label,
+        endpoint: ENDPOINT,
+        accessToken: "revoked-access-token",
+        expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
+        dpopThumbprint: "thumbprint-1",
+      });
+      const harness = yield* makeHarness({
+        initialToken: cached,
+        responses: [
+          Response.json(DESCRIPTOR),
+          authInvalid(),
+          Response.json(DESCRIPTOR),
+          accessToken("replacement-access-token"),
+          websocketTicket("lan-ticket"),
+        ],
+      });
+
+      const authorized = yield* Effect.gen(function* () {
+        const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
+        return yield* remote.authorizeDpop({
+          expectedEnvironmentId: ENVIRONMENT_ID,
+          directEndpoint: {
+            httpBaseUrl: "http://192.168.1.10:3773/",
+            wsBaseUrl: "ws://192.168.1.10:3773/",
+          },
+        });
+      }).pipe(Effect.provide(harness.layer));
+
+      expect(authorized.socketUrl).toContain("wsTicket=lan-ticket");
+      expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
+      expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
+        "replacement-access-token",
+      );
+    }),
+  );
+
   it.effect("refreshes and persists an expired environment token", () =>
     Effect.gen(function* () {
       const expired = new TokenStore.RemoteDpopAccessToken({
diff --git a/packages/client-runtime/src/authorization/service.ts b/packages/client-runtime/src/authorization/service.ts
index 85929f73dd38..56b0ced30729 100644
--- a/packages/client-runtime/src/authorization/service.ts
+++ b/packages/client-runtime/src/authorization/service.ts
@@ -71,6 +71,13 @@ export class RemoteEnvironmentAuthorization extends Context.Service<
     }) => Effect.Effect<AuthorizedRemoteEnvironment, ConnectionAttemptError>;
     readonly authorizeDpop: (input: {
       readonly expectedEnvironmentId: EnvironmentId;
+      /**
+       * Connect to this origin instead of the T3 Connect tunnel. The access
+       * token is not bound to an origin, and each proof is minted for the URL
+       * it signs, so a token from the relay also works on the environment's
+       * LAN or tailnet address.
+       */
+      readonly directEndpoint?: { readonly httpBaseUrl: string; readonly wsBaseUrl: string };
     }) => Effect.Effect<AuthorizedRemoteEnvironment, ConnectionAttemptError>;
     readonly authorizeDpopHttp: (input: {
       readonly expectedEnvironmentId: EnvironmentId;
@@ -132,14 +139,15 @@ export const make = Effect.gen(function* () {
     >
   >(new Map());
 
-  const authorizeBearer = Effect.fn("clientRuntime.connection.remote.authorizeBearer")(
+  /**
+   * Confirms a direct address still serves the expected environment before a
+   * credential is sent there. A saved LAN address can belong to another
+   * machine on a different network.
+   */
+  const verifyDirectEndpoint = Effect.fn("clientRuntime.connection.remote.verifyDirectEndpoint")(
     function* (input: {
-      readonly expectedEnvironmentId: Parameters<
-        RemoteEnvironmentAuthorization["Service"]["authorizeBearer"]
-      >[0]["expectedEnvironmentId"];
+      readonly expectedEnvironmentId: EnvironmentId;
       readonly httpBaseUrl: string;
-      readonly wsBaseUrl: string;
-      readonly bearerToken: string;
       readonly connectionMethod: ClientConnectionMethod;
     }) {
       const now = yield* Clock.currentTimeMillis;
@@ -169,6 +177,21 @@ export const make = Effect.gen(function* () {
           return next;
         });
       }
+      return descriptor;
+    },
+  );
+
+  const authorizeBearer = Effect.fn("clientRuntime.connection.remote.authorizeBearer")(
+    function* (input: {
+      readonly expectedEnvironmentId: Parameters<
+        RemoteEnvironmentAuthorization["Service"]["authorizeBearer"]
+      >[0]["expectedEnvironmentId"];
+      readonly httpBaseUrl: string;
+      readonly wsBaseUrl: string;
+      readonly bearerToken: string;
+      readonly connectionMethod: ClientConnectionMethod;
+    }) {
+      const descriptor = yield* verifyDirectEndpoint(input);
       const socketUrl = yield* resolveRemoteWebSocketConnectionUrl({
         wsBaseUrl: input.wsBaseUrl,
         httpBaseUrl: input.httpBaseUrl,
@@ -193,11 +216,15 @@ export const make = Effect.gen(function* () {
   );
 
   const createDpopSocketUrl = Effect.fn("clientRuntime.connection.remote.createDpopSocketUrl")(
-    function* (token: TokenStore.RemoteDpopAccessToken, timeoutMs?: number) {
+    function* (
+      token: TokenStore.RemoteDpopAccessToken,
+      timeoutMs?: number,
+      endpoint: { readonly httpBaseUrl: string; readonly wsBaseUrl: string } = token.endpoint,
+    ) {
       const ticketProof = yield* signer
         .createProof({
           method: "POST",
-          url: environmentEndpointUrl(token.endpoint.httpBaseUrl, "/api/auth/websocket-ticket"),
+          url: environmentEndpointUrl(endpoint.httpBaseUrl, "/api/auth/websocket-ticket"),
           accessToken: token.accessToken,
         })
         .pipe(
@@ -210,8 +237,8 @@ export const make = Effect.gen(function* () {
           ),
         );
       return yield* resolveRemoteDpopWebSocketConnectionUrl({
-        wsBaseUrl: token.endpoint.wsBaseUrl,
-        httpBaseUrl: token.endpoint.httpBaseUrl,
+        wsBaseUrl: endpoint.wsBaseUrl,
+        httpBaseUrl: endpoint.httpBaseUrl,
         accessToken: token.accessToken,
         dpopProof: ticketProof,
         clientMetadata: presentation.metadata,
@@ -449,10 +476,11 @@ export const make = Effect.gen(function* () {
 
   const httpAuthorization = (
     token: TokenStore.RemoteDpopAccessToken,
+    httpBaseUrl = token.endpoint.httpBaseUrl,
   ): AuthorizedRemoteHttpEnvironment => ({
     environmentId: token.environmentId,
     label: token.label,
-    httpBaseUrl: token.endpoint.httpBaseUrl,
+    httpBaseUrl,
     httpAuthorization: {
       _tag: "Dpop",
       accessToken: token.accessToken,
@@ -463,33 +491,57 @@ export const make = Effect.gen(function* () {
   const authorizeDpop = Effect.fn("clientRuntime.connection.remote.authorizeDpop")(function* (
     input: Parameters<RemoteEnvironmentAuthorization["Service"]["authorizeDpop"]>[0],
   ) {
+    const endpoint = input.directEndpoint;
+    if (endpoint !== undefined) {
+      yield* verifyDirectEndpoint({
+        expectedEnvironmentId: input.expectedEnvironmentId,
+        httpBaseUrl: endpoint.httpBaseUrl,
+        connectionMethod: "direct",
+      });
+    }
+    const authorized = (token: TokenStore.RemoteDpopAccessToken, socketUrl: string) => ({
+      ...httpAuthorization(token, endpoint?.httpBaseUrl),
+      socketUrl,
+    });
     let selected = yield* getDpopToken(input);
     if (selected.fromCache) {
       const cachedSocket = yield* createDpopSocketUrl(
         selected.token,
         CACHED_ENDPOINT_SOCKET_TIMEOUT_MS,
+        endpoint,
       ).pipe(Effect.result);
       if (Result.isSuccess(cachedSocket)) {
         yield* assertSession(selected.identity);
-        return { ...httpAuthorization(selected.token), socketUrl: cachedSocket.success };
+        return authorized(selected.token, cachedSocket.success);
       }
       if (cachedSocket.failure._tag === "ConnectionBlockedError") {
         return yield* mapDpopSocketError(cachedSocket.failure);
       }
+      // An unreachable direct address says nothing about the token, so keep
+      // it for the T3 Connect route rather than forcing a relay round trip.
+      // A rejected token falls through and is replaced like on the tunnel.
+      if (endpoint !== undefined && cachedSocket.failure._tag !== "EnvironmentAuthInvalidError") {
+        return yield* mapDpopSocketError(cachedSocket.failure);
+      }
       selected = yield* getDpopToken({
         ...input,
         rejectedAccessToken: selected.token.accessToken,
       });
     }
-    const socket = yield* createDpopSocketUrl(selected.token).pipe(Effect.result);
+    const socket = yield* createDpopSocketUrl(selected.token, undefined, endpoint).pipe(
+      Effect.result,
+    );
     if (Result.isFailure(socket)) {
-      yield* tokenLock.withPermits(1)(
-        removeRejectedToken(input.expectedEnvironmentId, selected.token.accessToken),
-      );
+      // A direct address that refuses the socket says nothing about the token.
+      if (endpoint === undefined || socket.failure._tag === "ConnectionBlockedError") {
+        yield* tokenLock.withPermits(1)(
+          removeRejectedToken(input.expectedEnvironmentId, selected.token.accessToken),
+        );
+      }
       return yield* mapDpopSocketError(socket.failure);
     }
     yield* assertSession(selected.identity);
-    return { ...httpAuthorization(selected.token), socketUrl: socket.success };
+    return authorized(selected.token, socket.success);
   });
 
   return RemoteEnvironmentAuthorization.of({
diff --git a/packages/client-runtime/src/connection/boxCatalog.ts b/packages/client-runtime/src/connection/boxCatalog.ts
index 43d96167bcbb..2ea906f9e50a 100644
--- a/packages/client-runtime/src/connection/boxCatalog.ts
+++ b/packages/client-runtime/src/connection/boxCatalog.ts
@@ -2,7 +2,7 @@ import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 
 import type { ConnectionCatalogEntry, ConnectionRegistration } from "./catalog.ts";
-import { BearerConnectionTarget, type ConnectionTarget, connectionBox } from "./model.ts";
+import { BearerConnectionTarget, connectionBox } from "./model.ts";
 
 /**
  * Saves a box's target and leaves whatever pairing this device holds for it untouched. It is the
@@ -30,18 +30,3 @@ export function holdsPairing(entry: ConnectionCatalogEntry | undefined): boolean
 export function isUnpairedBox(entry: ConnectionCatalogEntry): boolean {
   return connectionBox(entry.target) !== null && !holdsPairing(entry);
 }
-
-/**
- * Whether saving `registration` over `previous` keeps the profile and credential saved under the
- * unchanged connection id, so relabeling or marking a paired box never drops its pairing.
- */
-export function keepsBoxPairing(
-  registration: CatalogRegistration,
-  previous: ConnectionTarget,
-): boolean {
-  return (
-    registration._tag === "BoxTargetRegistration" &&
-    previous._tag === "BearerConnectionTarget" &&
-    previous.connectionId === registration.target.connectionId
-  );
-}
diff --git a/packages/client-runtime/src/connection/boxErrors.ts b/packages/client-runtime/src/connection/boxErrors.ts
index 7eafcff62794..67048624b4cc 100644
--- a/packages/client-runtime/src/connection/boxErrors.ts
+++ b/packages/client-runtime/src/connection/boxErrors.ts
@@ -1,5 +1,3 @@
-import type { EnvironmentId } from "@t3tools/contracts";
-
 import type { RemoteEnvironmentAuthError } from "../authorization/remote.ts";
 import { ConnectionBlockedError } from "./model.ts";
 
@@ -20,19 +18,3 @@ export function isBoxNotServing(error: RemoteEnvironmentAuthError): boolean {
     NOT_SERVING_STATUSES.has(error.status)
   );
 }
-
-/**
- * Refuses a pairing whose server is not the environment the caller expected, checked before the
- * pairing grant is consumed. Null when nothing was expected or the server matches.
- */
-export function pairedEnvironmentMismatch(
-  expected: EnvironmentId | undefined,
-  actual: EnvironmentId,
-): ConnectionBlockedError | null {
-  return expected === undefined || expected === actual
-    ? null
-    : new ConnectionBlockedError({
-        reason: "configuration",
-        detail: "The paired server does not match the expected environment.",
-      });
-}
diff --git a/packages/client-runtime/src/connection/catalog.ts b/packages/client-runtime/src/connection/catalog.ts
index e986b79f88ad..62dcde7fb119 100644
--- a/packages/client-runtime/src/connection/catalog.ts
+++ b/packages/client-runtime/src/connection/catalog.ts
@@ -24,6 +24,17 @@ export class BearerConnectionProfile extends Schema.TaggedClass<BearerConnection
     ...ConnectionProfileBase,
     httpBaseUrl: Schema.String,
     wsBaseUrl: Schema.String,
+    /**
+     * Set on a route the server reported while this client was connected,
+     * rather than one the user paired. Learned routes are replaced when the
+     * server reports a different address, for example after a DHCP change.
+     */
+    learned: Schema.optionalKey(Schema.Literal(true)),
+    /**
+     * "t3-connect" when the route authenticates with the environment's T3
+     * Connect credential instead of a stored bearer token.
+     */
+    authorization: Schema.optionalKey(Schema.Literal("t3-connect")),
   },
 ) {}
 
@@ -38,9 +49,21 @@ export class SshConnectionProfile extends Schema.TaggedClass<SshConnectionProfil
 export const ConnectionProfile = Schema.Union([BearerConnectionProfile, SshConnectionProfile]);
 export type ConnectionProfile = typeof ConnectionProfile.Type;
 
+/** One way to reach an environment: T3 Connect, a direct URL, or SSH. */
+export interface ConnectionRoute {
+  readonly target: ConnectionTarget;
+  readonly profile: Option.Option<ConnectionProfile>;
+}
+
+/**
+ * A saved environment. `target` and `profile` are its preferred route;
+ * `alternateRoutes` holds the others in preference order. Read them together
+ * with `connectionRoutes`.
+ */
 export interface ConnectionCatalogEntry {
   readonly target: ConnectionTarget;
   readonly profile: Option.Option<ConnectionProfile>;
+  readonly alternateRoutes?: ReadonlyArray<ConnectionRoute>;
   /** False when the user switched the environment off: saved, but never connects. */
   readonly enabled: boolean;
   /** Discovery rejection stays visible while the saved connection is switched off. */
diff --git a/packages/client-runtime/src/connection/driver.ts b/packages/client-runtime/src/connection/driver.ts
index ceec663c1bb5..701f1c3d185d 100644
--- a/packages/client-runtime/src/connection/driver.ts
+++ b/packages/client-runtime/src/connection/driver.ts
@@ -1,16 +1,22 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
-import type * as Scope from "effect/Scope";
+import * as Scope from "effect/Scope";
+import * as HttpClient from "effect/unstable/http/HttpClient";
 
-import type { ConnectionCatalogEntry } from "./catalog.ts";
+import type { ConnectionCatalogEntry, ConnectionRoute } from "./catalog.ts";
 import type {
   ConnectionAttemptError,
   ConnectionAttemptStage,
   PreparedConnection,
 } from "./model.ts";
+import { ConnectionTransientError } from "./model.ts";
 import * as ConnectionResolver from "./resolver.ts";
+import { connectionRoutes, routeEntry, routeHttpBaseUrl } from "./routes.ts";
 import * as RpcSession from "../rpc/session.ts";
+import { fetchRemoteEnvironmentDescriptor } from "../environment/descriptor.ts";
 
 export type ConnectionDriverProgress =
   | {
@@ -26,6 +32,15 @@ export interface EnvironmentConnectionLease {
   readonly session: RpcSession.RpcSession;
 }
 
+/**
+ * The result of an unauthenticated reachability check. T3 Connect and SSH
+ * routes have no cheap check, so they are "unchecked".
+ */
+export type RouteCheck = "answered" | "silent" | "unchecked";
+
+/** How long a direct route has to answer before it counts as unreachable from here. */
+const ROUTE_CHECK_TIMEOUT_MS = 2_500;
+
 export class ConnectionDriver extends Context.Service<
   ConnectionDriver,
   {
@@ -33,13 +48,118 @@ export class ConnectionDriver extends Context.Service<
       entry: ConnectionCatalogEntry,
       reportProgress: (progress: ConnectionDriverProgress) => Effect.Effect<void>,
     ) => Effect.Effect<EnvironmentConnectionLease, ConnectionAttemptError, Scope.Scope>;
+    /** Whether a direct route answers as the entry's environment, without credentials. */
+    readonly checkRoute: (
+      entry: ConnectionCatalogEntry,
+      route: ConnectionRoute,
+    ) => Effect.Effect<RouteCheck>;
+    /**
+     * Whether a direct route answers and accepts this client's credential,
+     * without opening a socket. Switching to a route that fails this would
+     * drop a working connection for nothing.
+     */
+    readonly preflight: (
+      entry: ConnectionCatalogEntry,
+      route: ConnectionRoute,
+    ) => Effect.Effect<boolean>;
   }
 >()("@t3tools/client-runtime/connection/driver/ConnectionDriver") {}
 
+/**
+ * Connects over the first route, in preference order, that is worth trying.
+ * Every route is checked at once, but a route only waits for its own check,
+ * so a reachable LAN address connects without waiting on a silent tailnet
+ * one. A silent route is skipped on the first pass so a LAN address from
+ * another network costs one short check, not a connection timeout. A route
+ * that fails to connect moves on to the next: a signed-out T3 Connect must
+ * not hide a working LAN. Silent routes are tried last, since a check is not
+ * proof.
+ *
+ * The reported error is a transient one when any route failed transiently,
+ * so the supervisor keeps retrying a route that may come back; a blocked
+ * error is reported only when every attempted route was blocked.
+ */
+export const connectOverRoutes = Effect.fn("ConnectionDriver.connectOverRoutes")(function* <R>(
+  entry: ConnectionCatalogEntry,
+  checkRoute: (route: ConnectionRoute) => Effect.Effect<RouteCheck>,
+  connectRoute: (
+    route: ConnectionRoute,
+  ) => Effect.Effect<EnvironmentConnectionLease, ConnectionAttemptError, R | Scope.Scope>,
+) {
+  const routes = connectionRoutes(entry);
+  const checks =
+    routes.length === 1
+      ? []
+      : yield* Effect.forEach(routes, (route) => Effect.forkChild(checkRoute(route)));
+  const attemptScope = yield* Scope.Scope;
+  let transient: ConnectionAttemptError | undefined;
+  let blocked: ConnectionAttemptError | undefined;
+  // Each route gets its own scope so a half-open session closes before the next try.
+  const attempt = Effect.fnUntraced(function* (route: ConnectionRoute) {
+    const routeScope = yield* Scope.fork(attemptScope);
+    const result = yield* connectRoute(route).pipe(
+      Scope.provide(routeScope),
+      Effect.onExit((exit) => (Exit.isSuccess(exit) ? Effect.void : Scope.close(routeScope, exit))),
+      Effect.result,
+    );
+    if (result._tag === "Failure") {
+      if (result.failure._tag === "ConnectionTransientError") transient ??= result.failure;
+      else blocked ??= result.failure;
+    }
+    return result;
+  });
+  const silent: Array<ConnectionRoute> = [];
+  for (const [index, route] of routes.entries()) {
+    const check = checks.length === 0 ? "unchecked" : yield* Fiber.join(checks[index]!);
+    if (check === "silent") {
+      silent.push(route);
+      continue;
+    }
+    const result = yield* attempt(route);
+    if (result._tag === "Success") return result.success;
+    // An incompatible server is the same server on every route.
+    if (result.failure.reason === "unsupported") return yield* result.failure;
+  }
+  for (const route of silent) {
+    const result = yield* attempt(route);
+    if (result._tag === "Success") return result.success;
+    if (result.failure.reason === "unsupported") return yield* result.failure;
+  }
+  return yield* (
+    transient ??
+      blocked ??
+      new ConnectionTransientError({
+        reason: "endpoint-unavailable",
+        detail: `${entry.target.label} did not answer on any saved route.`,
+      })
+  );
+});
+
 /** @public Service construction is part of the canonical Effect module API. */
 export const make = Effect.gen(function* () {
   const resolver = yield* ConnectionResolver.ConnectionResolver;
   const sessions = yield* RpcSession.RpcSessionFactory;
+  const httpClient = yield* HttpClient.HttpClient;
+
+  const checkRoute = (entry: ConnectionCatalogEntry, route: ConnectionRoute) => {
+    const httpBaseUrl = routeHttpBaseUrl(route);
+    if (httpBaseUrl === null) return Effect.succeed<RouteCheck>("unchecked");
+    // The descriptor is public, so this sends no credential to whatever
+    // answers at a saved LAN address on a different network.
+    return fetchRemoteEnvironmentDescriptor({
+      httpBaseUrl,
+      timeoutMs: ROUTE_CHECK_TIMEOUT_MS,
+    }).pipe(
+      Effect.map((descriptor): RouteCheck =>
+        descriptor.environmentId === entry.target.environmentId ? "answered" : "silent",
+      ),
+      Effect.orElseSucceed((): RouteCheck => "silent"),
+      Effect.provideService(HttpClient.HttpClient, httpClient),
+      Effect.withSpan("ConnectionDriver.checkRoute", {
+        attributes: { "connection.target.kind": route.target._tag },
+      }),
+    );
+  };
 
   const connect = Effect.fn("ConnectionDriver.connect")(function* (
     entry: ConnectionCatalogEntry,
@@ -49,17 +169,37 @@ export const make = Effect.gen(function* () {
     yield* Effect.annotateCurrentSpan({
       "connection.environment.id": target.environmentId,
       "connection.target.kind": target._tag,
+      "connection.route.count": connectionRoutes(entry).length,
     });
     yield* reportProgress({ stage: "preparing" });
-    const prepared = yield* resolver.prepare(entry);
-    yield* reportProgress({ stage: "opening", prepared });
-    const session = yield* sessions.connect(prepared);
-    yield* reportProgress({ stage: "synchronizing", prepared });
-    yield* session.ready;
-    return { prepared, session } satisfies EnvironmentConnectionLease;
+    return yield* connectOverRoutes(
+      entry,
+      (route) => checkRoute(entry, route),
+      Effect.fnUntraced(function* (route) {
+        const prepared = yield* resolver.prepare(routeEntry(entry, route));
+        yield* reportProgress({ stage: "opening", prepared });
+        const session = yield* sessions.connect(prepared);
+        yield* reportProgress({ stage: "synchronizing", prepared });
+        yield* session.ready;
+        return { prepared, session } satisfies EnvironmentConnectionLease;
+      }),
+    );
   });
 
-  return ConnectionDriver.of({ connect });
+  const preflight = (entry: ConnectionCatalogEntry, route: ConnectionRoute) =>
+    checkRoute(entry, route).pipe(
+      Effect.flatMap((check) =>
+        check === "answered"
+          ? resolver.prepare(routeEntry(entry, route)).pipe(
+              Effect.as(true),
+              Effect.orElseSucceed(() => false),
+            )
+          : Effect.succeed(false),
+      ),
+      Effect.withSpan("ConnectionDriver.preflight"),
+    );
+
+  return ConnectionDriver.of({ connect, checkRoute, preflight });
 });
 
 export const layer = Layer.effect(ConnectionDriver, make);
diff --git a/packages/client-runtime/src/connection/githubRoutingPermissions.ts b/packages/client-runtime/src/connection/githubRoutingPermissions.ts
index fb9ddb1dbd46..da02c2a41ed3 100644
--- a/packages/client-runtime/src/connection/githubRoutingPermissions.ts
+++ b/packages/client-runtime/src/connection/githubRoutingPermissions.ts
@@ -19,9 +19,31 @@ export const StoredGitHubRoutingPermission = Schema.Struct({
 });
 export type StoredGitHubRoutingPermission = typeof StoredGitHubRoutingPermission.Type;
 
-/** Trust belongs to the saved endpoint, never to an environment id advertised by a server alone. */
+/**
+ * Trust belongs to the saved endpoints, never to an environment id advertised
+ * by a server alone. With several routes the key covers all of them, sorted so
+ * reordering keeps trust but adding or changing an address revokes it.
+ */
 export function gitHubRoutingConnectionKey(entry: ConnectionCatalogEntry): string | null {
-  const target = entry.target;
+  // Learned routes come and go with the server's addresses and reuse a saved
+  // route's credential, so they leave trust where the user put it.
+  const routes = [
+    { target: entry.target, profile: entry.profile },
+    ...(entry.alternateRoutes ?? []),
+  ].filter((route) => {
+    const profile = Option.getOrNull(route.profile);
+    return !(profile?._tag === "BearerConnectionProfile" && profile.learned === true);
+  });
+  if (routes.length === 1) return routeConnectionKey(routes[0]!.target, routes[0]!.profile);
+  const keys = routes.map((route) => routeConnectionKey(route.target, route.profile));
+  return keys.every((key) => key !== null) ? JSON.stringify([...keys].sort()) : null;
+}
+
+function routeConnectionKey(
+  target: ConnectionCatalogEntry["target"],
+  routeProfile: ConnectionCatalogEntry["profile"],
+): string | null {
+  const entry = { profile: routeProfile };
   if (target._tag === "RelayConnectionTarget")
     return JSON.stringify([target._tag, target.environmentId]);
   const profile = Option.getOrNull(entry.profile);
diff --git a/packages/client-runtime/src/connection/index.ts b/packages/client-runtime/src/connection/index.ts
index df534cc98d2f..48f39b89b566 100644
--- a/packages/client-runtime/src/connection/index.ts
+++ b/packages/client-runtime/src/connection/index.ts
@@ -11,6 +11,8 @@ export * as Presence from "./presence.ts";
 export * from "./presentation.ts";
 export * as ProfileStore from "./profileStore.ts";
 export * from "./provisioned.ts";
+export * from "./routes.ts";
+export { type RouteCheck } from "./driver.ts";
 export * as EnvironmentRegistry from "./registry.ts";
 // Flat so consumers' inferred types can name them.
 export { EnvironmentNotRegisteredError, PlatformEnvironmentRemovalError } from "./registry.ts";
diff --git a/packages/client-runtime/src/connection/layer.ts b/packages/client-runtime/src/connection/layer.ts
index 79e86affc7c2..b203dbd96774 100644
--- a/packages/client-runtime/src/connection/layer.ts
+++ b/packages/client-runtime/src/connection/layer.ts
@@ -10,6 +10,7 @@ import * as ConnectionResolver from "./resolver.ts";
 import * as ConnectionDriver from "./driver.ts";
 import * as EnvironmentRegistry from "./registry.ts";
 import * as ConnectionOnboarding from "./onboarding.ts";
+import { connectionRoutes, hasRelayRoute } from "./routes.ts";
 import * as PlatformConnectionSource from "../platform/source.ts";
 import * as RelayEnvironmentDiscovery from "../relay/discovery.ts";
 import * as RemoteEnvironmentAuthorization from "../authorization/service.ts";
@@ -45,7 +46,13 @@ export const watchDiscoveredCompatibility = Effect.fn("connection.watchDiscovere
             // a different server with the same environment id, such as a
             // preview app that shares the home directory. Its socket handshake
             // already checks the protocol.
-            if (registered.get(environmentId)?.target._tag !== "RelayConnectionTarget") continue;
+            const saved = registered.get(environmentId);
+            if (
+              saved === undefined ||
+              connectionRoutes(saved).length !== 1 ||
+              !hasRelayRoute(saved)
+            )
+              continue;
             const previous = seenChecks.get(environmentId);
             const fresh =
               previous?.checkedAt !== status.checkedAt ||
diff --git a/packages/client-runtime/src/connection/onboarding.test.ts b/packages/client-runtime/src/connection/onboarding.test.ts
index af86b65912ea..b8c81154b941 100644
--- a/packages/client-runtime/src/connection/onboarding.test.ts
+++ b/packages/client-runtime/src/connection/onboarding.test.ts
@@ -98,12 +98,12 @@ describe("connection onboarding", () => {
         target: {
           environmentId: "environment-paired",
           label: "Paired environment",
-          connectionId: "bearer:environment-paired",
+          connectionId: "bearer:environment-paired:https://remote.example.test",
         },
         profile: {
           environmentId: "environment-paired",
           label: "Paired environment",
-          connectionId: "bearer:environment-paired",
+          connectionId: "bearer:environment-paired:https://remote.example.test",
           httpBaseUrl: "https://remote.example.test/",
           wsBaseUrl: "wss://remote.example.test/",
         },
@@ -150,6 +150,25 @@ describe("connection onboarding", () => {
     }),
   );
 
+  it.effect("refuses to add a route that reaches a different machine, keeping the code", () =>
+    Effect.gen(function* () {
+      const calls: Array<{ readonly url: string; readonly init: RequestInit }> = [];
+      const error = yield* preparePairingRegistration({
+        host: "remote.example.test",
+        pairingCode: "pairing-token",
+        expectedEnvironmentId: EnvironmentId.make("some-other-machine"),
+      }).pipe(
+        Effect.provide(Layer.mergeAll(CLIENT_PRESENTATION_LAYER, pairingHttpLayer(calls))),
+        Effect.flip,
+      );
+      expect(error).toMatchObject({ reason: "configuration" });
+      expect(error.message).toContain("different machine");
+      expect(calls.map((call) => call.url)).toEqual([
+        "https://remote.example.test/.well-known/t3/environment",
+      ]);
+    }),
+  );
+
   it.effect("pairs an outdated server so it can be updated from this client", () =>
     Effect.gen(function* () {
       const calls: Array<{ readonly url: string; readonly init: RequestInit }> = [];
@@ -321,12 +340,12 @@ describe("connection onboarding", () => {
         target: {
           environmentId: "environment-ssh",
           label: "Remote development box",
-          connectionId: "ssh:environment-ssh",
+          connectionId: 'ssh:environment-ssh:["devbox","devbox.example.test","developer",22]',
         },
         profile: {
           environmentId: "environment-ssh",
           label: "Remote development box",
-          connectionId: "ssh:environment-ssh",
+          connectionId: 'ssh:environment-ssh:["devbox","devbox.example.test","developer",22]',
           target,
         },
       });
diff --git a/packages/client-runtime/src/connection/onboarding.ts b/packages/client-runtime/src/connection/onboarding.ts
index f2c5f5ebbcec..bf5ffc2c3ba7 100644
--- a/packages/client-runtime/src/connection/onboarding.ts
+++ b/packages/client-runtime/src/connection/onboarding.ts
@@ -23,7 +23,6 @@ import {
 } from "./catalog.ts";
 import * as ConnectionCredentialStore from "./credentialStore.ts";
 import { mapRemoteEnvironmentError } from "./errors.ts";
-import { pairedEnvironmentMismatch } from "./boxErrors.ts";
 import {
   BearerConnectionTarget,
   type BoxAttachment,
@@ -34,19 +33,26 @@ import {
 import * as Persistence from "../platform/persistence.ts";
 import * as EnvironmentRegistry from "./registry.ts";
 import { orchestrationProtocolCompatibilityError } from "./compatibility.ts";
+import { connectionRoutes, routeEntry, sshTargetKey } from "./routes.ts";
 
 export interface PairingConnectionInput {
-  readonly expectedEnvironmentId?: EnvironmentId;
   /** Set when the pairing reaches a cloud box, which is saved as its chat's, not a user environment. */
   readonly box?: BoxAttachment;
   readonly pairingUrl?: string;
   readonly host?: string;
   readonly pairingCode?: string;
+  /**
+   * Set when adding a route to a saved machine: the pairing must reach this
+   * environment, or nothing is saved.
+   */
+  readonly expectedEnvironmentId?: EnvironmentId;
 }
 
 export interface SshConnectionInput {
   readonly target: DesktopSshEnvironmentTarget;
   readonly label?: string;
+  /** Set when adding a route to a saved machine; see `PairingConnectionInput`. */
+  readonly expectedEnvironmentId?: EnvironmentId;
 }
 
 export interface BearerConnectionUpdateInput {
@@ -89,6 +95,22 @@ const resolvePairingTarget = Effect.fn("clientRuntime.connection.onboarding.reso
   },
 );
 
+/**
+ * One bearer route per address, so pairing over Tailscale adds a route next
+ * to the LAN one instead of replacing it. Pairing the same address again
+ * reuses the id and replaces that route.
+ */
+function bearerConnectionId(environmentId: EnvironmentId, httpBaseUrl: string): string {
+  return `bearer:${environmentId}:${new URL(httpBaseUrl).origin}`;
+}
+
+function differentMachineError(label: string) {
+  return new ConnectionBlockedError({
+    reason: "configuration",
+    detail: `That address reaches ${label}, a different machine. Add it as its own environment instead.`,
+  });
+}
+
 export const preparePairingRegistration = Effect.fn(
   "clientRuntime.connection.onboarding.preparePairingRegistration",
 )(function* (input: PairingConnectionInput) {
@@ -97,20 +119,25 @@ export const preparePairingRegistration = Effect.fn(
   const descriptor = yield* fetchRemoteEnvironmentDescriptor({
     httpBaseUrl: target.httpBaseUrl,
   }).pipe(Effect.mapError(mapRemoteEnvironmentError));
+  // Checked before redeeming the one-time code, so a wrong link is not spent.
+  if (
+    input.expectedEnvironmentId !== undefined &&
+    descriptor.environmentId !== input.expectedEnvironmentId
+  ) {
+    return yield* differentMachineError(descriptor.label);
+  }
   const compatibilityError = orchestrationProtocolCompatibilityError(descriptor);
   // An outdated server is still saved so it can be updated from this client.
   if (compatibilityError !== null && compatibilityError.serverUpdateRequired !== true) {
     return yield* compatibilityError;
   }
-  const mismatch = pairedEnvironmentMismatch(input.expectedEnvironmentId, descriptor.environmentId);
-  if (mismatch !== null) return yield* mismatch;
   const access = yield* bootstrapRemoteBearerSession({
     httpBaseUrl: target.httpBaseUrl,
     credential: target.credential,
     scopes: presentation.scopes,
     clientMetadata: presentation.metadata,
   }).pipe(Effect.mapError(mapRemoteEnvironmentError));
-  const connectionId = `bearer:${descriptor.environmentId}`;
+  const connectionId = bearerConnectionId(descriptor.environmentId, target.httpBaseUrl);
 
   return new BearerConnectionRegistration({
     target: new BearerConnectionTarget({
@@ -149,7 +176,15 @@ const updateBearerConnection = Effect.fn(
 )(function* (input: BearerConnectionUpdateInput) {
   const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
   const credentials = yield* ConnectionCredentialStore.ConnectionCredentialStore;
-  const entry = (yield* SubscriptionRef.get(registry.entries)).get(input.environmentId);
+  const saved = (yield* SubscriptionRef.get(registry.entries)).get(input.environmentId);
+  // Editing changes the environment's first direct route; others stay as saved.
+  const route =
+    saved === undefined
+      ? undefined
+      : connectionRoutes(saved).find(
+          (candidate) => candidate.target._tag === "BearerConnectionTarget",
+        );
+  const entry = saved === undefined || route === undefined ? saved : routeEntry(saved, route);
   const credential =
     entry?.target._tag === "BearerConnectionTarget"
       ? yield* credentials.get(entry.target.connectionId)
@@ -228,8 +263,10 @@ export const prepareSshRegistration = Effect.fn(
   "clientRuntime.connection.onboarding.prepareSshRegistration",
 )(function* (input: SshConnectionInput) {
   const gateway = yield* ClientCapabilities.SshEnvironmentGateway;
-  const provisioned = yield* gateway.provision(input.target);
-  const connectionId = `ssh:${provisioned.environmentId}`;
+  const provisioned = yield* gateway.provision(input.target, input.expectedEnvironmentId);
+  // One id per SSH target, so a second host or alias for the same machine
+  // adds a route instead of replacing the first.
+  const connectionId = `ssh:${provisioned.environmentId}:${sshTargetKey(provisioned.bootstrap.target)}`;
   const label = input.label?.trim() || provisioned.label || provisioned.bootstrap.target.alias;
 
   return new SshConnectionRegistration({
@@ -251,6 +288,12 @@ const registerSshConnection = Effect.fn(
   "clientRuntime.connection.onboarding.registerSshConnection",
 )(function* (input: SshConnectionInput) {
   const registration = yield* prepareSshRegistration(input);
+  if (
+    input.expectedEnvironmentId !== undefined &&
+    registration.target.environmentId !== input.expectedEnvironmentId
+  ) {
+    return yield* differentMachineError(registration.target.label);
+  }
   const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
   yield* registry.register(registration);
   return registration.target.environmentId;
diff --git a/packages/client-runtime/src/connection/outdatedHostUpdate.ts b/packages/client-runtime/src/connection/outdatedHostUpdate.ts
index 0ca445b89386..08b5ae28651f 100644
--- a/packages/client-runtime/src/connection/outdatedHostUpdate.ts
+++ b/packages/client-runtime/src/connection/outdatedHostUpdate.ts
@@ -26,6 +26,7 @@ import { isLegacyUpdateHandoffLoss, resolveServerUpdateProgressResult } from "..
 import * as RelayEnvironmentDiscovery from "../relay/discovery.ts";
 import * as ConnectionResolver from "./resolver.ts";
 import * as EnvironmentRegistry from "./registry.ts";
+import { connectionRoutes, hasRelayRoute, routeEntry, routeHttpBaseUrl } from "./routes.ts";
 
 // A v1 host restarting into v2 runs migrations before its descriptor answers again.
 const OUTDATED_HOST_RESTART_TIMEOUT = Duration.minutes(4);
@@ -63,7 +64,11 @@ export const updateOutdatedHost = Effect.fn("clientRuntime.connection.updateOutd
     if (entry === undefined) {
       return yield* new EnvironmentRegistry.EnvironmentNotRegisteredError({ environmentId });
     }
-    const { prepared, descriptor } = yield* resolver.prepareForUpdate(entry);
+    // An outdated server cannot connect normally, so the routes are tried in
+    // order here. The first that authorizes carries the update.
+    const { prepared, descriptor } = yield* Effect.firstSuccessOf(
+      connectionRoutes(entry).map((route) => resolver.prepareForUpdate(routeEntry(entry, route))),
+    );
     const capabilities = descriptor.capabilities;
     if (
       capabilities.serverSelfUpdate === undefined ||
@@ -154,9 +159,23 @@ export const updateOutdatedHost = Effect.fn("clientRuntime.connection.updateOutd
     );
 
     yield* onStage("resuming");
-    const resumed = yield* fetchRemoteEnvironmentDescriptor({
-      httpBaseUrl: prepared.httpBaseUrl,
-    }).pipe(
+    // The restarted host may answer on another saved route, so each poll asks
+    // every direct address, the one that carried the update first.
+    const pollUrls = [
+      prepared.httpBaseUrl,
+      ...connectionRoutes(entry).flatMap((route) => routeHttpBaseUrl(route) ?? []),
+    ].filter((url, index, all) => all.indexOf(url) === index);
+    const resumed = yield* Effect.firstSuccessOf(
+      pollUrls.map((httpBaseUrl) =>
+        fetchRemoteEnvironmentDescriptor({ httpBaseUrl }).pipe(
+          Effect.filterOrFail(
+            (descriptor) =>
+              descriptor.environmentId === environmentId && isCompatibleDescriptor(descriptor),
+            () => "not-ready" as const,
+          ),
+        ),
+      ),
+    ).pipe(
       Effect.provideService(HttpClient.HttpClient, httpClient),
       Effect.option,
       Effect.repeat({
@@ -175,7 +194,7 @@ export const updateOutdatedHost = Effect.fn("clientRuntime.connection.updateOutd
 
     // Discovery still holds the old relay descriptor and would re-block the
     // environment from it, so replace that before clearing the block.
-    if (entry.target._tag === "RelayConnectionTarget") {
+    if (hasRelayRoute(entry)) {
       const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
       yield* discovery.refresh;
     }
diff --git a/packages/client-runtime/src/connection/registry.cloud.test.ts b/packages/client-runtime/src/connection/registry.cloud.test.ts
index a3aa8ddbfe03..d68facb9f7ae 100644
--- a/packages/client-runtime/src/connection/registry.cloud.test.ts
+++ b/packages/client-runtime/src/connection/registry.cloud.test.ts
@@ -70,6 +70,8 @@ import {
 } from "./presentation.ts";
 import * as ConnectionProfileStore from "./profileStore.ts";
 import * as EnvironmentRegistry from "./registry.ts";
+import { remoteHttpClientLayer } from "../rpc/http.ts";
+import { connectionRouteId } from "./routes.ts";
 import * as RpcSession from "../rpc/session.ts";
 import * as EnvironmentSupervisor from "./supervisor.ts";
 import * as ConnectionWakeups from "./wakeups.ts";
@@ -259,15 +261,12 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
     readonly beforeRegistrationRegister?: (
       registration: CatalogRegistration,
     ) => Effect.Effect<void, Persistence.ConnectionPersistenceError>;
-    readonly beforeRegistrationRemove?: (
-      target: ConnectionTarget,
-    ) => Effect.Effect<void, Persistence.ConnectionPersistenceError>;
     readonly initialDisabled?: ReadonlyArray<EnvironmentId>;
     /** Runs as the cache is read, holding whoever reads it. */
     readonly beforeLoadShell?: (environmentId: EnvironmentId) => Effect.Effect<void>;
   },
 ) {
-  const storedTargets = yield* Ref.make(
+  const storedTargets = yield* Ref.make<ReadonlyMap<EnvironmentId, ConnectionTarget>>(
     new Map(initialTargets.map((target) => [target.environmentId, target])),
   );
   const shellCache = yield* Ref.make(new Map([[TARGET.environmentId, CACHED_SNAPSHOT]]));
@@ -315,15 +314,13 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
     listDisabled: Ref.get(storedDisabled).pipe(Effect.map((ids) => [...ids])),
   });
   const registrationStore = Persistence.ConnectionRegistrationStore.of({
-    register: (registration) =>
+    register: (registration, routes) =>
       Effect.gen(function* () {
         yield* options?.beforeRegistrationRegister?.(registration) ?? Effect.void;
         yield* Ref.update(registrationWrites, (count) => count + 1);
-        yield* Ref.update(storedTargets, (current) => {
-          const next = new Map(current);
-          next.set(registration.target.environmentId, registration.target);
-          return next;
-        });
+        yield* Ref.update(storedTargets, (current) =>
+          withPreferredRoute(current, registration.target.environmentId, routes),
+        );
         switch (registration._tag) {
           case "RelayConnectionRegistration":
             return;
@@ -347,29 +344,32 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
             });
         }
       }),
-    remove: (target) =>
+    setRoutes: (environmentId, routes) =>
+      Ref.update(storedTargets, (current) => withPreferredRoute(current, environmentId, routes)),
+    remove: (environmentId) =>
       Effect.gen(function* () {
-        yield* options?.beforeRegistrationRemove?.(target) ?? Effect.void;
+        const target = (yield* Ref.get(storedTargets)).get(environmentId);
         yield* Ref.update(storedTargets, (current) => {
           const next = new Map(current);
-          next.delete(target.environmentId);
+          next.delete(environmentId);
           return next;
         });
-        if (target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget") {
+        if (target?._tag === "BearerConnectionTarget" || target?._tag === "SshConnectionTarget") {
+          const { connectionId } = target;
           yield* Ref.update(storedProfiles, (current) => {
             const next = new Map(current);
-            next.delete(target.connectionId);
+            next.delete(connectionId);
             return next;
           });
           yield* Ref.update(storedCredentials, (current) => {
             const next = new Map(current);
-            next.delete(target.connectionId);
+            next.delete(connectionId);
             return next;
           });
         }
         yield* Ref.update(storedRemoteTokens, (current) => {
           const next = new Map(current);
-          next.delete(target.environmentId);
+          next.delete(environmentId);
           return next;
         });
       }),
@@ -502,6 +502,11 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
         }),
       prepareForUpdate: () => Effect.die(new Error("Updating outdated hosts is not used.")),
     }),
+    // Route checks find nothing, so each saved route is dialed as it would be after a check.
+    Effect.provide(
+      remoteHttpClientLayer((() =>
+        Promise.reject(new TypeError("Route checks are not used."))) as typeof fetch),
+    ),
     Effect.provideService(RpcSession.RpcSessionFactory, {
       connect: (prepared) =>
         Effect.gen(function* () {
@@ -753,6 +758,19 @@ const recordPhases = Effect.fn("TestEnvironmentRegistry.recordPhases")(function*
   return phases;
 });
 
+/** The store keeps one route per environment: the preferred one, which is all a box has. */
+function withPreferredRoute(
+  current: ReadonlyMap<EnvironmentId, ConnectionTarget>,
+  environmentId: EnvironmentId,
+  routes: ReadonlyArray<ConnectionTarget>,
+): ReadonlyMap<EnvironmentId, ConnectionTarget> {
+  const next = new Map(current);
+  const [preferred] = routes;
+  if (preferred === undefined) next.delete(environmentId);
+  else next.set(environmentId, preferred);
+  return next;
+}
+
 describe("EnvironmentRegistry", () => {
   it.effect("persists a missing workspace without reconnecting or deleting saved data", () =>
     Effect.gen(function* () {
@@ -2424,4 +2442,31 @@ describe("EnvironmentRegistry.syncHostBoxes", () => {
       }).pipe(Effect.provide(harness.layer), Effect.scoped);
     }),
   );
+
+  it.effect("removing a host's last route forgets the unpaired boxes it lists", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [TARGET, HOST_BOX],
+        [HOST_BOX_PROFILE],
+        [[HOST_BOX.connectionId, BEARER_CREDENTIAL]],
+      );
+
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        yield* registry.start;
+        yield* registry.syncHostBoxes(
+          TARGET.environmentId,
+          listing(listedBox(CHAT_BOX_ID, { chat: chatAt(4) }), listedBox(HOST_BOX.environmentId)),
+        );
+        yield* registry.removeRoute(TARGET.environmentId, connectionRouteId(TARGET));
+
+        expect([...(yield* SubscriptionRef.get(registry.entries)).keys()]).toEqual([
+          HOST_BOX.environmentId,
+        ]);
+        expect([...(yield* Ref.get(harness.storedTargets)).keys()]).toEqual([
+          HOST_BOX.environmentId,
+        ]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
 });
diff --git a/packages/client-runtime/src/connection/registry.test.ts b/packages/client-runtime/src/connection/registry.test.ts
index e6dc0f0a8429..b825a39ac2ad 100644
--- a/packages/client-runtime/src/connection/registry.test.ts
+++ b/packages/client-runtime/src/connection/registry.test.ts
@@ -27,15 +27,21 @@ import {
   BearerConnectionProfile,
   BearerConnectionRegistration,
   type CatalogRegistration,
+  type ConnectionCatalogEntry,
+  type ConnectionRegistration,
+  type ConnectionRoute,
   PrimaryConnectionRegistration,
   RelayConnectionRegistration,
   SshConnectionProfile,
+  SshConnectionRegistration,
   type ConnectionCredential,
   type ConnectionProfile,
 } from "./catalog.ts";
 import * as Connectivity from "./connectivity.ts";
 import * as ConnectionCredentialStore from "./credentialStore.ts";
 import * as ConnectionDriver from "./driver.ts";
+import type { RouteCheck } from "./driver.ts";
+import { connectionRouteId } from "./routes.ts";
 import {
   ConnectionTransientError,
   ConnectionBlockedError,
@@ -52,6 +58,7 @@ import * as ConnectionProfileStore from "./profileStore.ts";
 import * as EnvironmentRegistry from "./registry.ts";
 import {
   GitHubRoutingPermissions,
+  type StoredGitHubRoutingPermission,
   makeGitHubRoutingPermissions,
 } from "./githubRoutingPermissions.ts";
 import * as RpcSession from "../rpc/session.ts";
@@ -148,14 +155,14 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
       registration: CatalogRegistration,
     ) => Effect.Effect<void, Persistence.ConnectionPersistenceError>;
     readonly beforeRegistrationRemove?: (
-      target: ConnectionTarget,
+      environmentId: EnvironmentId,
     ) => Effect.Effect<void, Persistence.ConnectionPersistenceError>;
+    readonly checkRoute?: (route: ConnectionRoute) => RouteCheck;
+    readonly prepareRoute?: (target: ConnectionTarget) => ConnectionBlockedError | undefined;
     readonly initialDisabled?: ReadonlyArray<EnvironmentId>;
   },
 ) {
-  const storedTargets = yield* Ref.make(
-    new Map(initialTargets.map((target) => [target.environmentId, target])),
-  );
+  const storedTargets = yield* Ref.make<ReadonlyArray<ConnectionTarget>>(initialTargets);
   const shellCache = yield* Ref.make(new Map([[TARGET.environmentId, CACHED_SNAPSHOT]]));
   const cacheClears = yield* Ref.make<ReadonlyArray<EnvironmentId>>([]);
   const ownedDataClears = yield* Ref.make<ReadonlyArray<EnvironmentId>>([]);
@@ -191,18 +198,16 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
     new Set(options?.initialDisabled ?? []),
   );
   const targetStore = Persistence.ConnectionTargetStore.of({
-    list: Ref.get(storedTargets).pipe(Effect.map((targets) => [...targets.values()])),
+    list: Ref.get(storedTargets),
     listDisabled: Ref.get(storedDisabled).pipe(Effect.map((ids) => [...ids])),
   });
   const registrationStore = Persistence.ConnectionRegistrationStore.of({
-    register: (registration) =>
+    register: (registration, routes) =>
       Effect.gen(function* () {
         yield* options?.beforeRegistrationRegister?.(registration) ?? Effect.void;
-        yield* Ref.update(storedTargets, (current) => {
-          const next = new Map(current);
-          next.set(registration.target.environmentId, registration.target);
-          return next;
-        });
+        yield* Ref.update(storedTargets, (current) =>
+          replaceRoutes(current, registration.target.environmentId, routes),
+        );
         switch (registration._tag) {
           case "RelayConnectionRegistration":
             return;
@@ -226,29 +231,34 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
             });
         }
       }),
-    remove: (target) =>
+    setRoutes: (environmentId, routes) =>
+      Ref.update(storedTargets, (current) => replaceRoutes(current, environmentId, routes)),
+    remove: (environmentId) =>
       Effect.gen(function* () {
-        yield* options?.beforeRegistrationRemove?.(target) ?? Effect.void;
-        yield* Ref.update(storedTargets, (current) => {
-          const next = new Map(current);
-          next.delete(target.environmentId);
-          return next;
-        });
-        if (target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget") {
-          yield* Ref.update(storedProfiles, (current) => {
-            const next = new Map(current);
-            next.delete(target.connectionId);
-            return next;
-          });
-          yield* Ref.update(storedCredentials, (current) => {
-            const next = new Map(current);
-            next.delete(target.connectionId);
-            return next;
-          });
+        yield* options?.beforeRegistrationRemove?.(environmentId) ?? Effect.void;
+        const removed = (yield* Ref.get(storedTargets)).filter(
+          (target) => target.environmentId === environmentId,
+        );
+        yield* Ref.update(storedTargets, (current) =>
+          current.filter((target) => target.environmentId !== environmentId),
+        );
+        for (const target of removed) {
+          if (target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget") {
+            yield* Ref.update(storedProfiles, (current) => {
+              const next = new Map(current);
+              next.delete(target.connectionId);
+              return next;
+            });
+            yield* Ref.update(storedCredentials, (current) => {
+              const next = new Map(current);
+              next.delete(target.connectionId);
+              return next;
+            });
+          }
         }
         yield* Ref.update(storedRemoteTokens, (current) => {
           const next = new Map(current);
-          next.delete(target.environmentId);
+          next.delete(environmentId);
           return next;
         });
       }),
@@ -363,38 +373,52 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
     prepare: () => Effect.die(new Error("SSH preparation is not used.")),
     disconnect: (target) => Ref.update(disconnectedSshTargets, (current) => [...current, target]),
   });
+  const connectedRoutes = yield* Ref.make<ReadonlyArray<string>>([]);
+  const checkRoute = (route: ConnectionRoute) =>
+    Effect.succeed(options?.checkRoute?.(route) ?? "unchecked");
+  const connectRoute = (entry: ConnectionCatalogEntry, route: ConnectionRoute) =>
+    Effect.gen(function* () {
+      const target = route.target;
+      const prepared = {
+        ...PREPARED,
+        environmentId: target.environmentId,
+        label: target.label,
+        target,
+      };
+      if (options?.prepareError) return yield* options.prepareError;
+      const routeError = options?.prepareRoute?.(target);
+      if (routeError !== undefined) return yield* routeError;
+      yield* Ref.update(connectedRoutes, (current) => [...current, connectionRouteId(target)]);
+      yield* options?.beforeSessionConnect?.(target.environmentId) ?? Effect.void;
+      const closed = yield* Deferred.make<never, ConnectionTransientError>();
+      yield* Ref.update(sessions, (current) => [...current, { closed }]);
+      const session = yield* Effect.acquireRelease(
+        Effect.succeed({
+          client: {} as RpcSession.RpcSession["client"],
+          initialConfig: Effect.die(new Error("Config is not used by registry tests.")),
+          subscribeServerConfig: () =>
+            Stream.die(new Error("Config is not used by registry tests.")),
+          ready: Effect.void,
+          probe: Effect.void,
+          closed: Deferred.await(closed),
+        } satisfies RpcSession.RpcSession),
+        () => Ref.update(releasedSessions, (count) => count + 1),
+      );
+      yield* session.ready;
+      return { prepared, session };
+    });
   const driver = ConnectionDriver.ConnectionDriver.of({
     connect: (entry, reportProgress) =>
-      Effect.gen(function* () {
-        const target = entry.target;
-        const prepared = {
-          ...PREPARED,
-          environmentId: target.environmentId,
-          label: target.label,
-          target,
-        };
-        yield* reportProgress({ stage: "preparing" });
-        if (options?.prepareError) return yield* options.prepareError;
-        yield* reportProgress({ stage: "opening", prepared });
-        yield* options?.beforeSessionConnect?.(target.environmentId) ?? Effect.void;
-        const closed = yield* Deferred.make<never, ConnectionTransientError>();
-        yield* Ref.update(sessions, (current) => [...current, { closed }]);
-        const session = yield* Effect.acquireRelease(
-          Effect.succeed({
-            client: {} as RpcSession.RpcSession["client"],
-            initialConfig: Effect.die(new Error("Config is not used by registry tests.")),
-            subscribeServerConfig: () =>
-              Stream.die(new Error("Config is not used by registry tests.")),
-            ready: Effect.void,
-            probe: Effect.void,
-            closed: Deferred.await(closed),
-          } satisfies RpcSession.RpcSession),
-          () => Ref.update(releasedSessions, (count) => count + 1),
-        );
-        yield* reportProgress({ stage: "synchronizing", prepared });
-        yield* session.ready;
-        return { prepared, session };
-      }),
+      reportProgress({ stage: "preparing" }).pipe(
+        Effect.andThen(
+          ConnectionDriver.connectOverRoutes(entry, checkRoute, (route) =>
+            connectRoute(entry, route),
+          ),
+        ),
+      ),
+    checkRoute: (_entry, route) => checkRoute(route),
+    preflight: (_entry, route) =>
+      checkRoute(route).pipe(Effect.map((check) => check === "answered")),
   });
 
   const cacheLayer = Layer.succeed(Persistence.EnvironmentCacheStore, cacheStore);
@@ -434,9 +458,33 @@ const makeHarness = Effect.fn("TestEnvironmentRegistry.makeHarness")(function* (
     storedDisabled,
     disconnectedSshTargets,
     networkStatus,
+    connectedRoutes,
   };
 });
 
+function routesOf(targets: ReadonlyArray<ConnectionTarget>, environmentId: EnvironmentId) {
+  return targets.filter((target) => target.environmentId === environmentId);
+}
+
+function hasRoutes(targets: ReadonlyArray<ConnectionTarget>, environmentId: EnvironmentId) {
+  return routesOf(targets, environmentId).length > 0;
+}
+
+function replaceRoutes(
+  current: ReadonlyArray<ConnectionTarget>,
+  environmentId: EnvironmentId,
+  routes: ReadonlyArray<ConnectionTarget>,
+): ReadonlyArray<ConnectionTarget> {
+  const firstIndex = current.findIndex((target) => target.environmentId === environmentId);
+  const others = current.filter((target) => target.environmentId !== environmentId);
+  const insertAt =
+    firstIndex === -1
+      ? others.length
+      : current.slice(0, firstIndex).filter((target) => target.environmentId !== environmentId)
+          .length;
+  return [...others.slice(0, insertAt), ...routes, ...others.slice(insertAt)];
+}
+
 function awaitConnectionState(
   registry: EnvironmentRegistry.EnvironmentRegistry["Service"],
   environmentId: EnvironmentId,
@@ -649,7 +697,7 @@ describe("EnvironmentRegistry", () => {
         );
 
         yield* registry.remove(TARGET.environmentId);
-        expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), TARGET.environmentId)).toBe(false);
         expect((yield* Ref.get(harness.shellCache)).has(TARGET.environmentId)).toBe(false);
         expect(yield* Ref.get(harness.cacheClears)).toEqual([TARGET.environmentId]);
         expect((yield* SubscriptionRef.get(registry.entries)).has(TARGET.environmentId)).toBe(
@@ -672,8 +720,8 @@ describe("EnvironmentRegistry", () => {
           (state) => state.phase === "connected",
         );
 
-        expect((yield* Ref.get(harness.storedTargets)).get(RELAY_TARGET.environmentId)).toEqual(
-          RELAY_TARGET,
+        expect(routesOf(yield* Ref.get(harness.storedTargets), RELAY_TARGET.environmentId)).toEqual(
+          [RELAY_TARGET],
         );
         expect(yield* Ref.get(harness.sessions)).toHaveLength(1);
       }).pipe(Effect.provide(harness.layer));
@@ -997,7 +1045,9 @@ describe("EnvironmentRegistry", () => {
         );
         expect(entry?.enabled).toBe(false);
         expect((yield* Ref.get(harness.storedDisabled)).has(RELAY_TARGET.environmentId)).toBe(true);
-        expect((yield* Ref.get(harness.storedTargets)).has(RELAY_TARGET.environmentId)).toBe(true);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), RELAY_TARGET.environmentId)).toBe(
+          true,
+        );
         expect(yield* Ref.get(harness.releasedSessions)).toBe(1);
 
         yield* registry.setEnabled(RELAY_TARGET.environmentId, true);
@@ -1060,7 +1110,7 @@ describe("EnvironmentRegistry", () => {
         );
 
         expect(yield* Ref.get(harness.disconnectedSshTargets)).toEqual([SSH_TARGET]);
-        expect((yield* Ref.get(harness.storedTargets)).has(SSH_CONNECTION.environmentId)).toBe(
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), SSH_CONNECTION.environmentId)).toBe(
           true,
         );
       }).pipe(Effect.provide(harness.layer));
@@ -1168,9 +1218,9 @@ describe("EnvironmentRegistry", () => {
         yield* registry.removeRelayEnvironments();
 
         const targets = yield* Ref.get(harness.storedTargets);
-        expect(targets.has(RELAY_TARGET.environmentId)).toBe(false);
-        expect(targets.has(SECOND_RELAY_TARGET.environmentId)).toBe(false);
-        expect(targets.get(BEARER_TARGET.environmentId)).toEqual(BEARER_TARGET);
+        expect(hasRoutes(targets, RELAY_TARGET.environmentId)).toBe(false);
+        expect(hasRoutes(targets, SECOND_RELAY_TARGET.environmentId)).toBe(false);
+        expect(routesOf(targets, BEARER_TARGET.environmentId)).toEqual([BEARER_TARGET]);
         expect(yield* Ref.get(harness.cacheClears)).toEqual(
           expect.arrayContaining([RELAY_TARGET.environmentId, SECOND_RELAY_TARGET.environmentId]),
         );
@@ -1212,7 +1262,9 @@ describe("EnvironmentRegistry", () => {
         expect((yield* SubscriptionRef.get(registry.entries)).has(RELAY_TARGET.environmentId)).toBe(
           true,
         );
-        expect((yield* Ref.get(harness.storedTargets)).has(RELAY_TARGET.environmentId)).toBe(true);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), RELAY_TARGET.environmentId)).toBe(
+          true,
+        );
         expect(yield* Ref.get(harness.cacheClears)).toEqual([]);
         expect(yield* Ref.get(harness.ownedDataClears)).toEqual([]);
       }).pipe(Effect.provide(harness.layer), Effect.scoped);
@@ -1262,7 +1314,7 @@ describe("EnvironmentRegistry", () => {
           (state) => state.phase === "connected",
         );
 
-        expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), TARGET.environmentId)).toBe(false);
         expect(
           (yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
         ).toEqual(TARGET);
@@ -1298,14 +1350,14 @@ describe("EnvironmentRegistry", () => {
         expect(
           (yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
         ).toEqual(TARGET);
-        expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), TARGET.environmentId)).toBe(false);
 
         yield* registry.register(new RelayConnectionRegistration({ target: shadowedTarget }));
 
         expect(
           (yield* SubscriptionRef.get(registry.entries)).get(TARGET.environmentId)?.target,
         ).toEqual(TARGET);
-        expect((yield* Ref.get(harness.storedTargets)).has(TARGET.environmentId)).toBe(false);
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), TARGET.environmentId)).toBe(false);
       }).pipe(
         Effect.provide(harness.layer),
         Effect.provideService(GitHubRoutingPermissions, permissions),
@@ -1582,3 +1634,264 @@ describe("EnvironmentRegistry", () => {
     }),
   );
 });
+
+describe("EnvironmentRegistry routes", () => {
+  // The relay environment, reachable on the LAN as well.
+  const LAN_TARGET = new BearerConnectionTarget({
+    environmentId: RELAY_TARGET.environmentId,
+    label: RELAY_TARGET.label,
+    connectionId: "bearer:lan",
+  });
+  const LAN_PROFILE = new BearerConnectionProfile({
+    connectionId: LAN_TARGET.connectionId,
+    environmentId: LAN_TARGET.environmentId,
+    label: LAN_TARGET.label,
+    httpBaseUrl: "http://192.168.1.10:3773/",
+    wsBaseUrl: "ws://192.168.1.10:3773/",
+  });
+  const lanRegistration = (target = LAN_TARGET, profile = LAN_PROFILE) =>
+    new BearerConnectionRegistration({ target, profile, credential: BEARER_CREDENTIAL });
+
+  it.effect("adds a paired LAN route ahead of T3 Connect instead of replacing it", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness([RELAY_TARGET]);
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        yield* registry.register(lanRegistration());
+
+        expect(routesOf(yield* Ref.get(harness.storedTargets), LAN_TARGET.environmentId)).toEqual([
+          LAN_TARGET,
+          RELAY_TARGET,
+        ]);
+        const entry = (yield* SubscriptionRef.get(registry.entries)).get(LAN_TARGET.environmentId);
+        expect(entry?.target).toEqual(LAN_TARGET);
+        expect(entry?.alternateRoutes?.map((route) => route.target)).toEqual([RELAY_TARGET]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("re-pairing the same address replaces that route rather than adding another", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [LAN_TARGET, RELAY_TARGET],
+        [LAN_PROFILE],
+        [[LAN_TARGET.connectionId, BEARER_CREDENTIAL]],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        const repaired = new BearerConnectionTarget({
+          ...LAN_TARGET,
+          connectionId: "bearer:lan-again",
+        });
+        yield* registry.register(
+          lanRegistration(
+            repaired,
+            new BearerConnectionProfile({ ...LAN_PROFILE, connectionId: repaired.connectionId }),
+          ),
+        );
+
+        expect(routesOf(yield* Ref.get(harness.storedTargets), LAN_TARGET.environmentId)).toEqual([
+          repaired,
+          RELAY_TARGET,
+        ]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("a second SSH host for the same machine adds a route beside the first", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness([SSH_CONNECTION], [SSH_PROFILE]);
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        const other = new SshConnectionTarget({
+          ...SSH_CONNECTION,
+          connectionId: "ssh-connection-other-host",
+        });
+        yield* registry.register(
+          new SshConnectionRegistration({
+            target: other,
+            profile: new SshConnectionProfile({
+              ...SSH_PROFILE,
+              connectionId: other.connectionId,
+              target: { ...SSH_TARGET, alias: "other", hostname: "other.example.test" },
+            }),
+          }),
+        );
+
+        expect(
+          routesOf(yield* Ref.get(harness.storedTargets), SSH_CONNECTION.environmentId),
+        ).toEqual([SSH_CONNECTION, other]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect(
+    "adding a saved SSH host again replaces its route, whatever id it was saved under",
+    () =>
+      Effect.gen(function* () {
+        const harness = yield* makeHarness([SSH_CONNECTION], [SSH_PROFILE]);
+        yield* Effect.gen(function* () {
+          const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+          const again = new SshConnectionTarget({
+            ...SSH_CONNECTION,
+            connectionId: "ssh-connection-new-id",
+          });
+          yield* registry.register(
+            new SshConnectionRegistration({
+              target: again,
+              profile: new SshConnectionProfile({
+                ...SSH_PROFILE,
+                connectionId: again.connectionId,
+              }),
+            }),
+          );
+
+          expect(
+            routesOf(yield* Ref.get(harness.storedTargets), SSH_CONNECTION.environmentId),
+          ).toEqual([again]);
+        }).pipe(Effect.provide(harness.layer), Effect.scoped);
+      }),
+  );
+
+  it.effect("signing out of T3 Connect keeps an environment that still has a LAN route", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [LAN_TARGET, RELAY_TARGET, SECOND_RELAY_TARGET],
+        [LAN_PROFILE],
+        [[LAN_TARGET.connectionId, BEARER_CREDENTIAL]],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        yield* registry.removeRelayEnvironments();
+
+        const targets = yield* Ref.get(harness.storedTargets);
+        expect(routesOf(targets, LAN_TARGET.environmentId)).toEqual([LAN_TARGET]);
+        expect(hasRoutes(targets, SECOND_RELAY_TARGET.environmentId)).toBe(false);
+        // Only the environment that lost its last route is forgotten.
+        expect(yield* Ref.get(harness.cacheClears)).toEqual([SECOND_RELAY_TARGET.environmentId]);
+        expect(
+          (yield* SubscriptionRef.get(registry.entries)).get(LAN_TARGET.environmentId)?.target,
+        ).toEqual(LAN_TARGET);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("reorders routes and rejects an order that drops one", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [LAN_TARGET, RELAY_TARGET],
+        [LAN_PROFILE],
+        [[LAN_TARGET.connectionId, BEARER_CREDENTIAL]],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        yield* registry.reorderRoutes(LAN_TARGET.environmentId, ["relay", LAN_TARGET.connectionId]);
+        expect(routesOf(yield* Ref.get(harness.storedTargets), LAN_TARGET.environmentId)).toEqual([
+          RELAY_TARGET,
+          LAN_TARGET,
+        ]);
+
+        const error = yield* registry
+          .reorderRoutes(LAN_TARGET.environmentId, ["relay"])
+          .pipe(Effect.flip);
+        expect(error._tag).toBe("ConnectionBlockedError");
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("removing the last route forgets the environment", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [LAN_TARGET, RELAY_TARGET],
+        [LAN_PROFILE],
+        [[LAN_TARGET.connectionId, BEARER_CREDENTIAL]],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        yield* registry.removeRoute(LAN_TARGET.environmentId, LAN_TARGET.connectionId);
+        expect(routesOf(yield* Ref.get(harness.storedTargets), LAN_TARGET.environmentId)).toEqual([
+          RELAY_TARGET,
+        ]);
+        expect(yield* Ref.get(harness.cacheClears)).toEqual([]);
+
+        yield* registry.removeRoute(LAN_TARGET.environmentId, "relay");
+        expect(hasRoutes(yield* Ref.get(harness.storedTargets), LAN_TARGET.environmentId)).toBe(
+          false,
+        );
+        expect(yield* Ref.get(harness.cacheClears)).toEqual([LAN_TARGET.environmentId]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("revokes GitHub routing trust when a route is added but keeps it on reorder", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness([RELAY_TARGET]);
+      let stored: ReadonlyArray<StoredGitHubRoutingPermission> = [];
+      const permissions = yield* makeGitHubRoutingPermissions({
+        read: Effect.sync(() => stored),
+        write: (next) => Effect.sync(() => void (stored = next)),
+      });
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        const current = () =>
+          SubscriptionRef.get(registry.entries).pipe(
+            Effect.map((entries) => entries.get(RELAY_TARGET.environmentId)!),
+          );
+        yield* permissions.set(yield* current(), "read");
+        yield* registry.register(lanRegistration());
+        expect(yield* permissions.get(yield* current())).toBe("off");
+
+        yield* permissions.set(yield* current(), "read");
+        yield* registry.reorderRoutes(LAN_TARGET.environmentId, ["relay", LAN_TARGET.connectionId]);
+        expect(yield* permissions.get(yield* current())).toBe("read");
+      }).pipe(
+        Effect.provide(harness.layer),
+        Effect.provideService(GitHubRoutingPermissions, permissions),
+        Effect.scoped,
+      );
+    }),
+  );
+
+  it.effect("loads saved routes grouped by environment, in saved order", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness(
+        [LAN_TARGET, BEARER_TARGET, RELAY_TARGET],
+        [LAN_PROFILE, BEARER_PROFILE],
+        [
+          [LAN_TARGET.connectionId, BEARER_CREDENTIAL],
+          [BEARER_TARGET.connectionId, BEARER_CREDENTIAL],
+        ],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        const entries = yield* SubscriptionRef.get(registry.entries);
+        expect([...entries.keys()]).toEqual([
+          LAN_TARGET.environmentId,
+          BEARER_TARGET.environmentId,
+        ]);
+        expect(entries.get(LAN_TARGET.environmentId)?.alternateRoutes?.[0]?.target).toEqual(
+          RELAY_TARGET,
+        );
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+
+  it.effect("drops a learned route whose profile was not saved instead of duplicating it", () =>
+    Effect.gen(function* () {
+      const learnedId = `learned:${LAN_TARGET.environmentId}:100.64.0.9:3773@${LAN_TARGET.connectionId}`;
+      const learned = new BearerConnectionTarget({ ...LAN_TARGET, connectionId: learnedId });
+      // An earlier build saved the learned target twice and never its profile.
+      const harness = yield* makeHarness(
+        [LAN_TARGET, learned, learned],
+        [LAN_PROFILE],
+        [[LAN_TARGET.connectionId, BEARER_CREDENTIAL]],
+      );
+      yield* Effect.gen(function* () {
+        const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
+        const entry = (yield* SubscriptionRef.get(registry.entries)).get(LAN_TARGET.environmentId);
+        expect(entry?.target).toEqual(LAN_TARGET);
+        expect(entry?.alternateRoutes ?? []).toEqual([]);
+      }).pipe(Effect.provide(harness.layer), Effect.scoped);
+    }),
+  );
+});
diff --git a/packages/client-runtime/src/connection/registry.ts b/packages/client-runtime/src/connection/registry.ts
index 90acb224fcd5..eda32cd73dcd 100644
--- a/packages/client-runtime/src/connection/registry.ts
+++ b/packages/client-runtime/src/connection/registry.ts
@@ -15,7 +15,9 @@ import * as SubscriptionRef from "effect/SubscriptionRef";
 import * as ClientCapabilities from "../platform/capabilities.ts";
 import {
   type ConnectionCatalogEntry,
+  type ConnectionProfile,
   type ConnectionRegistration,
+  type ConnectionRoute,
   type PlatformConnectionRegistration,
   type PrimaryConnectionRegistration,
   SshConnectionProfile,
@@ -28,6 +30,7 @@ import type {
   ConnectionAttemptError,
   ConnectionTarget,
   NetworkStatus,
+  PersistedConnectionTarget,
   SupervisorConnectionState,
 } from "./model.ts";
 import { ConnectionBlockedError } from "./model.ts";
@@ -45,6 +48,17 @@ import {
   GitHubRoutingPermissions,
   gitHubRoutingConnectionKey,
 } from "./githubRoutingPermissions.ts";
+import {
+  RELAY_ROUTE_ID,
+  connectionRouteId,
+  connectionRoutes,
+  entryWithRoutes,
+  findRouteToSameAddress,
+  isLearned,
+  mergeLearnedRoutes,
+  routesAfterRemoving,
+  upsertRoute,
+} from "./routes.ts";
 
 const isSshConnectionProfile = Schema.is(SshConnectionProfile);
 
@@ -105,6 +119,35 @@ export class EnvironmentRegistry extends Context.Service<
       | EnvironmentNotRegisteredError
       | PlatformEnvironmentRemovalError
     >;
+    /**
+     * Drops one route. Removing an environment's last route removes the
+     * environment, the same as `remove`.
+     */
+    readonly removeRoute: (
+      environmentId: EnvironmentId,
+      routeId: string,
+    ) => Effect.Effect<
+      void,
+      | Persistence.ConnectionPersistenceError
+      | ConnectionAttemptError
+      | EnvironmentNotRegisteredError
+      | PlatformEnvironmentRemovalError
+    >;
+    /** Reorders an environment's routes; `routeIds` lists every route, preferred first. */
+    readonly reorderRoutes: (
+      environmentId: EnvironmentId,
+      routeIds: ReadonlyArray<string>,
+    ) => Effect.Effect<
+      void,
+      | Persistence.ConnectionPersistenceError
+      | EnvironmentNotRegisteredError
+      | PlatformEnvironmentRemovalError
+      | ConnectionBlockedError
+    >;
+    /**
+     * Drops the T3 Connect route of every environment, after a cloud sign-out
+     * or account change. Environments with no other route are removed.
+     */
     readonly removeRelayEnvironments: () => Effect.Effect<
       void,
       | Persistence.ConnectionPersistenceError
@@ -181,21 +224,48 @@ export const make = Effect.gen(function* () {
   const ssh = yield* ClientCapabilities.SshEnvironmentGateway;
   const persistedTargets = yield* storage.list;
   const disabledEnvironmentIds = new Set(yield* storage.listDisabled);
+  const loadRoute = Effect.fn("EnvironmentRegistry.loadRoute")(function* (
+    target: ConnectionTarget,
+  ) {
+    const profile: Option.Option<ConnectionProfile> =
+      target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget"
+        ? yield* profiles.get(target.connectionId)
+        : Option.none();
+    return { target, profile } satisfies ConnectionRoute;
+  });
+  const persistedRoutesByEnvironment = new Map<EnvironmentId, Array<ConnectionTarget>>();
+  for (const target of persistedTargets) {
+    const routes = persistedRoutesByEnvironment.get(target.environmentId) ?? [];
+    routes.push(target);
+    persistedRoutesByEnvironment.set(target.environmentId, routes);
+  }
   const initialEntries = new Map(
     yield* Effect.forEach(
-      persistedTargets,
-      Effect.fn("EnvironmentRegistry.loadCatalogEntry")(function* (target) {
-        const profile =
-          target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget"
-            ? yield* profiles.get(target.connectionId)
-            : Option.none();
+      persistedRoutesByEnvironment,
+      Effect.fn("EnvironmentRegistry.loadCatalogEntry")(function* ([environmentId, targets]) {
+        const loaded = yield* Effect.forEach(targets, loadRoute, { concurrency: "unbounded" });
+        // A learned route without its profile has no address to reach; it is
+        // learned again on the next connection. A paired route keeps its slot
+        // so its missing profile still surfaces as a connection error.
+        const seen = new Set<string>();
+        const usable = loaded.filter((route) => {
+          const id = connectionRouteId(route.target);
+          if (seen.has(id)) return false;
+          seen.add(id);
+          return !(id.startsWith("learned:") && Option.isNone(route.profile));
+        });
+        const routes = usable.length > 0 ? usable : loaded.slice(0, 1);
+        const first = routes[0]!;
         return [
-          target.environmentId,
-          {
-            target,
-            profile,
-            enabled: !disabledEnvironmentIds.has(target.environmentId),
-          } satisfies ConnectionCatalogEntry,
+          environmentId,
+          entryWithRoutes(
+            {
+              target: first.target,
+              profile: first.profile,
+              enabled: !disabledEnvironmentIds.has(environmentId),
+            },
+            routes,
+          ),
         ] as const;
       }),
       { concurrency: "unbounded" },
@@ -208,9 +278,9 @@ export const make = Effect.gen(function* () {
     ReadonlyMap<EnvironmentId, EnvironmentServiceScope>
   >(new Map());
   const platformEnvironmentIds = yield* Ref.make<ReadonlySet<EnvironmentId>>(new Set());
-  const persistedTargetsByEnvironment = yield* Ref.make<
-    ReadonlyMap<EnvironmentId, ConnectionTarget>
-  >(new Map(persistedTargets.map((target) => [target.environmentId, target])));
+  const persistedEnvironmentIds = yield* Ref.make<ReadonlySet<EnvironmentId>>(
+    new Set(persistedRoutesByEnvironment.keys()),
+  );
   interface LeaseLock {
     readonly semaphore: Semaphore.Semaphore;
     readonly users: number;
@@ -300,6 +370,7 @@ export const make = Effect.gen(function* () {
           const scope = yield* Scope.fork(registryScope);
           const supervisor = yield* EnvironmentSupervisor.make(entry, {
             initiallyDesired: false,
+            learnRoutes: (input) => learnRoutes({ environmentId, ...input }),
             ...boxes.supervisorOptions(entry),
           }).pipe(
             Effect.provideService(Connectivity.Connectivity, connectivity),
@@ -409,9 +480,9 @@ export const make = Effect.gen(function* () {
       return;
     }
     yield* Effect.forEach(
-      persistedTargets,
-      (target) =>
-        acquireSupervisor(target.environmentId).pipe(
+      persistedRoutesByEnvironment.keys(),
+      (environmentId) =>
+        acquireSupervisor(environmentId).pipe(
           Effect.catchTag("EnvironmentNotRegisteredError", () => Effect.void),
         ),
       {
@@ -447,6 +518,38 @@ export const make = Effect.gen(function* () {
     yield* createServiceScope(entry);
   });
 
+  const forgetRoutingTrust = (
+    environmentId: EnvironmentId,
+    operation: "register-connection" | "set-connection-routes",
+  ) =>
+    githubRoutingPermissions.forget(environmentId).pipe(
+      Effect.mapError(
+        (error) =>
+          new Persistence.ConnectionPersistenceError({
+            operation,
+            message: error.message,
+          }),
+      ),
+    );
+
+  const persistedRoutes = (entry: ConnectionCatalogEntry) =>
+    connectionRoutes(entry).map((route) => route.target as PersistedConnectionTarget);
+
+  /**
+   * The entry after its routes change. GitHub trust and an unsupported
+   * verdict both belong to the saved addresses: a changed set may reach a
+   * different server, so both are dropped and the next connection decides.
+   * Reordering keeps the same addresses, so both stay.
+   */
+  const withRoutes = (previous: ConnectionCatalogEntry, routes: ReadonlyArray<ConnectionRoute>) => {
+    const next = entryWithRoutes(previous, routes);
+    if (gitHubRoutingConnectionKey(previous) === gitHubRoutingConnectionKey(next)) {
+      return { entry: next, addressesChanged: false };
+    }
+    const { unsupportedReason: _reason, serverUpdateRequired: _update, ...rest } = next;
+    return { entry: rest, addressesChanged: true };
+  };
+
   const register = Effect.fn("EnvironmentRegistry.register")(function* (
     requested: ConnectionRegistration,
   ) {
@@ -457,46 +560,60 @@ export const make = Effect.gen(function* () {
         if ((yield* Ref.get(platformEnvironmentIds)).has(environmentId)) {
           return;
         }
-        // Editing a saved environment must preserve its disabled state.
+        // A new route joins the environment's saved routes. Registering one it
+        // already has (the same id, or a pairing to the same address) replaces
+        // it in place. Editing keeps the disabled state.
         const previous = (yield* SubscriptionRef.get(entries)).get(environmentId);
         const registration = keepBoxIdentity(previous, requested);
         const registered = connectionRegistrationCatalogEntry(registration);
-        const entry: ConnectionCatalogEntry =
-          previous === undefined
-            ? registered
-            : {
-                ...registered,
-                enabled: previous.enabled,
-                ...(previous.unsupportedReason !== undefined &&
-                gitHubRoutingConnectionKey(previous) === gitHubRoutingConnectionKey(registered)
-                  ? unsupportedState(previous)
-                  : {}),
-              };
-        if (
-          previous !== undefined &&
-          gitHubRoutingConnectionKey(previous) !== gitHubRoutingConnectionKey(entry)
-        ) {
-          yield* githubRoutingPermissions.forget(environmentId).pipe(
-            Effect.mapError(
-              (error) =>
-                new Persistence.ConnectionPersistenceError({
-                  operation: "register-connection",
-                  message: error.message,
-                }),
-            ),
+        let entry = registered;
+        if (previous !== undefined) {
+          const route: ConnectionRoute = { target: registered.target, profile: registered.profile };
+          const existing = connectionRoutes(previous);
+          const sameAddress = findRouteToSameAddress(existing, route);
+          const routes = existing.filter(
+            (existing) =>
+              existing !== sameAddress ||
+              connectionRouteId(existing.target) === connectionRouteId(route.target),
           );
+          const next = withRoutes(previous, upsertRoute(routes, route));
+          if (next.addressesChanged) {
+            yield* forgetRoutingTrust(environmentId, "register-connection");
+          }
+          entry = next.entry;
         }
-        yield* registrations.register(registration);
-        yield* Ref.update(persistedTargetsByEnvironment, (current) => {
-          const next = new Map(current);
-          next.set(environmentId, registration.target);
-          return next;
-        });
+        yield* registrations.register(registration, persistedRoutes(entry));
+        yield* Ref.update(persistedEnvironmentIds, (current) =>
+          new Set(current).add(environmentId),
+        );
         yield* installEntryLocked(entry);
       }),
     );
   });
 
+  /** Writes a new route list for a user-saved environment and restarts its connection. */
+  const replaceRoutesLocked = Effect.fn("EnvironmentRegistry.replaceRoutesLocked")(function* (
+    previous: ConnectionCatalogEntry,
+    routes: ReadonlyArray<ConnectionRoute>,
+  ) {
+    const environmentId = previous.target.environmentId;
+    const next = withRoutes(previous, routes);
+    if (next.addressesChanged) {
+      yield* forgetRoutingTrust(environmentId, "set-connection-routes");
+    }
+    yield* registrations.setRoutes(environmentId, persistedRoutes(next.entry));
+    yield* installEntryLocked(next.entry);
+  });
+
+  const userEntry = Effect.fn("EnvironmentRegistry.userEntry")(function* (
+    environmentId: EnvironmentId,
+  ) {
+    if ((yield* Ref.get(platformEnvironmentIds)).has(environmentId)) {
+      return yield* new PlatformEnvironmentRemovalError({ environmentId });
+    }
+    return yield* getEntry(environmentId);
+  });
+
   const installPlatformRegistration = Effect.fn("EnvironmentRegistry.installPlatformRegistration")(
     function* (registration: PlatformConnectionRegistration) {
       const registered = connectionRegistrationCatalogEntry(registration);
@@ -510,11 +627,9 @@ export const make = Effect.gen(function* () {
             gitHubRoutingConnectionKey(previous) === gitHubRoutingConnectionKey(registered)
               ? { ...registered, enabled: false, ...unsupportedState(previous) }
               : registered;
-          const persistedTarget = (yield* Ref.get(persistedTargetsByEnvironment)).get(
-            target.environmentId,
-          );
+          const persisted = (yield* Ref.get(persistedEnvironmentIds)).has(target.environmentId);
           if (
-            persistedTarget !== undefined ||
+            persisted ||
             (previous !== undefined &&
               gitHubRoutingConnectionKey(previous) !== gitHubRoutingConnectionKey(entry))
           ) {
@@ -553,11 +668,11 @@ export const make = Effect.gen(function* () {
             );
           }
 
-          if (persistedTarget !== undefined) {
-            yield* registrations.remove(persistedTarget).pipe(
+          if (persisted) {
+            yield* registrations.remove(target.environmentId).pipe(
               Effect.tap(() =>
-                Ref.update(persistedTargetsByEnvironment, (current) => {
-                  const next = new Map(current);
+                Ref.update(persistedEnvironmentIds, (current) => {
+                  const next = new Set(current);
                   next.delete(target.environmentId);
                   return next;
                 }),
@@ -668,69 +783,176 @@ export const make = Effect.gen(function* () {
     yield* Effect.forEach(platformRegistrations, installPlatformRegistration, { discard: true });
   });
 
-  const remove = Effect.fn("EnvironmentRegistry.remove")(function* (
+  /** Forgets a user-saved environment. Callers hold its lease lock. */
+  const removeLocked = Effect.fn("EnvironmentRegistry.removeLocked")(function* (
     environmentId: EnvironmentId,
-    keep?: (entry: ConnectionCatalogEntry) => boolean,
   ) {
+    if ((yield* Ref.get(platformEnvironmentIds)).has(environmentId)) {
+      return yield* new PlatformEnvironmentRemovalError({
+        environmentId,
+      });
+    }
+    const entry = yield* getEntry(environmentId);
+
+    yield* githubRoutingPermissions.forget(environmentId);
+    yield* registrations.remove(environmentId);
+    yield* Ref.update(persistedEnvironmentIds, (current) => {
+      const next = new Set(current);
+      next.delete(environmentId);
+      return next;
+    });
+    yield* closeServiceScope(environmentId);
+    yield* SubscriptionRef.update(entries, (current) => {
+      const next = new Map(current);
+      next.delete(environmentId);
+      return next;
+    });
+    yield* Effect.all(
+      [
+        cache.clear(environmentId).pipe(
+          Effect.catch((error) =>
+            Effect.logWarning("Could not clear cached environment data after removal.", {
+              environmentId,
+              error,
+            }),
+          ),
+        ),
+        ownedDataCleanup.clear(environmentId),
+      ],
+      { concurrency: "unbounded", discard: true },
+    );
+
+    for (const route of connectionRoutes(entry)) {
+      const profile = Option.getOrNull(route.profile);
+      if (profile !== null && isSshConnectionProfile(profile)) {
+        yield* disconnectSsh(environmentId, profile);
+      }
+    }
+  });
+
+  const remove = Effect.fn("EnvironmentRegistry.remove")(function* (environmentId: EnvironmentId) {
+    return yield* withLeaseLock(environmentId, removeLocked(environmentId));
+  });
+
+  const disconnectSsh = (environmentId: EnvironmentId, profile: SshConnectionProfile) =>
+    ssh.disconnect(profile.target).pipe(
+      Effect.tapError((error) =>
+        Effect.logWarning("Could not disconnect the managed SSH environment.", {
+          environmentId,
+          error,
+        }),
+      ),
+      Effect.ignore,
+    );
+
+  // Plain HTTP routes are unusable from an HTTPS page, which blocks mixed content.
+  const allowInsecureRoutes =
+    typeof globalThis.location === "undefined" || globalThis.location.protocol !== "https:";
+
+  /**
+   * Saves the direct addresses a connected server reports as learned routes,
+   * replacing learned routes it no longer reports. Routes the user saved are
+   * never changed. Learned routes reuse the active route's credential, so they
+   * do not revoke GitHub routing trust the way a newly paired address does.
+   */
+  const learnRoutes = Effect.fn("EnvironmentRegistry.learnRoutes")(function* (input: {
+    readonly environmentId: EnvironmentId;
+    readonly activeRoute: ConnectionRoute;
+    readonly reported: ReadonlyArray<{ readonly httpBaseUrl: string }>;
+  }) {
     return yield* withLeaseLock(
-      environmentId,
+      input.environmentId,
       Effect.gen(function* () {
-        if ((yield* Ref.get(platformEnvironmentIds)).has(environmentId)) {
-          return yield* new PlatformEnvironmentRemovalError({
-            environmentId,
-          });
+        if ((yield* Ref.get(platformEnvironmentIds)).has(input.environmentId)) {
+          return Option.none<ConnectionCatalogEntry>();
         }
-        const entry = yield* getEntry(environmentId);
-        if (keep?.(entry) === true) return;
-        const target = entry.target;
-        const profile =
-          target._tag === "BearerConnectionTarget" || target._tag === "SshConnectionTarget"
-            ? yield* profiles.get(target.connectionId)
-            : Option.none();
-
-        yield* githubRoutingPermissions.forget(environmentId);
-        yield* registrations.remove(target);
-        yield* Ref.update(persistedTargetsByEnvironment, (current) => {
-          const next = new Map(current);
-          next.delete(environmentId);
-          return next;
-        });
-        yield* closeServiceScope(environmentId);
-        yield* SubscriptionRef.update(entries, (current) => {
-          const next = new Map(current);
-          next.delete(environmentId);
-          return next;
+        const entry = (yield* SubscriptionRef.get(entries)).get(input.environmentId);
+        if (entry === undefined) return Option.none<ConnectionCatalogEntry>();
+        const routes = mergeLearnedRoutes({
+          entry,
+          activeRoute: input.activeRoute,
+          reported: input.reported,
+          allowInsecure: allowInsecureRoutes,
         });
-        yield* Effect.all(
-          [
-            cache.clear(environmentId).pipe(
-              Effect.catch((error) =>
-                Effect.logWarning("Could not clear cached environment data after removal.", {
-                  environmentId,
-                  error,
-                }),
-              ),
-            ),
-            ownedDataCleanup.clear(environmentId),
-          ],
-          { concurrency: "unbounded", discard: true },
+        if (routes === null) return Option.none<ConnectionCatalogEntry>();
+        const next = entryWithRoutes(entry, routes);
+        // A learned route owns its profile (address and authorization); the
+        // credential stays with the route it borrows from.
+        const previousIds = new Set(
+          connectionRoutes(entry).map((route) => connectionRouteId(route.target)),
         );
-
-        if (
-          target._tag === "SshConnectionTarget" &&
-          Option.isSome(profile) &&
-          isSshConnectionProfile(profile.value)
-        ) {
-          yield* ssh.disconnect(profile.value.target).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("Could not disconnect the managed SSH environment.", {
-                environmentId,
-                error,
-              }),
-            ),
-            Effect.ignore,
+        for (const route of routes) {
+          if (!isLearned(route) || previousIds.has(connectionRouteId(route.target))) continue;
+          const profile = Option.getOrNull(route.profile);
+          if (profile !== null) yield* profiles.put(profile);
+        }
+        yield* registrations.setRoutes(input.environmentId, persistedRoutes(next));
+        // Update the lease in place: the live session already works, and
+        // `installEntryLocked` would replace it for a route list change.
+        const lease = (yield* SubscriptionRef.get(serviceScopes)).get(input.environmentId);
+        if (lease !== undefined) {
+          yield* SubscriptionRef.update(serviceScopes, (current) =>
+            new Map(current).set(input.environmentId, { ...lease, entry: next }),
           );
         }
+        yield* SubscriptionRef.update(entries, (current) =>
+          new Map(current).set(input.environmentId, next),
+        );
+        return Option.some(next);
+      }),
+    ).pipe(
+      Effect.catch((error) =>
+        Effect.logWarning("Could not save routes learned from the environment.", {
+          environmentId: input.environmentId,
+          error,
+        }).pipe(Effect.as(Option.none<ConnectionCatalogEntry>())),
+      ),
+    );
+  });
+
+  const removeRoute = Effect.fn("EnvironmentRegistry.removeRoute")(function* (
+    environmentId: EnvironmentId,
+    routeId: string,
+  ) {
+    // One lock for the whole decision: a route registered between "this was
+    // the last route" and the removal must not be deleted with it.
+    yield* withLeaseLock(
+      environmentId,
+      Effect.gen(function* () {
+        const entry = yield* userEntry(environmentId);
+        const routes = connectionRoutes(entry);
+        const route = routes.find((candidate) => connectionRouteId(candidate.target) === routeId);
+        if (route === undefined) return;
+        const remaining = routesAfterRemoving(routes, routeId);
+        if (remaining.length === 0) return yield* removeLocked(environmentId);
+        yield* replaceRoutesLocked(entry, remaining);
+        const profile = Option.getOrNull(route.profile);
+        if (profile !== null && isSshConnectionProfile(profile)) {
+          yield* disconnectSsh(environmentId, profile);
+        }
+      }),
+    );
+  });
+
+  const reorderRoutes = Effect.fn("EnvironmentRegistry.reorderRoutes")(function* (
+    environmentId: EnvironmentId,
+    routeIds: ReadonlyArray<string>,
+  ) {
+    yield* withLeaseLock(
+      environmentId,
+      Effect.gen(function* () {
+        const entry = yield* userEntry(environmentId);
+        const routes = connectionRoutes(entry);
+        const byId = new Map(routes.map((route) => [connectionRouteId(route.target), route]));
+        const reordered = routeIds.flatMap((id) => byId.get(id) ?? []);
+        if (reordered.length !== routes.length || new Set(routeIds).size !== routes.length) {
+          return yield* new ConnectionBlockedError({
+            reason: "configuration",
+            detail: "The route order must list every saved route once.",
+          });
+        }
+        if (reordered.every((route, index) => route === routes[index])) return;
+        yield* replaceRoutesLocked(entry, reordered);
       }),
     );
   });
@@ -738,14 +960,16 @@ export const make = Effect.gen(function* () {
   const removeRelayEnvironments = Effect.fn("EnvironmentRegistry.removeRelayEnvironments")(
     function* () {
       const relayEnvironmentIds = [...(yield* SubscriptionRef.get(entries)).values()]
-        .filter((entry) => entry.target._tag === "RelayConnectionTarget")
+        .filter((entry) =>
+          connectionRoutes(entry).some((route) => route.target._tag === "RelayConnectionTarget"),
+        )
         .map((entry) => entry.target.environmentId);
 
       yield* Effect.forEach(
         relayEnvironmentIds,
         (environmentId) =>
           boxes
-            .remove(environmentId)
+            .removeRoute(environmentId, RELAY_ROUTE_ID)
             .pipe(Effect.catchTag("EnvironmentNotRegisteredError", () => Effect.void)),
         {
           concurrency: "unbounded",
@@ -808,21 +1032,13 @@ export const make = Effect.gen(function* () {
         }
         // The supervisor only owns the RPC session. A managed SSH backend and
         // its tunnel outlive it, so switching off tears those down as well.
-        if (
-          !enabled &&
-          entry.target._tag === "SshConnectionTarget" &&
-          Option.isSome(entry.profile) &&
-          isSshConnectionProfile(entry.profile.value)
-        ) {
-          yield* ssh.disconnect(entry.profile.value.target).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("Could not disconnect the switched-off SSH environment.", {
-                environmentId,
-                error,
-              }),
-            ),
-            Effect.ignore,
-          );
+        if (!enabled) {
+          for (const route of connectionRoutes(entry)) {
+            const profile = Option.getOrNull(route.profile);
+            if (profile !== null && isSshConnectionProfile(profile)) {
+              yield* disconnectSsh(environmentId, profile);
+            }
+          }
         }
       }),
     );
@@ -911,7 +1127,8 @@ export const make = Effect.gen(function* () {
     entries,
     serviceScopes,
     platformEnvironmentIds,
-    persistedTargetsByEnvironment,
+    persistedEnvironmentIds,
+    persistedRoutes,
     registrations,
     credentials,
     cache,
@@ -920,7 +1137,8 @@ export const make = Effect.gen(function* () {
     getEntry,
     installEntryLocked,
     createServiceScope,
-    remove,
+    removeLocked,
+    removeRoute,
     run,
   });
 
@@ -932,6 +1150,8 @@ export const make = Effect.gen(function* () {
     registerPlatform,
     reconcilePlatform,
     remove: boxes.remove,
+    removeRoute: boxes.removeRoute,
+    reorderRoutes,
     removeRelayEnvironments,
     retryNow,
     ...boxes.methods,
diff --git a/packages/client-runtime/src/connection/registryBoxes.ts b/packages/client-runtime/src/connection/registryBoxes.ts
index e1c7621e4710..dc4f8efc5484 100644
--- a/packages/client-runtime/src/connection/registryBoxes.ts
+++ b/packages/client-runtime/src/connection/registryBoxes.ts
@@ -17,7 +17,7 @@ import type { ProvisionedBox } from "../cloud/provisioning.ts";
 import type * as Persistence from "../platform/persistence.ts";
 import * as EnvironmentRpc from "../rpc/client.ts";
 import { type BoxPairingPorts, PairingRedemption, pairBoxThroughHost } from "./boxPairing.ts";
-import type { BoxSupervisorOptions, BoxWakeOutcome } from "./boxWake.ts";
+import type { BoxWakeOutcome } from "./boxWake.ts";
 import {
   BearerConnectionRegistration,
   BoxTargetRegistration,
@@ -40,9 +40,9 @@ import {
   type BoxAttachment,
   type ConnectionAttemptError,
   ConnectionBlockedError,
-  type ConnectionTarget,
   ConnectionTransientError,
   connectionBox,
+  type PersistedConnectionTarget,
   type SupervisorConnectionState,
 } from "./model.ts";
 import { UserPresence } from "./presence.ts";
@@ -117,7 +117,11 @@ export interface RegistryInternals {
     ReadonlyMap<EnvironmentId, EnvironmentServiceScope>
   >;
   readonly platformEnvironmentIds: Ref.Ref<ReadonlySet<EnvironmentId>>;
-  readonly persistedTargetsByEnvironment: Ref.Ref<ReadonlyMap<EnvironmentId, ConnectionTarget>>;
+  readonly persistedEnvironmentIds: Ref.Ref<ReadonlySet<EnvironmentId>>;
+  /** The targets `registrations` saves for an entry, its preferred route first. */
+  readonly persistedRoutes: (
+    entry: ConnectionCatalogEntry,
+  ) => ReadonlyArray<PersistedConnectionTarget>;
   readonly registrations: Persistence.ConnectionRegistrationStore["Service"];
   readonly credentials: ConnectionCredentialStore.ConnectionCredentialStore["Service"];
   readonly cache: Persistence.EnvironmentCacheStore["Service"];
@@ -132,10 +136,9 @@ export interface RegistryInternals {
   /** Replaces an entry and its runtime. Run under the entry's lease lock. */
   readonly installEntryLocked: (entry: ConnectionCatalogEntry) => Effect.Effect<void>;
   readonly createServiceScope: (entry: ConnectionCatalogEntry) => Effect.Effect<unknown>;
-  /** The registry's `remove`, skipping an entry `keep` holds for under its lock. */
-  readonly remove: (
+  /** Forgets a saved environment. Run under the entry's lease lock. */
+  readonly removeLocked: (
     environmentId: EnvironmentId,
-    keep?: (entry: ConnectionCatalogEntry) => boolean,
   ) => Effect.Effect<
     void,
     | Persistence.ConnectionPersistenceError
@@ -143,6 +146,7 @@ export interface RegistryInternals {
     | EnvironmentNotRegisteredError
     | PlatformEnvironmentRemovalError
   >;
+  readonly removeRoute: EnvironmentRegistry["Service"]["removeRoute"];
   readonly run: EnvironmentRegistry["Service"]["run"];
 }
 
@@ -182,7 +186,8 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
     entries,
     serviceScopes,
     platformEnvironmentIds,
-    persistedTargetsByEnvironment,
+    persistedEnvironmentIds,
+    persistedRoutes,
     registrations,
     credentials,
     cache,
@@ -191,11 +196,13 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
     getEntry,
     installEntryLocked,
     createServiceScope,
-    remove: removeEntry,
+    removeLocked,
+    removeRoute: removeRouteEntry,
     run,
   } = internals;
   // A saved connection whose workspace is gone is not dialed again until it is paired anew.
   const driver = ConnectionDriver.ConnectionDriver.of({
+    ...dialer,
     connect: (entry, reportProgress) =>
       entry.target._tag === "BearerConnectionTarget" && entry.target.workspaceStatus === "missing"
         ? Effect.fail(workspaceMissingError())
@@ -526,21 +533,22 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
           ...current.target,
           connectionId: registration.target.connectionId,
         });
+        const next: ConnectionCatalogEntry = {
+          ...current,
+          target,
+          profile: Option.some(registration.profile),
+        };
         yield* registrations.register(
           new BearerConnectionRegistration({
             target,
             profile: registration.profile,
             credential: registration.credential,
           }),
+          persistedRoutes(next),
         );
-        yield* Ref.update(persistedTargetsByEnvironment, (persisted) =>
-          new Map(persisted).set(environmentId, target),
+        yield* Ref.update(persistedEnvironmentIds, (persisted) =>
+          new Set(persisted).add(environmentId),
         );
-        const next: ConnectionCatalogEntry = {
-          ...current,
-          target,
-          profile: Option.some(registration.profile),
-        };
         yield* replaceEntryInPlace(environmentId, next);
         return next;
       }),
@@ -559,6 +567,7 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
   // first and the pairing happens at most once per device: every later dial finds it saved.
   const boxDriver = (environmentId: EnvironmentId, managerId: EnvironmentId) =>
     ConnectionDriver.ConnectionDriver.of({
+      ...driver,
       connect: (captured, reportProgress) =>
         Effect.gen(function* () {
           const entry = (yield* SubscriptionRef.get(entries)).get(environmentId) ?? captured;
@@ -603,9 +612,13 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
         if (target === null) {
           return;
         }
+        const next: ConnectionCatalogEntry = { ...entry, target };
         if (target.box !== undefined) {
           // A box's target is saved alone, keeping its pairing, or its lack of one.
-          yield* registrations.register(new BoxTargetRegistration({ target }));
+          yield* registrations.register(
+            new BoxTargetRegistration({ target }),
+            persistedRoutes(next),
+          );
         } else {
           if (
             Option.isNone(entry.profile) ||
@@ -623,12 +636,13 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
               profile: entry.profile.value,
               credential: credential.value,
             }),
+            persistedRoutes(next),
           );
         }
-        yield* Ref.update(persistedTargetsByEnvironment, (current) =>
-          new Map(current).set(environmentId, target),
+        yield* Ref.update(persistedEnvironmentIds, (current) =>
+          new Set(current).add(environmentId),
         );
-        yield* installEntryLocked({ ...entry, target });
+        yield* installEntryLocked(next);
       }),
     );
   });
@@ -726,7 +740,13 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
     environmentId: EnvironmentId,
     keep?: (entry: ConnectionCatalogEntry) => boolean,
   ) =>
-    removeEntry(environmentId, keep).pipe(
+    withLeaseLock(
+      environmentId,
+      Effect.gen(function* () {
+        if (keep?.(yield* getEntry(environmentId)) === true) return;
+        yield* removeLocked(environmentId);
+      }),
+    ).pipe(
       Effect.andThen(SubscriptionRef.get(entries)),
       Effect.map((current) => !current.has(environmentId)),
       Effect.tap((forgotten) =>
@@ -749,12 +769,14 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
   const forgetUnpairedBox = (environmentId: EnvironmentId) =>
     forgetEntry(environmentId, (current) => !isUnpairedBox(current));
 
-  const remove = Effect.fn("EnvironmentRegistry.remove")(function* (environmentId: EnvironmentId) {
-    yield* forgetEntry(environmentId);
-    // A host's unpaired boxes exist on this device only because it listed them, so they go too.
-    for (const entry of (yield* SubscriptionRef.get(entries)).values()) {
-      if (!isUnpairedBox(entry) || connectionBox(entry.target)?.managerId !== environmentId)
-        continue;
+  // A host's unpaired boxes exist on this device only because it listed them, so they go with it.
+  const forgetRemovedHostBoxes = Effect.fn("EnvironmentRegistry.forgetRemovedHostBoxes")(function* (
+    managerId: EnvironmentId,
+  ) {
+    const current = yield* SubscriptionRef.get(entries);
+    if (current.has(managerId)) return;
+    for (const entry of current.values()) {
+      if (!isUnpairedBox(entry) || connectionBox(entry.target)?.managerId !== managerId) continue;
       yield* forgetUnpairedBox(entry.target.environmentId).pipe(
         Effect.catch((error) =>
           Effect.logWarning("Could not forget a removed host's unpaired box.", {
@@ -766,6 +788,20 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
     }
   });
 
+  const remove = Effect.fn("EnvironmentRegistry.remove")(function* (environmentId: EnvironmentId) {
+    yield* forgetEntry(environmentId);
+    yield* forgetRemovedHostBoxes(environmentId);
+  });
+
+  // Removing a host's last route removes the host, and its unpaired boxes with it.
+  const removeRoute = Effect.fn("EnvironmentRegistry.removeRoute")(function* (
+    environmentId: EnvironmentId,
+    routeId: string,
+  ) {
+    yield* removeRouteEntry(environmentId, routeId);
+    yield* forgetRemovedHostBoxes(environmentId);
+  });
+
   const adoptBox = Effect.fn("EnvironmentRegistry.adoptBox")(function* (
     target: BearerConnectionTarget,
     chat: ProvisionedChat | null,
@@ -776,9 +812,9 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
         if ((yield* SubscriptionRef.get(entries)).has(target.environmentId)) return;
         // Seeded before the entry exists, so the shell its chat lists from starts with the chat.
         if (chat !== null) yield* cache.saveShell(target.environmentId, chatShellSnapshot(chat));
-        yield* registrations.register(new BoxTargetRegistration({ target }));
-        yield* Ref.update(persistedTargetsByEnvironment, (persisted) =>
-          new Map(persisted).set(target.environmentId, target),
+        yield* registrations.register(new BoxTargetRegistration({ target }), [target]);
+        yield* Ref.update(persistedEnvironmentIds, (persisted) =>
+          new Set(persisted).add(target.environmentId),
         );
         yield* installEntryLocked({ target, profile: Option.none(), enabled: true });
       }),
@@ -801,11 +837,12 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
         )
           return;
         const target = new BearerConnectionTarget({ ...entry.target, label });
-        yield* registrations.register(new BoxTargetRegistration({ target }));
-        yield* Ref.update(persistedTargetsByEnvironment, (persisted) =>
-          new Map(persisted).set(environmentId, target),
+        const next: ConnectionCatalogEntry = { ...entry, target };
+        yield* registrations.register(new BoxTargetRegistration({ target }), persistedRoutes(next));
+        yield* Ref.update(persistedEnvironmentIds, (persisted) =>
+          new Set(persisted).add(environmentId),
         );
-        yield* replaceEntryInPlace(environmentId, { ...entry, target });
+        yield* replaceEntryInPlace(environmentId, next);
       }),
     );
   });
@@ -926,8 +963,11 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
       ),
     );
 
-  // A box's supervisor wakes it through its host and keeps its lease alive while connected.
-  const supervisorOptions = (entry: ConnectionCatalogEntry): BoxSupervisorOptions => {
+  // A box's supervisor wakes it through its host and keeps its lease alive while connected. A box
+  // is reached only through its host, so the addresses it reports are never saved as routes.
+  const supervisorOptions = (
+    entry: ConnectionCatalogEntry,
+  ): EnvironmentSupervisor.EnvironmentSupervisorOptions => {
     const box = connectionBox(entry.target);
     if (box === null) return {};
     const environmentId = entry.target.environmentId;
@@ -938,6 +978,7 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
         ([here, connected]) => here && connected,
       ),
       keepAlive: keepBoxAlive(environmentId, box.managerId),
+      learnRoutes: () => Effect.succeedNone,
     };
   };
 
@@ -961,6 +1002,7 @@ export const makeRegistryBoxes = Effect.fn("EnvironmentRegistry.makeRegistryBoxe
   return {
     methods,
     remove,
+    removeRoute,
     wantsConnection,
     supervisorOptions,
     driverFor,
diff --git a/packages/client-runtime/src/connection/resolver.ts b/packages/client-runtime/src/connection/resolver.ts
index 77b778a50aa8..c1f6ac9ea416 100644
--- a/packages/client-runtime/src/connection/resolver.ts
+++ b/packages/client-runtime/src/connection/resolver.ts
@@ -44,6 +44,7 @@ import {
   appendOrchestrationProtocol,
   orchestrationProtocolCompatibilityError,
 } from "./compatibility.ts";
+import { credentialConnectionId } from "./routes.ts";
 import { fetchRemoteEnvironmentDescriptor } from "../environment/descriptor.ts";
 
 export class ConnectionResolver extends Context.Service<
@@ -139,7 +140,15 @@ const makeBearerBroker = Effect.fn("clientRuntime.connection.broker.makeBearer")
         actual: profile.environmentId,
       });
     }
-    const credential = yield* credentials.get(target.connectionId).pipe(
+    if (profile.authorization === "t3-connect") {
+      const authorized = yield* remote.authorizeDpop({
+        expectedEnvironmentId: target.environmentId,
+        directEndpoint: { httpBaseUrl: profile.httpBaseUrl, wsBaseUrl: profile.wsBaseUrl },
+      });
+      return { ...authorized, target } satisfies PreparedConnection;
+    }
+    // A learned route borrows the credential of the route it was learned from.
+    const credential = yield* credentials.get(credentialConnectionId(target.connectionId)).pipe(
       Effect.flatMap(
         Option.match({
           onNone: () => Effect.fail(credentialMissingError(target.connectionId)),
diff --git a/packages/client-runtime/src/connection/routes.test.ts b/packages/client-runtime/src/connection/routes.test.ts
new file mode 100644
index 000000000000..19b433f95738
--- /dev/null
+++ b/packages/client-runtime/src/connection/routes.test.ts
@@ -0,0 +1,316 @@
+import { EnvironmentId } from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+import * as Option from "effect/Option";
+
+import {
+  BearerConnectionProfile,
+  type ConnectionCatalogEntry,
+  type ConnectionRoute,
+} from "./catalog.ts";
+import { gitHubRoutingConnectionKey } from "./githubRoutingPermissions.ts";
+import { BearerConnectionTarget, RelayConnectionTarget } from "./model.ts";
+import {
+  connectionRouteId,
+  connectionRouteKind,
+  connectionRouteLabel,
+  credentialConnectionId,
+  insertRoute,
+  entryWithRoutes,
+  mergeLearnedRoutes,
+  removedWithRelay,
+  routesAfterRemoving,
+  upsertRoute,
+} from "./routes.ts";
+
+const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
+
+function direct(id: string, httpBaseUrl: string): ConnectionRoute {
+  return {
+    target: new BearerConnectionTarget({
+      environmentId: ENVIRONMENT_ID,
+      label: "Desk",
+      connectionId: id,
+    }),
+    profile: Option.some(
+      new BearerConnectionProfile({
+        connectionId: id,
+        environmentId: ENVIRONMENT_ID,
+        label: "Desk",
+        httpBaseUrl,
+        wsBaseUrl: httpBaseUrl.replace(/^http/, "ws"),
+      }),
+    ),
+  };
+}
+
+const RELAY: ConnectionRoute = {
+  target: new RelayConnectionTarget({ environmentId: ENVIRONMENT_ID, label: "Desk" }),
+  profile: Option.none(),
+};
+const LAN = direct("lan", "http://192.168.1.10:3773/");
+const TAILNET = direct("tailnet", "https://desk.tail1234.ts.net/");
+const PUBLIC = direct("public", "https://desk.example.com/");
+
+describe("connection routes", () => {
+  it("classifies direct routes by address", () => {
+    expect(connectionRouteKind(LAN)).toBe("lan");
+    expect(connectionRouteKind(direct("ip", "http://100.101.102.103:3773/"))).toBe("tailnet");
+    expect(connectionRouteKind(TAILNET)).toBe("tailnet");
+    expect(connectionRouteKind(PUBLIC)).toBe("public");
+    expect(connectionRouteKind(direct("lo", "http://127.0.0.1:3773/"))).toBe("loopback");
+    expect(connectionRouteKind(direct("ts6", "http://[fd7a:115c:a1e0::1]:3773/"))).toBe("tailnet");
+    expect(connectionRouteLabel(TAILNET)).toBe("Tailscale");
+    expect(connectionRouteLabel(RELAY)).toBe("T3 Connect");
+  });
+
+  it("places a new route after faster kinds and ahead of T3 Connect", () => {
+    expect(insertRoute([RELAY], LAN)).toEqual([LAN, RELAY]);
+    expect(insertRoute([LAN, RELAY], TAILNET)).toEqual([LAN, TAILNET, RELAY]);
+    expect(insertRoute([TAILNET], LAN)).toEqual([LAN, TAILNET]);
+    expect(insertRoute([LAN, TAILNET], RELAY)).toEqual([LAN, TAILNET, RELAY]);
+  });
+
+  it("keeps a user's order when a saved route is replaced", () => {
+    // The user preferred T3 Connect over the LAN; re-pairing the LAN keeps that.
+    const repaired = direct("lan", "http://192.168.1.11:3773/");
+    expect(upsertRoute([RELAY, LAN], repaired)).toEqual([RELAY, repaired]);
+  });
+});
+
+describe("learned routes", () => {
+  const relayOnly: ConnectionCatalogEntry = {
+    target: RELAY.target,
+    profile: RELAY.profile,
+    enabled: true,
+  };
+  const ids = (routes: ReadonlyArray<ConnectionRoute> | null) =>
+    routes?.map((route) => connectionRouteId(route.target)) ?? null;
+  const profileOf = (route: ConnectionRoute) => Option.getOrThrow(route.profile);
+
+  it("learns a LAN address over T3 Connect, ahead of it, using the T3 Connect credential", () => {
+    const routes = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    });
+    expect(ids(routes)).toEqual([`learned:${ENVIRONMENT_ID}:http://192.168.1.10:3773`, "relay"]);
+    expect(profileOf(routes![0]!)).toMatchObject({
+      learned: true,
+      authorization: "t3-connect",
+      wsBaseUrl: "ws://192.168.1.10:3773/",
+    });
+  });
+
+  it("replaces a learned LAN address when the server reports a new one", () => {
+    const first = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    })!;
+    const entry: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: first[0]!.target,
+      profile: first[0]!.profile,
+      alternateRoutes: first.slice(1),
+    };
+    const moved = mergeLearnedRoutes({
+      entry,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://10.0.0.42:3773/" }],
+      allowInsecure: true,
+    });
+    expect(ids(moved)).toEqual([`learned:${ENVIRONMENT_ID}:http://10.0.0.42:3773`, "relay"]);
+  });
+
+  it("keeps a learned route where the user moved it while the server reports it", () => {
+    const lan = { httpBaseUrl: "http://192.168.1.10:3773/" };
+    const first = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [lan],
+      allowInsecure: true,
+    })!;
+    // The user prefers T3 Connect over the learned LAN address.
+    const reordered = entryWithRoutes(relayOnly, [first[1]!, first[0]!]);
+    expect(
+      mergeLearnedRoutes({
+        entry: reordered,
+        activeRoute: RELAY,
+        reported: [lan],
+        allowInsecure: true,
+      }),
+    ).toBeNull();
+    // A newly reported address is still placed by speed.
+    const next = mergeLearnedRoutes({
+      entry: reordered,
+      activeRoute: RELAY,
+      reported: [lan, { httpBaseUrl: "http://100.101.102.103:3773/" }],
+      allowInsecure: true,
+    });
+    expect(ids(next)).toEqual([
+      `learned:${ENVIRONMENT_ID}:http://100.101.102.103:3773`,
+      "relay",
+      `learned:${ENVIRONMENT_ID}:http://192.168.1.10:3773`,
+    ]);
+  });
+
+  it("leaves user routes alone and does not learn an address already saved", () => {
+    const entry: ConnectionCatalogEntry = {
+      target: LAN.target,
+      profile: LAN.profile,
+      alternateRoutes: [RELAY],
+      enabled: true,
+    };
+    expect(
+      mergeLearnedRoutes({
+        entry,
+        activeRoute: RELAY,
+        reported: [{ httpBaseUrl: "http://192.168.1.10:3773" }],
+        allowInsecure: true,
+      }),
+    ).toBeNull();
+    // The server stops reporting the LAN address; the paired route stays.
+    expect(
+      mergeLearnedRoutes({ entry, activeRoute: RELAY, reported: [], allowInsecure: true }),
+    ).toBeNull();
+  });
+
+  it("borrows the paired token when learned over a bearer route", () => {
+    const entry: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: LAN.target,
+      profile: LAN.profile,
+    };
+    const routes = mergeLearnedRoutes({
+      entry,
+      activeRoute: LAN,
+      reported: [{ httpBaseUrl: "https://desk.tail1234.ts.net/" }],
+      allowInsecure: true,
+    })!;
+    const learned = routes.find((route) => connectionRouteKind(route) === "tailnet")!;
+    expect(profileOf(learned)).not.toHaveProperty("authorization");
+    expect(credentialConnectionId(connectionRouteId(learned.target))).toBe("lan");
+  });
+
+  it("skips plain HTTP from an HTTPS page and never learns loopback", () => {
+    expect(
+      mergeLearnedRoutes({
+        entry: relayOnly,
+        activeRoute: RELAY,
+        reported: [
+          { httpBaseUrl: "http://192.168.1.10:3773/" },
+          { httpBaseUrl: "http://127.0.0.1:3773/" },
+        ],
+        allowInsecure: false,
+      }),
+    ).toBeNull();
+  });
+
+  it("removes learned routes along with the route whose credential they borrow", () => {
+    const overRelay = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    })!;
+    expect(routesAfterRemoving(overRelay, "relay")).toEqual([]);
+
+    const paired: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: LAN.target,
+      profile: LAN.profile,
+      alternateRoutes: [RELAY],
+    };
+    const overLan = mergeLearnedRoutes({
+      entry: paired,
+      activeRoute: LAN,
+      reported: [{ httpBaseUrl: "https://desk.tail1234.ts.net/" }],
+      allowInsecure: true,
+    })!;
+    expect(ids(routesAfterRemoving(overLan, "lan"))).toEqual(["relay"]);
+    // Removing T3 Connect keeps the paired LAN and what it learned.
+    expect(ids(routesAfterRemoving(overLan, "relay"))).toHaveLength(2);
+  });
+
+  it("counts an environment reached only through T3 Connect as removed with it", () => {
+    const learned = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    })!;
+    expect(removedWithRelay(relayOnly)).toBe(true);
+    expect(removedWithRelay(entryWithRoutes(relayOnly, learned))).toBe(true);
+    expect(removedWithRelay(entryWithRoutes(relayOnly, [LAN, RELAY]))).toBe(false);
+  });
+
+  it("keeps GitHub routing trust when a route is learned", () => {
+    const learned = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    })!;
+    const withLearned: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: learned[0]!.target,
+      profile: learned[0]!.profile,
+      alternateRoutes: learned.slice(1),
+    };
+    expect(gitHubRoutingConnectionKey(withLearned)).toBe(gitHubRoutingConnectionKey(relayOnly));
+  });
+
+  it("keeps the T3 Connect credential when learning over a learned T3 Connect route", () => {
+    const first = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://192.168.1.10:3773/" }],
+      allowInsecure: true,
+    })!;
+    const learnedLan = first[0]!;
+    const entry: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: learnedLan.target,
+      profile: learnedLan.profile,
+      alternateRoutes: first.slice(1),
+    };
+    const next = mergeLearnedRoutes({
+      entry,
+      activeRoute: learnedLan,
+      reported: [
+        { httpBaseUrl: "http://192.168.1.10:3773/" },
+        { httpBaseUrl: "https://desk.tail1234.ts.net/" },
+      ],
+      allowInsecure: true,
+    })!;
+    for (const route of next.filter((candidate) => connectionRouteKind(candidate) !== "relay")) {
+      expect(profileOf(route)).toMatchObject({ authorization: "t3-connect" });
+      expect(connectionRouteId(route.target)).not.toContain("@");
+    }
+  });
+
+  it("saves a scheme change on the same host as a new address", () => {
+    const first = mergeLearnedRoutes({
+      entry: relayOnly,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "http://desk.local:3773/" }],
+      allowInsecure: true,
+    })!;
+    const entry: ConnectionCatalogEntry = {
+      ...relayOnly,
+      target: first[0]!.target,
+      profile: first[0]!.profile,
+      alternateRoutes: first.slice(1),
+    };
+    const moved = mergeLearnedRoutes({
+      entry,
+      activeRoute: RELAY,
+      reported: [{ httpBaseUrl: "https://desk.local:3773/" }],
+      allowInsecure: true,
+    });
+    expect(moved).not.toBeNull();
+    expect(profileOf(moved![0]!)).toMatchObject({ httpBaseUrl: "https://desk.local:3773/" });
+  });
+});
diff --git a/packages/client-runtime/src/connection/routes.ts b/packages/client-runtime/src/connection/routes.ts
new file mode 100644
index 000000000000..8b2ebf3e0743
--- /dev/null
+++ b/packages/client-runtime/src/connection/routes.ts
@@ -0,0 +1,374 @@
+import {
+  isLocalLoopbackHost,
+  isPrivateNetworkHost,
+  isTailnetHost,
+} from "@t3tools/shared/hostClassification";
+import type { DesktopSshEnvironmentTarget } from "@t3tools/contracts";
+import * as Option from "effect/Option";
+
+import {
+  BearerConnectionProfile,
+  type ConnectionCatalogEntry,
+  type ConnectionRoute,
+} from "./catalog.ts";
+import { BearerConnectionTarget, type ConnectionTarget } from "./model.ts";
+
+/**
+ * A saved environment can hold several routes: T3 Connect, direct URLs (LAN,
+ * tailnet, public), and SSH. The client connects over the first route in
+ * preference order that answers as the expected environment, and moves back
+ * to a better one when it becomes reachable again.
+ */
+
+export type ConnectionRouteKind = "relay" | "loopback" | "lan" | "tailnet" | "public" | "ssh";
+
+/** An environment has at most one T3 Connect route, so it needs no per-route id. */
+export const RELAY_ROUTE_ID = "relay";
+
+export function connectionRouteId(target: ConnectionTarget): string {
+  switch (target._tag) {
+    case "PrimaryConnectionTarget":
+      return "primary";
+    case "RelayConnectionTarget":
+      return RELAY_ROUTE_ID;
+    case "BearerConnectionTarget":
+    case "SshConnectionTarget":
+      return target.connectionId;
+  }
+}
+
+/** Every route of an entry, preferred first. */
+export function connectionRoutes(entry: ConnectionCatalogEntry): ReadonlyArray<ConnectionRoute> {
+  return [{ target: entry.target, profile: entry.profile }, ...(entry.alternateRoutes ?? [])];
+}
+
+/** Builds an entry whose preferred route is the first of `routes`, which must not be empty. */
+export function entryWithRoutes(
+  entry: ConnectionCatalogEntry,
+  routes: ReadonlyArray<ConnectionRoute>,
+): ConnectionCatalogEntry {
+  const [first, ...rest] = routes;
+  if (first === undefined) {
+    throw new Error("A saved environment needs at least one route.");
+  }
+  const { alternateRoutes: _previous, ...base } = entry;
+  return {
+    ...base,
+    target: first.target,
+    profile: first.profile,
+    ...(rest.length === 0 ? {} : { alternateRoutes: rest }),
+  };
+}
+
+/** The entry a single route connects with. */
+export function routeEntry(
+  entry: ConnectionCatalogEntry,
+  route: ConnectionRoute,
+): ConnectionCatalogEntry {
+  return entryWithRoutes(entry, [route]);
+}
+
+/** The base URL of a direct route, or null for T3 Connect and SSH. */
+export function routeHttpBaseUrl(route: ConnectionRoute): string | null {
+  if (route.target._tag === "PrimaryConnectionTarget") return route.target.httpBaseUrl;
+  const profile = Option.getOrNull(route.profile);
+  return profile?._tag === "BearerConnectionProfile" ? profile.httpBaseUrl : null;
+}
+
+function routeHostname(route: ConnectionRoute): string | null {
+  const httpBaseUrl = routeHttpBaseUrl(route);
+  if (httpBaseUrl === null) return null;
+  try {
+    return new URL(httpBaseUrl).hostname;
+  } catch {
+    return null;
+  }
+}
+
+export function connectionRouteKind(route: ConnectionRoute): ConnectionRouteKind {
+  switch (route.target._tag) {
+    case "RelayConnectionTarget":
+      return "relay";
+    case "SshConnectionTarget":
+      return "ssh";
+    case "PrimaryConnectionTarget":
+    case "BearerConnectionTarget": {
+      const hostname = routeHostname(route);
+      if (hostname === null) return "public";
+      if (isLocalLoopbackHost(hostname)) return "loopback";
+      if (isTailnetHost(hostname)) return "tailnet";
+      return isPrivateNetworkHost(hostname) ? "lan" : "public";
+    }
+  }
+}
+
+const ROUTE_KIND_RANK: Record<ConnectionRouteKind, number> = {
+  loopback: 0,
+  lan: 1,
+  tailnet: 2,
+  public: 3,
+  ssh: 4,
+  relay: 5,
+};
+
+/**
+ * Where a newly added route goes: after every saved route of the same or a
+ * faster kind, so LAN lands ahead of tailnet and both ahead of T3 Connect.
+ * Users can reorder afterwards; this only picks a sensible starting point.
+ */
+export function insertRoute(
+  routes: ReadonlyArray<ConnectionRoute>,
+  route: ConnectionRoute,
+): ReadonlyArray<ConnectionRoute> {
+  const rank = ROUTE_KIND_RANK[connectionRouteKind(route)];
+  const index = routes.findIndex(
+    (existing) => ROUTE_KIND_RANK[connectionRouteKind(existing)] > rank,
+  );
+  return index === -1
+    ? [...routes, route]
+    : [...routes.slice(0, index), route, ...routes.slice(index)];
+}
+
+/** Replaces the route with the same id in place, or inserts it by kind. */
+export function upsertRoute(
+  routes: ReadonlyArray<ConnectionRoute>,
+  route: ConnectionRoute,
+): ReadonlyArray<ConnectionRoute> {
+  const id = connectionRouteId(route.target);
+  return routes.some((existing) => connectionRouteId(existing.target) === id)
+    ? routes.map((existing) => (connectionRouteId(existing.target) === id ? route : existing))
+    : insertRoute(routes, route);
+}
+
+/**
+ * A saved route that reaches the same address as `route`: the same bearer
+ * URL, or the same SSH target (alias, host, user, and port, as desktop keys
+ * its tunnels). Registering it again replaces that route, even when it was
+ * saved under another id.
+ */
+export function findRouteToSameAddress(
+  routes: ReadonlyArray<ConnectionRoute>,
+  route: ConnectionRoute,
+): ConnectionRoute | undefined {
+  const key = routeAddressKey(route);
+  return key === null ? undefined : routes.find((existing) => routeAddressKey(existing) === key);
+}
+
+function routeAddressKey(route: ConnectionRoute): string | null {
+  const profile = Option.getOrNull(route.profile);
+  switch (profile?._tag) {
+    case "BearerConnectionProfile":
+      return `bearer:${profile.httpBaseUrl.replace(/\/+$/, "")}`;
+    case "SshConnectionProfile":
+      return `ssh:${sshTargetKey(profile.target)}`;
+    default:
+      return null;
+  }
+}
+
+/** Short user-facing route description: "LAN", "Tailscale", "T3 Connect", a URL, or an SSH host. */
+export function connectionRouteLabel(route: ConnectionRoute): string {
+  switch (connectionRouteKind(route)) {
+    case "relay":
+      return "T3 Connect";
+    case "loopback":
+      return "This device";
+    case "lan":
+      return "LAN";
+    case "tailnet":
+      return "Tailscale";
+    case "ssh": {
+      const profile = Option.getOrNull(route.profile);
+      return profile?._tag === "SshConnectionProfile"
+        ? `SSH ${profile.target.username ? `${profile.target.username}@` : ""}${profile.target.hostname}`
+        : "SSH";
+    }
+    case "public":
+      return routeHostname(route) ?? "Remote link";
+  }
+}
+
+/** The address shown under a route, or null for T3 Connect. */
+export function connectionRouteAddress(route: ConnectionRoute): string | null {
+  if (route.target._tag === "SshConnectionTarget") {
+    const profile = Option.getOrNull(route.profile);
+    return profile?._tag === "SshConnectionProfile" ? profile.target.alias : null;
+  }
+  return routeHttpBaseUrl(route);
+}
+
+/** Whether the environment can be reached through T3 Connect. */
+export function hasRelayRoute(
+  entry: Pick<ConnectionCatalogEntry, "target" | "alternateRoutes">,
+): boolean {
+  return [entry.target, ...(entry.alternateRoutes ?? []).map((route) => route.target)].some(
+    (target) => target._tag === "RelayConnectionTarget",
+  );
+}
+
+/**
+ * The routes after the server reports where it listens. Each newly reported
+ * address becomes a learned route that authenticates the same way as the route
+ * in use: the paired token for a bearer route, the T3 Connect credential for
+ * relay. A learned route the server still reports keeps its place, so the
+ * user's order holds; one it no longer reports is dropped, so a changed LAN
+ * address replaces the old one. Routes the user saved are never touched, and
+ * an address already saved is not learned twice.
+ */
+export function mergeLearnedRoutes(input: {
+  readonly entry: ConnectionCatalogEntry;
+  readonly activeRoute: ConnectionRoute;
+  readonly reported: ReadonlyArray<{ readonly httpBaseUrl: string }>;
+  /** Plain HTTP routes are unusable from an HTTPS page (mixed content). */
+  readonly allowInsecure: boolean;
+}): ReadonlyArray<ConnectionRoute> | null {
+  const { entry } = input;
+  const active = input.activeRoute.target;
+  const saved = connectionRoutes(entry);
+  // The primary and SSH routes have no credential a learned route could reuse.
+  if (active._tag !== "RelayConnectionTarget" && active._tag !== "BearerConnectionTarget") {
+    return null;
+  }
+  // A route learned over another learned route inherits what that one uses:
+  // the T3 Connect credential, or the paired token it borrows.
+  const activeProfile = Option.getOrNull(input.activeRoute.profile);
+  const authorization =
+    active._tag === "RelayConnectionTarget" ||
+    (activeProfile?._tag === "BearerConnectionProfile" &&
+      activeProfile.authorization === "t3-connect")
+      ? ("t3-connect" as const)
+      : undefined;
+  const sharedCredential =
+    authorization === undefined && active._tag === "BearerConnectionTarget"
+      ? credentialConnectionId(active.connectionId)
+      : undefined;
+
+  // Usable reported addresses, by origin.
+  const reported = new Map<string, URL>();
+  for (const endpoint of input.reported) {
+    let url: URL;
+    try {
+      url = new URL(endpoint.httpBaseUrl);
+    } catch {
+      continue;
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") continue;
+    if (url.protocol === "http:" && !input.allowInsecure) continue;
+    // A loopback address names whichever device opens it, never the server.
+    if (isLocalLoopbackHost(url.hostname)) continue;
+    reported.set(url.origin, url);
+  }
+  const normalized = (url: string) => url.replace(/\/+$/, "");
+  const known = new Set(
+    saved.flatMap((route) => {
+      const url = routeHttpBaseUrl(route);
+      return url === null || isLearned(route) ? [] : [normalized(url)];
+    }),
+  );
+  const kept = saved.filter((route) => {
+    if (!isLearned(route)) return true;
+    const url = routeHttpBaseUrl(route);
+    if (url === null || !reported.has(normalized(url)) || known.has(normalized(url))) return false;
+    known.add(normalized(url));
+    return true;
+  });
+  let next: ReadonlyArray<ConnectionRoute> = kept;
+  for (const url of reported.values()) {
+    if (known.has(url.origin)) continue;
+    const httpBaseUrl = `${url.origin}/`;
+    const connectionId = learnedConnectionId(
+      entry.target.environmentId,
+      url.origin,
+      sharedCredential,
+    );
+    next = insertRoute(next, {
+      target: new BearerConnectionTarget({
+        environmentId: entry.target.environmentId,
+        label: entry.target.label,
+        connectionId,
+      }),
+      profile: Option.some(
+        new BearerConnectionProfile({
+          connectionId,
+          environmentId: entry.target.environmentId,
+          label: entry.target.label,
+          httpBaseUrl,
+          wsBaseUrl: `${url.protocol === "https:" ? "wss:" : "ws:"}//${url.host}/`,
+          learned: true,
+          ...(authorization === undefined ? {} : { authorization }),
+        }),
+      ),
+    });
+  }
+  // Compare addresses too: a scheme or port change keeps no id stable.
+  const signature = (routes: ReadonlyArray<ConnectionRoute>) =>
+    routes
+      .map((route) => `${connectionRouteId(route.target)} ${routeHttpBaseUrl(route) ?? ""}`)
+      .join("\n");
+  return signature(saved) === signature(next) ? null : next;
+}
+
+/**
+ * A learned bearer route borrows the credential of the route it was learned
+ * from, so its id points back at that credential's owner.
+ */
+function learnedConnectionId(
+  environmentId: string,
+  origin: string,
+  sharedCredential: string | undefined,
+): string {
+  return sharedCredential === undefined
+    ? `learned:${environmentId}:${origin}`
+    : `learned:${environmentId}:${origin}@${sharedCredential}`;
+}
+
+/** The connection id whose stored credential a bearer route uses. */
+export function credentialConnectionId(connectionId: string): string {
+  // The borrowed id follows the first "@"; neither an environment id nor an
+  // origin contains one.
+  const at = connectionId.indexOf("@");
+  return connectionId.startsWith("learned:") && at !== -1
+    ? connectionId.slice(at + 1)
+    : connectionId;
+}
+
+export function isLearned(route: ConnectionRoute): boolean {
+  const profile = Option.getOrNull(route.profile);
+  return profile?._tag === "BearerConnectionProfile" && profile.learned === true;
+}
+
+/**
+ * Routes left after the user removes one. A learned route borrows the
+ * credential of the route it was learned over, so it cannot outlive that
+ * route: removing T3 Connect also removes routes learned through it, and
+ * removing a paired address removes routes that borrow its token.
+ */
+export function routesAfterRemoving(
+  routes: ReadonlyArray<ConnectionRoute>,
+  removedId: string,
+): ReadonlyArray<ConnectionRoute> {
+  const removed = routes.find((route) => connectionRouteId(route.target) === removedId);
+  if (removed === undefined) return routes;
+  return routes.filter((route) => {
+    if (route === removed) return false;
+    if (!isLearned(route)) return true;
+    const profile = Option.getOrNull(route.profile);
+    if (profile?._tag === "BearerConnectionProfile" && profile.authorization === "t3-connect") {
+      return removed.target._tag !== "RelayConnectionTarget";
+    }
+    return credentialConnectionId(connectionRouteId(route.target)) !== removedId;
+  });
+}
+
+/**
+ * Whether removing T3 Connect leaves the environment no route, so signing out
+ * removes it entirely. Routes learned through T3 Connect go with it.
+ */
+export function removedWithRelay(entry: ConnectionCatalogEntry): boolean {
+  return routesAfterRemoving(connectionRoutes(entry), RELAY_ROUTE_ID).length === 0;
+}
+
+/** One SSH target, as desktop keys its tunnels: alias, host, user, and port. */
+export function sshTargetKey(target: DesktopSshEnvironmentTarget): string {
+  return JSON.stringify([target.alias, target.hostname, target.username, target.port]);
+}
diff --git a/packages/client-runtime/src/connection/supervisor.test.ts b/packages/client-runtime/src/connection/supervisor.test.ts
index 1d518f017d6d..235eedfde218 100644
--- a/packages/client-runtime/src/connection/supervisor.test.ts
+++ b/packages/client-runtime/src/connection/supervisor.test.ts
@@ -1,4 +1,4 @@
-import { AuthStandardClientScopes, EnvironmentId } from "@t3tools/contracts";
+import { AuthStandardClientScopes, EnvironmentId, type ServerConfig } from "@t3tools/contracts";
 import { RelayClientTracer } from "@t3tools/shared/relayTracing";
 import { describe, expect, it } from "@effect/vitest";
 import * as Deferred from "effect/Deferred";
@@ -19,10 +19,12 @@ import * as ManagedRelay from "../relay/managedRelay.ts";
 import { remoteHttpClientLayer } from "../rpc/http.ts";
 import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
 import { fetchEnvironmentSessionState } from "../state/session.ts";
-import type { ConnectionCatalogEntry } from "./catalog.ts";
+import type { ConnectionCatalogEntry, ConnectionRoute } from "./catalog.ts";
 import * as Connectivity from "./connectivity.ts";
 import * as ConnectionDriver from "./driver.ts";
+import { BearerConnectionProfile } from "./catalog.ts";
 import {
+  BearerConnectionTarget,
   ConnectionBlockedError,
   ConnectionTransientError,
   PrimaryConnectionTarget,
@@ -36,6 +38,7 @@ import {
 import * as RpcSession from "../rpc/session.ts";
 import * as EnvironmentSupervisor from "./supervisor.ts";
 import * as ConnectionWakeups from "./wakeups.ts";
+import { connectionRouteId, entryWithRoutes, isLearned, mergeLearnedRoutes } from "./routes.ts";
 import { NETWORK_BLOCKING_HINT } from "../errors/network.ts";
 
 const TARGET = new PrimaryConnectionTarget({
@@ -73,6 +76,35 @@ const PREPARED_CONNECTION: PreparedConnection = {
 
 const TEST_RPC_CLIENT = {} as WsRpcProtocolClient;
 
+const LAN_TARGET = new BearerConnectionTarget({
+  environmentId: TARGET.environmentId,
+  label: TARGET.label,
+  connectionId: "bearer:lan",
+});
+const LAN_ROUTE: ConnectionRoute = {
+  target: LAN_TARGET,
+  profile: Option.some(
+    new BearerConnectionProfile({
+      connectionId: LAN_TARGET.connectionId,
+      environmentId: TARGET.environmentId,
+      label: TARGET.label,
+      httpBaseUrl: "http://192.168.1.10:3773/",
+      wsBaseUrl: "ws://192.168.1.10:3773/",
+    }),
+  ),
+};
+// LAN first, T3 Connect as the fallback.
+const LAN_THEN_RELAY_ENTRY: ConnectionCatalogEntry = {
+  target: LAN_ROUTE.target,
+  profile: LAN_ROUTE.profile,
+  alternateRoutes: [{ target: RELAY_TARGET, profile: Option.none() }],
+  enabled: true,
+};
+
+function preparedFor(target: ConnectionTarget): PreparedConnection {
+  return { ...PREPARED_CONNECTION, target };
+}
+
 function transient(message = "Connection failed.") {
   return new ConnectionTransientError({
     reason: "transport",
@@ -125,6 +157,8 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
   ) => Effect.Effect<PreparedConnection, ConnectionAttemptError>;
   readonly ready?: (attempt: number) => Effect.Effect<void, ConnectionAttemptError>;
   readonly probe?: (attempt: number) => Effect.Effect<void, ConnectionAttemptError>;
+  readonly initialConfig?: (attempt: number) => Effect.Effect<ServerConfig, ConnectionAttemptError>;
+  readonly checkRoute?: (route: ConnectionRoute) => Effect.Effect<ConnectionDriver.RouteCheck>;
 }) {
   const networkStatus = yield* SubscriptionRef.make<NetworkStatus>(
     options?.networkStatus ?? "online",
@@ -156,12 +190,13 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
     return PREPARED_CONNECTION;
   });
 
-  const connect = Effect.fn("TestConnectionDriver.connect")(function* (
-    entry: ConnectionCatalogEntry,
+  const checkRoute = (route: ConnectionRoute) =>
+    options?.checkRoute?.(route) ?? Effect.succeed<ConnectionDriver.RouteCheck>("unchecked");
+
+  const connectRoute = Effect.fn("TestConnectionDriver.connectRoute")(function* (
+    target: ConnectionTarget,
     reportProgress: (progress: ConnectionDriver.ConnectionDriverProgress) => Effect.Effect<void>,
   ) {
-    const target = entry.target;
-    yield* reportProgress({ stage: "preparing" });
     const prepared = yield* prepare(target);
     yield* reportProgress({ stage: "opening", prepared });
 
@@ -172,7 +207,9 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
     const session = yield* Effect.acquireRelease(
       Effect.succeed({
         client: TEST_RPC_CLIENT,
-        initialConfig: Effect.die(new Error("Initial config is not used by supervisor tests.")),
+        initialConfig:
+          options?.initialConfig?.(attempt) ??
+          Effect.die(new Error("Initial config is not used by supervisor tests.")),
         subscribeServerConfig: (input) => TEST_RPC_CLIENT.subscribeServerConfig(input),
         ready: options?.ready?.(attempt) ?? Effect.void,
         probe: options?.probe?.(attempt) ?? Effect.void,
@@ -186,6 +223,16 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
     return { prepared, session } satisfies ConnectionDriver.EnvironmentConnectionLease;
   });
 
+  const connect = Effect.fn("TestConnectionDriver.connect")(function* (
+    entry: ConnectionCatalogEntry,
+    reportProgress: (progress: ConnectionDriver.ConnectionDriverProgress) => Effect.Effect<void>,
+  ) {
+    yield* reportProgress({ stage: "preparing" });
+    return yield* ConnectionDriver.connectOverRoutes(entry, checkRoute, (route) =>
+      connectRoute(route.target, reportProgress),
+    );
+  });
+
   const dependencies = Layer.mergeAll(
     // Jitter at its maximum, so each retry waits exactly its ceiling: 2s, 4s, 8s...
     Layer.succeed(Random.Random, {
@@ -204,7 +251,12 @@ const makeHarness = Effect.fn("TestConnectionHarness.make")(function* (options?:
     ),
     Layer.succeed(
       ConnectionDriver.ConnectionDriver,
-      ConnectionDriver.ConnectionDriver.of({ connect }),
+      ConnectionDriver.ConnectionDriver.of({
+        connect,
+        checkRoute: (_entry, route) => checkRoute(route),
+        preflight: (_entry, route) =>
+          checkRoute(route).pipe(Effect.map((check) => check === "answered")),
+      }),
     ),
   );
 
@@ -1336,7 +1388,9 @@ describe("EnvironmentSupervisor", () => {
 
   it.effect("releases and reconnects a relay session when credentials change", () =>
     Effect.gen(function* () {
-      const harness = yield* makeHarness();
+      const harness = yield* makeHarness({
+        prepare: () => Effect.succeed(preparedFor(RELAY_TARGET)),
+      });
       const supervisor = yield* EnvironmentSupervisor.make(RELAY_ENTRY, {
         initiallyDesired: true,
       }).pipe(Effect.provide(harness.dependencies));
@@ -1633,3 +1687,366 @@ describe("EnvironmentSupervisor", () => {
     }),
   );
 });
+
+describe("EnvironmentSupervisor routes", () => {
+  it.effect("skips a silent LAN route and connects over T3 Connect", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          Effect.succeed(route.target._tag === "BearerConnectionTarget" ? "silent" : "unchecked"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      const prepared = Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared));
+      expect(prepared.target._tag).toBe("RelayConnectionTarget");
+      // The silent route never reached the resolver.
+      expect(yield* Ref.get(harness.prepareCount)).toBe(1);
+    }),
+  );
+
+  it.effect("moves to a blocked route's fallback instead of stopping", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: () => Effect.succeed("answered"),
+        prepare: (_attempt, target) =>
+          target._tag === "BearerConnectionTarget"
+            ? Effect.fail(blocked("The environment credential is invalid."))
+            : Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      const prepared = Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared));
+      expect(prepared.target._tag).toBe("RelayConnectionTarget");
+    }),
+  );
+
+  it.effect("tries every route when none answers the reachability check", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: () => Effect.succeed("silent"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      const prepared = Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared));
+      expect(prepared.target._tag).toBe("BearerConnectionTarget");
+    }),
+  );
+
+  it.effect("still tries a silent LAN route after the T3 Connect route fails", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          Effect.succeed(route.target._tag === "BearerConnectionTarget" ? "silent" : "unchecked"),
+        // Signed out of T3 Connect; the LAN is up but its check timed out.
+        prepare: (_attempt, target) =>
+          target._tag === "RelayConnectionTarget"
+            ? Effect.fail(blocked("Sign in to T3 Connect."))
+            : Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "BearerConnectionTarget",
+      );
+    }),
+  );
+
+  it.effect("keeps retrying when one route is blocked and another failed transiently", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: () => Effect.succeed("answered"),
+        prepare: (_attempt, target) =>
+          target._tag === "RelayConnectionTarget"
+            ? Effect.fail(blocked("Sign in to T3 Connect."))
+            : Effect.fail(transient("LAN socket refused.")),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      // A blocked state would stop retrying; the LAN may come back.
+      const state = yield* awaitState(supervisor.state, (value) => value.phase === "backoff");
+      expect(state.lastFailure?._tag).toBe("ConnectionTransientError");
+    }),
+  );
+
+  it.effect("moves back to the LAN route when the network changes and it answers again", () =>
+    Effect.gen(function* () {
+      const lanReachable = yield* Ref.make(false);
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          route.target._tag === "BearerConnectionTarget"
+            ? Ref.get(lanReachable).pipe(
+                Effect.map((reachable) => (reachable ? "answered" : "silent")),
+              )
+            : Effect.succeed("unchecked"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 1,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "RelayConnectionTarget",
+      );
+
+      // Back home: the LAN answers, and a network change asks for a better route.
+      yield* Ref.set(lanReachable, true);
+      yield* harness.setNetworkStatus("unknown");
+      yield* harness.setNetworkStatus("online");
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 2,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "BearerConnectionTarget",
+      );
+      expect(yield* Ref.get(harness.releaseCount)).toBe(1);
+    }),
+  );
+
+  it.effect("checks for a better route periodically while on a fallback", () =>
+    Effect.gen(function* () {
+      const lanReachable = yield* Ref.make(false);
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          route.target._tag === "BearerConnectionTarget"
+            ? Ref.get(lanReachable).pipe(
+                Effect.map((reachable) => (reachable ? "answered" : "silent")),
+              )
+            : Effect.succeed("unchecked"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 1,
+      );
+      yield* Ref.set(lanReachable, true);
+      yield* TestClock.adjust("60 seconds");
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 2,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "BearerConnectionTarget",
+      );
+    }),
+  );
+
+  it.effect("does not retry a better route that answered but failed to connect", () =>
+    Effect.gen(function* () {
+      const lanAnswers = yield* Ref.make(false);
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          route.target._tag === "BearerConnectionTarget"
+            ? Ref.get(lanAnswers).pipe(Effect.map((answers) => (answers ? "answered" : "silent")))
+            : Effect.succeed("unchecked"),
+        // The LAN answers its check but the socket never opens.
+        prepare: (_attempt, target) =>
+          target._tag === "BearerConnectionTarget"
+            ? Effect.fail(transient("Socket refused."))
+            : Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 1,
+      );
+      yield* Ref.set(lanAnswers, true);
+      yield* TestClock.adjust("60 seconds");
+      // The switch lands back on T3 Connect.
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 2,
+      );
+      const preparesAfterSwitch = yield* Ref.get(harness.prepareCount);
+
+      // The failed LAN is cooling down, so the next periodic check leaves the
+      // session alone.
+      yield* TestClock.adjust("60 seconds");
+      yield* Effect.yieldNow;
+      expect(yield* Ref.get(harness.prepareCount)).toBe(preparesAfterSwitch);
+      expect(yield* SubscriptionRef.get(supervisor.state)).toMatchObject({
+        phase: "connected",
+        generation: 2,
+      });
+    }),
+  );
+
+  it.effect("stays on the preferred route without checking other routes", () =>
+    Effect.gen(function* () {
+      const checks = yield* Ref.make(0);
+      const harness = yield* makeHarness({
+        checkRoute: () => Ref.update(checks, (count) => count + 1).pipe(Effect.as("answered")),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      const checksAtConnect = yield* Ref.get(checks);
+      yield* harness.setNetworkStatus("unknown");
+      yield* harness.setNetworkStatus("online");
+      yield* TestClock.adjust("5 minutes");
+      yield* Effect.yieldNow;
+
+      expect(yield* Ref.get(checks)).toBe(checksAtConnect);
+      expect(yield* Ref.get(harness.sessionCount)).toBe(1);
+    }),
+  );
+
+  it.effect("moves off a dead LAN socket when the phone switches to cellular", () =>
+    Effect.gen(function* () {
+      const lanReachable = yield* Ref.make(true);
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          route.target._tag === "BearerConnectionTarget"
+            ? Ref.get(lanReachable).pipe(
+                Effect.map((reachable) => (reachable ? "answered" : "silent")),
+              )
+            : Effect.succeed("unchecked"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+        // The LAN socket never answers once the phone has left the network.
+        probe: () =>
+          Ref.get(lanReachable).pipe(
+            Effect.flatMap((reachable) => (reachable ? Effect.void : Effect.never)),
+          ),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 1,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "BearerConnectionTarget",
+      );
+
+      yield* Ref.set(lanReachable, false);
+      yield* harness.wake("network-changed");
+      yield* TestClock.adjust("3 seconds");
+
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 2,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "RelayConnectionTarget",
+      );
+    }),
+  );
+
+  it.effect("keeps a LAN session when the T3 Connect account changes", () =>
+    Effect.gen(function* () {
+      const harness = yield* makeHarness({
+        checkRoute: () => Effect.succeed("answered"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+      });
+      const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
+        initiallyDesired: true,
+      }).pipe(Effect.provide(harness.dependencies));
+
+      yield* awaitState(supervisor.state, (state) => state.phase === "connected");
+      yield* harness.wake("credentials-changed");
+      yield* Effect.yieldNow;
+
+      expect(yield* Ref.get(harness.sessionCount)).toBe(1);
+      expect(yield* SubscriptionRef.get(supervisor.state)).toMatchObject({
+        phase: "connected",
+        generation: 1,
+      });
+    }),
+  );
+
+  it.effect("learns the LAN address over T3 Connect and moves to it", () =>
+    Effect.gen(function* () {
+      const relayEntry: ConnectionCatalogEntry = {
+        target: RELAY_TARGET,
+        profile: Option.none(),
+        enabled: true,
+      };
+      const lanAddress = yield* Ref.make("http://192.168.1.10:3773/");
+      const learned = yield* Ref.make<ReadonlyArray<string>>([]);
+      const harness = yield* makeHarness({
+        checkRoute: (route) =>
+          route.target._tag === "BearerConnectionTarget"
+            ? Effect.succeed("answered")
+            : Effect.succeed("unchecked"),
+        prepare: (_attempt, target) => Effect.succeed(preparedFor(target)),
+        // Only the reported endpoints matter to the supervisor.
+        initialConfig: () =>
+          Ref.get(lanAddress).pipe(
+            Effect.map((httpBaseUrl): Pick<ServerConfig, "directEndpoints"> => ({
+              directEndpoints: [{ kind: "lan", httpBaseUrl }],
+            })),
+            Effect.map((config) => config as ServerConfig),
+          ),
+      });
+      const current = yield* Ref.make(relayEntry);
+      const supervisor = yield* EnvironmentSupervisor.make(relayEntry, {
+        initiallyDesired: true,
+        learnRoutes: ({ activeRoute, reported }) =>
+          Effect.gen(function* () {
+            const entry = yield* Ref.get(current);
+            const routes = mergeLearnedRoutes({
+              entry,
+              activeRoute,
+              reported,
+              allowInsecure: true,
+            });
+            if (routes === null) return Option.none();
+            const next = entryWithRoutes(entry, routes);
+            yield* Ref.set(current, next);
+            yield* Ref.update(learned, (all) => [
+              ...all,
+              ...routes.filter(isLearned).map((route) => connectionRouteId(route.target)),
+            ]);
+            return Option.some(next);
+          }),
+      }).pipe(Effect.provide(harness.dependencies));
+
+      // Connected over T3 Connect, the server reports its LAN address; the
+      // learned route ranks first, answers, and the session moves to it.
+      yield* awaitState(
+        supervisor.state,
+        (state) => state.phase === "connected" && state.generation === 2,
+      );
+      expect(Option.getOrThrow(yield* SubscriptionRef.get(supervisor.prepared)).target._tag).toBe(
+        "BearerConnectionTarget",
+      );
+      expect(yield* Ref.get(learned)).toEqual([
+        `learned:${TARGET.environmentId}:http://192.168.1.10:3773`,
+      ]);
+    }),
+  );
+});
diff --git a/packages/client-runtime/src/connection/supervisor.ts b/packages/client-runtime/src/connection/supervisor.ts
index f8277865695c..b4c7f54b81f8 100644
--- a/packages/client-runtime/src/connection/supervisor.ts
+++ b/packages/client-runtime/src/connection/supervisor.ts
@@ -15,7 +15,7 @@ import * as Stream from "effect/Stream";
 import * as SubscriptionRef from "effect/SubscriptionRef";
 import * as Tracer from "effect/Tracer";
 
-import type { ConnectionCatalogEntry } from "./catalog.ts";
+import type { ConnectionCatalogEntry, ConnectionRoute } from "./catalog.ts";
 import * as Connectivity from "./connectivity.ts";
 import * as ConnectionDriver from "./driver.ts";
 import {
@@ -31,15 +31,23 @@ import { safeErrorLogAttributes } from "../errors/safeLog.ts";
 import { NETWORK_BLOCKING_HINT } from "../errors/network.ts";
 import * as ConnectionWakeups from "./wakeups.ts";
 import { type BoxSupervisorOptions, makeBoxWaker } from "./boxWake.ts";
+import { connectionRouteId, connectionRoutes, entryWithRoutes } from "./routes.ts";
 
 const RETRY_BASE_DELAY_MS = 1_000;
 const RETRY_MAX_DELAY_MS = 300_000;
 const CONNECTION_ESTABLISHMENT_TIMEOUT = "15 seconds";
+const establishmentTimeout = Duration.fromInputUnsafe(CONNECTION_ESTABLISHMENT_TIMEOUT);
 const CONNECTION_PROBE_TIMEOUT = "15 seconds";
 // Mobile resumes, explicit retries, and offline events want a fast answer:
 // the user is waiting, or the network may be gone.
 const QUICK_CONNECTION_PROBE_TIMEOUT = "3 seconds";
 const BACKOFF_RESET_AFTER_MS = 30_000;
+// While connected over a fallback route, how often to look for a better one.
+// Network changes and returning to the app also trigger a check.
+const BETTER_ROUTE_CHECK_INTERVAL = "60 seconds";
+// A better route that answered the check but then failed to connect is not
+// tried again for this long, so a flaky LAN cannot bounce the connection.
+const BETTER_ROUTE_COOLDOWN_MS = 300_000;
 
 interface SupervisorIntent {
   readonly desired: boolean;
@@ -51,7 +59,8 @@ type SupervisorSignal =
   | { readonly _tag: "DisconnectRequested" }
   | { readonly _tag: "RetryRequested" }
   | { readonly _tag: "NetworkChanged"; readonly network: NetworkStatus }
-  | { readonly _tag: "Wakeup"; readonly reason: ConnectionWakeups.ConnectionWakeup };
+  | { readonly _tag: "Wakeup"; readonly reason: ConnectionWakeups.ConnectionWakeup }
+  | { readonly _tag: "BetterRouteAvailable"; readonly routeId: string };
 
 interface PendingRetryTrace {
   readonly previousAttempt: Tracer.Span;
@@ -105,6 +114,15 @@ function exitUnlessInterrupted<A, E, R>(
 
 export interface EnvironmentSupervisorOptions extends BoxSupervisorOptions {
   readonly initiallyDesired?: boolean;
+  /**
+   * Saves the direct addresses the server reports once a session is ready and
+   * returns the entry with its updated routes, which later attempts use. The
+   * live session is left alone: it already works.
+   */
+  readonly learnRoutes?: (input: {
+    readonly activeRoute: ConnectionRoute;
+    readonly reported: ReadonlyArray<{ readonly httpBaseUrl: string }>;
+  }) => Effect.Effect<Option.Option<ConnectionCatalogEntry>>;
 }
 
 /**
@@ -237,8 +255,13 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
   | ConnectionWakeups.ConnectionWakeups
 > {
   const target = entry.target;
+  // Relay-specific handling applies when any route is T3 Connect, since the
+  // attempt or the live session may be using it.
+  const usesRelay = connectionRoutes(entry).some(
+    (route) => route.target._tag === "RelayConnectionTarget",
+  );
   const setupTimeoutDetail = `${target.label} did not respond during connection setup.${
-    target._tag === "RelayConnectionTarget" ? ` ${NETWORK_BLOCKING_HINT}` : ""
+    usesRelay ? ` ${NETWORK_BLOCKING_HINT}` : ""
   }`;
   yield* annotateTarget(target);
 
@@ -266,6 +289,98 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
   );
   const session = yield* SubscriptionRef.make<Option.Option<RpcSession.RpcSession>>(Option.none());
   const prepared = yield* SubscriptionRef.make<Option.Option<PreparedConnection>>(Option.none());
+  // Learned routes arrive while a session is live, so the route list is read
+  // fresh by each attempt and check instead of being fixed at creation.
+  const currentEntry = yield* Ref.make(entry);
+  const currentRoutes = Ref.get(currentEntry).pipe(Effect.map(connectionRoutes));
+  // Set when a better route answered while connected over a worse one; the
+  // replacement attempt tries it first. Cleared once an attempt starts.
+  const preferredRouteId = yield* Ref.make(Option.none<string>());
+  // Monotonic deadline per route that answered a check but failed to connect.
+  const routeCooldowns = yield* Ref.make<ReadonlyMap<string, bigint>>(new Map());
+
+  const attemptEntry = Effect.gen(function* () {
+    const latest = yield* Ref.get(currentEntry);
+    const routes = connectionRoutes(latest);
+    const preferred = yield* Ref.getAndSet(preferredRouteId, Option.none());
+    if (Option.isNone(preferred)) return latest;
+    const route = routes.find(
+      (candidate) => connectionRouteId(candidate.target) === preferred.value,
+    );
+    return route === undefined
+      ? latest
+      : entryWithRoutes(latest, [route, ...routes.filter((candidate) => candidate !== route)]);
+  });
+
+  const learnRoutesFrom = Effect.fnUntraced(function* (
+    learn: NonNullable<EnvironmentSupervisorOptions["learnRoutes"]>,
+    lease: ConnectionDriver.EnvironmentConnectionLease,
+  ) {
+    const config = yield* lease.session.initialConfig.pipe(Effect.option);
+    const reported = Option.getOrUndefined(config)?.directEndpoints;
+    if (reported === undefined) return;
+    const activeId = connectionRouteId(lease.prepared.target);
+    const activeRoute = (yield* currentRoutes).find(
+      (route) => connectionRouteId(route.target) === activeId,
+    );
+    if (activeRoute === undefined) return;
+    const updated = yield* learn({ activeRoute, reported });
+    if (Option.isSome(updated)) {
+      yield* Ref.set(currentEntry, updated.value);
+      // A learned route may rank above the one in use.
+      yield* requestBetterRouteCheck(lease);
+    }
+  });
+
+  const routeIndex = (lease: ConnectionDriver.EnvironmentConnectionLease) =>
+    currentRoutes.pipe(
+      Effect.map((routes) =>
+        routes.findIndex(
+          (route) => connectionRouteId(route.target) === connectionRouteId(lease.prepared.target),
+        ),
+      ),
+    );
+
+  /**
+   * Preflights the routes ranked above the one in use and signals the best
+   * that would connect. Routes without a cheap check (T3 Connect, SSH) never
+   * pass, so they are fallbacks, not destinations.
+   */
+  const checkBetterRoutes = Effect.fnUntraced(function* (
+    lease: ConnectionDriver.EnvironmentConnectionLease,
+  ) {
+    const latest = yield* Ref.get(currentEntry);
+    const current = yield* routeIndex(lease);
+    if (current <= 0) return;
+    const now = yield* Clock.monotonicTimeNanos;
+    const cooldowns = yield* Ref.get(routeCooldowns);
+    const better = connectionRoutes(latest)
+      .slice(0, current)
+      .filter((route) => (cooldowns.get(connectionRouteId(route.target)) ?? 0n) <= now);
+    const passed = yield* Effect.forEach(
+      better,
+      (route: ConnectionRoute) => driver.preflight(latest, route),
+      { concurrency: "unbounded" },
+    );
+    const index = passed.indexOf(true);
+    if (index === -1) return;
+    // The check may outlive the session it was asked about.
+    const live = yield* SubscriptionRef.get(session);
+    if (Option.isNone(live) || live.value !== lease.session) return;
+    yield* signal({
+      _tag: "BetterRouteAvailable",
+      routeId: connectionRouteId(better[index]!.target),
+    });
+  });
+
+  // One check at a time; a trigger during a check is dropped, not queued.
+  const betterRouteChecks = yield* Queue.dropping<ConnectionDriver.EnvironmentConnectionLease>(1);
+  const requestBetterRouteCheck = (lease: ConnectionDriver.EnvironmentConnectionLease) =>
+    routeIndex(lease).pipe(
+      Effect.flatMap((index) =>
+        index > 0 ? Queue.offer(betterRouteChecks, lease).pipe(Effect.asVoid) : Effect.void,
+      ),
+    );
 
   const clearLease = Effect.all(
     [SubscriptionRef.set(session, Option.none()), SubscriptionRef.set(prepared, Option.none())],
@@ -310,7 +425,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     generation: number,
     lastFailure: ConnectionAttemptError | null,
   ) {
-    return yield* driver.connect(entry, (progress) =>
+    return yield* driver.connect(yield* attemptEntry, (progress) =>
       reportProgress(attempt, generation, lastFailure, progress),
     );
   });
@@ -363,7 +478,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     lastFailure: ConnectionAttemptError | null,
     pendingRetry: Option.Option<PendingRetryTrace>,
   ) {
-    if (target._tag === "RelayConnectionTarget") {
+    if (usesRelay) {
       return yield* traceRelayEstablishment(
         establishConnection(attempt, generation, lastFailure),
         attempt,
@@ -396,12 +511,13 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
           }
           break;
         case "ConnectRequested":
+        case "BetterRouteAvailable":
           break;
         case "Wakeup":
           if (next.reason === "application-active-reconnect") {
             return true;
           }
-          if (next.reason === "credentials-changed" && target._tag === "RelayConnectionTarget") {
+          if (next.reason === "credentials-changed" && usesRelay) {
             yield* logManagedRelayAccountChange;
             return false;
           }
@@ -412,10 +528,22 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
 
   // Signals that end a connected lease whatever its health: "reset" ends it
   // and restarts the retry ladder, "end" ends it, undefined keeps it.
-  const connectedLeaseEnd = Effect.fnUntraced(function* (next: SupervisorSignal) {
+  const isRelayLease = (lease: ConnectionDriver.EnvironmentConnectionLease) =>
+    lease.prepared.target._tag === "RelayConnectionTarget";
+
+  const connectedLeaseEnd = Effect.fnUntraced(function* (
+    next: SupervisorSignal,
+    lease: ConnectionDriver.EnvironmentConnectionLease,
+  ) {
     if (next._tag === "DisconnectRequested") {
       return "end" as const;
     }
+    if (next._tag === "BetterRouteAvailable") {
+      // Replaced like a long resume: the new attempt prefers the better route
+      // and its session takes over the durable subscriptions.
+      yield* Ref.set(preferredRouteId, Option.some(next.routeId));
+      return "reset" as const;
+    }
     if (next._tag !== "Wakeup") {
       return undefined;
     }
@@ -425,7 +553,8 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
       // out, so a long background resume replaces the session at once.
       return "reset" as const;
     }
-    if (next.reason === "credentials-changed" && target._tag === "RelayConnectionTarget") {
+    // Only a session over T3 Connect holds the old account's credential.
+    if (next.reason === "credentials-changed" && isRelayLease(lease)) {
       yield* logManagedRelayAccountChange;
       return "end" as const;
     }
@@ -444,11 +573,13 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
         if (next.reason === "application-active") {
           return CONNECTION_PROBE_TIMEOUT;
         }
-        return next.reason === "application-active-probe"
+        // A socket opened on the previous network may now be unroutable.
+        return next.reason === "application-active-probe" || next.reason === "network-changed"
           ? QUICK_CONNECTION_PROBE_TIMEOUT
           : undefined;
       case "ConnectRequested":
       case "DisconnectRequested":
+      case "BetterRouteAvailable":
         return undefined;
     }
   };
@@ -470,12 +601,26 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
         next._tag === "RetryRequested" ? Ref.set(resetRetryState, false) : Effect.void,
       ),
     );
+    // Ticks always run: the check skips the preferred route itself, and the
+    // route list can grow while connected (learned routes).
+    yield* Stream.tick(BETTER_ROUTE_CHECK_INTERVAL).pipe(
+      Stream.drop(1),
+      Stream.runForEach(() => requestBetterRouteCheck(lease)),
+      Effect.forkScoped,
+    );
     for (;;) {
       const next = yield* takeSignal;
-      const end = yield* connectedLeaseEnd(next);
+      const end = yield* connectedLeaseEnd(next, lease);
       if (end !== undefined) {
         return end === "reset";
       }
+      // A new network or a return to the app may have brought a better route back.
+      if (
+        (next._tag === "NetworkChanged" && next.network !== "offline") ||
+        (next._tag === "Wakeup" && ConnectionWakeups.resetsRetryBackoff(next.reason))
+      ) {
+        yield* requestBetterRouteCheck(lease);
+      }
       const probeTimeout = probeTimeoutFor(next);
       if (probeTimeout === undefined) {
         continue;
@@ -509,7 +654,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
           yield* probeEvent.exit;
           break;
         }
-        const endDuringProbe = yield* connectedLeaseEnd(probeEvent.signal);
+        const endDuringProbe = yield* connectedLeaseEnd(probeEvent.signal, lease);
         if (endDuringProbe !== undefined) {
           yield* Fiber.interrupt(probe);
           return endDuringProbe === "reset";
@@ -533,6 +678,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     pendingRetry: Option.Option<PendingRetryTrace>,
     ignoreOffline: boolean,
   ) {
+    const switchingTo = yield* Ref.get(preferredRouteId);
     yield* SubscriptionRef.set(prepared, Option.none());
     const establishment = yield* Effect.raceAllFirst([
       exitUnlessInterrupted(
@@ -549,9 +695,10 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
           resetRetry,
         })),
       ),
-      Effect.sleep(CONNECTION_ESTABLISHMENT_TIMEOUT).pipe(
-        Effect.as<EstablishmentEvent>({ _tag: "TimedOut" }),
-      ),
+      // Each route may use the full setup time before the next is tried.
+      Effect.sleep(
+        Duration.times(establishmentTimeout, connectionRoutes(yield* Ref.get(currentEntry)).length),
+      ).pipe(Effect.as<EstablishmentEvent>({ _tag: "TimedOut" })),
     ]);
 
     if (establishment._tag === "Interrupted") {
@@ -596,6 +743,16 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     }
 
     const active = establishment.exit.value;
+    if (Option.isSome(switchingTo)) {
+      const landed = connectionRouteId(active.lease.prepared.target);
+      if (landed !== switchingTo.value) {
+        const until =
+          (yield* Clock.monotonicTimeNanos) + BigInt(BETTER_ROUTE_COOLDOWN_MS) * 1_000_000n;
+        yield* Ref.update(routeCooldowns, (current) =>
+          new Map(current).set(switchingTo.value, until),
+        );
+      }
+    }
     const currentIntent = yield* Ref.get(intent);
     if (!currentIntent.desired || (currentIntent.network === "offline" && !ignoreOffline)) {
       return {
@@ -609,6 +766,9 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     const connectedAt = yield* Clock.currentTimeMillis;
     yield* SubscriptionRef.set(prepared, Option.some(active.lease.prepared));
     yield* SubscriptionRef.set(session, Option.some(active.lease.session));
+    if (options?.learnRoutes !== undefined) {
+      yield* learnRoutesFrom(options.learnRoutes, active.lease).pipe(Effect.forkScoped);
+    }
     yield* setState({
       desired: true,
       network: currentIntent.network,
@@ -656,21 +816,25 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
           const next = yield* Queue.take(signals);
           switch (next._tag) {
             case "Wakeup":
-              return ConnectionWakeups.isApplicationActiveWakeup(next.reason);
+              return ConnectionWakeups.resetsRetryBackoff(next.reason);
             case "ConnectRequested":
             case "DisconnectRequested":
             case "RetryRequested":
             case "NetworkChanged":
               return false;
+            case "BetterRouteAvailable":
+              break;
           }
         }
       }),
     );
   });
 
+  // A better route only matters to a live session, so idle states ignore it.
   const waitForSignal = Queue.take(signals).pipe(
+    Effect.repeat({ while: (next) => next._tag === "BetterRouteAvailable" }),
     Effect.map(
-      (next) => next._tag === "Wakeup" && ConnectionWakeups.isApplicationActiveWakeup(next.reason),
+      (next) => next._tag === "Wakeup" && ConnectionWakeups.resetsRetryBackoff(next.reason),
     ),
   );
 
@@ -827,6 +991,11 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
     Stream.runForEach((reason) => signal({ _tag: "Wakeup", reason })),
     Effect.forkScoped,
   );
+  yield* Queue.take(betterRouteChecks).pipe(
+    Effect.flatMap(checkBetterRoutes),
+    Effect.forever,
+    Effect.forkScoped,
+  );
   yield* run().pipe(Effect.forkScoped);
 
   const connect = Ref.update(intent, (current) => ({
diff --git a/packages/client-runtime/src/connection/wakeups.ts b/packages/client-runtime/src/connection/wakeups.ts
index 5f19924c47a1..38a45b092bbe 100644
--- a/packages/client-runtime/src/connection/wakeups.ts
+++ b/packages/client-runtime/src/connection/wakeups.ts
@@ -6,9 +6,12 @@ export type ConnectionWakeup =
   | "application-active"
   | "application-active-probe"
   | "application-active-reconnect"
-  | "credentials-changed";
+  | "credentials-changed"
+  // The device moved to a different network (another Wi-Fi, Wi-Fi to
+  // cellular) while staying online. Saved routes may have changed reach.
+  | "network-changed";
 
-export function isApplicationActiveWakeup(reason: ConnectionWakeup): boolean {
+function isApplicationActiveWakeup(reason: ConnectionWakeup): boolean {
   return (
     reason === "application-active" ||
     reason === "application-active-probe" ||
@@ -16,6 +19,11 @@ export function isApplicationActiveWakeup(reason: ConnectionWakeup): boolean {
   );
 }
 
+/** Conditions changed enough that a pending retry should run now, from the first rung. */
+export function resetsRetryBackoff(reason: ConnectionWakeup): boolean {
+  return isApplicationActiveWakeup(reason) || reason === "network-changed";
+}
+
 // A long resume replaces the session, and the new session subscribes on its own.
 export function shouldResubscribeAfterWakeup(reason: ConnectionWakeup): boolean {
   return reason === "application-active" || reason === "application-active-probe";
diff --git a/packages/client-runtime/src/markdownLinks.test.ts b/packages/client-runtime/src/markdownLinks.test.ts
index deea6960478e..b6e52e4534a1 100644
--- a/packages/client-runtime/src/markdownLinks.test.ts
+++ b/packages/client-runtime/src/markdownLinks.test.ts
@@ -3,12 +3,36 @@ import { describe, expect, it } from "vite-plus/test";
 import {
   fileBasename,
   inlineCodeFilePathCandidate,
+  isMarkdownFileLinkLabel,
   parseFileUrlHref,
   parseMarkdownFileLink,
   splitFilePathPosition,
   workspaceRelativeFilePath,
 } from "./markdownLinks.ts";
 
+describe("isMarkdownFileLinkLabel", () => {
+  it.each([
+    ["validates the input", "/repo/src/example.ts:12", false],
+    ["read src/example.ts", "/repo/src/example.ts:12", false],
+    ["example.ts?why this matters", "/repo/src/example.ts", false],
+    ["example.ts", "/repo/src/example.ts:12", true],
+    ["example.ts:12", "/repo/src/example.ts:12", true],
+    ["example.ts:99", "/repo/src/example.ts:12", false],
+    ["example.ts:12:2", "/repo/src/example.ts:12:2", true],
+    ["example.ts:12:3", "/repo/src/example.ts:12:2", false],
+    ["example.ts:12", "/repo/src/example.ts", false],
+    ["src/example.ts:12", "/repo/src/example.ts:12", true],
+    ["./src/example.ts", "/repo/src/example.ts", true],
+    ["/repo/src/example.ts", "/repo/src/example.ts", true],
+    ["src/", "/home/me/project/src/", true],
+    ["EXAMPLE.TS", "C:/repo/src/example.ts:12", true],
+    ["file name.ts", "file:///repo/file%20name.ts", true],
+    ["", "/repo/src/example.ts", true],
+  ])("classifies %s for %s", (label, href, expected) => {
+    expect(isMarkdownFileLinkLabel(label, href)).toBe(expected);
+  });
+});
+
 describe("inlineCodeFilePathCandidate", () => {
   it.each([
     ["src\\main.ts", "src/main.ts"],
diff --git a/packages/client-runtime/src/markdownLinks.ts b/packages/client-runtime/src/markdownLinks.ts
index 0a32f5061083..88db0e5a725a 100644
--- a/packages/client-runtime/src/markdownLinks.ts
+++ b/packages/client-runtime/src/markdownLinks.ts
@@ -265,6 +265,29 @@ export function formatFilePathPosition(position: FilePathPosition): string {
   return `${position.path}:${position.line}${position.column ? `:${position.column}` : ""}`;
 }
 
+/** Keeps filename and destination-path labels compact without discarding prose. */
+export function isMarkdownFileLinkLabel(label: string, href: string): boolean {
+  const destination = parseMarkdownFileLink(href);
+  if (!destination) return false;
+  const normalize = (path: string) =>
+    path.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  const labelPosition = splitFilePathPosition(label.trim());
+  if (
+    (labelPosition.line !== undefined && labelPosition.line !== destination.line) ||
+    (labelPosition.column !== undefined && labelPosition.column !== destination.column)
+  ) {
+    return false;
+  }
+  let labelPath = normalize(labelPosition.path);
+  let destinationPath = normalize(destination.path);
+  if (labelPath.length === 0) return true;
+  if (isWindowsAbsolutePath(destination.path)) {
+    labelPath = labelPath.toLowerCase();
+    destinationPath = destinationPath.toLowerCase();
+  }
+  return destinationPath === labelPath || destinationPath.endsWith(`/${labelPath}`);
+}
+
 export function isRelativeFilePath(path: string): boolean {
   return (
     RELATIVE_PATH_PREFIX_PATTERN.test(path) ||
diff --git a/packages/client-runtime/src/platform/capabilities.ts b/packages/client-runtime/src/platform/capabilities.ts
index bc793b00565d..c3ad29286bcb 100644
--- a/packages/client-runtime/src/platform/capabilities.ts
+++ b/packages/client-runtime/src/platform/capabilities.ts
@@ -59,8 +59,14 @@ export class PrimaryEnvironmentAuth extends Context.Service<
 export class SshEnvironmentGateway extends Context.Service<
   SshEnvironmentGateway,
   {
+    /**
+     * Starts or reuses the remote server and pairs with it. With
+     * `expectedEnvironmentId`, a server that is a different machine fails
+     * before its one-time pairing credential is spent.
+     */
     readonly provision: (
       target: DesktopSshEnvironmentTarget,
+      expectedEnvironmentId?: EnvironmentId,
     ) => Effect.Effect<ProvisionedSshEnvironment, ConnectionAttemptError>;
     readonly prepare: (input: {
       readonly connectionId: string;
diff --git a/packages/client-runtime/src/platform/persistence.ts b/packages/client-runtime/src/platform/persistence.ts
index 8f6e3f12d7e5..064c81d2b680 100644
--- a/packages/client-runtime/src/platform/persistence.ts
+++ b/packages/client-runtime/src/platform/persistence.ts
@@ -12,7 +12,7 @@ import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 
 import type { CatalogRegistration } from "../connection/catalog.ts";
-import type { ConnectionTarget } from "../connection/model.ts";
+import type { ConnectionTarget, PersistedConnectionTarget } from "../connection/model.ts";
 
 export class ConnectionPersistenceError extends Schema.TaggedError<ConnectionPersistenceError>()(
   "ConnectionPersistenceError",
@@ -21,6 +21,7 @@ export class ConnectionPersistenceError extends Schema.TaggedError<ConnectionPer
       "list-targets",
       "list-disabled-targets",
       "register-connection",
+      "set-connection-routes",
       "remove-connection",
       "set-connection-enabled",
       "load-shell",
@@ -52,10 +53,23 @@ export class ConnectionTargetStore extends Context.Service<
 export class ConnectionRegistrationStore extends Context.Service<
   ConnectionRegistrationStore,
   {
+    /**
+     * Saves one route's records and sets the environment's full route list,
+     * preferred first. Records of routes missing from `routes` are dropped.
+     */
     readonly register: (
       registration: CatalogRegistration,
+      routes: ReadonlyArray<PersistedConnectionTarget>,
+    ) => Effect.Effect<void, ConnectionPersistenceError>;
+    /** Reorders or drops routes without adding one. `routes` must not be empty. */
+    readonly setRoutes: (
+      environmentId: EnvironmentId,
+      routes: ReadonlyArray<PersistedConnectionTarget>,
+    ) => Effect.Effect<void, ConnectionPersistenceError>;
+    /** Forgets the environment and every route it had. */
+    readonly remove: (
+      environmentId: EnvironmentId,
     ) => Effect.Effect<void, ConnectionPersistenceError>;
-    readonly remove: (target: ConnectionTarget) => Effect.Effect<void, ConnectionPersistenceError>;
     readonly setEnabled: (
       environmentId: EnvironmentId,
       enabled: boolean,
diff --git a/packages/client-runtime/src/platform/storageDocument.test.ts b/packages/client-runtime/src/platform/storageDocument.test.ts
index 811ad170b6dd..e235ca3c9bd7 100644
--- a/packages/client-runtime/src/platform/storageDocument.test.ts
+++ b/packages/client-runtime/src/platform/storageDocument.test.ts
@@ -27,6 +27,8 @@ import {
 import {
   ConnectionCatalogDocument,
   EMPTY_CONNECTION_CATALOG_DOCUMENT,
+  catalogRoutes,
+  setRoutesInCatalog,
   putRemoteDpopTokenInCatalog,
   registerConnectionInCatalog,
   removeConnectionFromCatalog,
@@ -123,7 +125,7 @@ describe("ConnectionCatalogDocument", () => {
       expect(yield* afterRemoval.get(entry)).toBe("off");
 
       yield* permissions.set(entry, "read");
-      document = removeConnectionFromCatalog(document, BEARER_TARGET);
+      document = removeConnectionFromCatalog(document, ENVIRONMENT_ID);
       const afterCatalogRemoval = yield* makeGitHubRoutingPermissions(storage);
       expect(yield* afterCatalogRemoval.get(entry)).toBe("off");
     }),
@@ -273,7 +275,7 @@ describe("ConnectionCatalogDocument", () => {
       }),
     );
 
-    expect(removeConnectionFromCatalog(registered, BEARER_TARGET)).toEqual(
+    expect(removeConnectionFromCatalog(registered, ENVIRONMENT_ID)).toEqual(
       EMPTY_CONNECTION_CATALOG_DOCUMENT,
     );
   });
@@ -295,7 +297,7 @@ describe("ConnectionCatalogDocument", () => {
       EMPTY_CONNECTION_CATALOG_DOCUMENT,
       new RelayConnectionRegistration({ target: RELAY_TARGET }),
     );
-    const removed = removeConnectionFromCatalog(registered, RELAY_TARGET);
+    const removed = removeConnectionFromCatalog(registered, ENVIRONMENT_ID);
 
     expect(putRemoteDpopTokenInCatalog(removed, REMOTE_TOKEN)).toEqual(
       EMPTY_CONNECTION_CATALOG_DOCUMENT,
@@ -309,7 +311,7 @@ describe("ConnectionCatalogDocument", () => {
     );
     const refreshed = putRemoteDpopTokenInCatalog(registered, REMOTE_TOKEN);
 
-    expect(removeConnectionFromCatalog(refreshed, RELAY_TARGET)).toEqual(
+    expect(removeConnectionFromCatalog(refreshed, ENVIRONMENT_ID)).toEqual(
       EMPTY_CONNECTION_CATALOG_DOCUMENT,
     );
   });
@@ -382,7 +384,9 @@ describe("ConnectionCatalogDocument", () => {
         }),
       ).disabledEnvironmentIds,
     ).toEqual([ENVIRONMENT_ID]);
-    expect(removeConnectionFromCatalog(disabled, BEARER_TARGET).disabledEnvironmentIds).toEqual([]);
+    expect(removeConnectionFromCatalog(disabled, ENVIRONMENT_ID).disabledEnvironmentIds).toEqual(
+      [],
+    );
   });
 
   it("persists the normalized SSH profile beside its target", () => {
@@ -411,4 +415,48 @@ describe("ConnectionCatalogDocument", () => {
     expect(document.profiles).toEqual([profile]);
     expect(document.credentials).toEqual([]);
   });
+
+  it("keeps every route of an environment and drops only a removed route's records", () => {
+    const withBearer = registerConnectionInCatalog(
+      { ...EMPTY_CONNECTION_CATALOG_DOCUMENT, remoteDpopTokens: [REMOTE_TOKEN] },
+      new BearerConnectionRegistration({
+        target: BEARER_TARGET,
+        profile: BEARER_PROFILE,
+        credential: BEARER_CREDENTIAL,
+      }),
+    );
+    const withRelay = registerConnectionInCatalog(
+      withBearer,
+      new RelayConnectionRegistration({ target: RELAY_TARGET }),
+      [BEARER_TARGET, RELAY_TARGET],
+    );
+    expect(catalogRoutes(withRelay, ENVIRONMENT_ID)).toEqual([BEARER_TARGET, RELAY_TARGET]);
+    expect(withRelay.credentials).toHaveLength(1);
+
+    // Dropping the bearer route forgets its credential; T3 Connect keeps its token.
+    const relayOnly = setRoutesInCatalog(withRelay, ENVIRONMENT_ID, [RELAY_TARGET]);
+    expect(relayOnly.targets).toEqual([RELAY_TARGET]);
+    expect(relayOnly.profiles).toEqual([]);
+    expect(relayOnly.credentials).toEqual([]);
+    expect(relayOnly.remoteDpopTokens).toEqual([REMOTE_TOKEN]);
+
+    // Dropping T3 Connect forgets its token; the bearer route keeps its records.
+    const bearerOnly = setRoutesInCatalog(withRelay, ENVIRONMENT_ID, [BEARER_TARGET]);
+    expect(bearerOnly.credentials).toHaveLength(1);
+    expect(bearerOnly.remoteDpopTokens).toEqual([]);
+  });
+
+  it("keeps an environment's position in the catalog when its routes change", () => {
+    const other = new RelayConnectionTarget({
+      environmentId: EnvironmentId.make("environment-2"),
+      label: "Other",
+    });
+    const document = {
+      ...EMPTY_CONNECTION_CATALOG_DOCUMENT,
+      targets: [RELAY_TARGET, other],
+    };
+    expect(
+      setRoutesInCatalog(document, ENVIRONMENT_ID, [BEARER_TARGET, RELAY_TARGET]).targets,
+    ).toEqual([BEARER_TARGET, RELAY_TARGET, other]);
+  });
 });
diff --git a/packages/client-runtime/src/platform/storageDocument.ts b/packages/client-runtime/src/platform/storageDocument.ts
index b7d604ee3bb2..c836e1128b8f 100644
--- a/packages/client-runtime/src/platform/storageDocument.ts
+++ b/packages/client-runtime/src/platform/storageDocument.ts
@@ -6,7 +6,6 @@ import {
   type CatalogRegistration,
   ConnectionCredential,
   ConnectionProfile,
-  keepsBoxPairing,
 } from "../connection/catalog.ts";
 import { type ConnectionTarget, PersistedConnectionTarget } from "../connection/model.ts";
 import * as TokenStore from "../authorization/tokenStore.ts";
@@ -71,60 +70,77 @@ function connectionIdOf(target: ConnectionTarget): string | null {
   }
 }
 
-function removeConnectionMetadata(
+function routeKey(target: ConnectionTarget): string {
+  return connectionIdOf(target) ?? target._tag;
+}
+
+function removeRouteMetadata(
   document: ConnectionCatalogDocument,
-  target: ConnectionTarget,
-  removeRemoteToken: boolean,
+  removed: ReadonlyArray<ConnectionTarget>,
 ): ConnectionCatalogDocument {
-  const connectionId = connectionIdOf(target);
+  const connectionIds = new Set(removed.flatMap((target) => connectionIdOf(target) ?? []));
+  const relayRemoved = removed.some((target) => target._tag === "RelayConnectionTarget");
+  const environmentIds = new Set(removed.map((target) => target.environmentId));
   return {
     ...document,
-    targets: removeCatalogValue(
-      document.targets,
-      (value) => value.environmentId,
-      target.environmentId,
-    ),
-    profiles:
-      connectionId === null
-        ? document.profiles
-        : removeCatalogValue(document.profiles, (value) => value.connectionId, connectionId),
-    credentials:
-      connectionId === null
-        ? document.credentials
-        : removeCatalogValue(document.credentials, (value) => value.connectionId, connectionId),
-    remoteDpopTokens: removeRemoteToken
-      ? removeCatalogValue(
-          document.remoteDpopTokens,
-          (value) => value.environmentId,
-          target.environmentId,
-        )
+    profiles: document.profiles.filter((value) => !connectionIds.has(value.connectionId)),
+    credentials: document.credentials.filter((value) => !connectionIds.has(value.connectionId)),
+    // The DPoP token belongs to the T3 Connect route.
+    remoteDpopTokens: relayRemoved
+      ? document.remoteDpopTokens.filter((value) => !environmentIds.has(value.environmentId))
       : document.remoteDpopTokens,
-    // Re-registration passes `removeRemoteToken: false` and must keep the
-    // switched-off flag; only a real removal clears it.
-    disabledEnvironmentIds: removeRemoteToken
-      ? removeCatalogValue(document.disabledEnvironmentIds, (value) => value, target.environmentId)
-      : document.disabledEnvironmentIds,
   };
 }
 
+/**
+ * An environment's saved routes in preference order. Targets of one
+ * environment keep their relative order in `targets`, so a document written
+ * before routes existed is one environment with one route.
+ */
+export function catalogRoutes(
+  document: ConnectionCatalogDocument,
+  environmentId: EnvironmentId,
+): ReadonlyArray<PersistedConnectionTarget> {
+  return document.targets.filter((target) => target.environmentId === environmentId);
+}
+
+/**
+ * Replaces an environment's routes with `routes`, preferred first. Records
+ * owned by a dropped route go with it; the environment keeps its position in
+ * the catalog. An empty list leaves the environment's other records in place;
+ * use `removeConnectionFromCatalog` to forget the environment.
+ */
+export function setRoutesInCatalog(
+  document: ConnectionCatalogDocument,
+  environmentId: EnvironmentId,
+  routes: ReadonlyArray<PersistedConnectionTarget>,
+): ConnectionCatalogDocument {
+  const kept = new Set(routes.map(routeKey));
+  const dropped = catalogRoutes(document, environmentId).filter(
+    (target) => !kept.has(routeKey(target)),
+  );
+  const firstIndex = document.targets.findIndex((target) => target.environmentId === environmentId);
+  const others = document.targets.filter((target) => target.environmentId !== environmentId);
+  const insertAt =
+    firstIndex === -1
+      ? others.length
+      : document.targets.slice(0, firstIndex).filter((t) => t.environmentId !== environmentId)
+          .length;
+  return {
+    ...removeRouteMetadata(document, dropped),
+    targets: [...others.slice(0, insertAt), ...routes, ...others.slice(insertAt)],
+  };
+}
+
+/** Saves one route of an environment, keeping its other routes. */
 export function registerConnectionInCatalog(
   document: ConnectionCatalogDocument,
   registration: CatalogRegistration,
+  routes: ReadonlyArray<PersistedConnectionTarget> = [registration.target],
 ): ConnectionCatalogDocument {
-  const target = registration.target;
-  const previous = document.targets.find(
-    (candidate) => candidate.environmentId === target.environmentId,
-  );
-  const cleaned =
-    previous === undefined || keepsBoxPairing(registration, previous)
-      ? document
-      : removeConnectionMetadata(document, previous, false);
   // Re-registering (for example editing a label or URL) keeps the disabled
   // flag; only `setConnectionEnabledInCatalog` or removal changes it.
-  const next: ConnectionCatalogDocument = {
-    ...cleaned,
-    targets: replaceCatalogValue(cleaned.targets, (value) => value.environmentId, target),
-  };
+  const next = setRoutesInCatalog(document, registration.target.environmentId, routes);
 
   switch (registration._tag) {
     case "RelayConnectionRegistration":
@@ -155,19 +171,32 @@ export function registerConnectionInCatalog(
   }
 }
 
+/** Forgets an environment and every route it had. */
 export function removeConnectionFromCatalog(
   document: ConnectionCatalogDocument,
-  target: ConnectionTarget,
+  environmentId: EnvironmentId,
 ): ConnectionCatalogDocument {
-  const next = removeConnectionMetadata(document, target, true);
-  return document.githubRoutingPermissions === undefined
-    ? next
-    : {
-        ...next,
-        githubRoutingPermissions: document.githubRoutingPermissions.filter(
-          (permission) => permission.environmentId !== target.environmentId,
-        ),
-      };
+  const next = setRoutesInCatalog(document, environmentId, []);
+  return {
+    ...next,
+    remoteDpopTokens: removeCatalogValue(
+      next.remoteDpopTokens,
+      (value) => value.environmentId,
+      environmentId,
+    ),
+    disabledEnvironmentIds: removeCatalogValue(
+      next.disabledEnvironmentIds,
+      (value) => value,
+      environmentId,
+    ),
+    ...(next.githubRoutingPermissions === undefined
+      ? {}
+      : {
+          githubRoutingPermissions: next.githubRoutingPermissions.filter(
+            (permission) => permission.environmentId !== environmentId,
+          ),
+        }),
+  };
 }
 
 /** Flips the disabled flag for a saved environment; unknown ids are ignored. */
diff --git a/packages/client-runtime/src/providerSkills.test.ts b/packages/client-runtime/src/providerSkills.test.ts
index 62d0319db1bc..30b804d176ac 100644
--- a/packages/client-runtime/src/providerSkills.test.ts
+++ b/packages/client-runtime/src/providerSkills.test.ts
@@ -6,6 +6,7 @@ import {
   formatProviderSkillDisplayName,
   getProviderSlashCommandsForSlashMenu,
   getProviderSkillsForSlashMenu,
+  hasCompleteProviderWorkspaceSnapshot,
   resolveProviderSkillsForCwd,
   resolveProviderSlashCommandsForCwd,
   resolveProviderSkillSourceKind,
@@ -251,4 +252,26 @@ describe("workspace provider snapshots", () => {
     expect(resolveProviderSkillsForCwd(provider, "/workspace/project-b")).toEqual(provider.skills);
     expect(resolveProviderSlashCommandsForCwd(provider, null)).toEqual(provider.slashCommands);
   });
+
+  it("uses partial workspace skills and commands while keeping discovery retryable", () => {
+    const partial = {
+      ...provider,
+      workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
+        ...snapshot,
+        slashCommands: [{ name: "compact" }],
+        slashCommandsPending: true,
+      })),
+    } satisfies ServerProvider;
+    expect(resolveProviderSkillsForCwd(partial, "/workspace/project-a")).toEqual(
+      provider.workspaceSnapshots[0]?.skills,
+    );
+    expect(resolveProviderSlashCommandsForCwd(partial, "/workspace/project-a")).toEqual([
+      { name: "compact" },
+    ]);
+    expect(hasCompleteProviderWorkspaceSnapshot(partial, "/workspace/project-a")).toBe(false);
+    expect(hasCompleteProviderWorkspaceSnapshot(provider, "/workspace/project-a")).toBe(true);
+    expect(hasCompleteProviderWorkspaceSnapshot(provider, "/workspace/project-b")).toBe(false);
+    expect(hasCompleteProviderWorkspaceSnapshot(undefined, "/workspace/project-a")).toBe(false);
+    expect(hasCompleteProviderWorkspaceSnapshot(provider, null)).toBe(false);
+  });
 });
diff --git a/packages/client-runtime/src/providerSkills.ts b/packages/client-runtime/src/providerSkills.ts
index cde72ed20377..bac206faf659 100644
--- a/packages/client-runtime/src/providerSkills.ts
+++ b/packages/client-runtime/src/providerSkills.ts
@@ -112,6 +112,14 @@ function resolveProviderWorkspaceSnapshot(
   return provider.workspaceSnapshots?.find((snapshot) => snapshot.cwd === cwd);
 }
 
+export function hasCompleteProviderWorkspaceSnapshot(
+  provider: ServerProvider | null | undefined,
+  cwd: string | null | undefined,
+): boolean {
+  const snapshot = provider && resolveProviderWorkspaceSnapshot(provider, cwd);
+  return Boolean(snapshot && !snapshot.slashCommandsPending);
+}
+
 /**
  * A host's `provisionedSkills` join the result and win a name clash, since that copy is the one
  * its chats run.
diff --git a/packages/client-runtime/src/state/connections.ts b/packages/client-runtime/src/state/connections.ts
index 2059dcd0e74d..78b46331c658 100644
--- a/packages/client-runtime/src/state/connections.ts
+++ b/packages/client-runtime/src/state/connections.ts
@@ -164,6 +164,27 @@ export function createEnvironmentCatalogAtoms<R, E>(
         Effect.flatMap((registry) => registry.setEnabled(input.environmentId, input.enabled)),
       ),
   });
+  const removeRoute = createRuntimeCommand(runtime, {
+    label: "environment-catalog:remove-route",
+    scheduler: commandScheduler,
+    concurrency: serial,
+    execute: (input: { readonly environmentId: EnvironmentIdType; readonly routeId: string }) =>
+      EnvironmentRegistry.EnvironmentRegistry.pipe(
+        Effect.flatMap((registry) => registry.removeRoute(input.environmentId, input.routeId)),
+      ),
+  });
+  const reorderRoutes = createRuntimeCommand(runtime, {
+    label: "environment-catalog:reorder-routes",
+    scheduler: commandScheduler,
+    concurrency: serial,
+    execute: (input: {
+      readonly environmentId: EnvironmentIdType;
+      readonly routeIds: ReadonlyArray<string>;
+    }) =>
+      EnvironmentRegistry.EnvironmentRegistry.pipe(
+        Effect.flatMap((registry) => registry.reorderRoutes(input.environmentId, input.routeIds)),
+      ),
+  });
   const retryNow = createRuntimeCommand(runtime, {
     label: "environment-catalog:retry-now",
     scheduler: commandScheduler,
@@ -184,6 +205,8 @@ export function createEnvironmentCatalogAtoms<R, E>(
     stateAtom,
     register,
     remove,
+    removeRoute,
+    reorderRoutes,
     removeRelayEnvironments,
     retryNow,
     ...createEnvironmentCatalogCloudAtoms(runtime, { catalogValueAtom, commandScheduler, serial }),
diff --git a/packages/client-runtime/src/state/environmentHttpAuth.ts b/packages/client-runtime/src/state/environmentHttpAuth.ts
index 0fa7bbc7ffe2..1d6d9b2f144f 100644
--- a/packages/client-runtime/src/state/environmentHttpAuth.ts
+++ b/packages/client-runtime/src/state/environmentHttpAuth.ts
@@ -152,7 +152,10 @@ export const executeAuthenticatedEnvironmentHttpRequest = Effect.fn(
                 }),
             ),
           );
-        httpBaseUrl = current.httpBaseUrl;
+        // A learned direct route keeps its own origin; only the token renews.
+        if (input.prepared.target._tag === "RelayConnectionTarget") {
+          httpBaseUrl = current.httpBaseUrl;
+        }
         authorization = current.httpAuthorization;
       }
 
diff --git a/packages/client-runtime/src/state/orchestration.ts b/packages/client-runtime/src/state/orchestration.ts
index 728c08593731..94877ebc091d 100644
--- a/packages/client-runtime/src/state/orchestration.ts
+++ b/packages/client-runtime/src/state/orchestration.ts
@@ -44,6 +44,13 @@ export function createOrchestrationEnvironmentAtoms<R, E>(
       staleTimeMs: 300_000,
       idleTtlMs: 300_000,
     }),
+    // Keyed by the item revision, so a live row refetches as its output grows.
+    turnItem: createEnvironmentRpcQueryAtomFamily(runtime, {
+      label: "environment-data:orchestration:turn-item",
+      tag: ORCHESTRATION_V2_WS_METHODS.getTurnItem,
+      staleTimeMs: 60_000,
+      idleTtlMs: 60_000,
+    }),
     fullThreadDiff: createEnvironmentRpcQueryAtomFamily(runtime, {
       label: "environment-data:orchestration:full-thread-diff",
       tag: ORCHESTRATION_V2_WS_METHODS.getFullThreadDiff,
diff --git a/packages/client-runtime/src/state/presentation.ts b/packages/client-runtime/src/state/presentation.ts
index 79c51b91e084..1648136996cb 100644
--- a/packages/client-runtime/src/state/presentation.ts
+++ b/packages/client-runtime/src/state/presentation.ts
@@ -15,6 +15,7 @@ import {
   type EnvironmentPresentation,
 } from "../connection/presentation.ts";
 import type { EnvironmentCatalogState } from "./connections.ts";
+import { hasRelayRoute } from "../connection/routes.ts";
 import { isBoxEntry } from "./connectionsCloud.ts";
 
 function mapsEqual<K, V>(left: ReadonlyMap<K, V>, right: ReadonlyMap<K, V>): boolean {
@@ -101,7 +102,7 @@ export function projectEnvironmentConnectionSummary(
     environmentId,
     environmentLabel: environment.entry.target.label,
     displayUrl: connectionCatalogDisplayUrl(environment.entry) ?? "",
-    isRelayManaged: environment.entry.target._tag === "RelayConnectionTarget",
+    isRelayManaged: hasRelayRoute(environment.entry),
     isEnabled: environment.entry.enabled,
     connectionState: environment.connection.phase,
     connectionError: environment.connection.error,
diff --git a/packages/client-runtime/src/state/threads-atoms.test.ts b/packages/client-runtime/src/state/threads-atoms.test.ts
index f666faffc1dc..db9c3117723a 100644
--- a/packages/client-runtime/src/state/threads-atoms.test.ts
+++ b/packages/client-runtime/src/state/threads-atoms.test.ts
@@ -133,6 +133,8 @@ const makeHarness = Effect.fn("TestThreadAtoms.makeHarness")(function* (options?
     registerPlatform: () => Effect.die("Unexpected environment registration"),
     reconcilePlatform: () => Effect.die("Unexpected environment reconciliation"),
     remove: () => Effect.die("Unexpected environment removal"),
+    removeRoute: () => Effect.die("Unexpected route removal"),
+    reorderRoutes: () => Effect.die("Unexpected route reorder"),
     removeRelayEnvironments: () => Effect.die("Unexpected environment removal"),
     markWorkspaceMissing: () => Effect.die("Unexpected missing workspace"),
     syncHostBoxes: () => Effect.die("Unexpected host box sync"),
diff --git a/packages/client-runtime/src/work-log/commandLabel.test.ts b/packages/client-runtime/src/work-log/commandLabel.test.ts
index e048ef35d7c1..2ba38fd37a57 100644
--- a/packages/client-runtime/src/work-log/commandLabel.test.ts
+++ b/packages/client-runtime/src/work-log/commandLabel.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vite-plus/test";
 
-import { commandDisplayText, commandProgramName } from "./commandLabel.ts";
+import {
+  commandDisplayText,
+  commandHighlightLanguage,
+  commandProgramName,
+} from "./commandLabel.ts";
 
 describe("commandProgramName", () => {
   it.each([
@@ -493,3 +497,107 @@ describe("commandDisplayText", () => {
     expect(commandDisplayText(input)).toBe(expected);
   });
 });
+
+describe("commands recorded from each provider", () => {
+  // Inputs are copied from the recorded replay transcripts in
+  // apps/server/src/orchestration-v2/testkit/fixtures (turn_interrupt_mid_tool,
+  // todo_list, grok_background_bash and
+  // opencode_running_child_approval). In turn_interrupt_mid_tool every provider
+  // ran the same script, and only Codex wraps it in a login shell.
+  const interruptScript = `node -e "console.log('interrupt fixture tool started'); setTimeout(() => {}, 30000)"`;
+  it.each([
+    ["Claude", interruptScript, interruptScript],
+    ["Cursor", interruptScript, interruptScript],
+    ["Pi", interruptScript, interruptScript],
+    [
+      "Codex",
+      `/bin/bash -lc "node -e \\"console.log('interrupt fixture tool started'); setTimeout(() => {}, 30000)\\""`,
+      interruptScript,
+    ],
+    [
+      "Codex",
+      "/bin/bash -lc 'cat package.json && cat tsconfig.json'",
+      "cat package.json && cat tsconfig.json",
+    ],
+    [
+      "Grok",
+      "for i in 1 2 3; do sleep 8; echo tock $i; done",
+      "for i in 1 2 3; do sleep 8; echo tock $i; done",
+    ],
+    [
+      "OpenCode",
+      "printf 'running child approval' > running-child.txt",
+      "printf 'running child approval' > running-child.txt",
+    ],
+  ])("%s shows the script it ran: %s", (_provider, input, script) => {
+    expect(commandDisplayText(input)).toBe(script);
+    expect(commandHighlightLanguage(commandDisplayText(input))).toBe("shellscript");
+  });
+});
+
+describe("commandDisplayText with redacted Codex commands", () => {
+  // Codex replaces secrets in command text before sending it
+  // (codex-rs/secrets/src/sanitizer.rs). Usually the quoting survives.
+  it("unwraps a redacted command whose quoting is intact", () => {
+    expect(
+      commandDisplayText(
+        `/bin/zsh -lc 'curl -H "Authorization: Bearer [REDACTED_SECRET]" https://example.com'`,
+      ),
+    ).toBe('curl -H "Authorization: Bearer [REDACTED_SECRET]" https://example.com');
+  });
+
+  // Its secret-assignment pattern can also swallow the backslash of an escaped
+  // quote: `token=config[\"apiToken\"]` becomes `token=[REDACTED_SECRET]"apiToken\"]`.
+  // The bare quote ends the -lc argument early, so where the script ends is unknown.
+  it("keeps the wrapper when redaction broke the quoting", () => {
+    const input = `/bin/zsh -lc "python3 -c 'token=[REDACTED_SECRET]"apiToken\\"]; print(token)'"`;
+    expect(commandDisplayText(input)).toBe(input);
+  });
+});
+
+describe("commandDisplayText control characters", () => {
+  it.each([
+    ["printf '\u001b[31mred\u001b[0m'", "printf '␛[31mred␛[0m'"],
+    ["zsh -lc 'printf \"\u001b[1m\"'", 'printf "␛[1m"'],
+    ["echo bell\u0007 delete\u007f", "echo bell␇ delete␡"],
+    ["printf 'a\\tb'\r\necho done", "printf 'a\\tb'\r\necho done"],
+    ["cat <<'EOF'\n\tindented\nEOF", "cat <<'EOF'\n\tindented\nEOF"],
+  ])("shows %j as %j", (input, expected) => {
+    expect(commandDisplayText(input)).toBe(expected);
+  });
+});
+
+describe("commandHighlightLanguage", () => {
+  it.each([
+    [
+      '"C:\\Program Files\\PowerShell\\7\\pwsh.exe" -NoProfile -Command "Get-ChildItem -Recurse"',
+      "powershell",
+    ],
+    [
+      'powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\\work\\scripts\\doctor.ps1"',
+      "powershell",
+    ],
+    ["& pwsh -c 'Get-Date'", "powershell"],
+    ["PWSH.EXE -Command Get-Date", "powershell"],
+    ["pwsh-preview -c 'Get-Date'", "shellscript"],
+    ["git status; pwsh -c 'Get-Date'", "shellscript"],
+    ["cat <<'EOF' > notes.txt\npwsh\nEOF", "shellscript"],
+    ["", "shellscript"],
+    // Windows agents also run PowerShell directly, without a pwsh wrapper.
+    ["Get-Content package.json | Select-String version", "powershell"],
+    ["$env:CI='1'; npm test", "powershell"],
+    ["$tmp = Join-Path $env:TEMP repo; git clone example", "powershell"],
+    ['"=== CHECK FILE ==="; Get-Content file.txt', "powershell"],
+    ["& 'C:\\Python312\\python.exe' -c 'print(1)'", "powershell"],
+    ["Install-Module Pester -Scope CurrentUser", "powershell"],
+    ["ConvertTo-Json @{ a = 1 }", "powershell"],
+    ["update-alternatives --list java", "shellscript"],
+    ["install-info --version", "shellscript"],
+    ["Make-Thing now", "shellscript"],
+    ["echo Get-Content; git status", "shellscript"],
+    ["FOO=1 npm test", "shellscript"],
+    ["echo $HOME && ls", "shellscript"],
+  ])("%s", (command, language) => {
+    expect(commandHighlightLanguage(command)).toBe(language);
+  });
+});
diff --git a/packages/client-runtime/src/work-log/commandLabel.ts b/packages/client-runtime/src/work-log/commandLabel.ts
index c3df952f477d..12557bdc8698 100644
--- a/packages/client-runtime/src/work-log/commandLabel.ts
+++ b/packages/client-runtime/src/work-log/commandLabel.ts
@@ -1368,8 +1368,31 @@ export function commandProgramName(command: string, depth = 0): string | null {
   return commandProgramNameInternal(command, depth, "shell", MAX_COMMAND_SEGMENTS);
 }
 
-/** Removes a plain shell -c wrapper for display; callers retain the original for details. */
+// Escape bytes and other control characters render as invisible gaps; display
+// shows them as Unicode control pictures (ESC becomes ␛) instead. Tab, newline
+// and carriage return lay out as whitespace, so CRLF scripts stay unmarked.
+// oxlint-disable-next-line no-control-regex
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu;
+
+/**
+ * The command as rows show it: a plain shell -c wrapper removed and control
+ * characters made visible. Callers retain the original for details.
+ */
 export function commandDisplayText(command: string): string {
+  return withVisibleControlCharacters(withoutShellWrapper(command));
+}
+
+/** Replaces each control character with its control picture; the length does not change. */
+export function withVisibleControlCharacters(text: string): string {
+  return text.replace(CONTROL_CHARACTERS, (character) =>
+    character === "\u007f" ? "␡" : String.fromCharCode(0x2400 + character.charCodeAt(0)),
+  );
+}
+
+// A wrapper whose quoting does not balance is kept: the script's end cannot be
+// known, which happens when Codex's secret redaction removes the backslash of
+// an escaped quote inside `-lc "…"`.
+function withoutShellWrapper(command: string): string {
   const trimmed = command.trim();
   const split = splitFirstShellCommand(trimmed);
   if (split.remainingCommand !== null) return trimmed;
@@ -1384,3 +1407,55 @@ export function commandDisplayText(command: string): string {
   if (scriptIndex === null || scriptIndex !== tokens.length - 1) return trimmed;
   return tokens[scriptIndex]?.trim() || trimmed;
 }
+
+const POWERSHELL_PROGRAMS = new Set(["powershell", "pwsh"]);
+
+// PowerShell's approved verbs (`Get-Verb`), plus the ForEach, Where, Sort and
+// Tee of its built-in *-Object cmdlets. Cmdlets match only capitalized, as
+// agents write them: lowercase `update-grub` or `install-info` are Linux tools.
+const POWERSHELL_VERBS = new Set(
+  `Add Approve Assert Backup Block Build Checkpoint Clear Close Compare Complete Compress Confirm Connect Convert ConvertFrom ConvertTo Copy Debug Deny Deploy Disable Disconnect Dismount Edit Enable Enter Exit Expand Export Find ForEach Format Get Grant Group Hide Import Initialize Install Invoke Join Limit Lock Measure Merge Mount Move New Open Optimize Out Ping Pop Protect Publish Push Read Receive Redo Register Remove Rename Repair Request Reset Resize Resolve Restart Restore Resume Revoke Save Search Select Send Set Show Skip Sort Split Start Step Stop Submit Suspend Switch Sync Tee Test Trace Unblock Undo Uninstall Unlock Unprotect Unpublish Unregister Update Use Wait Watch Where Write`.split(
+    " ",
+  ),
+);
+
+function isPowerShellCmdlet(word: string): boolean {
+  const cmdlet = /^([A-Z][a-z]+(?:[A-Z][a-z]+)?)-[A-Z][A-Za-z]*$/u.exec(word);
+  return cmdlet !== null && POWERSHELL_VERBS.has(cmdlet[1]!);
+}
+
+/**
+ * The grammar to highlight a command with: PowerShell when pwsh or powershell
+ * runs it, or when it is written in PowerShell, as Windows agents run it.
+ */
+export function commandHighlightLanguage(command: string): "powershell" | "shellscript" {
+  const program = /^(?:&\s*)?(?:"([^"]*)"|'([^']*)'|(\S+))/u.exec(command.trim());
+  const name = (program?.[1] ?? program?.[2] ?? program?.[3] ?? "")
+    .split(/[\\/]/u)
+    .at(-1)
+    ?.toLowerCase()
+    .replace(/\.exe$/u, "");
+  if (name && POWERSHELL_PROGRAMS.has(name)) return "powershell";
+  return isPowerShellScript(command) ? "powershell" : "shellscript";
+}
+
+/** Whether any statement starts like PowerShell and never like POSIX shell. */
+function isPowerShellScript(command: string): boolean {
+  let rest: string | null = command.trim();
+  // A leading call operator; POSIX shell cannot start a command with `&`.
+  if (/^&\s*\S/u.test(rest)) return true;
+  for (let segment = 0; rest && segment < MAX_COMMAND_SEGMENTS; segment += 1) {
+    const { firstCommand, remainingCommand } = splitFirstShellCommand(rest);
+    const statement = firstCommand.trim();
+    if (
+      // `$env:NAME` or `$name = value`; neither parses as POSIX shell.
+      /^\$(?:env|global|local|script):/iu.test(statement) ||
+      /^\$[A-Za-z_]\w*\s+=/u.test(statement) ||
+      isPowerShellCmdlet(statement.match(/^\S+/u)?.[0] ?? "")
+    ) {
+      return true;
+    }
+    rest = remainingCommand;
+  }
+  return false;
+}
diff --git a/packages/client-runtime/src/work-log/itemDetail.ts b/packages/client-runtime/src/work-log/itemDetail.ts
new file mode 100644
index 000000000000..a138bed6f22c
--- /dev/null
+++ b/packages/client-runtime/src/work-log/itemDetail.ts
@@ -0,0 +1,248 @@
+import type { OrchestrationV2TurnItem } from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+
+const MAX_TEXT_BLOCK_DEPTH = 4;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Wire projection replaces a large dynamic input with `{ summary, truncated: true }`. */
+function isSummarizedValue(value: unknown): boolean {
+  return isRecord(value) && value.truncated === true && typeof value.summary === "string";
+}
+
+function textFromBlocks(value: unknown, depth: number): string | null {
+  if (depth > MAX_TEXT_BLOCK_DEPTH) return null;
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = value.map((block) => textFromBlocks(block, depth + 1));
+    return parts.every((part) => part !== null) ? parts.join("\n") : null;
+  }
+  if (!isRecord(value)) return null;
+  if (value.type === "text" && typeof value.text === "string") return value.text;
+  if (value.type === "image") return "[image]";
+  if (value.type === "resource_link" && typeof value.uri === "string") return value.uri;
+  if (value.type === "resource" && isRecord(value.resource)) {
+    const resource = value.resource;
+    if (typeof resource.text === "string") return resource.text;
+    if (typeof resource.uri === "string") return resource.uri;
+  }
+  const keys = Object.keys(value).filter((key) => key !== "isError" && key !== "is_error");
+  // MCP results and provider tool results wrap their text in `content`.
+  // `structuredContent` usually repeats it as data, so it only shows when the
+  // text is empty.
+  if (keys.length === 1 && keys[0] === "content") return textFromBlocks(value.content, depth + 1);
+  if (keys.length === 2 && keys.includes("content") && keys.includes("structuredContent")) {
+    const text = textFromBlocks(value.content, depth + 1);
+    return text?.trim() ? text : null;
+  }
+  return null;
+}
+
+function parseJson(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+}
+
+/** MCP tools often return JSON as minified text, one document per line. Indent each. */
+function prettyJsonText(text: string): string {
+  const trimmed = text.trim();
+  if (!/^[[{]/.test(trimmed)) return text;
+  const whole = parseJson(trimmed);
+  if (whole !== undefined) return JSON.stringify(whole, null, 2);
+  const lines = trimmed.split("\n").filter((line) => line.trim());
+  const documents = lines.map((line) => parseJson(line.trim()));
+  if (documents.some((document) => document === undefined)) return text;
+  return documents.map((document) => JSON.stringify(document, null, 2)).join("\n\n");
+}
+
+/** Formats a tool input or output for display: text blocks as text, the rest as JSON. */
+function formatToolValue(value: unknown): string | null {
+  if (value === undefined || value === null) return null;
+  const text = textFromBlocks(value, 0);
+  if (text !== null) return text.trim() ? prettyJsonText(text) : null;
+  let json: string | undefined;
+  try {
+    json = JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+  if (json === undefined || json === "{}" || json === "[]") return null;
+  return json;
+}
+
+/**
+ * The call a tool row's body shows above its result: the full command, the
+ * arguments as `key value` pairs, or formatted text when they are not flat.
+ */
+export function toolCallLines(input: {
+  readonly command?: string | undefined;
+  readonly args?: unknown;
+}): {
+  readonly command: string | null;
+  readonly args: ReadonlyArray<readonly [string, string]> | null;
+  readonly argsText: string | null;
+} {
+  if (input.command !== undefined) {
+    // The row title truncates to its width, so the body always has the full command.
+    const command = input.command.trim();
+    return { command: command || null, args: null, argsText: null };
+  }
+  const args = input.args;
+  if (isRecord(args) && !isSummarizedValue(args)) {
+    const entries = Object.entries(args).flatMap(
+      ([key, value]): Array<readonly [string, string]> => {
+        if (value === undefined) return [];
+        // An empty string or null can be the point of a call (a clear or reset), so show it.
+        return [
+          [
+            key,
+            typeof value === "string" && value !== ""
+              ? value
+              : (JSON.stringify(value) ?? String(value)),
+          ],
+        ];
+      },
+    );
+    return { command: null, args: entries.length > 0 ? entries : null, argsText: null };
+  }
+  return { command: null, args: null, argsText: formatToolValue(args) };
+}
+
+function toolCallHasLines(lines: ReturnType<typeof toolCallLines>): boolean {
+  return lines.command !== null || lines.args !== null || lines.argsText !== null;
+}
+
+const LIVE_TURN_ITEM_STATUSES: ReadonlySet<OrchestrationV2TurnItem["status"]> = new Set([
+  "idle",
+  "pending",
+  "running",
+  "waiting",
+]);
+
+/**
+ * Cache key for a fetched item. A running item keeps one key, so an open row
+ * fetches once while it streams and again when it finishes, not on every update.
+ */
+export function turnItemDetailRevision(item: OrchestrationV2TurnItem): string {
+  return LIVE_TURN_ITEM_STATUSES.has(item.status) ? "live" : DateTime.formatIso(item.updatedAt);
+}
+
+/** True when the timeline item withholds content that `getTurnItem` returns. */
+export function turnItemNeedsDetailFetch(item: OrchestrationV2TurnItem): boolean {
+  switch (item.type) {
+    case "command_execution":
+      return item.outputOmitted === true;
+    case "dynamic_tool":
+      return item.outputOmitted === true || isSummarizedValue(item.input);
+    default:
+      return false;
+  }
+}
+
+/** Older Claude bash rows stored the raw `{ stdout, stderr, interrupted, ... }` result. */
+function commandOutputText(output: string): string {
+  if (!output.trimStart().startsWith('{"stdout"')) return output;
+  const parsed = parseJson(output.trim());
+  if (
+    !isRecord(parsed) ||
+    typeof parsed.stdout !== "string" ||
+    typeof parsed.stderr !== "string" ||
+    typeof parsed.interrupted !== "boolean"
+  ) {
+    return output;
+  }
+  return [parsed.stdout, parsed.stderr]
+    .filter((part): part is string => typeof part === "string" && part.trim().length > 0)
+    .join("\n");
+}
+
+/** The tool output carried by a fetched item, formatted for display. */
+export function turnItemOutputText(item: OrchestrationV2TurnItem): string | null {
+  switch (item.type) {
+    case "command_execution":
+      return item.output?.trim() ? commandOutputText(item.output) || null : null;
+    case "dynamic_tool":
+      return item.outputOmitted === true ? null : formatToolValue(item.output);
+    case "file_search":
+      return item.results?.length
+        ? item.results
+            .map((result) =>
+              [
+                `${result.fileName}${result.line === undefined ? "" : `:${result.line}`}`,
+                result.preview?.trim(),
+              ]
+                .filter(Boolean)
+                .join("\n"),
+            )
+            .join("\n")
+        : null;
+    case "web_search":
+      return item.results?.length
+        ? item.results
+            .map((result) =>
+              [
+                result.title?.trim() || result.url,
+                result.title ? result.url : undefined,
+                result.snippet?.trim(),
+              ]
+                .filter(Boolean)
+                .join("\n"),
+            )
+            .join("\n\n")
+        : null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Whether expanding the item shows anything. Rows without content must not
+ * offer a disclosure, otherwise they open to an empty panel.
+ */
+export function turnItemHasDetail(item: OrchestrationV2TurnItem): boolean {
+  switch (item.type) {
+    case "reasoning":
+      return item.text.trim().length > 0;
+    case "command_execution":
+      return (
+        toolCallLines({ command: item.input }).command !== null ||
+        item.outputOmitted === true ||
+        Boolean(item.output?.trim()) ||
+        (item.exitCode !== undefined && item.exitCode !== 0)
+      );
+    case "file_change":
+    case "checkpoint":
+    case "fork":
+    case "handoff":
+      return true;
+    case "file_search":
+      return (item.results?.length ?? 0) > 0 || Boolean(item.pattern?.trim());
+    case "web_search":
+      return (item.results?.length ?? 0) > 0 || (item.patterns?.length ?? 0) > 0;
+    case "dynamic_tool":
+      return item.outputOmitted === true || toolCallHasLines(toolCallLines({ args: item.input }));
+    case "approval_request":
+      return Boolean(item.prompt?.trim());
+    case "user_input_request":
+      return item.questions.length > 0;
+    case "notification":
+      return Boolean(item.detail?.trim());
+    case "system_notice":
+      return item.message.trim().length > 0;
+    case "error":
+      return item.failure.message.trim().length > 0;
+    case "proposed_plan":
+      return item.markdown.trim().length > 0;
+    case "todo_list":
+      return item.steps.length > 0;
+    case "subagent":
+      return item.childThreadId !== null;
+    default:
+      return false;
+  }
+}
diff --git a/packages/client-runtime/src/work-log/presentation.ts b/packages/client-runtime/src/work-log/presentation.ts
index 84229d3bac7f..f5e9daab7490 100644
--- a/packages/client-runtime/src/work-log/presentation.ts
+++ b/packages/client-runtime/src/work-log/presentation.ts
@@ -38,8 +38,11 @@ export function toolItemForDisplay(item: OrchestrationV2TurnItem): Orchestration
       return displayItem;
     }
     case "file_change": {
-      const { diffStr: _diffStr, oldStr: _oldStr, newStr: _newStr, ...displayItem } = item;
-      return displayItem;
+      const { diffStr, oldStr: _oldStr, newStr: _newStr, ...displayItem } = item;
+      // A failed edit's diffStr holds the provider's error, not a diff.
+      return item.status === "failed" && diffStr?.trim()
+        ? { ...displayItem, diffStr }
+        : displayItem;
     }
     default:
       return item;
diff --git a/packages/contracts/src/environment.test.ts b/packages/contracts/src/environment.test.ts
index 3f624adf6fe2..96e176bccba1 100644
--- a/packages/contracts/src/environment.test.ts
+++ b/packages/contracts/src/environment.test.ts
@@ -14,6 +14,25 @@ const descriptor = {
 } as const;
 
 describe("ExecutionEnvironmentDescriptor", () => {
+  it("decodes old, recognized and future manual installation descriptors", () => {
+    expect(decodeDescriptor(descriptor).capabilities.serverInstallation).toBeUndefined();
+    for (const installation of [{ kind: "npx" }, { kind: "npm-global", prefix: "/opt/node" }]) {
+      expect(
+        decodeDescriptor({
+          ...descriptor,
+          capabilities: { ...descriptor.capabilities, serverInstallation: installation },
+        }).capabilities.serverInstallation,
+      ).toEqual(installation);
+    }
+    for (const installation of [{ kind: "future-manager" }, { kind: "npm-global" }]) {
+      expect(
+        decodeDescriptor({
+          ...descriptor,
+          capabilities: { ...descriptor.capabilities, serverInstallation: installation },
+        }).capabilities.serverInstallation,
+      ).toBeUndefined();
+    }
+  });
   it("requires an advertised required-worktree bootstrap capability", () => {
     expect(decodeDescriptor(descriptor).capabilities.requiredWorktreeBootstrap).toBeUndefined();
     expect(
diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts
index dcb5ea0acff8..03e97e8bbd8c 100644
--- a/packages/contracts/src/environment.ts
+++ b/packages/contracts/src/environment.ts
@@ -77,6 +77,13 @@ export type ExecutionEnvironmentPlatform = typeof ExecutionEnvironmentPlatform.T
 export const ServerSelfUpdateMethod = Schema.Literals(["boot-service", "respawn", "desktop-app"]);
 export type ServerSelfUpdateMethod = typeof ServerSelfUpdateMethod.Type;
 
+/** Proven ownership for a manual update; unknown installs omit this descriptor. */
+export const ServerInstallation = Schema.Union([
+  Schema.Struct({ kind: Schema.Literals(["npx", "pnpm-dlx", "bunx"]) }),
+  Schema.Struct({ kind: Schema.Literal("npm-global"), prefix: TrimmedNonEmptyString }),
+]);
+export type ServerInstallation = typeof ServerInstallation.Type;
+
 /** What update path a client should offer for a server: one of the RPC
     self-update methods above, or "desktop-managed" when the backend's
     version belongs to the T3 Code desktop app supervising it — updating the
@@ -171,6 +178,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({
       servers that must be relaunched manually (dev checkouts, Windows
       foreground runs, pre-update servers). */
   serverSelfUpdate: Schema.optionalKey(ServerSelfUpdateCapability),
+  /** Manual commands must update this install, not the host's default global prefix. */
+  serverInstallation: ForwardCompatibleOptional(ServerInstallation),
   /** Server can stream self-update progress before acknowledging the
       restart. Clients fall back to server.updateServer when absent. */
   serverSelfUpdateProgress: Schema.optionalKey(Schema.Boolean),
diff --git a/packages/contracts/src/orchestrationV2.test.ts b/packages/contracts/src/orchestrationV2.test.ts
index 601597fb568a..aae9cc40bd8c 100644
--- a/packages/contracts/src/orchestrationV2.test.ts
+++ b/packages/contracts/src/orchestrationV2.test.ts
@@ -1038,6 +1038,35 @@ describe("orchestration V2 contracts", () => {
   });
 });
 
+it("preserves tool cancellation and denial metadata through persisted and wire schemas", () => {
+  for (const kind of ["cancelled", "denied", undefined]) {
+    const item = decodeOrchestrationV2TurnItem({
+      id: "tool-result",
+      threadId: "thread",
+      runId: null,
+      nodeId: null,
+      providerThreadId: null,
+      providerTurnId: null,
+      nativeItemRef: null,
+      parentItemId: null,
+      ordinal: 1,
+      type: "dynamic_tool",
+      toolName: "task_status",
+      input: { taskId: "child" },
+      status: kind === "cancelled" ? "cancelled" : "failed",
+      ...(kind === undefined ? {} : { toolNonExecutionKind: kind }),
+      title: null,
+      startedAt: now,
+      completedAt: now,
+      updatedAt: now,
+      output: "Tool did not execute",
+    });
+    const wire = encodeOrchestrationV2TurnItemJson(item);
+    expect(wire.toolNonExecutionKind).toBe(kind);
+    expect(decodeOrchestrationV2TurnItemJson(wire)).toEqual(item);
+  }
+});
+
 it("round-trips typed notifications and keeps work outcome separate from item status", () => {
   const now = DateTime.makeUnsafe("2026-09-09T00:00:00Z");
   const base = {
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index c6e7f3ff0140..675faa4b7f4f 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -211,6 +211,8 @@ export const OrchestrationV2TurnCapabilities = Schema.Struct({
   emitsTurnCompleted: Schema.Boolean,
   supportsInterrupt: Schema.Boolean,
   supportsActiveSteering: Schema.Boolean,
+  // Some native steering mechanisms cancel pending tools before consuming the message.
+  activeSteeringInterruptsTools: Schema.optional(Schema.Boolean),
   supportsSteeringByInterruptRestart: Schema.Boolean,
   supportsQueuedMessages: Schema.Boolean,
   terminalStatusQuality: Schema.Literals(["strong", "weak", "none"]),
@@ -1253,6 +1255,7 @@ export type OrchestrationV2UserMessageInputIntent =
   typeof OrchestrationV2UserMessageInputIntent.Type;
 
 const OrchestrationV2TurnItemBaseFields = {
+  toolNonExecutionKind: Schema.optional(Schema.String),
   toolSurface: Schema.optional(ToolActivitySurface),
   toolIcon: Schema.optional(ToolActivityIcon),
   toolSource: Schema.optional(ToolActivitySource),
@@ -1357,6 +1360,8 @@ export const OrchestrationV2TurnItem = Schema.Union([
     type: Schema.Literal("command_execution"),
     input: Schema.String,
     output: Schema.optional(Schema.String),
+    /** Set on the wire when output was withheld; fetch it with getTurnItem. */
+    outputOmitted: Schema.optional(Schema.Boolean),
     outputIndicatesFailure: Schema.optional(Schema.Boolean),
     exitCode: Schema.optional(Schema.Int),
   }),
@@ -1483,6 +1488,8 @@ export const OrchestrationV2TurnItem = Schema.Union([
     viewedImagePath: Schema.optional(TrimmedNonEmptyString),
     input: Schema.Unknown,
     output: Schema.optional(Schema.Unknown),
+    /** Set on the wire when output was withheld; fetch it with getTurnItem. */
+    outputOmitted: Schema.optional(Schema.Boolean),
   }),
 ]);
 export type OrchestrationV2TurnItem = typeof OrchestrationV2TurnItem.Type;
@@ -2089,6 +2096,8 @@ export const OrchestrationV2TurnItemJson = Schema.Union([
     type: Schema.Literal("command_execution"),
     input: Schema.String,
     output: Schema.optional(Schema.String),
+    /** Set on the wire when output was withheld; fetch it with getTurnItem. */
+    outputOmitted: Schema.optional(Schema.Boolean),
     outputIndicatesFailure: Schema.optional(Schema.Boolean),
     exitCode: Schema.optional(Schema.Int),
   }),
@@ -2212,6 +2221,8 @@ export const OrchestrationV2TurnItemJson = Schema.Union([
     viewedImagePath: Schema.optional(TrimmedNonEmptyString),
     input: Schema.Unknown,
     output: Schema.optional(Schema.Unknown),
+    /** Set on the wire when output was withheld; fetch it with getTurnItem. */
+    outputOmitted: Schema.optional(Schema.Boolean),
   }),
 ]);
 export type OrchestrationV2TurnItemJson = typeof OrchestrationV2TurnItemJson.Type;
@@ -2969,6 +2980,7 @@ export const ORCHESTRATION_V2_WS_METHODS = {
   getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot",
   getThreadProjection: "orchestration.getThreadProjection",
   getWorkflowScript: "orchestration.getWorkflowScript",
+  getTurnItem: "orchestration.getTurnItem",
   launchThread: "orchestration.launchThread",
   subscribeArchivedShell: "orchestration.subscribeArchivedShell",
   subscribeShell: "orchestration.subscribeShell",
@@ -3255,6 +3267,20 @@ export const OrchestrationV2GetWorkflowScriptResult = Schema.Struct({
 export type OrchestrationV2GetWorkflowScriptResult =
   typeof OrchestrationV2GetWorkflowScriptResult.Type;
 
+export const OrchestrationV2GetTurnItemInput = Schema.Struct({
+  threadId: ThreadId,
+  itemId: TurnItemId,
+  /** The item updatedAt the client last saw. Only keys the client cache. */
+  revision: Schema.optional(Schema.String),
+});
+export type OrchestrationV2GetTurnItemInput = typeof OrchestrationV2GetTurnItemInput.Type;
+
+/** One persisted turn item with its full, size-bounded input and output. */
+export const OrchestrationV2GetTurnItemResult = Schema.Struct({
+  item: Schema.NullOr(OrchestrationV2TurnItem),
+});
+export type OrchestrationV2GetTurnItemResult = typeof OrchestrationV2GetTurnItemResult.Type;
+
 const WORKFLOW_SCRIPT_ERROR_MESSAGES = {
   "invalid-path": "Workflow scripts must be absolute .js paths.",
   "root-unavailable": "Script root unavailable.",
@@ -3313,6 +3339,10 @@ export const OrchestrationV2RpcSchemas = {
     input: OrchestrationV2GetWorkflowScriptInput,
     output: OrchestrationV2GetWorkflowScriptResult,
   },
+  getTurnItem: {
+    input: OrchestrationV2GetTurnItemInput,
+    output: OrchestrationV2GetTurnItemResult,
+  },
   launchThread: {
     input: OrchestrationV2ThreadLaunchInput,
     output: OrchestrationV2ThreadLaunchResult,
diff --git a/packages/contracts/src/orchestratorMcp.ts b/packages/contracts/src/orchestratorMcp.ts
index 565f42866466..bed1e7a782e2 100644
--- a/packages/contracts/src/orchestratorMcp.ts
+++ b/packages/contracts/src/orchestratorMcp.ts
@@ -280,7 +280,15 @@ export const OrchestratorMcpThreadStatus = Schema.Union([
 ]);
 export type OrchestratorMcpThreadStatus = typeof OrchestratorMcpThreadStatus.Type;
 
+const OrchestratorMcpProjectTarget = Schema.optional(
+  ProjectId.annotate({
+    description:
+      "Project to act on. Omit for the calling thread's project; required when the caller is not a T3 thread.",
+  }),
+);
+
 export const OrchestratorMcpThreadListInput = Schema.Struct({
+  projectId: OrchestratorMcpProjectTarget,
   statuses: Schema.optional(
     Schema.Array(OrchestratorMcpThreadStatus).check(Schema.isMaxLength(10)),
   ),
@@ -316,7 +324,8 @@ export type OrchestratorMcpThreadListItem = typeof OrchestratorMcpThreadListItem
 
 export const OrchestratorMcpThreadListResult = Schema.Struct({
   projectId: ProjectId,
-  currentThreadId: ThreadId,
+  /** The calling thread, or null when the caller is not a T3 thread. */
+  currentThreadId: Schema.NullOr(ThreadId),
   threads: Schema.Array(OrchestratorMcpThreadListItem),
   nextCursor: Schema.NullOr(NonNegativeInt),
   total: NonNegativeInt,
@@ -475,9 +484,11 @@ export const OrchestratorMcpProviderCapability = Schema.Struct({
 export type OrchestratorMcpProviderCapability = typeof OrchestratorMcpProviderCapability.Type;
 
 export const OrchestratorMcpCapabilitiesResult = Schema.Struct({
-  parentThreadId: ThreadId,
-  inheritedProviderInstanceId: ProviderInstanceId,
-  inheritedModel: Schema.String,
+  /** The calling thread, or null when the caller is not a T3 thread. */
+  parentThreadId: Schema.NullOr(ThreadId),
+  /** The calling thread's selection, or null when the caller is not a T3 thread. */
+  inheritedProviderInstanceId: Schema.NullOr(ProviderInstanceId),
+  inheritedModel: Schema.NullOr(Schema.String),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   providers: Schema.Array(OrchestratorMcpProviderCapability),
@@ -495,6 +506,7 @@ export const OrchestratorMcpCapabilitiesResult = Schema.Struct({
 export type OrchestratorMcpCapabilitiesResult = typeof OrchestratorMcpCapabilitiesResult.Type;
 
 export const OrchestratorMcpScheduleTaskInput = Schema.Struct({
+  projectId: OrchestratorMcpProjectTarget,
   prompt: OrchestratorMcpPrompt.annotate({
     description: "Prompt executed on every scheduled run.",
   }),
@@ -535,6 +547,17 @@ export type OrchestratorMcpScheduledTask = typeof OrchestratorMcpScheduledTask.T
 export const OrchestratorMcpScheduleTaskResult = OrchestratorMcpScheduledTask;
 export type OrchestratorMcpScheduleTaskResult = typeof OrchestratorMcpScheduleTaskResult.Type;
 
+export const OrchestratorMcpListScheduledTasksInput = Schema.Struct({
+  projectId: Schema.optional(
+    ProjectId.annotate({
+      description:
+        "Only list this project's tasks. Omit for the calling thread's project, or for every project when the caller is not a T3 thread.",
+    }),
+  ),
+});
+export type OrchestratorMcpListScheduledTasksInput =
+  typeof OrchestratorMcpListScheduledTasksInput.Type;
+
 export const OrchestratorMcpListScheduledTasksResult = Schema.Struct({
   tasks: Schema.Array(OrchestratorMcpScheduledTask),
 });
@@ -583,6 +606,8 @@ export class OrchestratorMcpFailure extends Schema.TaggedError<OrchestratorMcpFa
       "thread_not_interruptible",
       "invalid_request",
       "orchestration_error",
+      "thread_credential_required",
+      "target_required",
     ]),
     message: Schema.String,
   },
diff --git a/packages/contracts/src/previewAutomation.ts b/packages/contracts/src/previewAutomation.ts
index f87739670f75..734aa1bb53df 100644
--- a/packages/contracts/src/previewAutomation.ts
+++ b/packages/contracts/src/previewAutomation.ts
@@ -642,11 +642,12 @@ export const PreviewAutomationResponse = Schema.Struct({
 });
 export type PreviewAutomationResponse = typeof PreviewAutomationResponse.Type;
 
+// Thread fields are absent when the caller signed in from outside a T3 thread.
 const McpCapabilityErrorFields = {
   environmentId: EnvironmentId,
-  threadId: ThreadId,
-  providerSessionId: TrimmedNonEmptyString,
-  providerInstanceId: ProviderInstanceId,
+  threadId: Schema.optional(ThreadId),
+  providerSessionId: Schema.optional(TrimmedNonEmptyString),
+  providerInstanceId: Schema.optional(ProviderInstanceId),
 };
 
 /** Agents read this message, so it names the next step and not only the failure. */
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index 19b232c8d77a..9e2f39a320a4 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -1551,6 +1551,12 @@ const WsOrchestrationV2GetWorkflowScriptRpc = Rpc.make(
   },
 );
 
+const WsOrchestrationV2GetTurnItemRpc = Rpc.make(ORCHESTRATION_V2_WS_METHODS.getTurnItem, {
+  payload: OrchestrationV2RpcSchemas.getTurnItem.input,
+  success: OrchestrationV2RpcSchemas.getTurnItem.output,
+  error: Schema.Union([OrchestrationV2GetThreadProjectionError, EnvironmentAuthorizationError]),
+});
+
 const WsOrchestrationV2LaunchThreadRpc = Rpc.make(ORCHESTRATION_V2_WS_METHODS.launchThread, {
   payload: OrchestrationV2RpcSchemas.launchThread.input,
   success: OrchestrationV2RpcSchemas.launchThread.output,
@@ -1860,6 +1866,7 @@ export const WsRpcGroup = RpcGroup.make(
   WsSubscribeResourceTelemetryRpc,
   WsOrchestrationV2DispatchCommandRpc,
   WsOrchestrationV2GetWorkflowScriptRpc,
+  WsOrchestrationV2GetTurnItemRpc,
   WsOrchestrationV2GetTurnDiffRpc,
   WsOrchestrationV2GetFullThreadDiffRpc,
   WsOrchestrationV2SearchThreadsRpc,
diff --git a/packages/contracts/src/server.test.ts b/packages/contracts/src/server.test.ts
index ffbeb5cb9f11..fdb6b82b3dbc 100644
--- a/packages/contracts/src/server.test.ts
+++ b/packages/contracts/src/server.test.ts
@@ -31,6 +31,21 @@ const baseProviderSnapshot = {
 };
 
 describe("ServerProvider", () => {
+  it.each([undefined, true, false])("decodes workspace command discovery pending=%s", (pending) => {
+    const workspace = {
+      cwd: "/workspace/project",
+      checkedAt: baseProviderSnapshot.checkedAt,
+      slashCommands: [{ name: "compact" }],
+      ...(pending === undefined ? {} : { slashCommandsPending: pending }),
+      skills: [{ name: "project", path: "/workspace/project/SKILL.md", enabled: true }],
+    };
+    const parsed = decodeServerProvider({
+      ...baseProviderSnapshot,
+      workspaceSnapshots: [workspace],
+    });
+    expect(parsed.workspaceSnapshots).toEqual([workspace]);
+  });
+
   it("defaults capability arrays when decoding provider snapshots", () => {
     const parsed = decodeServerProvider({
       instanceId: "codex",
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index 54cca104f46b..8cd3e2d0bf68 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -143,6 +143,8 @@ export const ServerProviderWorkspaceSnapshot = Schema.Struct({
   cwd: TrimmedNonEmptyString,
   checkedAt: IsoDateTime,
   slashCommands: Schema.Array(ServerProviderSlashCommand),
+  /** Skills are available, but command discovery still needs a retry. */
+  slashCommandsPending: Schema.optional(Schema.Boolean),
   skills: Schema.Array(ServerProviderSkill),
 });
 export type ServerProviderWorkspaceSnapshot = typeof ServerProviderWorkspaceSnapshot.Type;
@@ -619,6 +621,15 @@ export function environmentThemeFileHasColors(file: EnvironmentThemeFile): boole
   );
 }
 
+export const ServerDirectEndpointKind = Schema.Literals(["lan", "tailnet"]);
+export type ServerDirectEndpointKind = typeof ServerDirectEndpointKind.Type;
+
+export const ServerDirectEndpoint = Schema.Struct({
+  kind: ServerDirectEndpointKind,
+  httpBaseUrl: TrimmedNonEmptyString,
+});
+export type ServerDirectEndpoint = typeof ServerDirectEndpoint.Type;
+
 export const ServerConfig = Schema.Struct({
   environmentControl: Schema.optionalKey(Schema.Boolean),
   /**
@@ -655,6 +666,13 @@ export const ServerConfig = Schema.Struct({
    * sshd or no advertisable name.
    */
   remoteOpenTargets: Schema.optionalKey(ForwardCompatibleArray(RemoteOpenTarget)),
+  /**
+   * Direct addresses this server listens on right now (LAN and tailnet), so a
+   * client connected one way can learn the others. Hints only: the client
+   * checks each address answers as this environment before using it. Absent on
+   * servers that predate the feature; empty when bound to loopback only.
+   */
+  directEndpoints: Schema.optionalKey(ForwardCompatibleArray(ServerDirectEndpoint)),
   observability: ServerObservability,
   settings: ServerSettings,
   /** Whether shell subscriptions can emit an opt-in catch-up completion marker. */
diff --git a/packages/contracts/src/threadMetadataMcp.ts b/packages/contracts/src/threadMetadataMcp.ts
index ca15a524d8d7..7c132e4d45f4 100644
--- a/packages/contracts/src/threadMetadataMcp.ts
+++ b/packages/contracts/src/threadMetadataMcp.ts
@@ -80,7 +80,7 @@ export type ThreadMetadataMcpPullRequest = typeof ThreadMetadataMcpPullRequest.T
 
 export const ThreadMetadataMcpUpdateInput = Schema.Struct({
   threadId: Schema.optional(ThreadId).annotate({
-    description: "Thread in the calling project. Omit to update the calling thread.",
+    description: "Thread to update. Omit to update the calling thread.",
   }),
   action: ThreadMetadataMcpAction,
   title: Schema.optional(ThreadMetadataTitle),
diff --git a/packages/contracts/src/worktreeMcp.ts b/packages/contracts/src/worktreeMcp.ts
index e0cf1446fc49..1ceafef55d9e 100644
--- a/packages/contracts/src/worktreeMcp.ts
+++ b/packages/contracts/src/worktreeMcp.ts
@@ -121,6 +121,7 @@ export class WorktreeMcpFailure extends Schema.TaggedError<WorktreeMcpFailure>()
       "handoff_in_progress",
       "invalid_request",
       "operation_failed",
+      "thread_credential_required",
     ]),
     message: Schema.String,
   },
diff --git a/packages/shared/package.json b/packages/shared/package.json
index b67a205e5bb3..0daaf6dd1993 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -95,6 +95,10 @@
       "types": "./src/KeyedCoalescingWorker.ts",
       "import": "./src/KeyedCoalescingWorker.ts"
     },
+    "./KeyedLock": {
+      "types": "./src/KeyedLock.ts",
+      "import": "./src/KeyedLock.ts"
+    },
     "./schemaJson": {
       "types": "./src/schemaJson.ts",
       "import": "./src/schemaJson.ts"
diff --git a/packages/shared/src/KeyedLock.test.ts b/packages/shared/src/KeyedLock.test.ts
new file mode 100644
index 000000000000..046729af5568
--- /dev/null
+++ b/packages/shared/src/KeyedLock.test.ts
@@ -0,0 +1,127 @@
+import { assert, describe, it } from "@effect/vitest";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Queue from "effect/Queue";
+import * as Ref from "effect/Ref";
+import * as Scope from "effect/Scope";
+
+import * as KeyedLock from "./KeyedLock.ts";
+
+describe("KeyedLock", () => {
+  it.effect("runs one holder of a key at a time, waiters in the order they queued", () =>
+    Effect.gen(function* () {
+      const lock = yield* KeyedLock.make<string>();
+      const events = yield* Ref.make<ReadonlyArray<string>>([]);
+      const record = (event: string) => Ref.update(events, (current) => [...current, event]);
+      const firstEntered = yield* Deferred.make<void>();
+      const releaseFirst = yield* Deferred.make<void>();
+
+      const first = yield* lock
+        .withLock(
+          "key",
+          record("first:start").pipe(
+            Effect.andThen(Deferred.succeed(firstEntered, undefined)),
+            Effect.andThen(Deferred.await(releaseFirst)),
+            Effect.andThen(record("first:end")),
+          ),
+        )
+        .pipe(Effect.forkChild);
+      yield* Deferred.await(firstEntered);
+      const second = yield* lock.withLock("key", record("second")).pipe(Effect.forkChild);
+      const third = yield* lock.withLock("key", record("third")).pipe(Effect.forkChild);
+      yield* Effect.yieldNow;
+      assert.deepStrictEqual(yield* Ref.get(events), ["first:start"]);
+
+      yield* Deferred.succeed(releaseFirst, undefined);
+      yield* Fiber.joinAll([first, second, third]);
+      assert.deepStrictEqual(yield* Ref.get(events), [
+        "first:start",
+        "first:end",
+        "second",
+        "third",
+      ]);
+    }),
+  );
+
+  it.effect("runs holders of different keys concurrently", () =>
+    Effect.gen(function* () {
+      const lock = yield* KeyedLock.make<string>();
+      const entered = yield* Queue.unbounded<string>();
+      const release = yield* Deferred.make<void>();
+      const hold = (key: string) =>
+        lock.withLock(key, Queue.offer(entered, key).pipe(Effect.andThen(Deferred.await(release))));
+
+      const holders = yield* Effect.forEach(["a", "b"], hold, { concurrency: "unbounded" }).pipe(
+        Effect.forkChild,
+      );
+      // Both enter while the other still holds its key.
+      const both = new Set([yield* Queue.take(entered), yield* Queue.take(entered)]);
+      assert.deepStrictEqual(both, new Set(["a", "b"]));
+      yield* Deferred.succeed(release, undefined);
+      yield* Fiber.join(holders);
+    }),
+  );
+
+  it.effect("keeps no lock for a key once its holders and waiters are gone", () =>
+    Effect.gen(function* () {
+      const lock = yield* KeyedLock.make<string>();
+      const entered = yield* Deferred.make<void>();
+      const release = yield* Deferred.make<void>();
+
+      const holder = yield* lock
+        .withLock(
+          "key",
+          Deferred.succeed(entered, undefined).pipe(Effect.andThen(Deferred.await(release))),
+        )
+        .pipe(Effect.forkChild);
+      yield* Deferred.await(entered);
+      // A waiter that gives up and one that runs.
+      const abandoned = yield* lock.withLock("key", Effect.void).pipe(Effect.forkChild);
+      const waiting = yield* lock.withLock("key", Effect.void).pipe(Effect.forkChild);
+      yield* Effect.yieldNow;
+      assert.deepStrictEqual(yield* lock.activeKeys, ["key"]);
+
+      yield* Fiber.interrupt(abandoned);
+      // The holder and the other waiter still need the lock.
+      assert.deepStrictEqual(yield* lock.activeKeys, ["key"]);
+      yield* Deferred.succeed(release, undefined);
+      yield* Fiber.joinAll([holder, waiting]);
+      // A holder that fails releases its key too.
+      assert.strictEqual(
+        yield* lock.withLock("other", Effect.fail("boom")).pipe(Effect.flip),
+        "boom",
+      );
+
+      assert.deepStrictEqual(yield* lock.activeKeys, []);
+    }),
+  );
+
+  it.effect("keeps working after the scope that made it closes", () =>
+    Effect.gen(function* () {
+      // Services built per request hand their lock to work that outlives the build.
+      const lock = yield* Effect.scoped(KeyedLock.make<string>());
+      assert.strictEqual(yield* lock.withLock("key", Effect.succeed("ran")), "ran");
+    }),
+  );
+
+  it.effect("runs the effect in the caller's scope", () =>
+    Effect.gen(function* () {
+      const lock = yield* KeyedLock.make<string>();
+      const finalized = yield* Ref.make(false);
+      const callerScope = yield* Scope.make();
+
+      yield* lock
+        .withLock(
+          "key",
+          Effect.addFinalizer(() => Ref.set(finalized, true)),
+        )
+        .pipe(Scope.provide(callerScope));
+      // The finalizer belongs to the caller, so releasing the lock leaves it.
+      assert.isFalse(yield* Ref.get(finalized));
+      yield* Scope.close(callerScope, Exit.void);
+      assert.isTrue(yield* Ref.get(finalized));
+    }),
+  );
+});
diff --git a/apps/server/src/orchestration-v2/KeyedSerialExecutor.ts b/packages/shared/src/KeyedLock.ts
similarity index 50%
rename from apps/server/src/orchestration-v2/KeyedSerialExecutor.ts
rename to packages/shared/src/KeyedLock.ts
index 93dbe04bbbfd..780ee3a9bbca 100644
--- a/apps/server/src/orchestration-v2/KeyedSerialExecutor.ts
+++ b/packages/shared/src/KeyedLock.ts
@@ -2,36 +2,42 @@ import * as Effect from "effect/Effect";
 import * as Ref from "effect/Ref";
 import * as Semaphore from "effect/Semaphore";
 
+export interface KeyedLock<Key> {
+  /** Runs `effect` once no other holder of `key` is running. Queued waiters go first-in, first-out. */
+  readonly withLock: <A, E, R>(key: Key, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  /** The keys someone holds or waits on right now. */
+  readonly activeKeys: Effect.Effect<ReadonlyArray<Key>>;
+}
+
 interface LockEntry {
   readonly semaphore: Semaphore.Semaphore;
   readonly users: number;
 }
 
-export interface KeyedSerialExecutor<Key> {
-  readonly withLock: <A, E, R>(key: Key, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-}
-
 /**
- * Serializes work that targets the same domain identity without coupling
- * unrelated identities to a process-wide mutex.
+ * Mutual exclusion per key. A key's lock exists only while someone holds or
+ * waits on it, so locks for keys that come and go never accumulate. Not
+ * reentrant: taking a key while already holding it deadlocks.
+ *
+ * Keys compare like `Map` keys (by value for strings and numbers). The lock is
+ * not tied to a scope, so it keeps working for as long as anyone references it.
  */
-export const makeKeyedSerialExecutor = <Key>(): Effect.Effect<KeyedSerialExecutor<Key>> =>
+export const make = <Key>(): Effect.Effect<KeyedLock<Key>> =>
   Effect.gen(function* () {
-    const locks = yield* Ref.make(new Map<Key, LockEntry>());
+    const locks = yield* Ref.make<ReadonlyMap<Key, LockEntry>>(new Map());
 
-    const acquireLock = (key: Key) =>
-      Effect.gen(function* () {
-        const candidate = yield* Semaphore.make(1);
-        return yield* Ref.modify(locks, (current) => {
+    const acquire = (key: Key) =>
+      Effect.flatMap(Semaphore.make(1), (candidate) =>
+        Ref.modify(locks, (current) => {
           const existing = current.get(key);
           const semaphore = existing?.semaphore ?? candidate;
           const next = new Map(current);
           next.set(key, { semaphore, users: (existing?.users ?? 0) + 1 });
           return [semaphore, next] as const;
-        });
-      });
+        }),
+      );
 
-    const releaseLock = (key: Key) =>
+    const release = (key: Key) =>
       Ref.update(locks, (current) => {
         const existing = current.get(key);
         if (existing === undefined) return current;
@@ -47,9 +53,10 @@ export const makeKeyedSerialExecutor = <Key>(): Effect.Effect<KeyedSerialExecuto
     return {
       withLock: (key, effect) =>
         Effect.acquireUseRelease(
-          acquireLock(key),
+          acquire(key),
           (semaphore) => semaphore.withPermit(effect),
-          () => releaseLock(key),
+          () => release(key),
         ),
-    } satisfies KeyedSerialExecutor<Key>;
+      activeKeys: Effect.map(Ref.get(locks), (current) => Array.from(current.keys())),
+    } satisfies KeyedLock<Key>;
   });
diff --git a/packages/shared/src/hostClassification.ts b/packages/shared/src/hostClassification.ts
index 7191fa78221f..ac56cd640af9 100644
--- a/packages/shared/src/hostClassification.ts
+++ b/packages/shared/src/hostClassification.ts
@@ -81,6 +81,19 @@ export const isLocalLoopbackHost = (host: string): boolean => {
   return parseIpv4Address(normalized)?.[0] === 127;
 };
 
+/**
+ * A Tailscale address: a MagicDNS name, the 100.64.0.0/10 range Tailscale
+ * assigns, or its IPv6 range fd7a:115c:a1e0::/48.
+ */
+export const isTailnetHost = (host: string): boolean => {
+  const normalized = normalizeHostname(host);
+  if (normalized.endsWith(".ts.net")) return true;
+  const parts = parseIpv4Address(normalized);
+  if (parts !== null) return parts[0] === 100 && parts[1]! >= 64 && parts[1]! <= 127;
+  const ipv6 = parseIpv6Address(normalized);
+  return ipv6 !== null && ipv6PrefixMatches(ipv6, [0xfd7a, 0x115c, 0xa1e0, 0, 0, 0, 0, 0], 48);
+};
+
 export const isPrivateNetworkHost = (host: string): boolean => {
   const normalized = normalizeHostname(host);
   if (
diff --git a/packages/ssh/src/tunnel.ts b/packages/ssh/src/tunnel.ts
index 6c58cf7174eb..37d539c806b4 100644
--- a/packages/ssh/src/tunnel.ts
+++ b/packages/ssh/src/tunnel.ts
@@ -7,6 +7,7 @@ import {
   waitForHttpReady as waitForHttpReadyShared,
 } from "@t3tools/shared/httpReadiness";
 import { cliReleaseDownloadBaseUrl } from "@t3tools/shared/cliRelease";
+import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import * as NetService from "@t3tools/shared/Net";
 import { extractJsonObject, fromLenientJson } from "@t3tools/shared/schemaJson";
 import { satisfiesSemverRange } from "@t3tools/shared/semver";
@@ -18,7 +19,6 @@ import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
-import * as Semaphore from "effect/Semaphore";
 import * as Stream from "effect/Stream";
 import { HttpClient } from "effect/unstable/http";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
@@ -1328,7 +1328,7 @@ const makeSshEnvironmentManager = Effect.fn("ssh/tunnel.SshEnvironmentManager.ma
 ): Effect.fn.Return<SshEnvironmentManagerShape, never, Scope.Scope> {
   const managerScope = yield* Scope.Scope;
   const tunnels = new Map<string, SshTunnelEntry>();
-  const targetLocks = new Map<string, Semaphore.Semaphore>();
+  const targetLocks = yield* KeyedLock.make<string>();
   const authSecrets = new Map<string, string>();
 
   // Keep one lock per target so reconnect cannot reuse a server while stop is pending.
@@ -1336,12 +1336,7 @@ const makeSshEnvironmentManager = Effect.fn("ssh/tunnel.SshEnvironmentManager.ma
     key: string,
     effect: Effect.Effect<A, E, R>,
   ): Effect.fn.Return<A, E, R> {
-    let lock = targetLocks.get(key);
-    if (lock === undefined) {
-      lock = Semaphore.makeUnsafe(1);
-      targetLocks.set(key, lock);
-    }
-    return yield* lock.withPermits(1)(effect);
+    return yield* targetLocks.withLock(key, effect);
   });
 
   const closeTunnelEntry = Effect.fn("ssh/tunnel.closeTunnelEntry")(function* (
diff --git a/patches/uniwind@1.11.0.patch b/patches/uniwind@1.11.0.patch
deleted file mode 100644
index 4a418bf6b077..000000000000
--- a/patches/uniwind@1.11.0.patch
+++ /dev/null
@@ -1,1011 +0,0 @@
-diff --git a/dist/common/bundler/css-processor/processor.js b/dist/common/bundler/css-processor/processor.js
-index 7dd369f..48321d1 100644
---- a/dist/common/bundler/css-processor/processor.js
-+++ b/dist/common/bundler/css-processor/processor.js
-@@ -105,6 +105,64 @@ class ProcessorBuilder {
-       style.importantProperties.push(declaration.property);
-     }
-   }
-+  readSelectorVariants(tokens) {
-+    const variants = {
-+      rtl: null,
-+      theme: null,
-+      active: null,
-+      focus: null,
-+      disabled: null,
-+      dataAttributes: null
-+    };
-+    tokens.forEach((token) => {
-+      if (token.type === "pseudo-class" && token.kind === "where") {
-+        token.selectors.forEach((compound) => {
-+          compound.forEach((inner) => {
-+            if (inner.type === "class" && this.bundlerConfig.themes.includes(inner.name)) {
-+              variants.theme = inner.name;
-+            }
-+            if (inner.type === "pseudo-class" && inner.kind === "dir") {
-+              variants.rtl = inner.direction === "rtl";
-+            }
-+          });
-+        });
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "active") {
-+        variants.active = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "focus") {
-+        variants.focus = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "disabled") {
-+        variants.disabled = true;
-+      }
-+      if (token.type === "attribute" && token.operation === null && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"true"`;
-+      }
-+      if (token.type === "attribute" && token.operation?.operator === "equal" && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"${token.operation.value}"`;
-+      }
-+    });
-+    const hasVariants = Object.values(variants).some(_utils.isDefined);
-+    return { variants, hasVariants };
-+  }
-+  withSelectorVariants(variants, run) {
-+    this.declarationConfig.rtl ??= variants.rtl;
-+    this.declarationConfig.theme ??= variants.theme;
-+    this.declarationConfig.active ??= variants.active;
-+    this.declarationConfig.focus ??= variants.focus;
-+    this.declarationConfig.disabled ??= variants.disabled;
-+    this.declarationConfig.dataAttributes ??= variants.dataAttributes;
-+    run();
-+    this.declarationConfig.rtl = null;
-+    this.declarationConfig.theme = null;
-+    this.declarationConfig.active = null;
-+    this.declarationConfig.focus = null;
-+    this.declarationConfig.disabled = null;
-+    this.declarationConfig.dataAttributes = null;
-+  }
-   parseRuleRec(rule) {
-     if (this.declarationConfig.className !== null) {
-       const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1);
-@@ -120,64 +178,30 @@ class ProcessorBuilder {
-           this.declarationConfig.className = newClassName;
-           this.stylesheets[newClassName] ??= [];
-           this.stylesheets[newClassName].push({});
--          rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach(rule2 => this.parseRuleRec(rule2));
--          return;
--        }
--        let rtl = null;
--        let theme = null;
--        let active = null;
--        let focus = null;
--        let disabled = null;
--        let dataAttributes = null;
--        selector.forEach(selector2 => {
--          if (selector2.type === "pseudo-class" && selector2.kind === "where") {
--            selector2.selectors.forEach(selector3 => {
--              selector3.forEach(selector4 => {
--                if (selector4.type === "class" && this.bundlerConfig.themes.includes(selector4.name)) {
--                  theme = selector4.name;
--                }
--                if (selector4.type === "pseudo-class" && selector4.kind === "dir") {
--                  rtl = selector4.direction === "rtl";
--                }
--              });
--            });
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "active") {
--            active = true;
-+          const trailing = selector.slice(1);
-+          const { variants, hasVariants } = this.readSelectorVariants(trailing);
-+          if (trailing.length > 0 && !hasVariants) {
-+            return;
-           }
--          if (selector2.type === "pseudo-class" && selector2.kind === "focus") {
--            focus = true;
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "disabled") {
--            disabled = true;
--          }
--          if (selector2.type === "attribute" && selector2.operation === null && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"true"`;
--          }
--          if (selector2.type === "attribute" && selector2.operation?.operator === "equal" && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"${selector2.operation.value}"`;
-+          const parseClassRule = () => {
-+            rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach(rule2 => this.parseRuleRec(rule2));
-+          };
-+          if (hasVariants) {
-+            this.withSelectorVariants(variants, parseClassRule);
-+          } else {
-+            parseClassRule();
-           }
--        });
--        if ([rtl, theme, active, focus, disabled, dataAttributes].some(_utils.isDefined)) {
--          this.declarationConfig.rtl ??= rtl;
--          this.declarationConfig.theme ??= theme;
--          this.declarationConfig.active ??= active;
--          this.declarationConfig.focus ??= focus;
--          this.declarationConfig.disabled ??= disabled;
--          this.declarationConfig.dataAttributes ??= dataAttributes;
--          rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach(rule2 => this.parseRuleRec(rule2));
--          this.declarationConfig.rtl = null;
--          this.declarationConfig.theme = null;
--          this.declarationConfig.active = null;
--          this.declarationConfig.focus = null;
--          this.declarationConfig.disabled = null;
--          this.declarationConfig.dataAttributes = null;
-+          return;
-+        }
-+        const { variants, hasVariants } = this.readSelectorVariants(selector);
-+        if (hasVariants) {
-+          this.withSelectorVariants(variants, () => {
-+            rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach(rule2 => this.parseRuleRec(rule2));
-+          });
-           return;
-         }
-         selector.forEach(selectorToken => {
-@@ -199,11 +223,16 @@ class ProcessorBuilder {
-       const {
-         mediaQueries
-       } = rule.value.query;
--      this.declarationConfig.mediaQueries.push(...mediaQueries);
-+      const outerConfig = this.declarationConfig;
-+      const blockMediaQueries = [...outerConfig.mediaQueries, ...mediaQueries];
-       rule.value.rules.forEach(rule2 => {
-+        this.declarationConfig = {
-+          ...outerConfig,
-+          mediaQueries: blockMediaQueries
-+        };
-         this.parseRuleRec(rule2);
--        this.declarationConfig = this.getDeclarationConfig();
-       });
-+      this.declarationConfig = outerConfig;
-       return;
-     }
-     if (rule.type === "layer-block") {
-diff --git a/dist/metro/transformer.cjs b/dist/metro/transformer.cjs
-index d57ca81..83b58d1 100644
---- a/dist/metro/transformer.cjs
-+++ b/dist/metro/transformer.cjs
-@@ -7,6 +7,7 @@ const culori = require('culori');
- const node = require('@tailwindcss/node');
- const oxide = require('@tailwindcss/oxide');
- const fs = require('fs');
-+const node_crypto = require('node:crypto');
- 
- function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
- 
-@@ -1537,6 +1538,64 @@ class ProcessorBuilder {
-       style.importantProperties.push(declaration.property);
-     }
-   }
-+  readSelectorVariants(tokens) {
-+    const variants = {
-+      rtl: null,
-+      theme: null,
-+      active: null,
-+      focus: null,
-+      disabled: null,
-+      dataAttributes: null
-+    };
-+    tokens.forEach((token) => {
-+      if (token.type === "pseudo-class" && token.kind === "where") {
-+        token.selectors.forEach((compound) => {
-+          compound.forEach((inner) => {
-+            if (inner.type === "class" && this.bundlerConfig.themes.includes(inner.name)) {
-+              variants.theme = inner.name;
-+            }
-+            if (inner.type === "pseudo-class" && inner.kind === "dir") {
-+              variants.rtl = inner.direction === "rtl";
-+            }
-+          });
-+        });
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "active") {
-+        variants.active = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "focus") {
-+        variants.focus = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "disabled") {
-+        variants.disabled = true;
-+      }
-+      if (token.type === "attribute" && token.operation === null && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"true"`;
-+      }
-+      if (token.type === "attribute" && token.operation?.operator === "equal" && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"${token.operation.value}"`;
-+      }
-+    });
-+    const hasVariants = Object.values(variants).some(config.isDefined);
-+    return { variants, hasVariants };
-+  }
-+  withSelectorVariants(variants, run) {
-+    this.declarationConfig.rtl ??= variants.rtl;
-+    this.declarationConfig.theme ??= variants.theme;
-+    this.declarationConfig.active ??= variants.active;
-+    this.declarationConfig.focus ??= variants.focus;
-+    this.declarationConfig.disabled ??= variants.disabled;
-+    this.declarationConfig.dataAttributes ??= variants.dataAttributes;
-+    run();
-+    this.declarationConfig.rtl = null;
-+    this.declarationConfig.theme = null;
-+    this.declarationConfig.active = null;
-+    this.declarationConfig.focus = null;
-+    this.declarationConfig.disabled = null;
-+    this.declarationConfig.dataAttributes = null;
-+  }
-   parseRuleRec(rule) {
-     if (this.declarationConfig.className !== null) {
-       const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1);
-@@ -1552,64 +1611,30 @@ class ProcessorBuilder {
-           this.declarationConfig.className = newClassName;
-           this.stylesheets[newClassName] ??= [];
-           this.stylesheets[newClassName].push({});
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          return;
--        }
--        let rtl = null;
--        let theme = null;
--        let active = null;
--        let focus = null;
--        let disabled = null;
--        let dataAttributes = null;
--        selector.forEach((selector2) => {
--          if (selector2.type === "pseudo-class" && selector2.kind === "where") {
--            selector2.selectors.forEach((selector3) => {
--              selector3.forEach((selector4) => {
--                if (selector4.type === "class" && this.bundlerConfig.themes.includes(selector4.name)) {
--                  theme = selector4.name;
--                }
--                if (selector4.type === "pseudo-class" && selector4.kind === "dir") {
--                  rtl = selector4.direction === "rtl";
--                }
--              });
--            });
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "active") {
--            active = true;
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "focus") {
--            focus = true;
-+          const trailing = selector.slice(1);
-+          const { variants, hasVariants } = this.readSelectorVariants(trailing);
-+          if (trailing.length > 0 && !hasVariants) {
-+            return;
-           }
--          if (selector2.type === "pseudo-class" && selector2.kind === "disabled") {
--            disabled = true;
--          }
--          if (selector2.type === "attribute" && selector2.operation === null && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"true"`;
--          }
--          if (selector2.type === "attribute" && selector2.operation?.operator === "equal" && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"${selector2.operation.value}"`;
-+          const parseClassRule = () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          };
-+          if (hasVariants) {
-+            this.withSelectorVariants(variants, parseClassRule);
-+          } else {
-+            parseClassRule();
-           }
--        });
--        if ([rtl, theme, active, focus, disabled, dataAttributes].some(config.isDefined)) {
--          this.declarationConfig.rtl ??= rtl;
--          this.declarationConfig.theme ??= theme;
--          this.declarationConfig.active ??= active;
--          this.declarationConfig.focus ??= focus;
--          this.declarationConfig.disabled ??= disabled;
--          this.declarationConfig.dataAttributes ??= dataAttributes;
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          this.declarationConfig.rtl = null;
--          this.declarationConfig.theme = null;
--          this.declarationConfig.active = null;
--          this.declarationConfig.focus = null;
--          this.declarationConfig.disabled = null;
--          this.declarationConfig.dataAttributes = null;
-+          return;
-+        }
-+        const { variants, hasVariants } = this.readSelectorVariants(selector);
-+        if (hasVariants) {
-+          this.withSelectorVariants(variants, () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          });
-           return;
-         }
-         selector.forEach((selectorToken) => {
-@@ -1629,11 +1654,13 @@ class ProcessorBuilder {
-     }
-     if (rule.type === "media") {
-       const { mediaQueries } = rule.value.query;
--      this.declarationConfig.mediaQueries.push(...mediaQueries);
-+      const outerConfig = this.declarationConfig;
-+      const blockMediaQueries = [...outerConfig.mediaQueries, ...mediaQueries];
-       rule.value.rules.forEach((rule2) => {
-+        this.declarationConfig = { ...outerConfig, mediaQueries: blockMediaQueries };
-         this.parseRuleRec(rule2);
--        this.declarationConfig = this.getDeclarationConfig();
-       });
-+      this.declarationConfig = outerConfig;
-       return;
-     }
-     if (rule.type === "layer-block") {
-@@ -1753,10 +1780,11 @@ const transform = async (config$1, projectRoot, filePath, data, options) => {
-   await bundlerConfig.generateArtifacts(cssArtifactPath);
-   const virtualCode = await compileCSS(bundlerConfig);
-   const isWeb = bundlerConfig.platform === config.Platform.Web;
-+  const nativeStylesFingerprint = isWeb ? void 0 : node_crypto.createHash("sha256").update(virtualCode).update("\0").update(bundlerConfig.stringifiedThemes).digest("hex");
-   data = Buffer.from(
-     isWeb ? virtualCode : [
-       `const { Uniwind } = require('uniwind');`,
--      `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes});`
-+      `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes}, '${nativeStylesFingerprint}');`
-     ].join(""),
-     "utf-8"
-   );
-diff --git a/dist/metro/transformer.mjs b/dist/metro/transformer.mjs
-index d3e7475..f92b73b 100644
---- a/dist/metro/transformer.mjs
-+++ b/dist/metro/transformer.mjs
-@@ -5,6 +5,7 @@ import { converter, parse, formatHex, formatHex8 } from 'culori';
- import { compile } from '@tailwindcss/node';
- import { Scanner } from '@tailwindcss/oxide';
- import fs from 'fs';
-+import { createHash } from 'node:crypto';
- 
- const toCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
- const pipe = (data) => ((...fns) => fns.reduce((acc, fn) => fn(acc), data));
-@@ -1530,6 +1531,64 @@ class ProcessorBuilder {
-       style.importantProperties.push(declaration.property);
-     }
-   }
-+  readSelectorVariants(tokens) {
-+    const variants = {
-+      rtl: null,
-+      theme: null,
-+      active: null,
-+      focus: null,
-+      disabled: null,
-+      dataAttributes: null
-+    };
-+    tokens.forEach((token) => {
-+      if (token.type === "pseudo-class" && token.kind === "where") {
-+        token.selectors.forEach((compound) => {
-+          compound.forEach((inner) => {
-+            if (inner.type === "class" && this.bundlerConfig.themes.includes(inner.name)) {
-+              variants.theme = inner.name;
-+            }
-+            if (inner.type === "pseudo-class" && inner.kind === "dir") {
-+              variants.rtl = inner.direction === "rtl";
-+            }
-+          });
-+        });
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "active") {
-+        variants.active = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "focus") {
-+        variants.focus = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "disabled") {
-+        variants.disabled = true;
-+      }
-+      if (token.type === "attribute" && token.operation === null && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"true"`;
-+      }
-+      if (token.type === "attribute" && token.operation?.operator === "equal" && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"${token.operation.value}"`;
-+      }
-+    });
-+    const hasVariants = Object.values(variants).some(isDefined);
-+    return { variants, hasVariants };
-+  }
-+  withSelectorVariants(variants, run) {
-+    this.declarationConfig.rtl ??= variants.rtl;
-+    this.declarationConfig.theme ??= variants.theme;
-+    this.declarationConfig.active ??= variants.active;
-+    this.declarationConfig.focus ??= variants.focus;
-+    this.declarationConfig.disabled ??= variants.disabled;
-+    this.declarationConfig.dataAttributes ??= variants.dataAttributes;
-+    run();
-+    this.declarationConfig.rtl = null;
-+    this.declarationConfig.theme = null;
-+    this.declarationConfig.active = null;
-+    this.declarationConfig.focus = null;
-+    this.declarationConfig.disabled = null;
-+    this.declarationConfig.dataAttributes = null;
-+  }
-   parseRuleRec(rule) {
-     if (this.declarationConfig.className !== null) {
-       const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1);
-@@ -1545,64 +1604,30 @@ class ProcessorBuilder {
-           this.declarationConfig.className = newClassName;
-           this.stylesheets[newClassName] ??= [];
-           this.stylesheets[newClassName].push({});
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          return;
--        }
--        let rtl = null;
--        let theme = null;
--        let active = null;
--        let focus = null;
--        let disabled = null;
--        let dataAttributes = null;
--        selector.forEach((selector2) => {
--          if (selector2.type === "pseudo-class" && selector2.kind === "where") {
--            selector2.selectors.forEach((selector3) => {
--              selector3.forEach((selector4) => {
--                if (selector4.type === "class" && this.bundlerConfig.themes.includes(selector4.name)) {
--                  theme = selector4.name;
--                }
--                if (selector4.type === "pseudo-class" && selector4.kind === "dir") {
--                  rtl = selector4.direction === "rtl";
--                }
--              });
--            });
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "active") {
--            active = true;
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "focus") {
--            focus = true;
-+          const trailing = selector.slice(1);
-+          const { variants, hasVariants } = this.readSelectorVariants(trailing);
-+          if (trailing.length > 0 && !hasVariants) {
-+            return;
-           }
--          if (selector2.type === "pseudo-class" && selector2.kind === "disabled") {
--            disabled = true;
--          }
--          if (selector2.type === "attribute" && selector2.operation === null && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"true"`;
--          }
--          if (selector2.type === "attribute" && selector2.operation?.operator === "equal" && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"${selector2.operation.value}"`;
-+          const parseClassRule = () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          };
-+          if (hasVariants) {
-+            this.withSelectorVariants(variants, parseClassRule);
-+          } else {
-+            parseClassRule();
-           }
--        });
--        if ([rtl, theme, active, focus, disabled, dataAttributes].some(isDefined)) {
--          this.declarationConfig.rtl ??= rtl;
--          this.declarationConfig.theme ??= theme;
--          this.declarationConfig.active ??= active;
--          this.declarationConfig.focus ??= focus;
--          this.declarationConfig.disabled ??= disabled;
--          this.declarationConfig.dataAttributes ??= dataAttributes;
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          this.declarationConfig.rtl = null;
--          this.declarationConfig.theme = null;
--          this.declarationConfig.active = null;
--          this.declarationConfig.focus = null;
--          this.declarationConfig.disabled = null;
--          this.declarationConfig.dataAttributes = null;
-+          return;
-+        }
-+        const { variants, hasVariants } = this.readSelectorVariants(selector);
-+        if (hasVariants) {
-+          this.withSelectorVariants(variants, () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          });
-           return;
-         }
-         selector.forEach((selectorToken) => {
-@@ -1622,11 +1647,13 @@ class ProcessorBuilder {
-     }
-     if (rule.type === "media") {
-       const { mediaQueries } = rule.value.query;
--      this.declarationConfig.mediaQueries.push(...mediaQueries);
-+      const outerConfig = this.declarationConfig;
-+      const blockMediaQueries = [...outerConfig.mediaQueries, ...mediaQueries];
-       rule.value.rules.forEach((rule2) => {
-+        this.declarationConfig = { ...outerConfig, mediaQueries: blockMediaQueries };
-         this.parseRuleRec(rule2);
--        this.declarationConfig = this.getDeclarationConfig();
-       });
-+      this.declarationConfig = outerConfig;
-       return;
-     }
-     if (rule.type === "layer-block") {
-@@ -1746,10 +1773,11 @@ const transform = async (config, projectRoot, filePath, data, options) => {
-   await bundlerConfig.generateArtifacts(cssArtifactPath);
-   const virtualCode = await compileCSS(bundlerConfig);
-   const isWeb = bundlerConfig.platform === Platform.Web;
-+  const nativeStylesFingerprint = isWeb ? void 0 : createHash("sha256").update(virtualCode).update("\0").update(bundlerConfig.stringifiedThemes).digest("hex");
-   data = Buffer.from(
-     isWeb ? virtualCode : [
-       `const { Uniwind } = require('uniwind');`,
--      `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes});`
-+      `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes}, '${nativeStylesFingerprint}');`
-     ].join(""),
-     "utf-8"
-   );
-diff --git a/dist/module/bundler/css-processor/processor.js b/dist/module/bundler/css-processor/processor.js
-index 58c96b6..6849ca7 100644
---- a/dist/module/bundler/css-processor/processor.js
-+++ b/dist/module/bundler/css-processor/processor.js
-@@ -99,6 +99,64 @@ export class ProcessorBuilder {
-       style.importantProperties.push(declaration.property);
-     }
-   }
-+  readSelectorVariants(tokens) {
-+    const variants = {
-+      rtl: null,
-+      theme: null,
-+      active: null,
-+      focus: null,
-+      disabled: null,
-+      dataAttributes: null
-+    };
-+    tokens.forEach((token) => {
-+      if (token.type === "pseudo-class" && token.kind === "where") {
-+        token.selectors.forEach((compound) => {
-+          compound.forEach((inner) => {
-+            if (inner.type === "class" && this.bundlerConfig.themes.includes(inner.name)) {
-+              variants.theme = inner.name;
-+            }
-+            if (inner.type === "pseudo-class" && inner.kind === "dir") {
-+              variants.rtl = inner.direction === "rtl";
-+            }
-+          });
-+        });
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "active") {
-+        variants.active = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "focus") {
-+        variants.focus = true;
-+      }
-+      if (token.type === "pseudo-class" && token.kind === "disabled") {
-+        variants.disabled = true;
-+      }
-+      if (token.type === "attribute" && token.operation === null && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"true"`;
-+      }
-+      if (token.type === "attribute" && token.operation?.operator === "equal" && token.name.startsWith("data-")) {
-+        variants.dataAttributes ??= {};
-+        variants.dataAttributes[token.name] = `"${token.operation.value}"`;
-+      }
-+    });
-+    const hasVariants = Object.values(variants).some(isDefined);
-+    return { variants, hasVariants };
-+  }
-+  withSelectorVariants(variants, run) {
-+    this.declarationConfig.rtl ??= variants.rtl;
-+    this.declarationConfig.theme ??= variants.theme;
-+    this.declarationConfig.active ??= variants.active;
-+    this.declarationConfig.focus ??= variants.focus;
-+    this.declarationConfig.disabled ??= variants.disabled;
-+    this.declarationConfig.dataAttributes ??= variants.dataAttributes;
-+    run();
-+    this.declarationConfig.rtl = null;
-+    this.declarationConfig.theme = null;
-+    this.declarationConfig.active = null;
-+    this.declarationConfig.focus = null;
-+    this.declarationConfig.disabled = null;
-+    this.declarationConfig.dataAttributes = null;
-+  }
-   parseRuleRec(rule) {
-     if (this.declarationConfig.className !== null) {
-       const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1);
-@@ -114,64 +172,30 @@ export class ProcessorBuilder {
-           this.declarationConfig.className = newClassName;
-           this.stylesheets[newClassName] ??= [];
-           this.stylesheets[newClassName].push({});
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          return;
--        }
--        let rtl = null;
--        let theme = null;
--        let active = null;
--        let focus = null;
--        let disabled = null;
--        let dataAttributes = null;
--        selector.forEach((selector2) => {
--          if (selector2.type === "pseudo-class" && selector2.kind === "where") {
--            selector2.selectors.forEach((selector3) => {
--              selector3.forEach((selector4) => {
--                if (selector4.type === "class" && this.bundlerConfig.themes.includes(selector4.name)) {
--                  theme = selector4.name;
--                }
--                if (selector4.type === "pseudo-class" && selector4.kind === "dir") {
--                  rtl = selector4.direction === "rtl";
--                }
--              });
--            });
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "active") {
--            active = true;
-+          const trailing = selector.slice(1);
-+          const { variants, hasVariants } = this.readSelectorVariants(trailing);
-+          if (trailing.length > 0 && !hasVariants) {
-+            return;
-           }
--          if (selector2.type === "pseudo-class" && selector2.kind === "focus") {
--            focus = true;
--          }
--          if (selector2.type === "pseudo-class" && selector2.kind === "disabled") {
--            disabled = true;
--          }
--          if (selector2.type === "attribute" && selector2.operation === null && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"true"`;
--          }
--          if (selector2.type === "attribute" && selector2.operation?.operator === "equal" && selector2.name.startsWith("data-")) {
--            dataAttributes ??= {};
--            dataAttributes[selector2.name] = `"${selector2.operation.value}"`;
-+          const parseClassRule = () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          };
-+          if (hasVariants) {
-+            this.withSelectorVariants(variants, parseClassRule);
-+          } else {
-+            parseClassRule();
-           }
--        });
--        if ([rtl, theme, active, focus, disabled, dataAttributes].some(isDefined)) {
--          this.declarationConfig.rtl ??= rtl;
--          this.declarationConfig.theme ??= theme;
--          this.declarationConfig.active ??= active;
--          this.declarationConfig.focus ??= focus;
--          this.declarationConfig.disabled ??= disabled;
--          this.declarationConfig.dataAttributes ??= dataAttributes;
--          rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
--          rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
--          rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
--          this.declarationConfig.rtl = null;
--          this.declarationConfig.theme = null;
--          this.declarationConfig.active = null;
--          this.declarationConfig.focus = null;
--          this.declarationConfig.disabled = null;
--          this.declarationConfig.dataAttributes = null;
-+          return;
-+        }
-+        const { variants, hasVariants } = this.readSelectorVariants(selector);
-+        if (hasVariants) {
-+          this.withSelectorVariants(variants, () => {
-+            rule.value.declarations?.declarations?.forEach((declaration) => this.addDeclaration(declaration));
-+            rule.value.declarations?.importantDeclarations?.forEach((declaration) => this.addDeclaration(declaration, true));
-+            rule.value.rules?.forEach((rule2) => this.parseRuleRec(rule2));
-+          });
-           return;
-         }
-         selector.forEach((selectorToken) => {
-@@ -191,11 +215,13 @@ export class ProcessorBuilder {
-     }
-     if (rule.type === "media") {
-       const { mediaQueries } = rule.value.query;
--      this.declarationConfig.mediaQueries.push(...mediaQueries);
-+      const outerConfig = this.declarationConfig;
-+      const blockMediaQueries = [...outerConfig.mediaQueries, ...mediaQueries];
-       rule.value.rules.forEach((rule2) => {
-+        this.declarationConfig = { ...outerConfig, mediaQueries: blockMediaQueries };
-         this.parseRuleRec(rule2);
--        this.declarationConfig = this.getDeclarationConfig();
-       });
-+      this.declarationConfig = outerConfig;
-       return;
-     }
-     if (rule.type === "layer-block") {
-diff --git a/src/bundler/adapters/metro/transformer.ts b/src/bundler/adapters/metro/transformer.ts
-index 08059b0..05c0515 100644
---- a/src/bundler/adapters/metro/transformer.ts
-+++ b/src/bundler/adapters/metro/transformer.ts
-@@ -5,6 +5,7 @@ import { Platform } from '@/common/consts'
- import type * as ExpoMetroConfig from '@expo/metro-config'
- import type * as MetroTransformWorker from 'metro-transform-worker'
- import type { JsTransformerConfig, JsTransformOptions } from 'metro-transform-worker'
-+import { createHash } from 'node:crypto'
- import path from 'path'
- 
- const cssArtifactPath = path.resolve(__dirname, '../../uniwind.css')
-@@ -69,13 +70,20 @@ export const transform = async (
-     await bundlerConfig.generateArtifacts(cssArtifactPath)
-     const virtualCode = await compileCSS(bundlerConfig)
-     const isWeb = bundlerConfig.platform === Platform.Web
-+    const nativeStylesFingerprint = isWeb
-+        ? undefined
-+        : createHash('sha256')
-+                .update(virtualCode)
-+                .update('\0')
-+                .update(bundlerConfig.stringifiedThemes)
-+                .digest('hex')
- 
-     data = Buffer.from(
-         isWeb
-             ? virtualCode
-             : [
-                 `const { Uniwind } = require('uniwind');`,
--                `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes});`,
-+                `Uniwind.__reinit(rt => ${virtualCode}, ${bundlerConfig.stringifiedThemes}, '${nativeStylesFingerprint}');`,
-             ].join(''),
-         'utf-8',
-     )
-diff --git a/src/bundler/css-processor/processor.ts b/src/bundler/css-processor/processor.ts
-index c8b3bb8..4af4199 100644
---- a/src/bundler/css-processor/processor.ts
-+++ b/src/bundler/css-processor/processor.ts
-@@ -123,6 +123,77 @@ export class ProcessorBuilder {
-         }
-     }
- 
-+    private readSelectorVariants(tokens: ReadonlyArray<any>) {
-+        const variants = {
-+            rtl: null as boolean | null,
-+            theme: null as string | null,
-+            active: null as boolean | null,
-+            focus: null as boolean | null,
-+            disabled: null as boolean | null,
-+            dataAttributes: null as Record<string, string> | null,
-+        }
-+
-+        tokens.forEach(token => {
-+            if (token.type === 'pseudo-class' && token.kind === 'where') {
-+                token.selectors.forEach((compound: Array<any>) => {
-+                    compound.forEach(inner => {
-+                        if (inner.type === 'class' && this.bundlerConfig.themes.includes(inner.name)) {
-+                            variants.theme = inner.name
-+                        }
-+
-+                        if (inner.type === 'pseudo-class' && inner.kind === 'dir') {
-+                            variants.rtl = inner.direction === 'rtl'
-+                        }
-+                    })
-+                })
-+            }
-+
-+            if (token.type === 'pseudo-class' && token.kind === 'active') {
-+                variants.active = true
-+            }
-+
-+            if (token.type === 'pseudo-class' && token.kind === 'focus') {
-+                variants.focus = true
-+            }
-+
-+            if (token.type === 'pseudo-class' && token.kind === 'disabled') {
-+                variants.disabled = true
-+            }
-+
-+            // data-x
-+            if (token.type === 'attribute' && token.operation === null && token.name.startsWith('data-')) {
-+                variants.dataAttributes ??= {}
-+                variants.dataAttributes[token.name] = `"true"`
-+            }
-+
-+            // data-x=
-+            if (token.type === 'attribute' && token.operation?.operator === 'equal' && token.name.startsWith('data-')) {
-+                variants.dataAttributes ??= {}
-+                variants.dataAttributes[token.name] = `"${token.operation.value}"`
-+            }
-+        })
-+
-+        return { variants, hasVariants: Object.values(variants).some(isDefined) }
-+    }
-+
-+    private withSelectorVariants(variants: ReturnType<ProcessorBuilder['readSelectorVariants']>['variants'], run: () => void) {
-+        this.declarationConfig.rtl ??= variants.rtl
-+        this.declarationConfig.theme ??= variants.theme
-+        this.declarationConfig.active ??= variants.active
-+        this.declarationConfig.focus ??= variants.focus
-+        this.declarationConfig.disabled ??= variants.disabled
-+        this.declarationConfig.dataAttributes ??= variants.dataAttributes
-+
-+        run()
-+
-+        this.declarationConfig.rtl = null
-+        this.declarationConfig.theme = null
-+        this.declarationConfig.active = null
-+        this.declarationConfig.focus = null
-+        this.declarationConfig.disabled = null
-+        this.declarationConfig.dataAttributes = null
-+    }
-+
-     private parseRuleRec(rule: Rule<Declaration, MediaQuery>) {
-         if (this.declarationConfig.className !== null) {
-             const lastStyle = this.stylesheets[this.declarationConfig.className]?.at(-1)
-@@ -142,78 +213,41 @@ export class ProcessorBuilder {
-                     this.stylesheets[newClassName] ??= []
-                     this.stylesheets[newClassName].push({})
- 
--                    rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration))
--                    rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true))
--                    rule.value.rules?.forEach(rule => this.parseRuleRec(rule))
-+                    // Tailwind >= 4.3.3 emits `.active\:x:active {}` instead of
-+                    // nesting `&:active` under the class, so the variant tokens
-+                    // sit right after the class token. A compound the runtime
-+                    // cannot express (e.g. `[aria-disabled="true"]`) used to be
-+                    // an empty nested rule and must not become unconditional.
-+                    const trailing = selector.slice(1)
-+                    const { variants, hasVariants } = this.readSelectorVariants(trailing)
- 
--                    return
--                }
--
--                let rtl = null as boolean | null
--                let theme = null as string | null
--                let active = null as boolean | null
--                let focus = null as boolean | null
--                let disabled = null as boolean | null
--                let dataAttributes = null as Record<string, string> | null
--
--                selector.forEach(selector => {
--                    if (selector.type === 'pseudo-class' && selector.kind === 'where') {
--                        selector.selectors.forEach(selector => {
--                            selector.forEach(selector => {
--                                if (selector.type === 'class' && this.bundlerConfig.themes.includes(selector.name)) {
--                                    theme = selector.name
--                                }
--
--                                if (selector.type === 'pseudo-class' && selector.kind === 'dir') {
--                                    rtl = selector.direction === 'rtl'
--                                }
--                            })
--                        })
-+                    if (trailing.length > 0 && !hasVariants) {
-+                        return
-                     }
- 
--                    if (selector.type === 'pseudo-class' && selector.kind === 'active') {
--                        active = true
--                    }
--
--                    if (selector.type === 'pseudo-class' && selector.kind === 'focus') {
--                        focus = true
-+                    const parseClassRule = () => {
-+                        rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration))
-+                        rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true))
-+                        rule.value.rules?.forEach(rule => this.parseRuleRec(rule))
-                     }
- 
--                    if (selector.type === 'pseudo-class' && selector.kind === 'disabled') {
--                        disabled = true
-+                    if (hasVariants) {
-+                        this.withSelectorVariants(variants, parseClassRule)
-+                    } else {
-+                        parseClassRule()
-                     }
- 
--                    // data-x
--                    if (selector.type === 'attribute' && selector.operation === null && selector.name.startsWith('data-')) {
--                        dataAttributes ??= {}
--                        dataAttributes[selector.name] = `"true"`
--                    }
-+                    return
-+                }
- 
--                    // data-x=
--                    if (selector.type === 'attribute' && selector.operation?.operator === 'equal' && selector.name.startsWith('data-')) {
--                        dataAttributes ??= {}
--                        dataAttributes[selector.name] = `"${selector.operation.value}"`
--                    }
--                })
-+                const { variants, hasVariants } = this.readSelectorVariants(selector)
- 
--                if ([rtl, theme, active, focus, disabled, dataAttributes].some(isDefined)) {
--                    this.declarationConfig.rtl ??= rtl
--                    this.declarationConfig.theme ??= theme
--                    this.declarationConfig.active ??= active
--                    this.declarationConfig.focus ??= focus
--                    this.declarationConfig.disabled ??= disabled
--                    this.declarationConfig.dataAttributes ??= dataAttributes
--
--                    rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration))
--                    rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true))
--                    rule.value.rules?.forEach(rule => this.parseRuleRec(rule))
--
--                    this.declarationConfig.rtl = null
--                    this.declarationConfig.theme = null
--                    this.declarationConfig.active = null
--                    this.declarationConfig.focus = null
--                    this.declarationConfig.disabled = null
--                    this.declarationConfig.dataAttributes = null
-+                if (hasVariants) {
-+                    this.withSelectorVariants(variants, () => {
-+                        rule.value.declarations?.declarations?.forEach(declaration => this.addDeclaration(declaration))
-+                        rule.value.declarations?.importantDeclarations?.forEach(declaration => this.addDeclaration(declaration, true))
-+                        rule.value.rules?.forEach(rule => this.parseRuleRec(rule))
-+                    })
- 
-                     return
-                 }
-@@ -241,13 +275,21 @@ export class ProcessorBuilder {
- 
-         if (rule.type === 'media') {
-             const { mediaQueries } = rule.value.query
-+            // Media queries have to outlive the reset between the block's sibling
-+            // rules: resetting only after each parse left every rule past the first
-+            // without the block's queries, shipping ios:/android: variants and later
-+            // utilities of a width breakpoint unguarded to every platform. Reset to
-+            // the outer config instead of a fresh one so media nested inside a class
-+            // rule keeps writing into that class.
-+            const outerConfig = this.declarationConfig
-+            const blockMediaQueries = [...outerConfig.mediaQueries, ...mediaQueries]
- 
--            this.declarationConfig.mediaQueries.push(...mediaQueries)
-             rule.value.rules.forEach(rule => {
-+                this.declarationConfig = { ...outerConfig, mediaQueries: blockMediaQueries }
-                 this.parseRuleRec(rule)
--                this.declarationConfig = this.getDeclarationConfig()
-             })
- 
-+            this.declarationConfig = outerConfig
-             return
-         }
- 
-diff --git a/src/core/config/config.native.ts b/src/core/config/config.native.ts
-index 5e0832b..01aed1b 100644
---- a/src/core/config/config.native.ts
-+++ b/src/core/config/config.native.ts
-@@ -8,6 +8,8 @@ import type { CSSVariables, GenerateStyleSheetsCallback, ThemeName } from '../ty
- import { UniwindConfigBuilder as UniwindConfigBuilderBase } from './config.common'
- 
- class UniwindConfigBuilder extends UniwindConfigBuilderBase {
-+    private stylesFingerprint: string | undefined
-+
-     constructor() {
-         super()
-     }
-@@ -35,9 +37,18 @@ class UniwindConfigBuilder extends UniwindConfigBuilderBase {
-         UniwindListener.notify([StyleDependency.Insets])
-     }
- 
--    protected __reinit(generateStyleSheetCallback: GenerateStyleSheetsCallback, themes: Array<string>) {
-+    protected __reinit(
-+        generateStyleSheetCallback: GenerateStyleSheetsCallback,
-+        themes: Array<string>,
-+        stylesFingerprint?: string,
-+    ) {
-+        if (__DEV__ && stylesFingerprint !== undefined && stylesFingerprint === this.stylesFingerprint) {
-+            return
-+        }
-+
-         super.__reinit(generateStyleSheetCallback, themes)
-         UniwindStore.reinit(generateStyleSheetCallback, themes)
-+        this.stylesFingerprint = stylesFingerprint
-     }
- 
-     protected onThemeChange() {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 498a5651906f..0332e38a7f06 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -115,7 +115,6 @@ patchedDependencies:
   react-native-nitro-markdown@0.5.8: 642b47830730acff3761fe29cf54271d18b493c0070c750097850b7ea032e00c
   react-native-nitro-modules@0.35.9: daf4a639ce3f951af630a3711e4082d58e3a11e5a79f45efb0b59925327ebde2
   react-native-screens@4.28.0: cc1301436ee62c39860acc9ee1a1e60b7d47e6abd211c42effa62c056d165483
-  uniwind@1.11.0: a91f3953483cfd434436de6358ff5b63c49974ef148fad91246c26ba95332625
 
 importers:
 
@@ -487,8 +486,8 @@ importers:
         specifier: ^3.5.0
         version: 3.6.0
       uniwind:
-        specifier: 1.11.0
-        version: 1.11.0(patch_hash=a91f3953483cfd434436de6358ff5b63c49974ef148fad91246c26ba95332625)(@expo/metro-config@58.0.6(patch_hash=90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760)(bufferutil@4.1.0)(expo@58.0.2)(typescript@7.0.2)(utf-8-validate@6.0.6))(metro-cache@0.87.1)(metro-transform-worker@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(metro@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0-rc.3(@babel/core@7.29.7)(@react-native/metro-config@0.88.0-rc.3(@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)(tailwindcss@4.3.3)
+        specifier: 1.12.1
+        version: 1.12.1(@expo/metro-config@58.0.6(patch_hash=90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760)(bufferutil@4.1.0)(expo@58.0.2)(typescript@7.0.2)(utf-8-validate@6.0.6))(metro-cache@0.87.1)(metro-transform-worker@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(metro@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0-rc.3(@babel/core@7.29.7)(@react-native/metro-config@0.88.0-rc.3(@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)(tailwindcss@4.3.3)
     devDependencies:
       '@effect/vitest':
         specifier: 4.0.0-rc.115
@@ -776,6 +775,9 @@ importers:
       tailwind-merge:
         specifier: ^3.4.0
         version: 3.6.0
+      unbash:
+        specifier: ^5.0.0
+        version: 5.0.0
       zustand:
         specifier: ^5.0.11
         version: 5.0.14(@types/react@19.3.0)(react@19.2.6)(use-sync-external-store@1.6.0(react@19.2.6))
@@ -10899,6 +10901,10 @@ packages:
     resolution: {integrity: sha512-FoSOKV7NEofQSkAefMVHam4ZPKYMxjAydxiV72UFEDNV/YofxjGfiZ2A9pZjdL/lRJzTjcu4PABo1JYJX8N5iQ==}
     engines: {node: '>=14'}
 
+  unbash@5.0.0:
+    resolution: {integrity: sha512-RYNm/ISFtflWpIcXTPHHLJZ0mqzInav+L9ke9PcL+hHsSf9+Fd/syPb614Mlqs/O3AYgjnvxDOFl0a+zVqi1/w==}
+    engines: {node: '>=14'}
+
   uncrypto@0.1.3:
     resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==}
 
@@ -10976,8 +10982,8 @@ packages:
     resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
     engines: {node: '>= 10.0.0'}
 
-  uniwind@1.11.0:
-    resolution: {integrity: sha512-e2mYlHrZzAQtZUf3STrfVDTetspv7p5vm/cu6p8kjLRQaL9r6QFG+MlwZ3hrI2LHnzgzjbSo+MwvoE380zz2JQ==}
+  uniwind@1.12.1:
+    resolution: {integrity: sha512-u0OVMVqefGchOpsPIwIYvcF2Jl9JtVVaXBb+wfqAYoyLrhN27Ll50aQ7aFT81k73JSq+He6dNlcbTl2Qb9cTMw==}
     hasBin: true
     peerDependencies:
       '@expo/metro-config': 58.0.6
@@ -22129,6 +22135,8 @@ snapshots:
 
   unbash@4.0.11: {}
 
+  unbash@5.0.0: {}
+
   uncrypto@0.1.3: {}
 
   undici-types@7.16.0: {}
@@ -22206,7 +22214,7 @@ snapshots:
 
   universalify@2.0.1: {}
 
-  uniwind@1.11.0(patch_hash=a91f3953483cfd434436de6358ff5b63c49974ef148fad91246c26ba95332625)(@expo/metro-config@58.0.6(patch_hash=90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760)(bufferutil@4.1.0)(expo@58.0.2)(typescript@7.0.2)(utf-8-validate@6.0.6))(metro-cache@0.87.1)(metro-transform-worker@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(metro@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0-rc.3(@babel/core@7.29.7)(@react-native/metro-config@0.88.0-rc.3(@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)(tailwindcss@4.3.3):
+  uniwind@1.12.1(@expo/metro-config@58.0.6(patch_hash=90fa980e8b6480631fb2fbb04559834e3c612db40c550cd828f11be297d8d760)(bufferutil@4.1.0)(expo@58.0.2)(typescript@7.0.2)(utf-8-validate@6.0.6))(metro-cache@0.87.1)(metro-transform-worker@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(metro@0.87.1(bufferutil@4.1.0)(utf-8-validate@6.0.6))(react-native@0.88.0-rc.3(@babel/core@7.29.7)(@react-native/metro-config@0.88.0-rc.3(@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)(tailwindcss@4.3.3):
     dependencies:
       '@tailwindcss/node': 4.3.3
       '@tailwindcss/oxide': 4.3.3
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 5bd65fcacbbb..11f052624a48 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -125,6 +125,7 @@ minimumReleaseAgeExclude:
   - "@distilled.cloud/stripe@1.0.0-rc.12"
   - "@shadcn/lint@0.1.5"
   - cn@0.3.2
+  - uniwind@1.12.1
   - "@expo/dom-webview@58.0.2"
   - "expo-auth-session@58.0.7"
   - "expo-camera@58.0.7"
@@ -263,7 +264,6 @@ patchedDependencies:
   react-native-keyboard-controller@1.22.6: patches/react-native-keyboard-controller@1.22.6.patch
   react-native-nitro-modules@0.35.9: patches/react-native-nitro-modules@0.35.9.patch
   react-native-screens@4.28.0: patches/react-native-screens@4.28.0.patch
-  uniwind@1.11.0: patches/uniwind@1.11.0.patch
 
 peerDependencyRules:
   allowAny:
diff --git a/scripts/cloud/verify-box-reconnect.ts b/scripts/cloud/verify-box-reconnect.ts
index 9dc63ea654da..e4c1329acd62 100644
--- a/scripts/cloud/verify-box-reconnect.ts
+++ b/scripts/cloud/verify-box-reconnect.ts
@@ -74,6 +74,7 @@ import {
   removeConnectionFromCatalog,
   replaceCatalogValue,
   setConnectionEnabledInCatalog,
+  setRoutesInCatalog,
 } from "@t3tools/client-runtime/platform";
 import { ManagedRelay } from "@t3tools/client-runtime/relay";
 import { request, remoteHttpClientLayer, subscribe } from "@t3tools/client-runtime/rpc";
@@ -299,9 +300,12 @@ const memoryStorageLayer = Layer.effectContext(
       listDisabled: Effect.map(read, (document) => document.disabledEnvironmentIds),
     });
     const registrations = Persistence.ConnectionRegistrationStore.of({
-      register: (registration) =>
-        update((document) => registerConnectionInCatalog(document, registration)),
-      remove: (target) => update((document) => removeConnectionFromCatalog(document, target)),
+      register: (registration, routes) =>
+        update((document) => registerConnectionInCatalog(document, registration, routes)),
+      setRoutes: (environmentId, routes) =>
+        update((document) => setRoutesInCatalog(document, environmentId, routes)),
+      remove: (environmentId) =>
+        update((document) => removeConnectionFromCatalog(document, environmentId)),
       setEnabled: (environmentId, enabled) =>
         update((document) => setConnectionEnabledInCatalog(document, environmentId, enabled)),
     });
diff --git a/scripts/notify-discord-release.test.ts b/scripts/notify-discord-release.test.ts
index dba0c6cd5dac..21588b718ecc 100644
--- a/scripts/notify-discord-release.test.ts
+++ b/scripts/notify-discord-release.test.ts
@@ -1,9 +1,25 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, it } from "@effect/vitest";
+import * as Cause from "effect/Cause";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
-import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http";
+import * as Logger from "effect/Logger";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as TestClock from "effect/testing/TestClock";
+import { Command } from "effect/unstable/cli";
+import { HttpClient, HttpClientError, HttpClientResponse, UrlParams } from "effect/unstable/http";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
-import { buildDiscordReleaseAnnouncement, postDiscordWebhook } from "./notify-discord-release.ts";
+import {
+  buildDiscordReleaseAnnouncement,
+  notifyDiscordReleaseCommand,
+  postDiscordWebhook,
+} from "./notify-discord-release.ts";
 
 const latestAnnouncement = {
   target: "latest",
@@ -11,158 +27,619 @@ const latestAnnouncement = {
   releaseName: "T3 Code v1.2.3",
   version: "1.2.3",
   tag: "v1.2.3",
-  releaseUrl: new URL("https://github.com/t3dotgg/t3-code/releases/tag/v1.2.3"),
+  releaseUrl: new URL("https://github.com/pingdotgg/t3code/releases/tag/v1.2.3"),
   timestamp: "2026-05-01T01:41:00.000Z",
 } as const;
+const nightlyAnnouncement = { ...latestAnnouncement, target: "prerelease" } as const;
+// Deliberately fake. All HTTP requests below use an injected client.
+const webhookUrl = new URL("https://discord.com/api/webhooks/123456/test-secret-token");
+const intro = "A new T3 Code prerelease is available for nightly testers.";
+const notes = `## What's Changed\n* Fix remote reconnection by @contributor in https://github.com/pingdotgg/t3code/pull/10\n* Improve thread search in https://github.com/pingdotgg/t3code/pull/11\n\n**Full Changelog**: https://github.com/pingdotgg/t3code/compare/v1.2.2...v1.2.3`;
+const formattedNotes = `## What's Changed\n* [Fix remote reconnection](https://github.com/pingdotgg/t3code/pull/10) by [@contributor](https://github.com/contributor)\n* [Improve thread search](https://github.com/pingdotgg/t3code/pull/11)\n\n[Full Changelog](https://github.com/pingdotgg/t3code/compare/v1.2.2...v1.2.3)`;
+const runCli = Command.runWith(notifyDiscordReleaseCommand, { version: "0.0.0" });
+const cliArgs = (target: "latest" | "prerelease") => [
+  target,
+  "--role-id",
+  latestAnnouncement.roleId,
+  "--release-name",
+  latestAnnouncement.releaseName,
+  "--release-version",
+  latestAnnouncement.version,
+  "--tag",
+  latestAnnouncement.tag,
+  "--release-url",
+  latestAnnouncement.releaseUrl.href,
+];
+const configLayer = ConfigProvider.layer(
+  ConfigProvider.fromEnv({ env: { DISCORD_WEBHOOK_URL: webhookUrl.href } }),
+);
+const PayloadSchema = Schema.fromJsonString(
+  Schema.Struct({
+    content: Schema.String,
+    allowed_mentions: Schema.Struct({
+      parse: Schema.Array(Schema.String),
+      roles: Schema.Array(Schema.String),
+    }),
+    embeds: Schema.Array(
+      Schema.Struct({ title: Schema.String, description: Schema.String, url: Schema.String }),
+    ),
+  }),
+);
+const decodePayload = Schema.decodeUnknownSync(PayloadSchema);
+const payloadDescription = (payloads: ReturnType<typeof buildDiscordReleaseAnnouncement>) =>
+  payloads.flatMap((payload) => payload.embeds.map((embed) => embed.description)).join("");
+const captureClient = (requests: string[], status = 204) =>
+  Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) => {
+      assert.deepStrictEqual(UrlParams.getAll(request.urlParams, "wait"), ["true"]);
+      assert.equal(request.body._tag, "Uint8Array");
+      if (request.body._tag !== "Uint8Array") return Effect.die("Expected JSON request body");
+      requests.push(new TextDecoder().decode(request.body.body));
+      return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status })));
+    }),
+  );
 
-const webhookUrl = new URL("https://discord.com/api/webhooks/123456/secret-token");
+function assertDiscordLimits(payloads: ReturnType<typeof buildDiscordReleaseAnnouncement>) {
+  for (const payload of payloads) {
+    assert.ok(payload.content.length <= 2000);
+    assert.equal(payload.embeds.length, 1);
+    let total = 0;
+    for (const embed of payload.embeds) {
+      assert.ok(embed.title.length <= 256);
+      assert.ok(embed.description.length <= 4096);
+      assert.ok(embed.footer.text.length <= 2048);
+      total += embed.title.length + embed.description.length + embed.footer.text.length;
+    }
+    assert.ok(total <= 6000);
+  }
+}
 
-it("builds a prerelease Discord announcement for nightly subscribers", () => {
-  assert.deepStrictEqual(
-    buildDiscordReleaseAnnouncement({
-      target: "prerelease",
-      roleId: "111111111111111111",
-      releaseName: "T3 Code Nightly 1.2.4-nightly.20260501.17 (abcdef123456)",
-      version: "1.2.4-nightly.20260501.17",
-      tag: "v1.2.4-nightly.20260501.17",
-      releaseUrl: new URL(
-        "https://github.com/t3dotgg/t3-code/releases/tag/v1.2.4-nightly.20260501.17",
-      ),
-      timestamp: "2026-05-01T01:41:00.000Z",
-    }),
+it("includes nightly changes in order with their links and existing metadata", () => {
+  const payloads = buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes: notes });
+  assert.deepStrictEqual(payloads, [
     {
-      content:
-        "<@&111111111111111111> Prerelease published: T3 Code Nightly 1.2.4-nightly.20260501.17 (abcdef123456)",
-      allowed_mentions: {
-        roles: ["111111111111111111"],
-      },
+      content: "-# <@&222222222222222222>",
+      allowed_mentions: { parse: [], roles: [latestAnnouncement.roleId] },
       embeds: [
         {
-          title: "T3 Code Nightly 1.2.4-nightly.20260501.17 (abcdef123456)",
-          url: "https://github.com/t3dotgg/t3-code/releases/tag/v1.2.4-nightly.20260501.17",
-          description: "A new T3 Code prerelease is available for nightly testers.",
+          title: latestAnnouncement.releaseName,
+          url: latestAnnouncement.releaseUrl.href,
+          description: `${intro}\n\n${formattedNotes}`,
           color: 0x5865f2,
-          fields: [
-            {
-              name: "Version",
-              value: "1.2.4-nightly.20260501.17",
-              inline: true,
-            },
-            {
-              name: "Tag",
-              value: "v1.2.4-nightly.20260501.17",
-              inline: true,
-            },
-          ],
-          timestamp: "2026-05-01T01:41:00.000Z",
+          footer: { text: "v1.2.3" },
+          timestamp: latestAnnouncement.timestamp,
         },
       ],
     },
-  );
+  ]);
+  assertDiscordLimits(payloads);
 });
 
-it("builds a latest Discord announcement for stable subscribers", () => {
-  assert.deepStrictEqual(buildDiscordReleaseAnnouncement(latestAnnouncement), {
-    content: "<@&222222222222222222> Latest published: T3 Code v1.2.3",
-    allowed_mentions: {
-      roles: ["222222222222222222"],
-    },
-    embeds: [
+it("keeps stable announcements short even when a long changelog is provided", () => {
+  assert.deepStrictEqual(
+    buildDiscordReleaseAnnouncement({ ...latestAnnouncement, releaseNotes: notes.repeat(200) }),
+    [
       {
-        title: "T3 Code v1.2.3",
-        url: "https://github.com/t3dotgg/t3-code/releases/tag/v1.2.3",
-        description: "A new T3 Code latest release is available.",
-        color: 0x2ecc71,
-        fields: [
-          {
-            name: "Version",
-            value: "1.2.3",
-            inline: true,
-          },
+        content: "-# <@&222222222222222222>",
+        allowed_mentions: { parse: [], roles: [latestAnnouncement.roleId] },
+        embeds: [
           {
-            name: "Tag",
-            value: "v1.2.3",
-            inline: true,
+            title: latestAnnouncement.releaseName,
+            url: latestAnnouncement.releaseUrl.href,
+            description: `[View full release notes on GitHub](${latestAnnouncement.releaseUrl.href})`,
+            color: 0x2ecc71,
+            footer: { text: "v1.2.3" },
+            timestamp: latestAnnouncement.timestamp,
           },
         ],
-        timestamp: "2026-05-01T01:41:00.000Z",
       },
     ],
+  );
+});
+
+it("links contributor profiles and escapes brackets in change titles and bot handles", () => {
+  const releaseNotes =
+    "* Fix [web] links by @octo-user in https://github.com/pingdotgg/t3code/pull/12\n* Bump dependencies by @dependabot[bot] in https://github.com/pingdotgg/t3code/pull/13";
+  const payloads = buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes });
+  assert.equal(
+    payloadDescription(payloads),
+    `${intro}\n\n* [Fix \\[web\\] links](https://github.com/pingdotgg/t3code/pull/12) by [@octo-user](https://github.com/octo-user)\n* [Bump dependencies](https://github.com/pingdotgg/t3code/pull/13) by [@dependabot\\[bot\\]](https://github.com/apps/dependabot)`,
+  );
+});
+
+it("preserves custom notes and links outside generated GitHub pull request entries", () => {
+  const releaseNotes =
+    "## Migration\n* Written by @someone in the docs\n* Commit https://github.com/pingdotgg/t3code/commit/abc123\n[Guide](https://example.com/guide)";
+  assert.equal(
+    payloadDescription(buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes })),
+    `${intro}\n\n${releaseNotes}`,
+  );
+});
+
+it("links the Full Changelog label instead of displaying the comparison URL", () => {
+  const url = "https://github.com/pingdotgg/t3code/compare/previous...next";
+  const releaseNotes = `**Full Changelog**: ${url}\nFull Changelog: ${url}`;
+  const description = payloadDescription(
+    buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes }),
+  );
+  assert.equal(description, `${intro}\n\n[Full Changelog](${url})\n[Full Changelog](${url})`);
+});
+
+it("keeps inline change attribution whole at a message boundary", () => {
+  const title = "* [Fix reconnection](https://github.com/pingdotgg/t3code/pull/10)";
+  const contributor = "[@contributor](https://github.com/contributor)";
+  const filler = "x".repeat(4096 - intro.length - 2 - title.length - 2);
+  const releaseNotes = `${filler}\n* Fix reconnection by @contributor in https://github.com/pingdotgg/t3code/pull/10`;
+  const payloads = buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes });
+  assert.equal(payloads.length, 2);
+  assert.equal(payloads[1]?.embeds[0]?.description, `${title} by ${contributor}`);
+  assert.equal(payloadDescription(payloads), `${intro}\n\n${filler}\n${title} by ${contributor}`);
+  assertDiscordLimits(payloads);
+});
+
+it("falls back when notes are missing, empty, or whitespace", () => {
+  const fallback = buildDiscordReleaseAnnouncement(nightlyAnnouncement);
+  assert.equal(payloadDescription(fallback), intro);
+  assert.deepStrictEqual(
+    buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes: "" }),
+    fallback,
+  );
+  assert.deepStrictEqual(
+    buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes: " \r\n\t" }),
+    fallback,
+  );
+});
+
+it("splits long notes at line boundaries without dropping changes or the comparison link", () => {
+  const longNotes =
+    Array.from(
+      { length: 150 },
+      (_, i) => `* Change ${i} in https://github.com/pingdotgg/t3code/pull/${i}\n`,
+    ).join("") + notes;
+  const payloads = buildDiscordReleaseAnnouncement({
+    ...nightlyAnnouncement,
+    releaseNotes: longNotes,
   });
+  assert.ok(payloads.length > 2);
+  const formattedChanges = Array.from(
+    { length: 150 },
+    (_, i) => `* [Change ${i}](https://github.com/pingdotgg/t3code/pull/${i})\n`,
+  ).join("");
+  assert.equal(payloadDescription(payloads), `${intro}\n\n${formattedChanges}${formattedNotes}`);
+  assertDiscordLimits(payloads);
+  for (const [index, payload] of payloads.entries()) {
+    assert.deepStrictEqual(payload.allowed_mentions, {
+      parse: [],
+      roles: index === 0 ? [latestAnnouncement.roleId] : [],
+    });
+    if (index > 0) {
+      assert.equal(payload.content, "");
+      assert.equal(
+        payload.embeds[0]?.title,
+        `Changelog continued (${index + 1}/${payloads.length})`,
+      );
+    }
+    if (index < payloads.length - 1) assert.ok(payload.embeds[0]?.description.endsWith("\n"));
+    assert.equal(payload.embeds[0]?.url, nightlyAnnouncement.releaseUrl.href);
+  }
 });
 
-it.effect("preserves webhook request context and the full client cause chain", () => {
-  const payload = buildDiscordReleaseAnnouncement(latestAnnouncement);
-  const requestCause = new Error("request encoder unavailable");
-  let clientError: HttpClientError.HttpClientError | undefined;
-  const httpClientLayer = Layer.succeed(
-    HttpClient.HttpClient,
-    HttpClient.make((request) => {
-      clientError = new HttpClientError.HttpClientError({
-        reason: new HttpClientError.EncodeError({
-          request,
-          cause: requestCause,
-        }),
-      });
-      return Effect.fail(clientError);
-    }),
+it("honors the aggregate embed limit when metadata is also large", () => {
+  const releaseNotes = "a".repeat(16000);
+  const payloads = buildDiscordReleaseAnnouncement({
+    ...nightlyAnnouncement,
+    releaseName: "n".repeat(256),
+    version: "x".repeat(2047),
+    releaseNotes,
+  });
+  assertDiscordLimits(payloads);
+  assert.equal(payloadDescription(payloads), `${intro}\n\n${releaseNotes}`);
+});
+
+it("handles oversized lines, words, and Unicode without losing or breaking characters", () => {
+  const longNotes =
+    "a".repeat(9000) + "\n" + "🦋".repeat(4500) + "\n" + "word ".repeat(2000).trim();
+  const payloads = buildDiscordReleaseAnnouncement({
+    ...nightlyAnnouncement,
+    releaseNotes: longNotes,
+  });
+  assertDiscordLimits(payloads);
+  assert.equal(payloadDescription(payloads), `${intro}\n\n${longNotes}`);
+  for (const payload of payloads) assert.ok(payload.embeds[0]?.description.isWellFormed());
+});
+
+it("accepts exactly 4096 description characters and splits the next character", () => {
+  const releaseNotes = "x".repeat(4096 - intro.length - 2);
+  assert.equal(buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseNotes }).length, 1);
+  const longer = buildDiscordReleaseAnnouncement({
+    ...nightlyAnnouncement,
+    releaseNotes: releaseNotes + "x",
+  });
+  assert.equal(longer.length, 2);
+  assert.equal(payloadDescription(longer), `${intro}\n\n${releaseNotes}x`);
+  assertDiscordLimits(longer);
+});
+
+it("suppresses everyone, here, user, and role mentions on every message", () => {
+  const mentions = `@everyone @here <@123> <@!123> <@&456> <@&${nightlyAnnouncement.roleId}>`;
+  const inert = mentions.replaceAll("@", "@\u200b");
+  const payloads = buildDiscordReleaseAnnouncement({
+    ...nightlyAnnouncement,
+    releaseName: mentions,
+    releaseNotes: `${mentions}\n`.repeat(100) + notes,
+  });
+  assert.ok(payloads.length > 1);
+  assert.equal(
+    payloadDescription(payloads),
+    `${intro}\n\n${`${inert}\n`.repeat(100)}${formattedNotes}`,
   );
+  for (const [index, payload] of payloads.entries()) {
+    assert.deepStrictEqual(payload.allowed_mentions, {
+      parse: [],
+      roles: index === 0 ? [latestAnnouncement.roleId] : [],
+    });
+    if (index === 0) assert.equal(payload.embeds[0]?.title, inert);
+    assert.ok(!payload.content.includes("@everyone"));
+    assert.ok(!payload.content.includes("@here"));
+    assert.equal(payload.content.match(/<@&\d+>/g)?.length ?? 0, index === 0 ? 1 : 0);
+  }
+});
 
-  return Effect.gen(function* () {
+it("rejects invalid metadata before sending", () => {
+  assert.throws(
+    () => buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, releaseName: "x".repeat(257) }),
+    /title exceeds/,
+  );
+  assert.throws(
+    () => buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, version: "x".repeat(2048) }),
+    /footer exceeds/,
+  );
+  assert.throws(
+    () => buildDiscordReleaseAnnouncement({ ...nightlyAnnouncement, roleId: "123> @everyone" }),
+    /Invalid Discord release role/,
+  );
+});
+
+it.effect("retains safe request context without leaking the webhook URL or nested cause", () =>
+  Effect.gen(function* () {
+    const payload = buildDiscordReleaseAnnouncement(latestAnnouncement)[0]!;
+    const logs: string[] = [];
+    const client = Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make((request) =>
+        Effect.fail(
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.EncodeError({
+              request,
+              cause: new Error(`Encoder failed for ${webhookUrl.href}`),
+            }),
+          }),
+        ),
+      ),
+    );
     const error = yield* postDiscordWebhook(webhookUrl, payload, latestAnnouncement).pipe(
-      Effect.provide(httpClientLayer),
+      Effect.tapCause(Effect.logError),
+      Effect.provide([
+        client,
+        Logger.layer([
+          Logger.make((options) => {
+            logs.push(Logger.formatJson.log(options));
+          }),
+        ]),
+      ]),
       Effect.flip,
     );
-
-    if (error._tag !== "DiscordReleaseWebhookRequestError") {
+    if (error._tag !== "DiscordReleaseWebhookRequestError")
       assert.fail(`Unexpected error: ${error._tag}`);
-    }
+    assert.equal(error.reason, "EncodeError");
     assert.equal(error.target, "latest");
-    assert.equal(error.releaseName, latestAnnouncement.releaseName);
-    assert.equal(error.version, latestAnnouncement.version);
     assert.equal(error.tag, latestAnnouncement.tag);
-    assert.equal(error.releaseUrl, latestAnnouncement.releaseUrl.href);
     assert.equal(error.webhookOrigin, webhookUrl.origin);
     assert.equal(error.webhookPathnameSegmentCount, 4);
     assert.equal(error.contentLength, payload.content.length);
-    assert.equal(error.embedCount, 1);
     assert.equal(error.allowedRoleMentionCount, 1);
-    assert.equal(error.hasRoleMentionSyntax, true);
-    assert.equal(error.cause, clientError);
-    assert.equal((error.cause as HttpClientError.HttpClientError).cause, requestCause);
-    assert.ok(!error.message.includes(requestCause.message));
-  });
-});
+    assert.ok(!Cause.pretty(Cause.fail(error)).includes("test-secret-token"));
+    assert.ok(!logs.join("\n").includes("test-secret-token"));
+  }),
+);
 
-it.effect("preserves a non-success response error with structured status context", () => {
-  const payload = buildDiscordReleaseAnnouncement(latestAnnouncement);
-  const httpClientLayer = Layer.succeed(
-    HttpClient.HttpClient,
-    HttpClient.make((request) =>
-      Effect.succeed(
-        HttpClientResponse.fromWeb(request, new Response("invalid webhook", { status: 400 })),
+it.effect(
+  "retains response status without retaining the secret-bearing request or response body",
+  () =>
+    Effect.gen(function* () {
+      const client = Layer.succeed(
+        HttpClient.HttpClient,
+        HttpClient.make((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(request, new Response(webhookUrl.href, { status: 400 })),
+          ),
+        ),
+      );
+      const error = yield* postDiscordWebhook(
+        webhookUrl,
+        buildDiscordReleaseAnnouncement(latestAnnouncement)[0]!,
+        latestAnnouncement,
+      ).pipe(Effect.provide(client), Effect.flip);
+      if (error._tag !== "DiscordReleaseWebhookResponseError")
+        assert.fail(`Unexpected error: ${error._tag}`);
+      assert.equal(error.status, 400);
+      assert.equal(error.tag, latestAnnouncement.tag);
+      assert.ok(!Cause.pretty(Cause.fail(error)).includes("test-secret-token"));
+    }),
+);
+
+it.effect("waits for Retry-After before retrying a rate-limited message", () =>
+  Effect.gen(function* () {
+    const limited = yield* Deferred.make<void>();
+    let attempts = 0;
+    const client = Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make((request) =>
+        Effect.gen(function* () {
+          attempts += 1;
+          if (attempts === 1) {
+            yield* Deferred.succeed(limited, undefined);
+            return HttpClientResponse.fromWeb(
+              request,
+              new Response(null, { status: 429, headers: { "retry-after": "2" } }),
+            );
+          }
+          return HttpClientResponse.fromWeb(request, new Response(null, { status: 204 }));
+        }),
       ),
-    ),
-  );
+    );
+    const fiber = yield* postDiscordWebhook(
+      webhookUrl,
+      buildDiscordReleaseAnnouncement(latestAnnouncement)[0]!,
+      latestAnnouncement,
+    ).pipe(Effect.provide(client), Effect.forkChild);
+    yield* Deferred.await(limited);
+    yield* TestClock.adjust("1 second");
+    assert.equal(attempts, 1);
+    yield* TestClock.adjust("1 second");
+    yield* Fiber.join(fiber);
+    assert.equal(attempts, 2);
+  }),
+);
 
-  return Effect.gen(function* () {
-    const error = yield* postDiscordWebhook(webhookUrl, payload, latestAnnouncement).pipe(
-      Effect.provide(httpClientLayer),
-      Effect.flip,
+it.effect("bounds total retry time while preserving delays within the deadline", () =>
+  Effect.gen(function* () {
+    const limited = yield* Deferred.make<void>();
+    let attempts = 0;
+    const client = Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make((request) =>
+        Effect.gen(function* () {
+          attempts += 1;
+          yield* Deferred.succeed(limited, undefined);
+          return HttpClientResponse.fromWeb(
+            request,
+            new Response(null, { status: 429, headers: { "retry-after": "40" } }),
+          );
+        }),
+      ),
     );
+    const fiber = yield* postDiscordWebhook(
+      webhookUrl,
+      buildDiscordReleaseAnnouncement(latestAnnouncement)[0]!,
+      latestAnnouncement,
+    ).pipe(Effect.provide(client), Effect.result, Effect.forkChild);
+    yield* Deferred.await(limited);
+    yield* TestClock.adjust("39 seconds");
+    assert.equal(attempts, 1);
+    yield* TestClock.adjust("1 second");
+    assert.equal(attempts, 2);
+    yield* TestClock.adjust("20 seconds");
+    const result = yield* Fiber.join(fiber);
+    assert.equal(attempts, 2);
+    assert.equal(result._tag, "Failure");
+    if (result._tag !== "Failure") assert.fail("Expected the retry deadline to expire");
+    assert.equal(result.failure._tag, "DiscordReleaseWebhookRequestError");
+    if (result.failure._tag !== "DiscordReleaseWebhookRequestError")
+      assert.fail(`Unexpected error: ${result.failure._tag}`);
+    assert.equal(result.failure.reason, "TimeoutError");
+    assert.ok(!Cause.pretty(Cause.fail(result.failure)).includes("test-secret-token"));
+  }),
+);
 
-    if (error._tag !== "DiscordReleaseWebhookResponseError") {
-      assert.fail(`Unexpected error: ${error._tag}`);
-    }
-    assert.equal(error.target, "latest");
-    assert.equal(error.tag, latestAnnouncement.tag);
-    assert.equal(error.webhookOrigin, webhookUrl.origin);
-    assert.equal(error.webhookPathnameSegmentCount, 4);
-    assert.equal(error.status, 400);
-    if (!HttpClientError.isHttpClientError(error.cause)) {
-      assert.fail("Expected HttpClientError cause");
-    }
-    assert.equal(error.cause.reason._tag, "StatusCodeError");
-    assert.ok(!error.message.includes(error.cause.message));
-  });
+// Run the checked-in shell commands with gh/node stubs, then send their captured
+// arguments through the real CLI parser and an injected HTTP client.
+function workflowRun(workflow: string, stepName: string) {
+  const step = workflow.split(`      - name: ${stepName}\n`)[1]?.split("\n      - name:")[0];
+  assert.ok(step, `Missing workflow step: ${stepName}`);
+  const run = step.split("        run: |\n")[1];
+  assert.ok(run, `Missing run block: ${stepName}`);
+  return run
+    .split("\n")
+    .map((line) => line.replace(/^          /, ""))
+    .join("\n");
+}
+
+it.layer(NodeServices.layer)("Discord release CLI and workflow", (it) => {
+  it.effect("passes the published nightly body from the workflow to ordered sends", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+      const temp = yield* fs.makeTempDirectoryScoped({ prefix: "discord release " });
+      const workflow = yield* fs.readFileString(
+        yield* path.fromFileUrl(new URL("../.github/workflows/release.yml", import.meta.url)),
+      );
+      const publishedNotes =
+        Array.from({ length: 50 }, () => notes).join("\n\n") +
+        '\n* Literal $(touch "$RUNNER_TEMP/executed") and `touch "$RUNNER_TEMP/executed"`';
+      const read = workflowRun(workflow, "Read published release notes");
+      const shellEnv = {
+        RUNNER_TEMP: temp,
+        RELEASE_TAG: nightlyAnnouncement.tag,
+        RELEASE_CHANNEL: "nightly",
+        FIXTURE_NOTES: publishedNotes,
+      };
+      const readStatus = yield* spawner.exitCode(
+        ChildProcess.make(
+          "bash",
+          [
+            "-e",
+            "-c",
+            `gh() { [ "$*" = 'release view v1.2.3 --json body --jq .body // ""' ] || return 1; printf '%s' "$FIXTURE_NOTES"; }\n${read}`,
+          ],
+          { env: shellEnv },
+        ),
+      );
+      assert.equal(readStatus, 0);
+      assert.equal(yield* fs.readFileString(`${temp}/discord-release-notes.md`), publishedNotes);
+      const replacements: Record<string, string> = {
+        "needs.preflight.outputs.release_name": latestAnnouncement.releaseName,
+        "needs.preflight.outputs.version": latestAnnouncement.version,
+        "needs.preflight.outputs.tag": latestAnnouncement.tag,
+        "github.repository": "pingdotgg/t3code",
+      };
+      const announce = workflowRun(workflow, "Announce prerelease on Discord").replace(
+        /\$\{\{ (.*?) \}\}/g,
+        (_, key: string) => {
+          assert.ok(replacements[key], `Unexpected expression: ${key}`);
+          return replacements[key]!;
+        },
+      );
+      const announceStatus = yield* spawner.exitCode(
+        ChildProcess.make(
+          "bash",
+          ["-e", "-c", `node() { printf '%s\\0' "$@" > "$RUNNER_TEMP/args"; }\n${announce}`],
+          { env: { RUNNER_TEMP: temp, DISCORD_MENTION_ROLE_ID: latestAnnouncement.roleId } },
+        ),
+      );
+      assert.equal(announceStatus, 0);
+      const args = (yield* fs.readFileString(`${temp}/args`)).split("\0").slice(1, -1);
+      const requests: string[] = [];
+      yield* runCli(args).pipe(Effect.provide([configLayer, captureClient(requests)]));
+      const payloads = requests.map((request) => decodePayload(request));
+      assert.ok(payloads.length > 2);
+      assert.equal(
+        payloads.flatMap((payload) => payload.embeds.map((embed) => embed.description)).join(""),
+        `${intro}\n\n${Array.from({ length: 50 }, () => formattedNotes).join("\n\n")}\n* Literal $(touch "$RUNNER_TEMP/executed") and \`touch "$RUNNER_TEMP/executed"\``,
+      );
+      for (const [index, payload] of payloads.entries())
+        assert.deepStrictEqual(payload.allowed_mentions, {
+          parse: [],
+          roles: index === 0 ? [latestAnnouncement.roleId] : [],
+        });
+      assert.equal(yield* fs.exists(`${temp}/executed`), false);
+      assert.equal(
+        yield* spawner.exitCode(
+          ChildProcess.make("bash", ["-e", "-c", `gh() { return 99; }\n${read}`], {
+            env: { ...shellEnv, RELEASE_CHANNEL: "stable" },
+          }),
+        ),
+        0,
+      );
+      assert.equal(yield* fs.readFileString(`${temp}/discord-release-notes.md`), "");
+      assert.equal(
+        yield* spawner.exitCode(
+          ChildProcess.make(
+            "bash",
+            ["-e", "-c", `gh() { printf '%s' 'partial changelog'; return 42; }\n${read}`],
+            { env: shellEnv },
+          ),
+        ),
+        0,
+      );
+      assert.equal(yield* fs.readFileString(`${temp}/discord-release-notes.md`), "");
+      const fallbackRequests: string[] = [];
+      yield* runCli(args).pipe(Effect.provide([configLayer, captureClient(fallbackRequests)]));
+      assert.equal(fallbackRequests.length, 1);
+      const fallback = decodePayload(fallbackRequests[0]!);
+      assert.equal(fallback.embeds[0]?.description, intro);
+      assert.equal(fallback.content, `-# <@&${latestAnnouncement.roleId}>`);
+      assert.deepStrictEqual(fallback.allowed_mentions, {
+        parse: [],
+        roles: [latestAnnouncement.roleId],
+      });
+      assert.ok(
+        workflow
+          .split("      - name: Announce prerelease on Discord\n")[1]
+          ?.startsWith("        if: needs.preflight.outputs.is_prerelease == 'true'\n"),
+      );
+      assert.ok(workflow.includes("GH_REPO: ${{ github.repository }}"));
+      assert.ok(workflow.includes("RELEASE_TAG: ${{ needs.preflight.outputs.tag }}"));
+      assert.ok(
+        !workflowRun(workflow, "Announce latest release on Discord").includes(
+          "--release-notes-file",
+        ),
+      );
+      assert.ok(
+        workflow
+          .slice(workflow.indexOf("  announce_discord:"))
+          .includes("needs.preflight.outputs.release_channel != 'preview'"),
+      );
+    }),
+  );
+
+  it.effect("uses the fallback when notes are omitted and ignores a notes file for latest", () =>
+    Effect.gen(function* () {
+      const requests: string[] = [];
+      yield* runCli(cliArgs("prerelease")).pipe(
+        Effect.provide([configLayer, captureClient(requests)]),
+      );
+      assert.equal(decodePayload(requests[0]!).embeds[0]?.description, intro);
+      yield* runCli([
+        ...cliArgs("latest"),
+        "--release-notes-file",
+        "/missing-stable-notes.md",
+      ]).pipe(Effect.provide([configLayer, captureClient(requests)]));
+      assert.equal(requests.length, 2);
+      assert.equal(
+        decodePayload(requests[1]!).embeds[0]?.description,
+        `[View full release notes on GitHub](${latestAnnouncement.releaseUrl.href})`,
+      );
+    }),
+  );
+
+  it.effect("fails before sending when the requested nightly notes file cannot be read", () =>
+    Effect.gen(function* () {
+      const requests: string[] = [];
+      const result = yield* runCli([
+        ...cliArgs("prerelease"),
+        "--release-notes-file",
+        "/missing-nightly-notes.md",
+      ]).pipe(Effect.provide([configLayer, captureClient(requests)]), Effect.result);
+      assert.equal(result._tag, "Failure");
+      assert.deepStrictEqual(requests, []);
+    }),
+  );
+
+  it.effect("stops on a failed send rather than posting later continuations", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const temp = yield* fs.makeTempDirectoryScoped();
+      const file = `${temp}/notes.md`;
+      yield* fs.writeFileString(file, notes.repeat(100));
+      const requests: string[] = [];
+      const result = yield* runCli([...cliArgs("prerelease"), "--release-notes-file", file]).pipe(
+        Effect.provide([configLayer, captureClient(requests, 400)]),
+        Effect.result,
+      );
+      assert.equal(result._tag, "Failure");
+      assert.equal(requests.length, 1);
+    }),
+  );
+
+  it.effect("does not expose an invalid webhook secret in configuration errors", () =>
+    Effect.gen(function* () {
+      const requests: string[] = [];
+      const result = yield* runCli(cliArgs("latest")).pipe(
+        Effect.provide([
+          ConfigProvider.layer(
+            ConfigProvider.fromEnv({ env: { DISCORD_WEBHOOK_URL: "invalid-test-secret-token" } }),
+          ),
+          captureClient(requests),
+        ]),
+        Effect.result,
+      );
+      assert.equal(result._tag, "Failure");
+      if (result._tag === "Failure")
+        assert.ok(!Cause.pretty(Cause.fail(result.failure)).includes("test-secret-token"));
+      assert.deepStrictEqual(requests, []);
+    }),
+  );
 });
diff --git a/scripts/notify-discord-release.ts b/scripts/notify-discord-release.ts
index 67cf556d4725..d096969c36b8 100644
--- a/scripts/notify-discord-release.ts
+++ b/scripts/notify-discord-release.ts
@@ -5,13 +5,18 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as Config from "effect/Config";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
 import * as Schema from "effect/Schema";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 import {
   FetchHttpClient,
   HttpClient,
+  HttpClientError,
   HttpClientRequest,
   HttpClientResponse,
 } from "effect/unstable/http";
@@ -26,11 +31,13 @@ export interface DiscordReleaseAnnouncementOptions {
   readonly tag: string;
   readonly releaseUrl: URL;
   readonly timestamp: string;
+  readonly releaseNotes?: string;
 }
 
 interface DiscordWebhookPayload {
   readonly content: string;
   readonly allowed_mentions: {
+    readonly parse: ReadonlyArray<never>;
     readonly roles: ReadonlyArray<string>;
   };
   readonly embeds: ReadonlyArray<{
@@ -38,18 +45,30 @@ interface DiscordWebhookPayload {
     readonly url: string;
     readonly description: string;
     readonly color: number;
-    readonly fields: ReadonlyArray<{
-      readonly name: string;
-      readonly value: string;
-      readonly inline: boolean;
-    }>;
+    readonly footer: { readonly text: string };
     readonly timestamp: string;
   }>;
 }
 
 const DISCORD_RELEASE_TARGETS = ["prerelease", "latest"] as const;
 const DiscordRoleIdSchema = Schema.String.check(Schema.isPattern(/^\d+$/));
-const DiscordWebhookUrl = Config.URL("DISCORD_WEBHOOK_URL");
+const DiscordWebhookUrl = Config.Redacted("DISCORD_WEBHOOK_URL").pipe(
+  Effect.flatMap((value) =>
+    Effect.try({
+      try: () => new URL(Redacted.value(value)),
+      catch: () => new DiscordReleaseWebhookConfigurationError({}),
+    }),
+  ),
+);
+
+export class DiscordReleaseWebhookConfigurationError extends Schema.TaggedError<DiscordReleaseWebhookConfigurationError>()(
+  "DiscordReleaseWebhookConfigurationError",
+  {},
+) {
+  override get message(): string {
+    return "DISCORD_WEBHOOK_URL must be a valid URL.";
+  }
+}
 
 const discordReleaseErrorContext = {
   target: Schema.Literals(["prerelease", "latest"]),
@@ -69,7 +88,7 @@ export class DiscordReleaseWebhookRequestError extends Schema.TaggedError<Discor
   "DiscordReleaseWebhookRequestError",
   {
     ...discordReleaseErrorContext,
-    cause: Schema.Defect(),
+    reason: Schema.String,
   },
 ) {
   override get message(): string {
@@ -82,7 +101,6 @@ export class DiscordReleaseWebhookResponseError extends Schema.TaggedError<Disco
   {
     ...discordReleaseErrorContext,
     status: Schema.Number,
-    cause: Schema.Defect(),
   },
 ) {
   override get message(): string {
@@ -90,11 +108,6 @@ export class DiscordReleaseWebhookResponseError extends Schema.TaggedError<Disco
   }
 }
 
-const targetLabels = {
-  prerelease: "Prerelease",
-  latest: "Latest",
-} as const satisfies Record<DiscordReleaseTarget, string>;
-
 const targetColors = {
   prerelease: 0x5865f2,
   latest: 0x2ecc71,
@@ -117,48 +130,137 @@ function summarizePayload(payload: DiscordWebhookPayload) {
   } as const;
 }
 
+// Keep release text inert, including occurrences of the intentionally pinged role.
+const suppressMentions = (text: string) =>
+  text.replace(/@(everyone|here)\b|<@[!&]?\d+>/g, (mention) => mention.replace("@", "@\u200b"));
+
+const escapeLinkLabel = (text: string) => text.replace(/[\\[\]]/g, "\\$&");
+
+// Compact GitHub's generated entries and comparison link, preserving custom
+// notes. Contributor links are GitHub profiles, not pings.
+function formatReleaseNotes(notes: string) {
+  return notes
+    .replace(
+      /^([*-] )(.+?)(?: by @([\w-]+(?:\[bot\])?))? in (https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+)[ \t]*\r?$/gm,
+      (
+        _entry,
+        bullet: string,
+        title: string,
+        author: string | undefined,
+        pullRequestUrl: string,
+      ) => {
+        const change = `${bullet}[${escapeLinkLabel(title)}](${pullRequestUrl})`;
+        if (!author) return change;
+        const profile = author.endsWith("[bot]") ? `apps/${author.slice(0, -5)}` : author;
+        return `${change} by [@${escapeLinkLabel(author)}](https://github.com/${profile})`;
+      },
+    )
+    .replace(
+      /^(?:\*\*)?Full Changelog(?:\*\*)?: (https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/compare\/\S+)[ \t]*\r?$/gm,
+      "[Full Changelog]($1)",
+    );
+}
+
+// Preserve every character and prefer whole lines, then words. A single oversized
+// line still needs splitting, but never between the halves of a Unicode character.
+function splitDescription(text: string, limit: number) {
+  const chunks: string[] = [];
+  while (text.length > limit) {
+    const newline = text.lastIndexOf("\n", limit - 1);
+    const space = text.lastIndexOf(" ", limit - 1);
+    let end = newline > 0 ? newline + 1 : space > 0 ? space + 1 : limit;
+    const lastCodeUnit = text.charCodeAt(end - 1);
+    if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) end -= 1;
+    chunks.push(text.slice(0, end));
+    text = text.slice(end);
+  }
+  chunks.push(text);
+  return chunks;
+}
+
 export const buildDiscordReleaseAnnouncement = (
   options: DiscordReleaseAnnouncementOptions,
-): DiscordWebhookPayload => ({
-  content: `<@&${options.roleId}> ${targetLabels[options.target]} published: ${options.releaseName}`,
-  allowed_mentions: {
-    roles: [options.roleId],
-  },
-  embeds: [
-    {
-      title: options.releaseName,
-      url: options.releaseUrl.href,
-      description:
-        options.target === "prerelease"
-          ? "A new T3 Code prerelease is available for nightly testers."
-          : "A new T3 Code latest release is available.",
-      color: targetColors[options.target],
-      fields: [
-        {
-          name: "Version",
-          value: options.version,
-          inline: true,
-        },
-        {
-          name: "Tag",
-          value: options.tag,
-          inline: true,
-        },
-      ],
-      timestamp: options.timestamp,
+): ReadonlyArray<DiscordWebhookPayload> => {
+  const releaseName = suppressMentions(options.releaseName);
+  const version = suppressMentions(options.version);
+  const footerText = `v${version.replace(/^v/, "")}`;
+  const content = `-# <@&${options.roleId}>`;
+  if (!/^\d+$/.test(options.roleId)) throw new RangeError("Invalid Discord release role ID.");
+  if (releaseName.length > 256)
+    throw new RangeError("Discord release title exceeds 256 characters.");
+  if (content.length > 2000)
+    throw new RangeError("Discord release content exceeds 2000 characters.");
+  if (footerText.length > 2048) {
+    throw new RangeError("Discord release footer exceeds 2048 characters.");
+  }
+
+  const intro =
+    options.target === "prerelease"
+      ? "A new T3 Code prerelease is available for nightly testers."
+      : `[View full release notes on GitHub](${options.releaseUrl.href})`;
+  const notes =
+    options.target === "prerelease"
+      ? suppressMentions(formatReleaseNotes(options.releaseNotes?.trim() ?? ""))
+      : "";
+  const description = notes ? `${intro}\n\n${notes}` : intro;
+  // One embed per message avoids Discord's URL deduplication. Reserve a full
+  // title and the version footer within the 6000-character aggregate limit.
+  const limit = Math.min(4096, 6000 - 256 - footerText.length);
+  const descriptions = splitDescription(description, limit);
+
+  return descriptions.map((description, index) => ({
+    content: index === 0 ? content : "",
+    allowed_mentions: {
+      parse: [],
+      roles: index === 0 ? [options.roleId] : [],
     },
-  ],
-});
+    embeds: [
+      {
+        title:
+          index === 0 ? releaseName : `Changelog continued (${index + 1}/${descriptions.length})`,
+        url: options.releaseUrl.href,
+        description,
+        color: targetColors[options.target],
+        footer: { text: footerText },
+        timestamp: options.timestamp,
+      },
+    ],
+  }));
+};
 
 export const postDiscordWebhook = Effect.fn("postDiscordWebhook")(function* (
   webhookUrl: URL,
   payload: DiscordWebhookPayload,
   announcement: DiscordReleaseAnnouncementOptions,
 ) {
+  const requestUrl = new URL(webhookUrl);
+  requestUrl.searchParams.set("wait", "true");
   const httpClient = (yield* HttpClient.HttpClient).pipe(
     HttpClient.retryTransient({
       retryOn: "errors-and-responses",
       times: 3,
+      schedule: Schedule.recurs(3).pipe(
+        Schedule.addDelay(
+          (
+            metadata: Schedule.Metadata<
+              number,
+              HttpClientResponse.HttpClientResponse | HttpClientError.HttpClientError
+            >,
+          ) => {
+            const response = !HttpClientError.isHttpClientError(metadata.input)
+              ? metadata.input
+              : metadata.input.reason._tag === "StatusCodeError"
+                ? metadata.input.reason.response
+                : undefined;
+            const retryAfterSeconds = Number(response?.headers["retry-after"]);
+            return Effect.succeed(
+              Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0
+                ? retryAfterSeconds * 1000
+                : 1000,
+            );
+          },
+        ),
+      ),
     }),
   );
 
@@ -180,14 +282,17 @@ export const postDiscordWebhook = Effect.fn("postDiscordWebhook")(function* (
     ...summarizePayload(payload),
   } as const;
 
-  const response = yield* HttpClientRequest.post(webhookUrl).pipe(
+  const response = yield* HttpClientRequest.post(requestUrl).pipe(
     HttpClientRequest.bodyJson(payload),
     Effect.flatMap(httpClient.execute),
+    // Bound requests and retry waits together without shortening Retry-After.
+    Effect.timeout("1 minute"),
     Effect.mapError(
-      (cause) =>
+      (error) =>
         new DiscordReleaseWebhookRequestError({
           ...errorContext,
-          cause,
+          // HTTP errors retain the request URL, including the webhook token.
+          reason: error._tag === "HttpClientError" ? error.reason._tag : error._tag,
         }),
     ),
   );
@@ -201,11 +306,10 @@ export const postDiscordWebhook = Effect.fn("postDiscordWebhook")(function* (
 
   yield* HttpClientResponse.filterStatusOk(response).pipe(
     Effect.mapError(
-      (cause) =>
+      () =>
         new DiscordReleaseWebhookResponseError({
           ...errorContext,
           status: response.status,
-          cause,
         }),
     ),
   );
@@ -237,8 +341,12 @@ export const notifyDiscordReleaseCommand = Command.make(
       Flag.withSchema(Schema.URLFromString),
       Flag.withDescription("Public GitHub release URL."),
     ),
+    releaseNotesFile: Flag.String("release-notes-file").pipe(
+      Flag.optional,
+      Flag.withDescription("File containing the published GitHub release notes."),
+    ),
   },
-  ({ target, roleId, releaseName, releaseVersion, tag, releaseUrl }) =>
+  ({ target, roleId, releaseName, releaseVersion, tag, releaseUrl, releaseNotesFile }) =>
     Effect.gen(function* () {
       yield* Effect.logInfo("discord release announcement starting").pipe(
         Effect.annotateLogs({
@@ -253,6 +361,11 @@ export const notifyDiscordReleaseCommand = Command.make(
       );
 
       const webhookUrl = yield* DiscordWebhookUrl;
+      const fs = yield* FileSystem.FileSystem;
+      const releaseNotes =
+        target === "prerelease" && Option.isSome(releaseNotesFile)
+          ? yield* fs.readFileString(releaseNotesFile.value)
+          : "";
       const timestamp = DateTime.formatIso(yield* DateTime.now);
       const announcement = {
         target,
@@ -262,13 +375,16 @@ export const notifyDiscordReleaseCommand = Command.make(
         tag,
         releaseUrl,
         timestamp,
+        releaseNotes,
       } satisfies DiscordReleaseAnnouncementOptions;
-      const payload = buildDiscordReleaseAnnouncement(announcement);
+      const payloads = yield* Effect.sync(() => buildDiscordReleaseAnnouncement(announcement));
 
-      yield* Effect.logInfo("discord release announcement payload built").pipe(
-        Effect.annotateLogs(summarizePayload(payload)),
+      yield* Effect.logInfo("discord release announcement payloads built").pipe(
+        Effect.annotateLogs({ messageCount: payloads.length }),
       );
-      yield* postDiscordWebhook(webhookUrl, payload, announcement);
+      for (const payload of payloads) {
+        yield* postDiscordWebhook(webhookUrl, payload, announcement);
+      }
       yield* Effect.logInfo("discord release announcement completed");
     }),
 ).pipe(Command.withDescription("Post a T3 Code release announcement to Discord."));
diff --git a/scripts/setup-worktree.ts b/scripts/setup-worktree.ts
index ea07a8b65ad8..027112ca1858 100644
--- a/scripts/setup-worktree.ts
+++ b/scripts/setup-worktree.ts
@@ -26,15 +26,22 @@ const install = NodeChildProcess.spawnSync("vp i", {
 });
 if (install.status !== 0) process.exit(install.status ?? 1);
 
-// In the main checkout itself, relinking would replace the real env files.
-if (NodeFS.realpathSync(projectRoot) !== NodeFS.realpathSync(worktree)) {
-  for (const file of ENV_FILES) {
-    const source = NodePath.join(projectRoot, file);
-    if (!NodeFS.existsSync(source)) continue;
-    const target = NodePath.join(worktree, file);
-    NodeFS.rmSync(target, { force: true });
-    NodeFS.symlinkSync(source, target);
+// Env files live as real files in the main checkout; worktrees only get
+// symlinks to them. Only a symlink is ever replaced, so a real env file is
+// never deleted, including when this runs in the main checkout itself.
+for (const file of ENV_FILES) {
+  const source = NodePath.join(projectRoot, file);
+  const sourceStat = NodeFS.lstatSync(source, { throwIfNoEntry: false });
+  if (!sourceStat) continue;
+  if (!sourceStat.isFile()) {
+    process.stderr.write(`Skipping ${file}: ${source} is not a regular file.\n`);
+    continue;
   }
+  const target = NodePath.join(worktree, file);
+  const existing = NodeFS.lstatSync(target, { throwIfNoEntry: false });
+  if (existing && !existing.isSymbolicLink()) continue;
+  if (existing) NodeFS.rmSync(target);
+  NodeFS.symlinkSync(source, target);
 }
 
 const warm = NodeChildProcess.spawnSync(
diff --git a/scripts/tsconfig.json b/scripts/tsconfig.json
index 1c6db08d4815..f6b814c23025 100644
--- a/scripts/tsconfig.json
+++ b/scripts/tsconfig.json
@@ -3,7 +3,7 @@
   "compilerOptions": {
     "composite": true,
     "types": ["node"],
-    "lib": ["ESNext", "esnext.disposable"]
+    "lib": ["ESNext", "esnext.disposable", "DOM"]
   },
   // The cloud deploy scripts share the server's credential paths and copy
   // transforms so the two cannot drift; these files have no dependencies.