chore(release): cut 0.15.1

docs(changelog): prepare 0.15.1
fix(terminal): start the daemon when the terminal worker cannot start (#8810 )
2026-11-07 08:54:42 +00:00 · 2026-11-05 03:27:21 +01:00 · 2026-11-05 03:01:38 +01:00 · 2026-11-05 02:59:14 +01:00 · 2026-11-03 06:08:53 +01:00 · 2026-11-03 05:34:45 +01:00
104 changed files with 2104 additions and 5100 deletions
@@ -135,6 +135,32 @@ jobs:
        env:
          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+      # Backport electron-builder#10172 to the pinned build tool only.
+      # Remove this step when app-builder-lib is upgraded to a release containing it.
+      - name: Repair temporary keychain password in signing tool
+        shell: bash
+        run: |
+          node <<'KEYCHAIN_FIX'
+          const fs = require('node:fs');
+          const path = require('node:path');
+          const manifestPath = require.resolve('app-builder-lib/package.json');
+          if (JSON.parse(fs.readFileSync(manifestPath, 'utf8')).version !== '26.8.1') {
+            throw new Error('Reassess/remove the signing backport for the new app-builder-lib version');
+          }
+          const sourcePath = path.join(path.dirname(manifestPath), 'out/codeSign/macCodeSign.js');
+          let source = fs.readFileSync(sourcePath, 'utf8');
+          const replacements = [
+            ['importCerts(keychainFile, certPaths, cscPasswords)', 'importCerts(keychainFile, certPaths, cscPasswords, keychainPassword)'],
+            ['importCerts(keychainFile, paths, keyPasswords)', 'importCerts(keychainFile, paths, keyPasswords, keychainPassword)'],
+            ['["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", password, keychainFile]', '["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", keychainPassword, keychainFile]'],
+          ];
+          for (const [before, after] of replacements) {
+            if (source.split(before).length !== 2) throw new Error('Unexpected signing tool source; refusing to patch');
+            source = source.replace(before, after);
+          }
+          fs.writeFileSync(sourcePath, source);
+          KEYCHAIN_FIX
+
      - name: Set desktop package version from tag
        shell: bash
        run: |
@@ -1,8 +1,14 @@
 # Changelog

-## 0.15.0-beta.1 - 2026-11-01
+## 0.15.1 - 2026-11-05

-Daemon restarts now keep terminal programs running and automatically resume interrupted agents in their existing conversations.
+### Fixed
+
+- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run `Get-CimInstance` ([#8810](https://github.com/getpaseo/paseo/pull/8810))
+
+## 0.15.0 - 2026-11-03
+
+Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.

 Mobile terminals have native rendering and draggable text-selection handles. Reconnecting restores up to 10,000 lines of terminal history.

@@ -13,7 +19,7 @@ Worktree setup can copy ignored files and use plugin-defined locations before ag
 - Insert known agent commands from replies into the Composer draft ([#8371](https://github.com/getpaseo/paseo/pull/8371))
 - Reuse running OpenCode v2 services ([#7435](https://github.com/getpaseo/paseo/pull/7435) by [@mcowger](https://github.com/mcowger))
 - Kept terminal programs running across daemon restarts, crashes and supported updates ([#7644](https://github.com/getpaseo/paseo/pull/7644), [#8155](https://github.com/getpaseo/paseo/pull/8155) by [@sebastianarena](https://github.com/sebastianarena))
- Automatically resume interrupted agents in their existing conversations after a host restart ([#8127](https://github.com/getpaseo/paseo/pull/8127) by [@coolwindX](https://github.com/coolwindX), [@suntianc](https://github.com/suntianc))
+- Added an opt-in setting to resume interrupted agents in their existing conversations after a host restart ([#8127](https://github.com/getpaseo/paseo/pull/8127), [#8619](https://github.com/getpaseo/paseo/pull/8619) by [@coolwindX](https://github.com/coolwindX), [@suntianc](https://github.com/suntianc))
 - Added draggable terminal text-selection handles on iOS and Android ([#8348](https://github.com/getpaseo/paseo/pull/8348))
 - Let phones and tablets rotate with the system orientation setting ([#8256](https://github.com/getpaseo/paseo/pull/8256) by [@magiclaw](https://github.com/magiclaw), [@yzim](https://github.com/yzim))
 - Copy ignored files selected by `.worktreeinclude` into new worktrees before setup and agents start ([#8100](https://github.com/getpaseo/paseo/pull/8100) by [@cprecioso](https://github.com/cprecioso))
@@ -64,6 +70,7 @@ Worktree setup can copy ignored files and use plugin-defined locations before ag
 - Fixed the MiniMax Code catalog command failing to select an executable ([#8201](https://github.com/getpaseo/paseo/pull/8201) by [@Peanut-HZM](https://github.com/Peanut-HZM))
 - Fixed Android keeping the wrong layout after folding or unfolding while backgrounded ([#8285](https://github.com/getpaseo/paseo/pull/8285))
 - Fixed Android workspace layouts and header fades retaining their old size after rotation ([#8349](https://github.com/getpaseo/paseo/pull/8349), [#8377](https://github.com/getpaseo/paseo/pull/8377))
+- Fixed chat reconnecting and updating status being hidden behind the header on iOS and Android phones ([#8568](https://github.com/getpaseo/paseo/pull/8568))
 - Fixed deleted agents leaving unclosable tabs in another window ([#8248](https://github.com/getpaseo/paseo/pull/8248) by [@loganmeyer](https://github.com/loganmeyer))
 - Fixed transcript text retaining old theme colors after the theme changes while the window is hidden ([#8199](https://github.com/getpaseo/paseo/pull/8199) by [@Nurshot](https://github.com/Nurshot), [@dansabin](https://github.com/dansabin))
 - Fixed web menus snapping back to their loading size after content arrives ([#8180](https://github.com/getpaseo/paseo/pull/8180) by [@babo-jeonguk](https://github.com/babo-jeonguk))
@@ -74,7 +81,7 @@ Worktree setup can copy ignored files and use plugin-defined locations before ag
 ### Notes

 - The first upgrade from 0.14.0 still closes terminals; terminal preservation starts once the new daemon is installed, and Windows desktop app upgrades still close them
- Automatic agent recovery is on by default and sends `Resume working.`; change the prompt or disable it in Host settings → Agents
+- Agent recovery is off by default; turn on **Resume agents after restart** in Host settings → Agents to send `Resume working.` or your own prompt
 - Before downgrading to 0.14.0, restore a backed-up `config.json` or remove the saved agent-resume and usage-check settings

 ## 0.14.0 - 2026-10-29
@@ -1,8 +1,14 @@
 # Changelog

-## 0.15.0-beta.1 - 2026-11-01
+## 0.15.1 - 2026-11-05

-daemon 重启后，终端中的程序继续运行，被中断的 Agent 会自动在原有会话中恢复工作。
+### 修复
+
+- 修复终端工作进程无法读取自身进程标识时 daemon 无法启动的问题；此前在 Windows PowerShell 5.1 无法运行 `Get-CimInstance` 的 Windows 机器上，Paseo 桌面版因此没有可用的 daemon ([#8810](https://github.com/getpaseo/paseo/pull/8810))
+
+## 0.15.0 - 2026-11-03
+
+daemon 重启后，终端中的程序继续运行。开启 Agent 恢复后，被中断的 Agent 会在原有会话中恢复工作。

 移动端终端采用原生渲染，并提供可拖动的文本选择手柄。重新连接时最多恢复 10,000 行终端历史。

@@ -13,7 +19,7 @@ worktree 初始化支持复制被忽略的文件，并在 Agent 启动前使用
 - 点击回复中的已知 Agent 命令，将其插入 Composer 草稿 ([#8371](https://github.com/getpaseo/paseo/pull/8371))
 - 复用已运行的 OpenCode v2 服务 ([#7435](https://github.com/getpaseo/paseo/pull/7435)，贡献者：[@mcowger](https://github.com/mcowger))
 - 让终端中的程序在 daemon 重启、崩溃和支持的更新过程中继续运行 ([#7644](https://github.com/getpaseo/paseo/pull/7644), [#8155](https://github.com/getpaseo/paseo/pull/8155)，贡献者：[@sebastianarena](https://github.com/sebastianarena))
- 主机重启后，自动在原有会话中恢复被中断的 Agent ([#8127](https://github.com/getpaseo/paseo/pull/8127)，贡献者：[@coolwindX](https://github.com/coolwindX), [@suntianc](https://github.com/suntianc))
+- 新增可选设置，在主机重启后于原有会话中恢复被中断的 Agent ([#8127](https://github.com/getpaseo/paseo/pull/8127), [#8619](https://github.com/getpaseo/paseo/pull/8619)，贡献者：[@coolwindX](https://github.com/coolwindX), [@suntianc](https://github.com/suntianc))
 - 在 iOS 和 Android 终端中新增可拖动的文本选择手柄 ([#8348](https://github.com/getpaseo/paseo/pull/8348))
 - 让手机和平板遵循系统屏幕旋转设置 ([#8256](https://github.com/getpaseo/paseo/pull/8256)，贡献者：[@magiclaw](https://github.com/magiclaw), [@yzim](https://github.com/yzim))
 - 通过 `.worktreeinclude` 选择要复制到新 worktree 的被忽略文件，在初始化和 Agent 启动前完成复制 ([#8100](https://github.com/getpaseo/paseo/pull/8100)，贡献者：[@cprecioso](https://github.com/cprecioso))
@@ -64,6 +70,7 @@ worktree 初始化支持复制被忽略的文件，并在 Agent 启动前使用
 - 修复了 MiniMax Code 目录命令无法选定可执行文件的问题 ([#8201](https://github.com/getpaseo/paseo/pull/8201)，贡献者：[@Peanut-HZM](https://github.com/Peanut-HZM))
 - 修复了 Android 应用在后台折叠或展开后保留错误布局的问题 ([#8285](https://github.com/getpaseo/paseo/pull/8285))
 - 修复了 Android 屏幕旋转后工作区布局和顶栏渐变保留旧尺寸的问题 ([#8349](https://github.com/getpaseo/paseo/pull/8349), [#8377](https://github.com/getpaseo/paseo/pull/8377))
+- 修复了 iOS 和 Android 手机聊天中重新连接和更新状态被顶栏遮挡的问题 ([#8568](https://github.com/getpaseo/paseo/pull/8568))
 - 修复了删除 Agent 后，另一个窗口留下无法关闭的标签页的问题 ([#8248](https://github.com/getpaseo/paseo/pull/8248)，贡献者：[@loganmeyer](https://github.com/loganmeyer))
 - 修复了窗口隐藏期间切换主题后，聊天文本保留旧主题颜色的问题 ([#8199](https://github.com/getpaseo/paseo/pull/8199)，贡献者：[@Nurshot](https://github.com/Nurshot), [@dansabin](https://github.com/dansabin))
 - 修复了网页菜单加载内容后跳回加载时尺寸的问题 ([#8180](https://github.com/getpaseo/paseo/pull/8180)，贡献者：[@babo-jeonguk](https://github.com/babo-jeonguk))
@@ -74,7 +81,7 @@ worktree 初始化支持复制被忽略的文件，并在 Agent 启动前使用
 ### 说明

 - 首次从 0.14.0 升级时仍会关闭终端；安装新 daemon 后才支持保留终端，Windows 桌面应用升级仍会关闭终端
- Agent 自动恢复默认开启，并发送 `Resume working.`；可在主机设置 → Agent 中修改提示词或关闭此功能
+- Agent 恢复默认关闭；在主机设置 → Agent 中开启 **重启后恢复智能体**，即可发送 `Resume working.` 或自定义提示词
 - 降级到 0.14.0 前，请恢复备份的 `config.json`，或删除已保存的 Agent 恢复和用量查询设置

 ## 0.14.0 - 2026-10-29
@@ -14,9 +14,10 @@ Each live agent in `AgentManager` carries a `lastStatus` of `initializing`, `idl

 ## Daemon restart recovery

-Hosts resume interrupted agents by default after graceful shutdown or a crash. The daemon
-reopens the saved provider conversation and settings, then sends `Resume working.`. Change
-`agents.resumePrompt` or disable `agents.resumeOnStartup` in host config or Host settings → Agents.
+Restart recovery is off by default. Enable `agents.resumeOnStartup` in host config or
+Host settings → Agents to resume interrupted agents after graceful shutdown or a crash. The daemon
+reopens the saved provider conversation and settings, then sends `Resume working.`. Customize
+the prompt with `agents.resumePrompt` or the same settings page.
 Disabling recovery consumes pending intent; enabling it later does not revive old work.

 Only agents recorded as running qualify. Idle and initializing agents stay inactive. Archived
@@ -74,10 +74,7 @@ registrations remain inspectable; a changed destination requires explicit identi

 Both daemons advertise `connectedHosts`; the shared link additionally requires `hostMultiplexing`.
 A completes capability and pinned-identity checks on each physical recovery before admitting channels. There is no local fallback. An older daemon continues to serve existing local
-operations; requesting this feature gives update guidance. The registry retries an older destination
-with capped backoff, so it comes online once updated. Self, duplicate, changed-identity, and
-authentication failures stay in `error` until an update changes the connection, `enabled`, or
-`replaceIdentity`, or A restarts.
+operations; requesting this feature gives update guidance.

 Disposing a routed API releases its observations and session. It does not remove the saved host or
 affect sibling API scopes. Disposing the origin cascades to its derived scopes. Observations restore
@@ -0,0 +1,10 @@
+Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.
+
+Mobile terminals have native rendering and draggable text-selection handles. Reconnecting restores up to 10,000 lines of terminal history.
+
+Worktree setup can copy ignored files and use plugin-defined locations before agents start.
+
+Added
+- Insert known agent commands from replies into the Composer draft
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,10 @@
+Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.
+
+Mobile terminals have native rendering and draggable text-selection handles. Reconnecting restores up to 10,000 lines of terminal history.
+
+Worktree setup can copy ignored files and use plugin-defined locations before agents start.
+
+Added
+- Insert known agent commands from replies into the Composer draft
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,10 @@
+Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.
+
+Mobile terminals have native rendering and draggable text-selection handles. Reconnecting restores up to 10,000 lines of terminal history.
+
+Worktree setup can copy ignored files and use plugin-defined locations before agents start.
+
+Added
+- Insert known agent commands from replies into the Composer draft
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,10 @@
+Daemon restarts now keep terminal programs running. Interrupted agents can resume in their existing conversations when you turn on agent recovery.
+
+Mobile terminals have native rendering and draggable text-selection handles. Reconnecting restores up to 10,000 lines of terminal history.
+
+Worktree setup can copy ignored files and use plugin-defined locations before agents start.
+
+Added
+- Insert known agent commands from replies into the Composer draft
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,4 @@
+Fixed
+- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,4 @@
+Fixed
+- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,4 @@
+Fixed
+- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
+
+Full notes: https://paseo.sh/changelog
@@ -0,0 +1,4 @@
+Fixed
+- Fixed the daemon failing to start when the terminal worker cannot read its own process identity, which left Paseo Desktop without a daemon on Windows machines where Windows PowerShell 5.1 cannot run Get-CimInstance
+
+Full notes: https://paseo.sh/changelog
@@ -127,7 +127,7 @@ buildNpmPackage {
        # The Nix output is not a distributable DMG, so leave it unsigned and
        # disable the hardened runtime that requires a matching signature.
        CSC_IDENTITY_AUTO_DISCOVERY=false \
-          npm exec --offline -- electron-builder \
+          ../../node_modules/.bin/electron-builder \
            --config electron-builder.yml \
            --dir \
            --mac \
@@ -1 +1 @@
-sha256-KN/AVZV/o0TleLLpmggSrdJqjFDJ/NJYVHiC54xb4jQ=
+sha256-YLrbUckIiyV7esu2tmiKdLL0YHsvwqcA0Xe0gSeMCC0=
@@ -1,6 +1,6 @@
 {
  "name": "paseo",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "private": true,
  "description": "Paseo: voice-controlled development environment for local AI coding agents",
  "keywords": [
@@ -3,7 +3,7 @@ import {
  composerLocator,
  expectComposerDraft,
  expectComposerVisible,
-  fillComposerDraft,
+  submitMessage,
  typeIntoFocusedComposer,
 } from "../support/helpers/composer";
 import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
@@ -12,14 +12,8 @@ function userMessages(page: Page) {
  return page.getByTestId("user-message");
 }

-async function sendDraftWhenReady(page: Page) {
-  await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeEnabled();
-  await pressInComposer(page, "Enter");
-}
-
 async function sendAndWaitForMessage(page: Page, text: string, expectedCount: number) {
-  await fillComposerDraft(page, text);
-  await sendDraftWhenReady(page);
+  await submitMessage(page, text);
  await expect(userMessages(page)).toHaveCount(expectedCount, { timeout: 30_000 });
  await expectComposerDraft(page, "");
 }
@@ -55,7 +49,7 @@ test.describe("Composer recall", () => {
      await pressInComposer(page, "ArrowUp");
      await expectComposerDraft(page, "add tests for login");

-      await sendDraftWhenReady(page);
+      await pressInComposer(page, "Enter");
      await expect(userMessages(page)).toHaveCount(3, { timeout: 30_000 });
      await expect(userMessages(page).last()).toContainText("add tests for login");
    } finally {
@@ -257,12 +257,15 @@ test.describe("Settings host page", () => {
  });
 });

-test("restart recovery host controls persist the opt-out and custom prompt", async ({ page }) => {
+test("restart recovery defaults off and persists opt-in and custom prompt", async ({ page }) => {
  const serverId = getServerId();
  await gotoAppShell(page);
  await openSettings(page);
  await openSettingsHost(page, serverId);
  await openHostSection(page, serverId, "agents");
+  await expectRestartRecoveryEnabled(page, false);
+  await setRestartRecoveryEnabled(page, true);
+  await page.reload();
  await expectRestartRecoveryEnabled(page, true);
  await expectRestartRecoveryPrompt(page, "Resume working.");
  await editRestartRecoveryPrompt(page, "Continue the interrupted work.");
@@ -0,0 +1,54 @@
+// Open an existing compact chat, with the keyboard closed, then interrupt its host connection.
+// Hold that interruption externally (for example, stop a disposable SSH TCP forward).
+// Leave the daemon running. This test observes the public reconnecting state.
+// node placement.mjs <session> <platform> <coordinate-scale> <composer-label> <artifacts>
+// coordinate-scale is screenshot pixels per layout point (Android density; iOS snapshots use 1).
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const [, , session, platform, coordinateScale, composerLabel, artifacts] = process.argv;
+assert(
+  session && ["android", "ios"].includes(platform) && composerLabel && artifacts,
+  "Pass all five arguments",
+);
+const scale = Number(coordinateScale);
+assert(scale > 0, "Pass a positive coordinate scale");
+mkdirSync(artifacts, { recursive: true });
+function ad(...args) {
+  return execFileSync("agent-device", ["--session", session, "--platform", platform, ...args], {
+    encoding: "utf8",
+    timeout: 90_000,
+  });
+}
+function capture(name) {
+  const snapshot = ad("snapshot", "--raw", "--json");
+  writeFileSync(path.join(artifacts, `${name}.json`), snapshot);
+  ad("screenshot", path.join(artifacts, `${name}.png`));
+  const nodes = JSON.parse(snapshot).data.nodes;
+  const header = nodes.find((node) => node.identifier === "floating-header");
+  const toast = nodes.find((node) => node.identifier === "agent-reconnecting-toast");
+  assert(header?.rect && toast?.rect, "Measured header and reconnecting toast must be present");
+  assert(toast.rect.height > 0 && toast.rect.width > 0, "Toast must have visible bounds");
+  const gap = (toast.rect.y - header.rect.y - header.rect.height) / scale;
+  assert(Math.abs(gap - 12) <= 1, `${name}: actual header-to-toast gap ${gap}, expected12 points`);
+  return toast.rect.y / scale;
+}
+
+ad("wait", 'id="agent-reconnecting-toast"', "20000");
+const closedTop = capture("keyboard-closed");
+ad("press", `label=${JSON.stringify(composerLabel)}`);
+const opened = ad("snapshot", "--raw", "--json");
+const nodes = JSON.parse(opened).data.nodes;
+assert(
+  nodes.some(
+    (node) => /keyboard/i.test(node.type ?? "") || /inputmethod/i.test(node.bundleId ?? ""),
+  ),
+  "Use a real visible software keyboard; open Android sessions with --no-test-ime",
+);
+const openTop = capture("keyboard-open");
+assert(Math.abs(openTop - closedTop) <= 1, "Keyboard must not translate the toast");
+console.log(
+  "PASS: rendered reconnecting toast stays12 points below measured header, keyboard closed/open",
+);
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/app",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "private": true,
  "main": "index.ts",
  "scripts": {
@@ -1,8 +1,26 @@
-import { useCallback, useState, type ReactNode } from "react";
+import { createContext, useContext, useCallback, useState, useId, type ReactNode } from "react";
 import { View, type LayoutChangeEvent } from "react-native";
 import { StyleSheet } from "react-native-unistyles";
+import { Portal, PortalHost } from "@gorhom/portal";
+import { useRetainedPanelActive } from "@/components/retained-panel";
 import { EdgeFade } from "@/components/ui/edge-fade";

+const OverlayClearanceContext = createContext(0);
+const OverlayHostContext = createContext<string | null>(null);
+
+/** Keep status overlays above the fade without lifting the scrolling content. */
+export function FloatingHeaderOverlay({ children }: { children: ReactNode }) {
+  const hostName = useContext(OverlayHostContext);
+  const active = useRetainedPanelActive();
+  if (!hostName) return children;
+  return active ? <Portal hostName={hostName}>{children}</Portal> : null;
+}
+
+/** Clearance for stationary overlays inside this layout, measured to the header bottom. */
+export function useFloatingHeaderOverlayClearance(): number {
+  return useContext(OverlayClearanceContext);
+}
+
 /** How far the fade runs past the header's bottom edge, so content dissolves instead of clipping. */
 const FADE_OVERHANG = 48;
 /** Share of the fade that stays opaque, so the header's title and icons keep contrast. */
@@ -20,15 +38,24 @@ interface FloatingHeaderLayoutProps {
 * same tree position in both modes, so toggling `floating` never remounts them.
 */
 export function FloatingHeaderLayout({ header, floating, children }: FloatingHeaderLayoutProps) {
+  const overlayHostName = useId();
  const [headerHeight, setHeaderHeight] = useState(0);
  const handleHeaderLayout = useCallback((event: LayoutChangeEvent) => {
    setHeaderHeight(Math.round(event.nativeEvent.layout.height));
  }, []);

+  const overlayClearance = floating ? headerHeight : 0;
+
  return (
    <View style={styles.root}>
      {floating ? null : header}
-      <View style={styles.content}>{children(floating ? headerHeight : 0)}</View>
+      <View style={styles.content}>
+        <OverlayClearanceContext.Provider value={overlayClearance}>
+          <OverlayHostContext.Provider value={floating ? overlayHostName : null}>
+            {children(floating ? headerHeight : 0)}
+          </OverlayHostContext.Provider>
+        </OverlayClearanceContext.Provider>
+      </View>
      {floating ? (
        <View style={styles.overlay} pointerEvents="box-none">
          <EdgeFade
@@ -37,11 +64,19 @@ export function FloatingHeaderLayout({ header, floating, children }: FloatingHea
            backdrop="surfaceWorkspace"
            style={styles.fade}
          />
-          <View pointerEvents="box-none" onLayout={handleHeaderLayout}>
+          <View
+            testID="floating-header"
+            collapsable={false}
+            pointerEvents="box-none"
+            onLayout={handleHeaderLayout}
+          >
            {header}
          </View>
        </View>
      ) : null}
+      <View style={styles.statusOverlay} pointerEvents="box-none">
+        <PortalHost name={overlayHostName} />
+      </View>
    </View>
  );
 }
@@ -55,6 +90,13 @@ const styles = StyleSheet.create({
    flex: 1,
    minHeight: 0,
  },
+  statusOverlay: {
+    position: "absolute",
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0,
+  },
  overlay: {
    position: "absolute",
    top: 0,
@@ -1,3 +1,7 @@
+import {
+  FloatingHeaderOverlay,
+  useFloatingHeaderOverlayClearance,
+} from "@/components/floating-header";
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import { createPortal } from "react-dom";
 import {
@@ -190,9 +194,11 @@ export function ToastViewport({
    return clearTimer;
  }, [clearTimer, durationMs, scheduleDismiss, toastId]);

+  const panelClearance = useFloatingHeaderOverlayClearance();
  const headerHeight = isMobile ? HEADER_INNER_HEIGHT_MOBILE : HEADER_INNER_HEIGHT;
  const headerTopPadding = isMobile ? HEADER_TOP_PADDING_MOBILE : 0;
-  const topOffset = placement === "app-shell" ? insets.top + headerTopPadding + headerHeight : 0;
+  const topOffset =
+    placement === "app-shell" ? insets.top + headerTopPadding + headerHeight : panelClearance;

  const content = (
    <View
@@ -220,7 +226,7 @@ export function ToastViewport({
    return createPortal(content, getOverlayRoot());
  }

-  return content;
+  return placement === "panel" ? <FloatingHeaderOverlay>{content}</FloatingHeaderOverlay> : content;
 }

 function ToastCard({
@@ -179,8 +179,8 @@ export function ComposerDock({
              <View style={fullscreen ? fullscreenSurface : dockStyles.composer}>{composer}</View>
            </ComposerViewportContent>
          </ComposerViewportContent>
-          {overlay}
        </KeyboardTranslateView>
+        {overlay}
      </ComposerViewport>
    );
  }
@@ -214,8 +214,8 @@ export function ComposerDock({
            {composer}
          </View>
        </ComposerViewportContent>
-        {overlay}
      </KeyboardTranslateView>
+      {overlay}
    </ComposerViewport>
  );
 }
@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import ts from "typescript";
+import { expect, it } from "vitest";
+
+it("keeps dock overlays outside keyboard translation in every native layout", () => {
+  const source = ts.createSourceFile(
+    "dock.tsx",
+    readFileSync(new URL("./index.native.tsx", import.meta.url), "utf8"),
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX,
+  );
+  let surfaces = 0;
+  function visit(node: ts.Node) {
+    if (
+      ts.isJsxElement(node) &&
+      node.openingElement.tagName.getText(source) === "KeyboardTranslateView"
+    ) {
+      surfaces++;
+      function assertStationary(child: ts.Node) {
+        if (ts.isJsxExpression(child))
+          expect(child.expression?.getText(source)).not.toBe("overlay");
+        ts.forEachChild(child, assertStationary);
+      }
+      ts.forEachChild(node, assertStationary);
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(source);
+  expect(surfaces).toBe(2);
+});
@@ -59,7 +59,7 @@ export function RestartRecoveryCard({ serverId }: { serverId: string }) {

  if (!isConnected || !isSupported || !config) return null;

-  const isEnabled = config.resumeOnStartup !== false;
+  const isEnabled = config.resumeOnStartup === true;

  return (
    <>
@@ -717,13 +717,11 @@ describe("terminal emulator runtime in a real browser", () => {
    { name: "DA1-zero", bytes: "\x1b[0c" },
    { name: "DA2", bytes: "\x1b[>c" },
    { name: "DA3", bytes: "\x1b[=c" },
-    { name: "XTVERSION", bytes: "\x1b[>q" },
    { name: "DSR-5", bytes: "\x1b[5n" },
    { name: "DSR-6", bytes: "\x1b[6n" },
    { name: "DSR-?6", bytes: "\x1b[?6n" },
    { name: "DECRQM", bytes: "\x1b[1$p" },
    { name: "DECRQM-?", bytes: "\x1b[?1$p" },
-    { name: "DECRQSS", bytes: "\x1bP$qm\x1b\\" },
    { name: "OSC-10-foreground-color", bytes: "\x1b]10;?\x07" },
    { name: "OSC-11-background-color", bytes: "\x1b]11;?\x07" },
    { name: "OSC-12-cursor-color", bytes: "\x1b]12;?\x07" },
@@ -647,7 +647,6 @@ export class TerminalEmulatorRuntime {
      terminal.parser.registerCsiHandler({ final: "c" }, () => true);
      terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, () => true);
      terminal.parser.registerCsiHandler({ prefix: "=", final: "c" }, () => true);
-      terminal.parser.registerCsiHandler({ prefix: ">", final: "q" }, () => true);
      terminal.parser.registerCsiHandler({ final: "n" }, () => true);
      terminal.parser.registerCsiHandler({ prefix: "?", final: "n" }, () => true);
      terminal.parser.registerCsiHandler({ final: "R" }, () => true);
@@ -656,7 +655,6 @@ export class TerminalEmulatorRuntime {
        { prefix: "?", intermediates: "$", final: "p" },
        () => true,
      );
-      terminal.parser.registerDcsHandler({ intermediates: "$", final: "q" }, () => true);
      for (const code of [10, 11, 12]) {
        terminal.parser.registerOscHandler(code, (data) => data.trim() === "?");
      }
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/cli",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo CLI - control your AI coding agents from the command line",
  "bin": {
    "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
  },
  "dependencies": {
    "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.15.0-beta.1",
-    "@getpaseo/protocol": "0.15.0-beta.1",
-    "@getpaseo/server": "0.15.0-beta.1",
+    "@getpaseo/client": "0.15.1",
+    "@getpaseo/protocol": "0.15.1",
+    "@getpaseo/server": "0.15.1",
    "chalk": "^5.3.0",
    "commander": "^12.0.0",
    "mime-types": "^2.1.35",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/client",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo client SDK package",
  "files": [
    "dist",
@@ -47,8 +47,8 @@
    "test": "vitest run"
  },
  "dependencies": {
-    "@getpaseo/protocol": "0.15.0-beta.1",
-    "@getpaseo/relay": "0.15.0-beta.1",
+    "@getpaseo/protocol": "0.15.1",
+    "@getpaseo/relay": "0.15.1",
    "ws": "^8.20.0",
    "zod": "^4.4.3"
  },
@@ -204,16 +204,15 @@ export function createHostTransportFactory(
 }
 export function createHostClient(
  connection: string,
-  config: Omit<DaemonClientConfig, "url"> & HostTransportOptions,
+  config: Omit<DaemonClientConfig, "url" | "transportFactory"> & HostTransportOptions,
  budget?: HostTransportBudget,
 ): DaemonClient {
  const target = parseHostTarget(connection);
-  const { webSocketAgent, transportFactory, ...clientConfig } = config;
+  const { webSocketAgent, ...clientConfig } = config;
  return new DaemonClient({
    ...clientConfig,
    url: "ws://host-connector/ws",
    ...(target.password ? { password: target.password } : {}),
-    transportFactory:
-      transportFactory ?? createHostTransportFactory(connection, budget, { webSocketAgent }),
+    transportFactory: createHostTransportFactory(connection, budget, { webSocketAgent }),
  });
 }
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/desktop",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "private": true,
  "description": "Paseo desktop app (Electron wrapper)",
  "homepage": "https://paseo.sh",
@@ -41,7 +41,7 @@
    "@types/node": "24.6.0",
    "@types/ws": "^8.5.14",
    "electron": "44.2.0",
-    "electron-builder": "26.18.0",
+    "electron-builder": "26.8.1",
    "typescript": "5.9.3",
    "unzip-crx-3": "^0.2.0",
    "vitest": "^4.1.6",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/expo-two-way-audio",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Native module for two way audio streaming",
  "keywords": [
    "ExpoTwoWayAudio",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/highlight",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "files": [
    "dist",
    "!dist/**/*.map",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/plugin",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo plugin SDK package",
  "files": [
    "dist",
@@ -77,8 +77,8 @@
    "use-sync-external-store": "^1.6.0"
  },
  "devDependencies": {
-    "@getpaseo/client": "0.15.0-beta.1",
-    "@getpaseo/protocol": "0.15.0-beta.1",
+    "@getpaseo/client": "0.15.1",
+    "@getpaseo/protocol": "0.15.1",
    "@types/node": "^20.9.0",
    "@types/react": "~19.2.0",
    "react": "19.2.3",
@@ -88,8 +88,8 @@
    "zod": "^4.4.3"
  },
  "peerDependencies": {
-    "@getpaseo/client": "0.15.0-beta.1",
-    "@getpaseo/protocol": "0.15.0-beta.1",
+    "@getpaseo/client": "0.15.1",
+    "@getpaseo/protocol": "0.15.1",
    "react": ">=19.1.0 <20",
    "react-native": ">=0.81.5",
    "zod": "^4.4.3"
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/protocol",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo shared protocol schemas and wire types",
  "files": [
    "dist",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/relay",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo relay for bridging daemon and client connections",
  "files": [
    "dist",
@@ -56,6 +56,9 @@ function spawnRelayDevServer(port: number): ChildProcess {
      wranglerCliPath,
      "dev",
      "--local",
+      // Local execution still inherits production vars; exercise the local Durable Object.
+      "--var",
+      "PASEO_RELAY_UPSTREAM:",
      "--ip",
      "127.0.0.1",
      "--port",
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/server",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "description": "Paseo backend server",
  "files": [
    "dist/server",
@@ -89,7 +89,7 @@
    "speech:transcribe:local": "tsx scripts/transcribe-local-wav.ts",
    "test": "npm run test:unit && npm run test:integration",
    "test:unit": "vitest run --fileParallelism --exclude \"**/*.e2e.test.ts\"",
-    "test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/create-agent-mode.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/creation-status.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/terminal-worker-lifecycle.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/plugins/usage-sources.e2e.test.ts src/server/plugins/lifecycle.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts src/server/owned-subscriptions.e2e.test.ts && vitest run --maxWorkers=1 src/server/agent/providers/omp/history.e2e.test.ts src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses|replays selected OMP history\"",
+    "test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/creation-status.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/terminal-worker-lifecycle.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/plugins/usage-sources.e2e.test.ts src/server/plugins/lifecycle.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts src/server/owned-subscriptions.e2e.test.ts && vitest run --maxWorkers=1 src/server/agent/providers/omp/history.e2e.test.ts src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses|replays selected OMP history\"",
    "test:hub-cli-contract": "vitest run --maxWorkers=1 src/server/hub/hub-cli-contract.test.ts",
    "test:integration:all": "npm run test:e2e",
    "test:integration:real": "vitest run real.e2e.test.ts",
@@ -107,11 +107,11 @@
    "@agentclientprotocol/sdk": "^0.17.1",
    "@anthropic-ai/claude-agent-sdk": "0.3.246",
    "@anthropic-ai/sdk": "^0.104.2",
-    "@getpaseo/client": "0.15.0-beta.1",
-    "@getpaseo/highlight": "0.15.0-beta.1",
-    "@getpaseo/plugin": "0.15.0-beta.1",
-    "@getpaseo/protocol": "0.15.0-beta.1",
-    "@getpaseo/relay": "0.15.0-beta.1",
+    "@getpaseo/client": "0.15.1",
+    "@getpaseo/highlight": "0.15.1",
+    "@getpaseo/plugin": "0.15.1",
+    "@getpaseo/protocol": "0.15.1",
+    "@getpaseo/relay": "0.15.1",
    "@isaacs/ttlcache": "^2.1.4",
    "@modelcontextprotocol/sdk": "1.29.0",
    "@opencode-ai/sdk": "1.14.46",
@@ -78,7 +78,7 @@ describe("resolveAndValidateCreateAgentMode", () => {
        availableModes: OPENCODE_MODES,
      }),
    ).toThrow(
-      "cannot inherit mode 'bypassPermissions' from caller (provider 'claude') for new agent (provider 'opencode'). Pass an explicit mode in settings.modeId. Available modes for 'opencode': build, plan",
+      "cannot inherit mode 'bypassPermissions' from caller (provider 'claude') for new agent (provider 'opencode'). Pass an explicit mode. Available modes for 'opencode': build, plan",
    );
  });

@@ -92,7 +92,7 @@ describe("resolveAndValidateCreateAgentMode", () => {
        availableModes: CODEX_MODES,
      }),
    ).toThrow(
-      "cannot inherit mode '<none>' from caller (provider 'opencode') for new agent (provider 'codex'). Pass an explicit mode in settings.modeId. Available modes for 'codex': auto, full-access",
+      "cannot inherit mode '<none>' from caller (provider 'opencode') for new agent (provider 'codex'). Pass an explicit mode. Available modes for 'codex': auto, full-access",
    );
  });

@@ -180,7 +180,7 @@ describe("resolveAndValidateCreateAgentMode", () => {
        targetUnattendedMode: "full-access",
      }),
    ).toThrow(
-      "cannot inherit mode 'default' from caller (provider 'claude') for new agent (provider 'codex'). Pass an explicit mode in settings.modeId. Available modes for 'codex': auto, full-access",
+      "cannot inherit mode 'default' from caller (provider 'claude') for new agent (provider 'codex'). Pass an explicit mode. Available modes for 'codex': auto, full-access",
    );
  });

@@ -195,7 +195,7 @@ describe("resolveAndValidateCreateAgentMode", () => {
        targetUnattendedMode: undefined,
      }),
    ).toThrow(
-      "cannot inherit mode 'bypassPermissions' from caller (provider 'claude') for new agent (provider 'zai-custom'). Pass an explicit mode in settings.modeId. Available modes for 'zai-custom': unknown",
+      "cannot inherit mode 'bypassPermissions' from caller (provider 'claude') for new agent (provider 'zai-custom'). Pass an explicit mode. Available modes for 'zai-custom': unknown",
    );
  });

@@ -77,7 +77,7 @@ export function resolveAndValidateCreateAgentMode(
  }

  throw new Error(
-    `cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode in settings.modeId. Available modes for '${targetProvider}': ${listModes(availableModes)}`,
+    `cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`,
  );
 }

@@ -120,7 +120,6 @@ import {
 } from "../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
-import { resolveResumeProcessCwd } from "./resume-process-cwd.js";
 import {
  buildStringCommandShellInvocation,
  createStringCommandShellEnvOverlay,
@@ -166,6 +165,18 @@ function rejectOnProcessFailure(child: ChildProcess, stderrChunks: string[]): Pr
  });
 }

+async function isDirectory(target: string): Promise<boolean> {
+  try {
+    return (await fs.stat(target)).isDirectory();
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
  return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -2872,8 +2883,11 @@ export class ACPAgentSession implements AgentSession, ACPClient {
  // Loading an archived agent's history runs nothing in its working directory, which
  // may have been removed with its worktree. session/load still names the original
  // directory; only the process starts from the home directory.
-  private resolveProcessCwd(): Promise<string> {
-    return resolveResumeProcessCwd(this.config.cwd, this.resumePurpose);
+  private async resolveProcessCwd(): Promise<string> {
+    if (this.resumePurpose !== "history" || (await isDirectory(this.config.cwd))) {
+      return this.config.cwd;
+    }
+    return homedir();
  }

  private async spawnProcess(): Promise<SpawnedACPProcess> {
@@ -1,190 +0,0 @@
-import { expect, test } from "vitest";
-import { createTestLogger } from "../../../../test-utils/test-logger.js";
-import { collectSessionTurnEvents } from "../test-utils/session-stream-adapter.js";
-import { ClaudeAgentClient } from "./agent.js";
-import type { ClaudeQueryFactory } from "./query.js";
-
-const LIMIT = "You've hit your session limit · resets 5:20pm (Asia/Singapore)";
-
-interface ScriptedTurn {
-  // An API error reply as Claude Code writes it: a synthetic assistant message with `error`.
-  errorReply?: string;
-  // Assistant text the model wrote before or after it.
-  before?: string;
-  after?: string;
-  isError: boolean;
-  usage?: {
-    inputTokens: number;
-    cachedInputTokens: number;
-    outputTokens: number;
-    totalCostUsd: number;
-  };
-}
-
-// A query dependency that speaks Claude Code's stream interface, one scripted turn per prompt.
-function scriptedQuery(turns: ScriptedTurn[]): ClaudeQueryFactory {
-  return ({ prompt }) => {
-    let index = 0;
-    const assistant = (id: string, text: string, error?: string) => ({
-      type: "assistant",
-      session_id: "error-session",
-      parent_tool_use_id: null,
-      uuid: id,
-      message: {
-        id,
-        role: "assistant",
-        model: error ? "<synthetic>" : "claude-opus-5-5",
-        content: [{ type: "text", text }],
-        stop_reason: "stop_sequence",
-        usage: { input_tokens: 0, output_tokens: 0 },
-      },
-      ...(error ? { error } : {}),
-    });
-    const messages = (async function* () {
-      if (typeof prompt === "string") throw new Error("Expected streaming input");
-      for await (const _message of prompt) {
-        const turn = turns[index];
-        index += 1;
-        yield {
-          type: "system",
-          subtype: "init",
-          session_id: "error-session",
-          permissionMode: "default",
-          model: "claude-opus-5-5",
-        };
-        if (turn.before) yield assistant(`before-${index}`, turn.before);
-        if (turn.errorReply) yield assistant(`error-${index}`, turn.errorReply, "rate_limit");
-        if (turn.after) yield assistant(`after-${index}`, turn.after);
-        yield {
-          type: "result",
-          subtype: "success",
-          session_id: "error-session",
-          duration_ms: 1,
-          duration_api_ms: 0,
-          is_error: turn.isError,
-          num_turns: 1,
-          result: turn.isError ? (turn.errorReply ?? "") : (turn.after ?? turn.errorReply ?? ""),
-          stop_reason: "stop_sequence",
-          total_cost_usd: turn.usage?.totalCostUsd ?? 0,
-          usage: {
-            input_tokens: turn.usage?.inputTokens ?? 0,
-            output_tokens: turn.usage?.outputTokens ?? 0,
-            cache_read_input_tokens: turn.usage?.cachedInputTokens ?? 0,
-          },
-          modelUsage: {},
-          permission_denials: [],
-          uuid: `result-${index}`,
-        };
-      }
-    })();
-    return Object.assign(messages, {
-      close: () => {
-        void messages.return();
-      },
-      interrupt: async () => undefined,
-      setModel: async () => undefined,
-      setPermissionMode: async () => undefined,
-      supportedModels: async () => [],
-      supportedCommands: async () => [],
-    }) as ReturnType<ClaudeQueryFactory>;
-  };
-}
-
-async function runTurns(turns: ScriptedTurn[]) {
-  const client = new ClaudeAgentClient({
-    logger: createTestLogger(),
-    queryFactory: scriptedQuery(turns),
-    resolveBinary: async () => process.execPath,
-  });
-  const session = await client.createSession({
-    provider: "claude",
-    cwd: process.cwd(),
-  });
-  try {
-    const results = [];
-    for (const [index] of turns.entries()) {
-      results.push(await collectSessionTurnEvents(session, `turn ${index + 1}`));
-    }
-    return results;
-  } finally {
-    await session.close();
-  }
-}
-
-function assistantTexts(events: Awaited<ReturnType<typeof runTurns>>[number]): string[] {
-  return events.flatMap((event) =>
-    event.type === "timeline" && event.item.type === "assistant_message" ? [event.item.text] : [],
-  );
-}
-
-function terminal(events: Awaited<ReturnType<typeof runTurns>>[number]) {
-  return events.find(
-    (event) =>
-      event.type === "turn_completed" ||
-      event.type === "turn_failed" ||
-      event.type === "turn_canceled",
-  );
-}
-
-test("a turn Claude Code ends on an API error fails with the error, shown once", async () => {
-  const [limited, overloaded, next] = await runTurns([
-    { errorReply: LIMIT, isError: true },
-    {
-      before: "Checking the deploy doc.",
-      errorReply: "API Error: 529 Overloaded",
-      isError: true,
-    },
-    { after: "Done.", isError: false },
-  ]);
-
-  expect(terminal(limited)).toMatchObject({
-    type: "turn_failed",
-    error: LIMIT,
-  });
-  expect(assistantTexts(limited)).toEqual([]);
-
-  expect(terminal(overloaded)).toMatchObject({
-    type: "turn_failed",
-    error: "API Error: 529 Overloaded",
-  });
-  expect(assistantTexts(overloaded)).toEqual(["Checking the deploy doc."]);
-
-  // The session keeps working after a failed turn.
-  expect(terminal(next)).toMatchObject({ type: "turn_completed" });
-  expect(assistantTexts(next)).toEqual(["Done."]);
-});
-
-test("a failed turn retains its final token counts and cost", async () => {
-  const usage = {
-    inputTokens: 120,
-    cachedInputTokens: 80,
-    outputTokens: 30,
-    totalCostUsd: 0.012,
-  };
-  const [failed] = await runTurns([
-    { before: "Checking the deploy doc.", errorReply: LIMIT, isError: true, usage },
-  ]);
-
-  expect(failed).toContainEqual(
-    expect.objectContaining({ type: "usage_updated", usage: expect.objectContaining(usage) }),
-  );
-  expect(terminal(failed)).toMatchObject({ type: "turn_failed", error: LIMIT });
-  expect(assistantTexts(failed)).toEqual(["Checking the deploy doc."]);
-});
-
-test("an error reply the turn moves past is still shown", async () => {
-  const [recovered, completed] = await runTurns([
-    {
-      errorReply: "API Error: 529 Overloaded",
-      after: "Recovered.",
-      isError: false,
-    },
-    { errorReply: LIMIT, isError: false },
-  ]);
-
-  expect(terminal(recovered)).toMatchObject({ type: "turn_completed" });
-  expect(assistantTexts(recovered)).toEqual(["API Error: 529 Overloaded", "Recovered."]);
-
-  expect(terminal(completed)).toMatchObject({ type: "turn_completed" });
-  expect(assistantTexts(completed)).toEqual([LIMIT]);
-});
@@ -1,4 +1,3 @@
-import { constants as bufferConstants } from "node:buffer";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -237,64 +236,4 @@ describe("importing a renamed Claude session", () => {

    await expect(importSession(sessionId)).rejects.toThrow();
  });
-
-  test("reads the rename from a transcript too large to hold as one string", async () => {
-    const sessionId = "oversized-transcript";
-    const projectDir = claudeProjectDirSync(SESSION_CWD, { configDir });
-    await fs.mkdir(projectDir, { recursive: true });
-    const transcript = path.join(projectDir, `${sessionId}.jsonl`);
-    // A hole stands in for the long session this used to fail on: the file only
-    // has to be longer than a string can be, and the rename sits at its end.
-    await fs.writeFile(transcript, "");
-    await fs.truncate(transcript, bufferConstants.MAX_STRING_LENGTH + 1);
-    await fs.appendFile(
-      transcript,
-      `\n${[
-        userRecord({ sessionId, content: "Trace the slow query" }),
-        { type: "custom-title", customTitle: "Slow query hunt", sessionId },
-      ]
-        .map((record) => JSON.stringify(record))
-        .join("\n")}\n`,
-    );
-
-    const imported = await importSession(sessionId);
-
-    expect(imported.config.title).toBe("Slow query hunt");
-  });
-
-  test("reads the rename from behind more records than one read covers", async () => {
-    const sessionId = "late-records-rename";
-    await writeSession({
-      sessionId,
-      records: [
-        userRecord({ sessionId, content: "Review this project" }),
-        { type: "custom-title", customTitle: "Scrollback review", sessionId },
-        // One record longer than a single read, then enough records to leave the
-        // rename several reads back from the end of the file.
-        userRecord({ sessionId, content: "x".repeat(128 * 1024) }),
-        ...Array.from({ length: 64 }, (_, index) =>
-          userRecord({ sessionId, content: `${"y".repeat(4 * 1024)} ${index}` }),
-        ),
-      ],
-    });
-
-    const imported = await importSession(sessionId);
-
-    expect(imported.config.title).toBe("Scrollback review");
-  });
-
-  test("imports a large record after the last rename without repeatedly copying it", async () => {
-    const sessionId = "large-record-after-rename";
-    await writeSession({
-      sessionId,
-      records: [
-        { type: "custom-title", customTitle: "Large attachment review", sessionId },
-        userRecord({ sessionId, content: "x".repeat(96 * 1024 * 1024) }),
-      ],
-    });
-
-    const imported = await importSession(sessionId);
-
-    expect(imported.config.title).toBe("Large attachment review");
-  });
 });
@@ -1183,6 +1183,7 @@ test("reuses one autonomous run for unbound stream_event bursts with no foregrou
  const session = await createSession();
  const internal: {
    turnState: "idle" | "foreground" | "autonomous";
+    nextTurnOrdinal: number;
    routeSdkMessageFromPump: (
      message: Record<string, unknown>,
      activeQuery: QueryMock,
@@ -1205,7 +1206,8 @@ test("reuses one autonomous run for unbound stream_event bursts with no foregrou
  );

  const firstRunId = internal.autonomousTurn?.id ?? null;
-  expect(firstRunId).toMatch(/^autonomous-turn-[0-9a-f]+-1$/);
+  expect(firstRunId).toBe("autonomous-turn-1");
+  expect(internal.nextTurnOrdinal).toBe(2);

  await internal.routeSdkMessageFromPump(
    {
@@ -1218,6 +1220,7 @@ test("reuses one autonomous run for unbound stream_event bursts with no foregrou
    queryMock,
  );
  expect(internal.autonomousTurn?.id).toBe(firstRunId);
+  expect(internal.nextTurnOrdinal).toBe(2);

  await internal.routeSdkMessageFromPump(
    {
@@ -1357,7 +1360,7 @@ test("a main-session frame opens no turn until Claude starts one", async () => {
  // session start a turn of its own, with no prompt from the user.
  await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
  await internal.routeSdkMessageFromPump(unboundTextDelta("picking this up"), queryMock);
-  expect(internal.autonomousTurn?.id).toMatch(/^autonomous-turn-[0-9a-f]+-1$/);
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");

  await internal.routeSdkMessageFromPump(successResult(), queryMock);
  expect(internal.autonomousTurn).toBeNull();
@@ -1407,7 +1410,7 @@ test("Claude waking up after a helper finishes gets an autonomous turn that its
  expect(internal.autonomousTurn).toBeNull();

  await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toMatch(/^autonomous-turn-[0-9a-f]+-1$/);
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");
  expect(internal.turnState).toBe("autonomous");

  await internal.routeSdkMessageFromPump(unboundTextDelta("the helper is done"), queryMock);
@@ -1443,7 +1446,7 @@ test("a steer folded into a turn keeps one turn, and a turn Claude starts after

  // A message that arrived while Claude wrote its final answer runs as a turn of its own.
  await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toMatch(/^autonomous-turn-[0-9a-f]+-2$/);
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-2");
  await internal.routeSdkMessageFromPump(successResult(), queryMock);
  expect(internal.autonomousTurn).toBeNull();
  expect(internal.turnState).toBe("idle");
@@ -1480,7 +1483,7 @@ test("an idle session state closes an autonomous turn that no result closed", as
  session.subscribe((event) => events.push(event));

  await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toMatch(/^autonomous-turn-[0-9a-f]+-1$/);
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");

  // Safety net: Claude says nothing at all is running any more.
  await internal.routeSdkMessageFromPump(sessionState("idle"), queryMock);
@@ -1682,7 +1685,7 @@ test("a new turn clears an interrupt flag no result will consume", async () => {

  await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
  expect(internal.pendingInterruptAbort).toBe(false);
-  expect(internal.autonomousTurn?.id).toMatch(/^autonomous-turn-[0-9a-f]+-1$/);
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");

  // This turn's own failure is reported, not swallowed as the interrupted turn's leftover.
  await internal.routeSdkMessageFromPump(
@@ -1,48 +0,0 @@
-import pino from "pino";
-import { describe, expect, test } from "vitest";
-
-import { ClaudeAgentClient } from "./agent.js";
-
-describe("Claude runtime info before a turn", () => {
-  const client = new ClaudeAgentClient({ logger: pino({ level: "silent" }) });
-
-  test("reports the explicitly configured model before the first turn", async () => {
-    const session = await client.createSession({
-      provider: "claude",
-      cwd: process.cwd(),
-      model: "claude-haiku-5-5",
-    });
-    try {
-      expect(await session.getRuntimeInfo()).toMatchObject({ model: "claude-haiku-5-5" });
-    } finally {
-      await session.close();
-    }
-  });
-
-  test("reports the persisted configured model after rebuilding an idle session", async () => {
-    const session = await client.resumeSession({
-      provider: "claude",
-      sessionId: "runtime-model-before-turn",
-      metadata: { cwd: process.cwd(), model: "claude-haiku-5-5" },
-    });
-    try {
-      expect(await session.getRuntimeInfo()).toMatchObject({
-        sessionId: "runtime-model-before-turn",
-        model: "claude-haiku-5-5",
-      });
-      expect((await session.getRuntimeInfo()).model).toBe("claude-haiku-5-5");
-      expect((await session.getRuntimeInfo()).extra?.runtimeModel).toBeUndefined();
-    } finally {
-      await session.close();
-    }
-  });
-
-  test("leaves the model unknown when Claude will choose its default", async () => {
-    const session = await client.createSession({ provider: "claude", cwd: process.cwd() });
-    try {
-      expect((await session.getRuntimeInfo()).model).toBeNull();
-    } finally {
-      await session.close();
-    }
-  });
-});
@@ -887,30 +887,6 @@ describe("ClaudeAgentSession features", () => {
    await session.close();
  });

-  test("issues turn ids that stay unique after the session is reopened", async () => {
-    // Idle runtime collection closes the provider session; the next prompt reopens it from
-    // persistence while the daemon keeps the earlier turns' rows and their turn ids.
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paseo-claude-turn-ids-"));
-    vi.stubEnv("CLAUDE_CONFIG_DIR", path.join(tempRoot, "claude-config"));
-    const client = new ClaudeAgentClient({
-      logger,
-      queryFactory: createQueryMock().queryFactory,
-      resolveBinary: async () => "/test/claude/bin",
-    });
-    const handle = { provider: "claude" as const, sessionId: "reopened-session" };
-    const first = await client.resumeSession(handle, { cwd: process.cwd() });
-    const { turnId: firstTurnId } = await first.startTurn("first prompt");
-    await first.close();
-
-    const second = await client.resumeSession(handle, { cwd: process.cwd() });
-    const { turnId: secondTurnId } = await second.startTurn("second prompt");
-    await second.close();
-    vi.unstubAllEnvs();
-    await fs.rm(tempRoot, { recursive: true, force: true });
-
-    expect(secondTurnId).not.toBe(firstTurnId);
-  });
-
  test("keeps an extraArgs settings file when Paseo sets Claude flag settings", async () => {
    const settingsDir = await fs.mkdtemp(path.join(os.tmpdir(), "paseo-claude-settings-"));
    const settingsPath = path.join(settingsDir, "settings.json");
@@ -1,6 +1,5 @@
 import { setImmediate } from "node:timers/promises";
 import { ClaudeRuntimeSafety } from "./runtime-safety.js";
-import { createTurnIdSequence } from "../../turn-ids.js";
 import { validateProviderOptions } from "../../provider-options.js";
 import type { ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -2372,7 +2371,7 @@ class ClaudeAgentSession implements AgentSession {
  private historySessionId: string | null = null;
  private replayingHistory = false;
  private turnState: TurnState = "idle";
-  private readonly nextTurnId = createTurnIdSequence(1);
+  private nextTurnOrdinal = 1;
  private cancelCurrentTurn: (() => void) | null = null;
  private cachedRuntimeInfo: AgentRuntimeInfo | null = null;
  private lastOptionsModel: string | null = null;
@@ -2390,12 +2389,6 @@ class ClaudeAgentSession implements AgentSession {
  private mainTurnInFlight = false;
  private foregroundHasVisibleActivity = false;
  private activeTurnHasAssistantText = false;
-  /**
-   * The reply Claude Code writes when a turn stops on an API error ("You've hit your session
-   * limit", "API Error: 529 ..."), held back until the result says whether the turn failed: a
-   * failed turn shows the same text as its error, so showing both would repeat it.
-   */
-  private withheldErrorReply: AgentTimelineItem[] = [];
  private readonly contextUsage: ClaudeContextUsageState;
  private userMessageIds: string[] = [];
  private readonly emittedUserMessageIds = new Set<string>();
@@ -2467,7 +2460,7 @@ class ClaudeAgentSession implements AgentSession {
    const info: AgentRuntimeInfo = {
      provider: "claude",
      sessionId: this.claudeSessionId,
-      model: this.lastOptionsModel ?? this.config.model ?? null,
+      model: this.lastOptionsModel,
      modeId: this.currentMode ?? null,
      ...(this.lastRuntimeModel
        ? {
@@ -2538,7 +2531,6 @@ class ClaudeAgentSession implements AgentSession {
    this.activeForegroundTurnId = turnId;
    this.foregroundHasVisibleActivity = false;
    this.activeTurnHasAssistantText = false;
-    this.withheldErrorReply = [];
    this.contextUsage.beginTurn();
    this.transitionTurnState("foreground", "foreground turn started");
    this.clearRecentStderr();
@@ -3941,7 +3933,7 @@ class ClaudeAgentSession implements AgentSession {
  }

  private createTurnId(owner: "foreground" | "autonomous"): string {
-    return this.nextTurnId(owner);
+    return `${owner}-turn-${this.nextTurnOrdinal++}`;
  }

  private isTerminalTurnEvent(event: AgentStreamEvent): boolean {
@@ -4427,21 +4419,6 @@ class ClaudeAgentSession implements AgentSession {
              }) satisfies AgentStreamEvent,
          );

-    if (!readClaudeParentToolUseId(message)) {
-      if (message.type === "assistant" && message.error) {
-        this.withheldErrorReply.push(...assistantTimelineEvents.map((event) => event.item));
-        return messageEvents;
-      }
-      if (
-        message.type === "assistant" ||
-        message.type === "user" ||
-        message.type === "stream_event"
-      ) {
-        const released: AgentStreamEvent[] = [];
-        this.releaseWithheldErrorReply(released);
-        return [...released, ...messageEvents, ...assistantTimelineEvents];
-      }
-    }
    return [...messageEvents, ...assistantTimelineEvents];
  }

@@ -4989,23 +4966,6 @@ class ClaudeAgentSession implements AgentSession {
    events: AgentStreamEvent[],
  ): void {
    const usage = this.convertUsage(message);
-    // Claude Code reports a turn that stopped on an API error (a usage limit, an overloaded or
-    // rejected request) as `success` with `is_error`, carrying the error text in `result`.
-    if (message.subtype === "success" && message.is_error) {
-      const withheld = this.withheldErrorReply;
-      this.withheldErrorReply = [];
-      const resultText = typeof message.result === "string" ? message.result.trim() : "";
-      const withheldText = withheld
-        .map((item) => (item.type === "assistant_message" ? item.text : ""))
-        .join("\n")
-        .trim();
-      if (usage) events.push({ type: "usage_updated", provider: "claude", usage });
-      events.push(...this.sidechainTracker.finishAll("failed"));
-      events.push(this.buildTurnFailedEvent(resultText || withheldText || "Claude run failed"));
-      return;
-    }
-    const releasedErrorReply = this.withheldErrorReply.length > 0;
-    this.releaseWithheldErrorReply(events);
    if (message.subtype === "success") {
      events.push(...this.sidechainTracker.finishAll("completed"));
      // Built-in slash commands (e.g. /voice, /usage, "Unknown command: …")
@@ -5015,12 +4975,7 @@ class ClaudeAgentSession implements AgentSession {
      // accounting from provider gateways does not duplicate streamed output.
      const resultText = typeof message.result === "string" ? message.result.trim() : "";
      const outputTokens = message.usage?.output_tokens;
-      if (
-        resultText.length > 0 &&
-        outputTokens === 0 &&
-        !this.activeTurnHasAssistantText &&
-        !releasedErrorReply
-      ) {
+      if (resultText.length > 0 && outputTokens === 0 && !this.activeTurnHasAssistantText) {
        events.push({
          type: "timeline",
          provider: "claude",
@@ -5042,14 +4997,6 @@ class ClaudeAgentSession implements AgentSession {
    events.push(this.buildTurnFailedEvent(errorMessage));
  }

-  private releaseWithheldErrorReply(events: AgentStreamEvent[]): void {
-    if (this.withheldErrorReply.length === 0) return;
-    for (const item of this.withheldErrorReply) {
-      events.push({ type: "timeline", item, provider: "claude" });
-    }
-    this.withheldErrorReply = [];
-  }
-
  private createClaudeSessionChangedNotice(
    oldSessionId: string,
    newSessionId: string,
@@ -6906,79 +6853,40 @@ function normalizeClaudeSessionTitle(title: string | null): string | null {
 }

 const CLAUDE_CUSTOM_TITLE_TYPE = "custom-title";
-const CLAUDE_CUSTOM_TITLE_NEEDLE = Buffer.from(`"${CLAUDE_CUSTOM_TITLE_TYPE}"`);
-const CLAUDE_TITLE_SCAN_CHUNK_BYTES = 64 * 1024;
-
-function readClaudeCustomTitleFromRecord(record: Buffer): string | null {
-  // The needle also matches a prompt that quotes it, so a record still has to
-  // parse as a `custom-title` entry carrying a usable name. Records without the
-  // needle are never decoded, so a long one costs a byte search and nothing more.
-  if (!record.includes(CLAUDE_CUSTOM_TITLE_NEEDLE)) {
-    return null;
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(record.toString("utf8").trim());
-  } catch {
-    return null;
-  }
-  const entry = toObjectRecord(parsed);
-  if (!entry || entry.isSidechain || entry.type !== CLAUDE_CUSTOM_TITLE_TYPE) {
-    return null;
-  }
-  return normalizeClaudeSessionTitle(
-    typeof entry.customTitle === "string" ? entry.customTitle : null,
-  );
-}

 /**
 * The `custom-title` record is re-emitted every time the session is saved, so
- * the current name is the last usable one in the file. Reading backwards a chunk
- * at a time finds it without walking the transcript, which matters because
- * sessions reach tens of megabytes, and never holds the file as one string, so a
- * transcript past V8's maximum string length still imports.
+ * the current name is the last usable one in the file. Searching backwards finds it without
+ * walking the transcript, which matters because sessions reach tens of
+ * megabytes.
 */
-async function readLastClaudeCustomTitle(filePath: string): Promise<string | null> {
-  const handle = await fsPromises.open(filePath, "r");
-  try {
-    const stats = await handle.stat();
-    if (!stats.isFile()) {
-      // Opening a directory succeeds on Windows even though reading it does not,
-      // so reject the way reading the transcript as a file would.
-      throw Object.assign(
-        new Error(`EISDIR: illegal operation on a directory, read '${filePath}'`),
-        { code: "EISDIR", path: filePath },
+function readLastClaudeCustomTitle(content: string): string | null {
+  const needle = `"${CLAUDE_CUSTOM_TITLE_TYPE}"`;
+  let at = content.lastIndexOf(needle);
+  while (at >= 0) {
+    const lineStart = content.lastIndexOf("\n", at) + 1;
+    const lineEnd = content.indexOf("\n", at);
+    const line = lineEnd === -1 ? content.slice(lineStart) : content.slice(lineStart, lineEnd);
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line.trim());
+    } catch {
+      parsed = undefined;
+    }
+    const entry = toObjectRecord(parsed);
+    if (entry && !entry.isSidechain && entry.type === CLAUDE_CUSTOM_TITLE_TYPE) {
+      const title = normalizeClaudeSessionTitle(
+        typeof entry.customTitle === "string" ? entry.customTitle : null,
      );
-    }
-    let end = stats.size;
-    // Retain unfinished record pieces in reverse file order. Assemble each
-    // complete record once, so a large tool/image record costs linear work.
-    let pieces: Buffer[] = [];
-    while (end > 0) {
-      const length = Math.min(CLAUDE_TITLE_SCAN_CHUNK_BYTES, end);
-      const chunk = Buffer.alloc(length);
-      await handle.read(chunk, 0, length, end - length);
-      let recordEnd = chunk.length;
-      for (
-        let at = chunk.lastIndexOf(10);
-        at >= 0;
-        at = at === 0 ? -1 : chunk.lastIndexOf(10, at - 1)
-      ) {
-        pieces.push(chunk.subarray(at + 1, recordEnd));
-        const record = Buffer.concat(pieces.toReversed());
-        const title = readClaudeCustomTitleFromRecord(record);
-        if (title) return title;
-        pieces = [];
-        recordEnd = at;
+      if (title) {
+        return title;
      }
-      if (recordEnd > 0) pieces.push(chunk.subarray(0, recordEnd));
-      end -= length;
    }
-    // The first record in the file has no newline in front of it.
-    return readClaudeCustomTitleFromRecord(Buffer.concat(pieces.toReversed()));
-  } finally {
-    await handle.close();
+    // The needle also matches a prompt that quotes it, and a record can carry no
+    // usable name, so keep looking backwards for one that does.
+    at = at <= 0 ? -1 : content.lastIndexOf(needle, at - 1);
  }
+  return null;
 }

 function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
@@ -6990,8 +6898,9 @@ async function readClaudeRenamedSessionTitle(input: {
  sessionId: string;
  configDir: string;
 }): Promise<string | null> {
+  let content: string;
  try {
-    return await readLastClaudeCustomTitle(await claudeTranscriptPath(input));
+    content = await fsPromises.readFile(await claudeTranscriptPath(input), "utf8");
  } catch (error) {
    // A session with no transcript on disk has no rename to carry over. Every
    // other read failure is a real fault and stays explicit.
@@ -7000,6 +6909,7 @@ async function readClaudeRenamedSessionTitle(input: {
    }
    throw error;
  }
+  return readLastClaudeCustomTitle(content);
 }

 function normalizeImportablePromptPreview(text: string): string | null {
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { type Dirent, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -100,12 +100,6 @@ import { createTestLogger } from "../../../test-utils/test-logger.js";
 import { asInternals as castInternals, createStub } from "../../test-utils/class-mocks.js";
 import { AgentManager } from "../agent-manager.js";
 import { buildProviderRegistry } from "../provider-registry.js";
-import { sessionTurnIds } from "./test-utils/turn-ids.js";
-
-let codexTurnId = sessionTurnIds("codex");
-beforeEach(() => {
-  codexTurnId = sessionTurnIds("codex");
-});

 interface CollaborationModeRecord {
  name: string;
@@ -1287,29 +1281,6 @@ describe("Codex app-server provider", () => {
    }
  });

-  test("issues turn ids that stay unique after the thread is reopened", async () => {
-    // Idle runtime collection closes the provider session; the next prompt reopens it from
-    // persistence while the daemon keeps the earlier turns' rows and their turn ids.
-    const beforeReopen = createFakeCodexAppServer();
-    const firstSession =
-      await createProviderWithFakeAppServer(beforeReopen).createSession(createConfig());
-    const { turnId: firstTurnId } = await firstSession.startTurn("first turn");
-    const saved = waitForNextEvent(firstSession, "thread_started");
-    beforeReopen.startsTurn({ threadId: "thread-1" });
-    await saved;
-    const handle = firstSession.describePersistence()!;
-    await firstSession.close();
-
-    const afterReopen = createFakeCodexAppServer();
-    const resumed = await createProviderWithFakeAppServer(afterReopen).resumeSession(handle);
-    try {
-      const { turnId: secondTurnId } = await resumed.startTurn("turn after reopen");
-      expect(secondTurnId).not.toBe(firstTurnId);
-    } finally {
-      await resumed.close();
-    }
-  });
-
  test("keeps the default effort when a session without one is resumed after a restart", async () => {
    const beforeRestart = createFakeCodexAppServer();
    const firstSession = await createProviderWithFakeAppServer(beforeRestart).createSession(
@@ -4640,7 +4611,7 @@ describe("Codex app-server provider", () => {
      await expect(child).resolves.toMatchObject({
        type: "provider_subagent",
        provider: "codex",
-        turnId: codexTurnId(0),
+        turnId: "codex-turn-0",
        event: {
          type: "upsert",
          id: "legacy-only-child-thread",
@@ -4650,7 +4621,7 @@ describe("Codex app-server provider", () => {
      await expect(spawn).resolves.toMatchObject({
        type: "timeline",
        provider: "codex",
-        turnId: codexTurnId(0),
+        turnId: "codex-turn-0",
        item: {
          type: "tool_call",
          callId: "spawn-legacy-only-child",
@@ -1,5 +1,4 @@
 import { validateProviderOptions } from "../provider-options.js";
-import { createTurnIdSequence } from "../turn-ids.js";
 import {
  getAgentStreamEventTurnId,
  type AgentPermissionAction,
@@ -151,15 +150,6 @@ function isCodexAlreadyUnarchivedError(error: unknown, threadId: string): boolea

 const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2_000;
-// `turn/interrupt` ends a turn but leaves the shell commands it started running.
-// Each terminate is bounded by the first constant. A turn start waits for the
-// interrupted turn's commands to end, at most the interrupt's own bound plus one
-// terminate's and a margin, so it gives up only when a request outlives its timeout.
-const INTERRUPTED_TURN_TERMINATE_TIMEOUT_MS = 2_000;
-const INTERRUPTED_TURN_CLEANUP_WAIT_MS =
-  INTERRUPT_TIMEOUT_MS + INTERRUPTED_TURN_TERMINATE_TIMEOUT_MS + 500;
-// Turns whose commands are remembered; older turns are forgotten first.
-const INTERRUPTED_TURN_TRACKED_TURNS = 16;
 const CODEX_PROVIDER = "codex" as const;
 // These native provider identities belong to Codex, not to an older custom
 // Paseo provider. Never include them in a custom provider's legacy import scan.
@@ -3463,7 +3453,7 @@ export class CodexAppServerAgentSession implements AgentSession {
  private threadRollbackAvailable = true;
  private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
  private startupEvents: AgentStreamEvent[] | null = null;
-  private readonly nextTurnId = createTurnIdSequence(0);
+  private nextTurnOrdinal = 0;
  private activeForegroundTurnId: string | null = null;
  private activeClientMessageId: string | null = null;
  private cachedRuntimeInfo: AgentRuntimeInfo | null = null;
@@ -3486,14 +3476,6 @@ export class CodexAppServerAgentSession implements AgentSession {
  private pendingFileChangeOutputDeltas = new Map<string, string[]>();
  private pendingAssistantMessageBoundary = false;
  private terminalCommandByProcessId = new Map<string, string>();
-  // The root thread's still-running command process ids, keyed by the native turn that
-  // started them. Codex's `thread/backgroundTerminals/list` carries no turn, so
-  // `item/started` is the only record of which turn owns a process.
-  private terminalProcessIdsByTurnId = new Map<
-    string,
-    { processIds: Set<string>; terminatedProcessIds: Set<string>; interruptAccepted: boolean }
-  >();
-  private interruptedTurnCleanup: Promise<void> | null = null;
  private pendingUnlabeledTerminalInteractions = new Map<
    string,
    Array<{ callId: string; stdin: string | null }>
@@ -4449,9 +4431,6 @@ export class CodexAppServerAgentSession implements AgentSession {
        hasDeveloperInstructions: turnStart.hasDeveloperInstructions,
        hasCodexConfig: turnStart.hasCodexConfig,
      });
-      // The interrupted turn's commands end before this turn begins, so none of them
-      // outlives it into the new turn.
-      await this.waitForInterruptedTurnCleanup();
      if (pendingStart.cancelRequested) {
        throw new Error("Codex turn start was interrupted before reaching Codex");
      }
@@ -5057,27 +5036,15 @@ export class CodexAppServerAgentSession implements AgentSession {
    if (!turnId || (foregroundTurnId && this.activeForegroundTurnId !== foregroundTurnId)) {
      throw new Error("Cannot interrupt Codex before turn/started identifies the active turn");
    }
-    const client = this.client;
-    const threadId = this.currentThreadId;
-    const interruptRequest = client.request(
-      "turn/interrupt",
-      {
-        threadId,
-        turnId,
-      },
-      INTERRUPT_TIMEOUT_MS,
-    );
-    // Once Codex accepts the interrupt, end the commands this turn started. Registered
-    // before the await, so a turn start racing this interrupt waits for it. An already-idle
-    // turn was not interrupted, and what it left running stays.
-    this.trackInterruptedTurnCleanup(
-      interruptRequest.then(
-        () => this.endInterruptedTurnProcesses(client, threadId, turnId),
-        () => undefined,
-      ),
-    );
    try {
-      await interruptRequest;
+      await this.client.request(
+        "turn/interrupt",
+        {
+          threadId: this.currentThreadId,
+          turnId,
+        },
+        INTERRUPT_TIMEOUT_MS,
+      );
    } catch (error) {
      if (!isCodexAlreadyIdleInterrupt(error)) {
        throw error;
@@ -5118,137 +5085,6 @@ export class CodexAppServerAgentSession implements AgentSession {
    return !this.client.hasPendingRequests();
  }

-  // Remember which turn started a command, so an interrupt ends that turn's commands and
-  // no other turn's. Only the root thread's: a subagent's commands live on its own thread.
-  // A command that starts after its turn's interrupt was accepted is ended as soon as it
-  // is seen.
-  private recordTurnTerminalProcess(
-    parsed: Extract<ParsedCodexNotification, { kind: "item_started" | "item_completed" }>,
-  ): void {
-    const processId = parsed.item.processId;
-    if (
-      parsed.source !== "item" ||
-      !parsed.turnId ||
-      !parsed.threadId ||
-      parsed.threadId !== this.currentThreadId ||
-      typeof processId !== "string" ||
-      !processId ||
-      normalizeCodexThreadItemType(
-        typeof parsed.item.type === "string" ? parsed.item.type : undefined,
-      ) !== "commandExecution"
-    ) {
-      return;
-    }
-    const record = this.terminalProcessIdsByTurnId.get(parsed.turnId);
-    if (parsed.kind === "item_completed") {
-      // Only a completed command has exited. A failed one can still be running:
-      // Codex reports an interrupted turn's live command as failed.
-      if (parsed.item.status === "completed") record?.processIds.delete(processId);
-      return;
-    }
-    const current = record ?? this.getTurnTerminalRecord(parsed.turnId);
-    current.processIds.add(processId);
-    if (current.interruptAccepted && this.client) {
-      this.trackInterruptedTurnCleanup(
-        this.endInterruptedTurnProcesses(this.client, parsed.threadId, parsed.turnId),
-      );
-    }
-  }
-
-  // An accepted interrupt needs a record even before any of its turn's commands is seen:
-  // an `item/started` can still be queued behind an earlier notification's conversion.
-  private getTurnTerminalRecord(turnId: string) {
-    const existing = this.terminalProcessIdsByTurnId.get(turnId);
-    if (existing) return existing;
-    const record = {
-      processIds: new Set<string>(),
-      terminatedProcessIds: new Set<string>(),
-      interruptAccepted: false,
-    };
-    this.terminalProcessIdsByTurnId.set(turnId, record);
-    for (const oldestTurnId of this.terminalProcessIdsByTurnId.keys()) {
-      if (this.terminalProcessIdsByTurnId.size <= INTERRUPTED_TURN_TRACKED_TURNS) break;
-      this.terminalProcessIdsByTurnId.delete(oldestTurnId);
-    }
-    return record;
-  }
-
-  // A later sweep joins the pending one, so a turn start waits for both.
-  private trackInterruptedTurnCleanup(cleanup: Promise<void>): void {
-    const tracked = Promise.all([this.interruptedTurnCleanup, cleanup])
-      .then(() => undefined)
-      .finally(() => {
-        if (this.interruptedTurnCleanup === tracked) this.interruptedTurnCleanup = null;
-      });
-    this.interruptedTurnCleanup = tracked;
-  }
-
-  // Terminate each process the interrupted turn started, by its own id, once each.
-  // `thread/backgroundTerminals/clean` is never used: it ends every terminal on the thread,
-  // an earlier turn's included. A process already gone answers `terminated: false`. Never
-  // rejects; failures are logged.
-  private async endInterruptedTurnProcesses(
-    client: CodexAppServerClient,
-    threadId: string | null,
-    turnId: string,
-  ): Promise<void> {
-    if (!threadId) return;
-    const record = this.getTurnTerminalRecord(turnId);
-    record.interruptAccepted = true;
-    const processIds = [...record.processIds].filter(
-      (processId) => !record.terminatedProcessIds.has(processId),
-    );
-    for (const processId of processIds) record.terminatedProcessIds.add(processId);
-    const logContext = { agentId: this.agentId, provider: CODEX_PROVIDER, threadId, turnId };
-    await Promise.all(
-      processIds.map(async (processId) => {
-        try {
-          const response = await client.request(
-            "thread/backgroundTerminals/terminate",
-            { threadId, processId },
-            INTERRUPTED_TURN_TERMINATE_TIMEOUT_MS,
-          );
-          this.logger.info(
-            { ...logContext, processId, terminated: toObjectRecord(response)?.terminated ?? null },
-            "provider.codex.interrupt.terminal_terminated",
-          );
-        } catch (error) {
-          this.logger.warn(
-            { ...logContext, processId, err: error },
-            "provider.codex.interrupt.terminal_terminate_failed",
-          );
-        }
-      }),
-    );
-  }
-
-  // A new turn starts only after every pending sweep of interrupted turns' commands has
-  // ended, or after the bound, whichever is first.
-  private async waitForInterruptedTurnCleanup(): Promise<void> {
-    if (!this.interruptedTurnCleanup) return;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const timedOut = await Promise.race([
-      (async () => {
-        while (this.interruptedTurnCleanup) await this.interruptedTurnCleanup;
-        return false;
-      })(),
-      new Promise<boolean>((resolve) => {
-        timer = setTimeout(() => resolve(true), INTERRUPTED_TURN_CLEANUP_WAIT_MS);
-      }),
-    ]);
-    clearTimeout(timer);
-    if (timedOut) {
-      this.logger.warn(
-        {
-          agentId: this.agentId,
-          provider: CODEX_PROVIDER,
-          waitMs: INTERRUPTED_TURN_CLEANUP_WAIT_MS,
-        },
-        "provider.codex.interrupt.terminal_cleanup_timed_out",
-      );
-    }
-  }
-
  async close(): Promise<void> {
    this.closed = true;
    this.clearPendingPermissions();
@@ -5628,7 +5464,7 @@ export class CodexAppServerAgentSession implements AgentSession {
  }

  private createTurnId(): string {
-    return this.nextTurnId("codex");
+    return `codex-turn-${this.nextTurnOrdinal++}`;
  }

  private pendingNotifications: Promise<void> = Promise.resolve();
@@ -6373,11 +6209,6 @@ export class CodexAppServerAgentSession implements AgentSession {
      return;
    }
    this.completePendingRootCompactions();
-    // What a turn that was not interrupted leaves running, it left on purpose; no later
-    // interrupt may end it.
-    if (parsed.status !== "interrupted" && this.currentTurnId) {
-      this.terminalProcessIdsByTurnId.delete(this.currentTurnId);
-    }
    if (parsed.status === "failed") {
      this.emitEvent({
        type: "turn_failed",
@@ -6782,7 +6613,6 @@ export class CodexAppServerAgentSession implements AgentSession {
  private async handleItemCompletedNotification(
    parsed: Extract<ParsedCodexNotification, { kind: "item_completed" }>,
  ): Promise<void> {
-    this.recordTurnTerminalProcess(parsed);
    // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
    // and canonical `item/*`. Render ordinary items only from the canonical
    // channel, but accept a legacy-only child announcement so it can establish
@@ -6945,7 +6775,6 @@ export class CodexAppServerAgentSession implements AgentSession {
  private async handleItemStartedNotification(
    parsed: Extract<ParsedCodexNotification, { kind: "item_started" }>,
  ): Promise<void> {
-    this.recordTurnTerminalProcess(parsed);
    if (shouldIgnoreMirroredLifecycleItem(parsed.source, parsed.item)) {
      return;
    }
@@ -1,374 +0,0 @@
-import { afterEach, describe, expect, test, vi } from "vitest";
-
-import type { AgentSession } from "../agent-sdk-types.js";
-import { createTestLogger } from "../../../test-utils/test-logger.js";
-import { CodexAppServerAgentSession } from "./codex-app-server-agent.js";
-import {
-  createFakeCodexAppServer,
-  type FakeCodexAppServer,
-  waitForNextEvent,
-  waitForTimelineToolCall,
-} from "./codex/test-utils/fake-app-server.js";
-
-const THREAD = "thread-1";
-const TERMINATE = "thread/backgroundTerminals/terminate";
-
-type Handler = (params: unknown) => unknown;
-
-function deferred<T = void>() {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((resolvePromise) => {
-    resolve = resolvePromise;
-  });
-  return { promise, resolve };
-}
-
-function paramsOf(value: unknown): Record<string, unknown> {
-  return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
-}
-
-let sessions: AgentSession[] = [];
-
-afterEach(async () => {
-  for (const session of sessions) await session.close().catch(() => undefined);
-  sessions = [];
-});
-
-/**
- * A Codex app-server whose interrupt ends the turn the way Codex does: an `interrupted`
- * turn completion, then the response. `terminate` answers per process.
- */
-function createHarness(
-  options: {
-    terminate?: (processId: string) => unknown;
-    interruptResponse?: (completeTurn: () => void) => unknown;
-  } = {},
-) {
-  const handlers: Record<string, Handler> = {
-    "turn/interrupt": () => {
-      const completeTurn = () =>
-        appServer.completeTurn({ threadId: THREAD, status: "interrupted" });
-      if (options.interruptResponse) return options.interruptResponse(completeTurn);
-      completeTurn();
-      return {};
-    },
-    [TERMINATE]: (params) =>
-      options.terminate?.(String(paramsOf(params).processId)) ?? { terminated: true },
-  };
-  const appServer: FakeCodexAppServer = createFakeCodexAppServer(handlers);
-  const session = new CodexAppServerAgentSession(
-    {
-      provider: "codex",
-      cwd: "/workspace/project",
-      modeId: "auto",
-      model: "gpt-5.4",
-    },
-    null,
-    createTestLogger(),
-    async () => appServer.child,
-  );
-  sessions.push(session);
-
-  function requests(method: string): Record<string, unknown>[] {
-    return appServer
-      .requests()
-      .filter((message) => message.method === method && "id" in message)
-      .map((message) => paramsOf(message.params));
-  }
-
-  function terminated(): string[] {
-    return requests(TERMINATE)
-      .map((params) => String(params.processId))
-      .sort();
-  }
-
-  // Starts a turn and lets Codex identify it as `nativeTurnId`.
-  async function startTurn(prompt: string, nativeTurnId: string): Promise<void> {
-    const before = requests("turn/start").length;
-    const started = session.startTurn(prompt);
-    await vi.waitFor(() => expect(requests("turn/start")).toHaveLength(before + 1), {
-      timeout: 5_000,
-    });
-    const turnStarted = waitForNextEvent(session, "turn_started");
-    appServer.startsTurn({ threadId: THREAD, turnId: nativeTurnId });
-    await started;
-    await turnStarted;
-  }
-
-  async function runsCommand(params: { turnId: string; processId: string }): Promise<void> {
-    const itemId = `exec-${params.processId}`;
-    const shown = waitForTimelineToolCall(session, itemId);
-    appServer.startsTerminalCommand({
-      threadId: THREAD,
-      turnId: params.turnId,
-      itemId,
-      processId: params.processId,
-      command: `sleep ${params.processId}`,
-    });
-    await shown;
-  }
-
-  async function completesTurn(): Promise<void> {
-    const completed = waitForNextEvent(session, "turn_completed");
-    appServer.completeTurn({ threadId: THREAD });
-    await completed;
-  }
-
-  // Interrupts the running turn and waits for the session to report it canceled, as a
-  // caller does before it starts the next turn: Codex notifications are handled in order
-  // but asynchronously, so the interrupt's answer can arrive before the turn has ended.
-  async function interrupts(): Promise<void> {
-    const canceled = waitForNextEvent(session, "turn_canceled");
-    await session.interrupt();
-    await canceled;
-  }
-
-  return {
-    appServer,
-    session,
-    requests,
-    terminated,
-    startTurn,
-    runsCommand,
-    completesTurn,
-    interrupts,
-  };
-}
-
-// Turn A leaves a server running on purpose and completes. Turn B starts two
-// commands, and a subagent on its own thread starts a third, then B is interrupted.
-async function interruptTurnB(harness: ReturnType<typeof createHarness>): Promise<void> {
-  await harness.startTurn("start a server", "native-A");
-  await harness.runsCommand({ turnId: "native-A", processId: "101" });
-  await harness.completesTurn();
-
-  await harness.startTurn("run two commands", "native-B");
-  await harness.runsCommand({ turnId: "native-B", processId: "201" });
-  // A subagent thread's command shows no row here; the next command's row shows it
-  // was read, because notifications are read in order.
-  harness.appServer.startsTerminalCommand({
-    threadId: "child-thread",
-    turnId: "native-B",
-    itemId: "exec-209",
-    processId: "209",
-    command: "sleep 209",
-  });
-  await harness.runsCommand({ turnId: "native-B", processId: "202" });
-  await harness.interrupts();
-}
-
-describe("an interrupted Codex turn's commands end before the next turn", () => {
-  test("terminates exactly the processes the interrupted turn started, by id, and never cleans", async () => {
-    const harness = createHarness();
-    await interruptTurnB(harness);
-    await harness.startTurn("correction", "native-C");
-
-    expect(harness.terminated()).toEqual(["201", "202"]);
-    expect(harness.requests(TERMINATE).every((params) => params.threadId === THREAD)).toBe(true);
-    // `clean` would end every terminal on the thread, an earlier turn's included.
-    expect(
-      harness.appServer
-        .requests()
-        .filter((message) => String(message.method).startsWith("thread/backgroundTerminals/"))
-        .map((message) => message.method),
-    ).toEqual([TERMINATE, TERMINATE]);
-    harness.appServer.assertNoErrors();
-  });
-
-  test("leaves the next turn's commands running when Codex starts that turn before acknowledging the interrupt", async () => {
-    const acknowledge = deferred();
-    const harness = createHarness({
-      // Codex ends B, starts a turn of its own (a goal continuation), and only then
-      // answers the interrupt.
-      interruptResponse: (completeTurn) => {
-        completeTurn();
-        return acknowledge.promise.then(() => ({}));
-      },
-    });
-    await harness.startTurn("run two commands", "native-B");
-    await harness.runsCommand({ turnId: "native-B", processId: "201" });
-    await harness.runsCommand({ turnId: "native-B", processId: "202" });
-    const interrupting = harness.session.interrupt();
-    await vi.waitFor(() => expect(harness.requests("turn/interrupt")).toHaveLength(1));
-    const autonomousTurn = waitForNextEvent(harness.session, "turn_started");
-    harness.appServer.startsTurn({ threadId: THREAD, turnId: "native-C" });
-    await autonomousTurn;
-    await harness.runsCommand({ turnId: "native-C", processId: "301" });
-
-    acknowledge.resolve();
-    await interrupting;
-    await vi.waitFor(() => expect(harness.terminated()).toEqual(["201", "202"]));
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    expect(harness.terminated()).toEqual(["201", "202"]);
-  });
-
-  test("sends the next turn/start only after the terminates are answered", async () => {
-    const answer = deferred();
-    const harness = createHarness({
-      terminate: () => answer.promise.then(() => ({ terminated: true })),
-    });
-    await interruptTurnB(harness);
-    const next = harness.startTurn("correction", "native-C");
-    await vi.waitFor(() => expect(harness.terminated()).toEqual(["201", "202"]));
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    expect(harness.requests("turn/start")).toHaveLength(2);
-
-    answer.resolve();
-    await next;
-    expect(harness.requests("turn/start")).toHaveLength(3);
-  });
-
-  test.each(["initial", "late"] as const)(
-    "tracks both cleanup sweeps when the %s answer arrives first",
-    async (answeredFirst) => {
-      const first = deferred();
-      const second = deferred();
-      const harness = createHarness({
-        terminate: (processId) =>
-          (processId === "201" ? first : second).promise.then(() => ({ terminated: true })),
-      });
-      await harness.startTurn("run commands", "native-B");
-      await harness.runsCommand({ turnId: "native-B", processId: "201" });
-      await harness.interrupts();
-      await vi.waitFor(() => expect(harness.terminated()).toEqual(["201"]));
-      const next = harness.startTurn("correction", "native-C");
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      expect(harness.requests("turn/start")).toHaveLength(1);
-      // The next turn is already waiting when another process is announced.
-      harness.appServer.startsTerminalCommand({
-        threadId: THREAD,
-        turnId: "native-B",
-        itemId: "late-202",
-        processId: "202",
-        command: "sleep 202",
-      });
-      harness.appServer.startsTerminalCommand({
-        threadId: THREAD,
-        turnId: "native-B",
-        itemId: "duplicate-202",
-        processId: "202",
-        command: "sleep 202",
-      });
-      await vi.waitFor(() => expect(harness.terminated()).toEqual(["201", "202"]));
-      (answeredFirst === "initial" ? first : second).resolve();
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      expect(harness.requests("turn/start")).toHaveLength(1);
-      (answeredFirst === "initial" ? second : first).resolve();
-      await next;
-      expect(harness.terminated()).toEqual(["201", "202"]);
-      // Accepted state survives the completed sweep and a newer foreground turn.
-      harness.appServer.startsTerminalCommand({
-        threadId: THREAD,
-        turnId: "native-B",
-        itemId: "late-203",
-        processId: "203",
-        command: "sleep 203",
-      });
-      await vi.waitFor(() => expect(harness.terminated()).toEqual(["201", "202", "203"]));
-      harness.appServer.assertNoErrors();
-    },
-  );
-
-  test("keeps the first sweep pending when a late sweep answers before the next start", async () => {
-    const first = deferred();
-    const harness = createHarness({
-      terminate: (processId) =>
-        processId === "201"
-          ? first.promise.then(() => ({ terminated: true }))
-          : { terminated: true },
-    });
-    await harness.startTurn("run commands", "native-B");
-    await harness.runsCommand({ turnId: "native-B", processId: "201" });
-    await harness.interrupts();
-    harness.appServer.startsTerminalCommand({
-      threadId: THREAD,
-      turnId: "native-B",
-      itemId: "late-202",
-      processId: "202",
-      command: "sleep 202",
-    });
-    await vi.waitFor(() => expect(harness.terminated()).toEqual(["201", "202"]));
-    const next = harness.startTurn("correction", "native-C");
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    expect(harness.requests("turn/start")).toHaveLength(1);
-    first.resolve();
-    await next;
-    harness.appServer.assertNoErrors();
-  });
-
-  test("forgets completed commands but retains failed commands at interrupt", async () => {
-    const harness = createHarness();
-    await harness.startTurn("run commands", "native-B");
-    for (const processId of ["201", "202"]) {
-      await harness.runsCommand({ turnId: "native-B", processId });
-      harness.appServer.child.stdout.write(
-        JSON.stringify({
-          method: "item/completed",
-          params: {
-            threadId: THREAD,
-            turnId: "native-B",
-            item: {
-              id: `exec-${processId}`,
-              type: "commandExecution",
-              processId,
-              command: `sleep ${processId}`,
-              status: processId === "201" ? "completed" : "failed",
-              exitCode: processId === "201" ? 0 : null,
-            },
-          },
-        }) + "\n",
-      );
-    }
-    // A following command's row is a barrier for both completion handlers.
-    await harness.runsCommand({ turnId: "native-B", processId: "203" });
-    await harness.interrupts();
-    await harness.startTurn("correction", "native-C");
-    expect(harness.terminated()).toEqual(["202", "203"]);
-    harness.appServer.assertNoErrors();
-  });
-
-  test("retains accepted interrupts for only the latest sixteen turns", async () => {
-    const harness = createHarness();
-    for (let index = 0; index < 17; index++) {
-      await harness.startTurn("run a command", `native-${index}`);
-      await harness.interrupts();
-    }
-    await harness.startTurn("correction", "native-current");
-    harness.appServer.startsTerminalCommand({
-      threadId: THREAD,
-      turnId: "native-0",
-      itemId: "evicted-201",
-      processId: "201",
-      command: "sleep 201",
-    });
-    harness.appServer.startsTerminalCommand({
-      threadId: THREAD,
-      turnId: "native-16",
-      itemId: "retained-202",
-      processId: "202",
-      command: "sleep 202",
-    });
-    await harness.runsCommand({ turnId: "native-current", processId: "301" });
-    expect(harness.terminated()).toEqual(["202"]);
-    harness.appServer.assertNoErrors();
-  });
-
-  test("a failing or unanswered terminate does not block or fail the next turn", async () => {
-    const harness = createHarness({
-      // 201 is refused while the next turn waits; 202 is never answered.
-      terminate: (processId) =>
-        processId === "201"
-          ? new Promise((resolve) => setTimeout(resolve, 300)).then(() => ({
-              __jsonRpcError: { code: -32600, message: "invalid background terminal process id" },
-            }))
-          : new Promise(() => {}),
-    });
-    await interruptTurnB(harness);
-    const startedAt = Date.now();
-    await harness.startTurn("correction", "native-C");
-
-    expect(Date.now() - startedAt).toBeLessThan(5_000);
-    expect(harness.requests("turn/start")).toHaveLength(3);
-    expect(harness.terminated()).toEqual(["201", "202"]);
-  }, 15_000);
-});
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -25,7 +25,6 @@ import type {
  AssistantMessageTimelineItem,
  AgentTimelineItem,
 } from "../agent-sdk-types.js";
-import { sessionTurnIds } from "./test-utils/turn-ids.js";

 // Deliberately an independent literal rather than the production constant these tests
 // guard: deriving the boundary from OPENCODE_SERVER_STARTUP_TIMEOUT_MS would keep the
@@ -33,11 +32,6 @@ import { sessionTurnIds } from "./test-utils/turn-ids.js";
 const EXPECTED_STARTUP_BUDGET_MS = 30_000;
 const EXPECTED_EVENT_READINESS_BUDGET_MS = 45_000;

-let openCodeTurnId = sessionTurnIds("opencode");
-beforeEach(() => {
-  openCodeTurnId = sessionTurnIds("opencode");
-});
-
 function tmpCwd(): string {
  const dir = mkdtempSync(path.join(os.tmpdir(), "opencode-agent-test-"));
  try {
@@ -1644,10 +1638,10 @@ describe("OpenCode adapter startTurn error handling", () => {
      item: { type: "user_message", clientMessageId: "client-message-1" },
    });
    expect(turn.events.map((event) => ("turnId" in event ? event.turnId : undefined))).toEqual([
-      openCodeTurnId(0),
-      openCodeTurnId(0),
-      openCodeTurnId(0),
-      openCodeTurnId(0),
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
    ]);
  });

@@ -1839,7 +1833,7 @@ describe("OpenCode adapter startTurn error handling", () => {
          type: "error",
          message: "Provider retry (attempt 1): model does not exist",
        },
-        turnId: openCodeTurnId(0),
+        turnId: "opencode-turn-0",
      });
      expect(events.some((event) => event.type === "turn_failed")).toBe(false);
      await session.close();
@@ -2379,35 +2373,6 @@ describe("OpenCode adapter startTurn error handling", () => {
    }
  });

-  test("issues turn ids that stay unique after the session is reopened", async () => {
-    // Idle runtime collection closes the provider session; the next prompt reopens it from
-    // persistence while the daemon keeps the earlier turns' rows and their turn ids.
-    const runtime = new TestOpenCodeHarness();
-    const client = new OpenCodeAgentClient(createTestLogger(), undefined, {
-      serverManager: runtime,
-      createClient: runtime.createClient,
-    });
-    const cwd = tmpCwd();
-    const handle = { provider: "opencode" as const, sessionId: "ses_reopened", metadata: { cwd } };
-    const turnIds: string[] = [];
-    try {
-      for (let instance = 0; instance < 2; instance += 1) {
-        const openCode = new TestOpenCodeClient();
-        openCode.sessionPromptAsyncEvents = [];
-        runtime.enqueueClient(openCode);
-        const session = await client.resumeSession(handle);
-        try {
-          turnIds.push((await session.startTurn("prompt")).turnId);
-        } finally {
-          await session.close();
-        }
-      }
-    } finally {
-      rmSync(cwd, { recursive: true, force: true });
-    }
-    expect(turnIds[1]).not.toBe(turnIds[0]);
-  });
-
  test("uses OpenCode native steer admission and reconciles the user echo", async () => {
    const { parent: session, openCode } = await createParentSession("ses_native_steer");
    openCode.sessionPromptAsyncEvents = [];
@@ -2676,11 +2641,11 @@ describe("OpenCode adapter startTurn error handling", () => {
      expect(
        turnEventSignatures(events.filter((event) => event.type !== "provider_subagent")),
      ).toEqual([
-        ["turn_started", openCodeTurnId(0)],
-        ["turn_canceled", openCodeTurnId(0)],
-        ["turn_started", openCodeTurnId(1)],
-        ["timeline", openCodeTurnId(1)],
-        ["turn_completed", openCodeTurnId(1)],
+        ["turn_started", "opencode-turn-0"],
+        ["turn_canceled", "opencode-turn-0"],
+        ["turn_started", "opencode-turn-1"],
+        ["timeline", "opencode-turn-1"],
+        ["turn_completed", "opencode-turn-1"],
      ]);
    } finally {
      settleRetry.resolve();
@@ -2741,7 +2706,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        expect(events).toContainEqual(
          expect.objectContaining({
            type: "timeline",
-            turnId: openCodeTurnId(1),
+            turnId: "opencode-turn-1",
            item: expect.objectContaining({ text: "Wake output streams live." }),
          }),
        ),
@@ -2761,11 +2726,11 @@ describe("OpenCode adapter startTurn error handling", () => {
      });
      await vi.waitFor(() =>
        expect(events).toContainEqual(
-          expect.objectContaining({ type: "turn_completed", turnId: openCodeTurnId(1) }),
+          expect.objectContaining({ type: "turn_completed", turnId: "opencode-turn-1" }),
        ),
      );
      await expect(session.startTurn("after the wake")).resolves.toEqual({
-        turnId: openCodeTurnId(2),
+        turnId: "opencode-turn-2",
      });
    } finally {
      settleAbort.resolve();
@@ -2878,13 +2843,13 @@ describe("OpenCode adapter startTurn error handling", () => {
      expect(events).toContainEqual({
        type: "turn_started",
        provider: "opencode",
-        turnId: openCodeTurnId(1),
+        turnId: "opencode-turn-1",
      });
      await vi.waitFor(() =>
        expect(events).toContainEqual({
          type: "turn_completed",
          provider: "opencode",
-          turnId: openCodeTurnId(1),
+          turnId: "opencode-turn-1",
          usage: expect.objectContaining({
            inputTokens: 7,
            outputTokens: 3,
@@ -2893,8 +2858,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        }),
      );
      const autonomousCompletion = events.find(
-        (event) =>
-          event.type === "turn_completed" && openCodeTurnId(1).asymmetricMatch(event.turnId),
+        (event) => event.type === "turn_completed" && event.turnId === "opencode-turn-1",
      );
      expect(autonomousCompletion?.type).toBe("turn_completed");
      if (autonomousCompletion?.type === "turn_completed") {
@@ -2903,7 +2867,7 @@ describe("OpenCode adapter startTurn error handling", () => {
      expect(events).toContainEqual(
        expect.objectContaining({
          type: "timeline",
-          turnId: openCodeTurnId(1),
+          turnId: "opencode-turn-1",
          item: expect.objectContaining({
            type: "assistant_message",
            text: "Autonomous wake completed.",
@@ -2911,7 +2875,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        }),
      );
      await expect(session.startTurn("after autonomous wake")).resolves.toEqual({
-        turnId: openCodeTurnId(2),
+        turnId: "opencode-turn-2",
      });
    } finally {
      settleAbort.resolve();
@@ -2990,7 +2954,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        type: "turn_canceled",
        provider: "opencode",
        reason: "interrupted",
-        turnId: openCodeTurnId(0),
+        turnId: "opencode-turn-0",
      });

      openCode.emitEvent({
@@ -2998,7 +2962,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        properties: { sessionID: "ses_retried_stop" },
      });
      await expect(session.startTurn("replacement")).resolves.toEqual({
-        turnId: openCodeTurnId(1),
+        turnId: "opencode-turn-1",
      });
      expect(openCode.calls.sessionPromptAsync).toHaveLength(2);
    } finally {
@@ -3094,7 +3058,7 @@ describe("OpenCode adapter startTurn error handling", () => {
        expect(events).toContainEqual({
          type: "turn_started",
          provider: "opencode",
-          turnId: openCodeTurnId(1),
+          turnId: "opencode-turn-1",
        }),
      );

@@ -3803,7 +3767,7 @@ describe("OpenCode adapter startTurn error handling", () => {
      ];
      const replacement = session.startTurn("second");
      await vi.advanceTimersByTimeAsync(10_000);
-      await expect(replacement).resolves.toEqual({ turnId: openCodeTurnId(1) });
+      await expect(replacement).resolves.toEqual({ turnId: "opencode-turn-1" });
      expect(countEvents(events, "turn_canceled")).toBe(1);
    } finally {
      vi.useRealTimers();
@@ -4058,7 +4022,7 @@ describe("OpenCode adapter startTurn error handling", () => {
      expect(openCode.calls.sessionStatus).toHaveLength(1);

      releaseIdle.resolve();
-      await expect(replacement).resolves.toEqual({ turnId: openCodeTurnId(1) });
+      await expect(replacement).resolves.toEqual({ turnId: "opencode-turn-1" });
      expect(openCode.calls.sessionPromptAsync).toHaveLength(2);
      expect(openCode.calls.sessionStatus.length).toBeGreaterThanOrEqual(2);
    } finally {
@@ -4758,9 +4722,9 @@ describe("OpenCode provider subagent contract", () => {
      "turn_completed",
    ]);
    expect(events.map((event) => ("turnId" in event ? event.turnId : undefined))).toEqual([
-      openCodeTurnId(0),
-      openCodeTurnId(0),
-      openCodeTurnId(0),
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
    ]);
    expect(events).toContainEqual(
      expect.objectContaining({
@@ -4796,7 +4760,7 @@ describe("OpenCode provider subagent contract", () => {
          expect(events).toContainEqual({
            type: "turn_started",
            provider: "opencode",
-            turnId: openCodeTurnId(0),
+            turnId: "opencode-turn-0",
          });
        });
        for (const event of assistantTurnEvents({
@@ -4810,9 +4774,9 @@ describe("OpenCode provider subagent contract", () => {

        expect(childClient.calls.sessionStatus).toEqual([{ directory: "/workspace/repo" }]);
        expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", openCodeTurnId(0)],
-          ["timeline", openCodeTurnId(0)],
-          ["turn_completed", openCodeTurnId(0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
        ]);
        expect(events).toContainEqual(
          expect.objectContaining({
@@ -4917,9 +4881,9 @@ describe("OpenCode provider subagent contract", () => {

      await vi.waitFor(() => {
        expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", openCodeTurnId(0)],
-          ["timeline", openCodeTurnId(0)],
-          ["turn_completed", openCodeTurnId(0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
        ]);
      });
      expect(events).toContainEqual(
@@ -4963,9 +4927,9 @@ describe("OpenCode provider subagent contract", () => {

      await vi.waitFor(() => {
        expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", openCodeTurnId(0)],
-          ["timeline", openCodeTurnId(0)],
-          ["turn_completed", openCodeTurnId(0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
        ]);
      });
    } finally {
@@ -5039,7 +5003,7 @@ describe("OpenCode provider subagent contract", () => {
      });
      await vi.waitFor(() => {
        expect(events).toEqual([
-          { type: "turn_started", provider: "opencode", turnId: openCodeTurnId(0) },
+          { type: "turn_started", provider: "opencode", turnId: "opencode-turn-0" },
        ]);
      });

@@ -5154,12 +5118,12 @@ describe("OpenCode provider subagent contract", () => {

      await streamDrained.promise;
      expect(events.filter((event) => event.type !== "provider_subagent")).toEqual([
-        { type: "turn_started", provider: "opencode", turnId: openCodeTurnId(0) },
+        { type: "turn_started", provider: "opencode", turnId: "opencode-turn-0" },
        {
          type: "turn_canceled",
          provider: "opencode",
          reason: "interrupted",
-          turnId: openCodeTurnId(0),
+          turnId: "opencode-turn-0",
        },
      ]);
    } finally {
@@ -5210,7 +5174,7 @@ describe("OpenCode provider subagent contract", () => {
      expect.objectContaining({
        type: "permission_requested",
        request: expect.objectContaining({ id: "perm_child_external" }),
-        turnId: openCodeTurnId(0),
+        turnId: "opencode-turn-0",
      }),
    );
  });
@@ -1,5 +1,4 @@
 import { validateProviderOptions } from "../provider-options.js";
-import { createTurnIdSequence } from "../turn-ids.js";
 import {
  createOpencodeClient,
  type AssistantMessage as OpenCodeAssistantMessage,
@@ -3406,7 +3405,7 @@ class OpenCodeAgentSession implements AgentSession {
  private partTypes = new Map<string, string>();
  private availableModesCache: AgentMode[] | null = null;
  private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
-  private readonly nextTurnId = createTurnIdSequence(0);
+  private nextTurnOrdinal = 0;
  private turnState: OpenCodeTurnState = { status: "idle" };
  /**
   * Settlement of every session-scoped abort issued so far. It outlives the stop
@@ -4883,7 +4882,7 @@ class OpenCodeAgentSession implements AgentSession {

  private createTurnId(): string {
    this.gapRepairRevision += 1;
-    return this.nextTurnId("opencode");
+    return `opencode-turn-${this.nextTurnOrdinal++}`;
  }

  private traceOpenCode(msg: OpenCodeTraceMessage, data: OpenCodeTraceData = {}): void {
@@ -4,102 +4,6 @@ import { createTestLogger } from "../../../../../test-utils/test-logger.js";
 import type { V2Api } from "./api.js";
 import { OpenCodeV2AgentClient } from "./agent.js";
 import { V2Harness } from "../test-utils/v2-harness.js";
-import type { AgentPermissionResponse } from "../../../agent-sdk-types.js";
-
-describe("OpenCode v2 denial reasons", () => {
-  test.each<{
-    response: AgentPermissionResponse;
-    decision: "reject" | "once" | "always";
-    message?: string;
-  }>([
-    {
-      response: { behavior: "deny", message: "Use the existing file instead." },
-      decision: "reject",
-      message: "Use the existing file instead.",
-    },
-    { response: { behavior: "deny" }, decision: "reject" },
-    { response: { behavior: "allow" }, decision: "once" },
-    { response: { behavior: "allow", selectedActionId: "always" }, decision: "always" },
-  ])("preserves a permission response: $response", async ({ response, decision, message }) => {
-    const harness = new V2Harness();
-    let pending = true;
-    harness.api.permission.list = async () =>
-      pending
-        ? [{ id: "approval", sessionID: "session", action: "shell", resources: ["pwd"] }]
-        : [];
-    const replies: Parameters<V2Api["permission"]["reply"]>[0][] = [];
-    harness.api.permission.reply = async (input) => {
-      replies.push(input);
-      pending = false;
-    };
-    const client = new OpenCodeV2AgentClient({
-      logger: createTestLogger(),
-      runtime: harness.runtime,
-    });
-    const session = await client.createSession({ provider: "opencode", cwd: "/tmp/project" });
-    try {
-      await session.respondToPermission("approval", response);
-      expect(replies).toEqual([
-        {
-          sessionID: "session",
-          requestID: "approval",
-          decision,
-          ...(message === undefined ? {} : { message }),
-        },
-      ]);
-      expect(session.getPendingPermissions()).toEqual([]);
-    } finally {
-      await session.close();
-    }
-  });
-
-  test.each([true, false])(
-    "explains cards superseded by a steer when clearing is %s",
-    async (clearPendingPermissions) => {
-      const harness = new V2Harness();
-      harness.autoComplete = false;
-      let pending = true;
-      harness.api.permission.list = async () =>
-        pending
-          ? [{ id: "approval", sessionID: "session", action: "shell", resources: ["pwd"] }]
-          : [];
-      const replies: Parameters<V2Api["permission"]["reply"]>[0][] = [];
-      harness.api.permission.reply = async (input) => {
-        replies.push(input);
-        pending = false;
-      };
-      const client = new OpenCodeV2AgentClient({
-        logger: createTestLogger(),
-        runtime: harness.runtime,
-      });
-      const session = await client.createSession({ provider: "opencode", cwd: "/tmp/project" });
-      try {
-        const { turnId } = await session.startTurn("Run pwd");
-        await expect.poll(() => harness.prompts).toEqual(["Run pwd"]);
-        await expect(
-          session.steerActiveTurn!("go ahead", { expectedTurnId: turnId, clearPendingPermissions }),
-        ).resolves.toEqual({ status: "accepted" });
-        expect(harness.prompts).toEqual(["Run pwd", "go ahead"]);
-        expect(replies).toEqual(
-          clearPendingPermissions
-            ? [
-                {
-                  sessionID: "session",
-                  requestID: "approval",
-                  decision: "reject",
-                  message:
-                    "The user answered with a message instead of approving. Their message follows.",
-                },
-              ]
-            : [],
-        );
-        expect(session.getPendingPermissions()).toHaveLength(clearPendingPermissions ? 0 : 1);
-      } finally {
-        await session.close();
-      }
-    },
-  );
-});

 describe("OpenCode v2 questions", () => {
  test("maps selected labels to native values and parses numeric and boolean answers", async () => {
@@ -68,9 +68,6 @@ export class SessionPermissions {
        sessionID: this.permissionOwners.get(requestId) ?? this.id,
        requestID: requestId,
        decision: permissionReply(response),
-        ...(response.behavior === "deny" && response.message !== undefined
-          ? { message: response.message }
-          : {}),
      });
    }
    this.resolvePending(requestId, response);
@@ -100,11 +100,7 @@ export class OpenCodeV2Session implements AgentSession {
        ),
      clearPermissions: async () => {
        for (const request of this.permissions.list())
-          await this.permissions.respondToPermission(request.id, {
-            behavior: "deny",
-            message:
-              "The user answered with a message instead of approving. Their message follows.",
-          });
+          await this.permissions.respondToPermission(request.id, { behavior: "deny" });
      },
    });
    this.usage = new SessionUsage({
@@ -5,13 +5,11 @@ import {
  mkdirSync,
  mkdtempSync,
  openSync,
-  readFileSync,
  readSync,
-  realpathSync,
  rmSync,
  writeFileSync,
 } from "node:fs";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import pino from "pino";
 import { setImmediate as waitForImmediate } from "node:timers/promises";
@@ -25,7 +23,6 @@ import {
  PiRpcAgentSession,
  transformPiModels,
 } from "./agent.js";
-import { PiCliRuntime } from "./cli-runtime.js";
 import { FakePi } from "./test-utils/fake-pi.js";
 import { createPiExtensionHost } from "./extensions/index.js";
 import { PiExtensionHost } from "./extensions/host.js";
@@ -2722,7 +2719,6 @@ describe("PiRpcAgentClient", () => {
    const root = mkdtempSync(path.join(tmpdir(), "paseo-pi-import-config-"));
    const cwd = path.join(root, "workspace");
    const sessionsDir = path.join(root, "sessions");
-    mkdirSync(cwd, { recursive: true });
    mkdirSync(sessionsDir, { recursive: true });
    const sessionFile = path.join(sessionsDir, "20260103_session.jsonl");
    writeFileSync(
@@ -3536,320 +3532,6 @@ describe("PiRpcAgentClient", () => {
  });
 });

-describe("PiRpcAgentClient history resume", () => {
-  const BUILTIN_MCP_COMMAND = {
-    name: "mcp",
-    source: "extension",
-    sourceInfo: { path: "builtin:mcp" },
-  } as const;
-  const PASEO_MCP_SERVERS = {
-    paseo: { type: "http", url: "http://127.0.0.1:6767/mcp/agents" },
-  } as const;
-
-  interface ArchivedPiSession {
-    handle: {
-      provider: string;
-      sessionId: string;
-      nativeHandle: string;
-      metadata: { cwd: string; model?: string };
-    };
-    sessionFile: string;
-    header: Record<string, unknown>;
-    body: string;
-    originalBytes: Buffer;
-  }
-
-  function createDeletedFolder(): string {
-    const folder = mkdtempSync(path.join(tmpdir(), "paseo-pi-deleted-cwd-"));
-    rmSync(folder, { recursive: true, force: true });
-    return folder;
-  }
-
-  function createFileWhereFolderWas(): string {
-    const folder = createDeletedFolder();
-    writeFileSync(folder, "not a directory");
-    onTestFinished(() => rmSync(folder, { force: true }));
-    return folder;
-  }
-
-  function createExistingFolder(): string {
-    const folder = mkdtempSync(path.join(tmpdir(), "paseo-pi-existing-cwd-"));
-    onTestFinished(() => rmSync(folder, { recursive: true, force: true }));
-    return folder;
-  }
-
-  function writeArchivedSession(cwd: string, metadata: { model?: string } = {}): ArchivedPiSession {
-    const dir = mkdtempSync(path.join(tmpdir(), "paseo-pi-archived-session-"));
-    onTestFinished(() => rmSync(dir, { recursive: true, force: true }));
-    const sessionFile = path.join(dir, "2026-01-01_pi-session-1.jsonl");
-    const header = {
-      type: "session",
-      version: 3,
-      id: "pi-session-1",
-      timestamp: "2026-01-01T00:00:00.000Z",
-      cwd,
-    };
-    const body = [
-      JSON.stringify({
-        type: "message",
-        id: "entry-1",
-        parentId: null,
-        message: { role: "user", content: "Où est le café ☕ ?" },
-      }),
-      JSON.stringify({
-        type: "message",
-        id: "entry-2",
-        parentId: "entry-1",
-        message: { role: "assistant", content: [{ type: "text", text: "Dans la cuisine." }] },
-      }),
-    ]
-      .map((line) => `${line}\n`)
-      .join("");
-    writeFileSync(sessionFile, `${JSON.stringify(header)}\n${body}`);
-    return {
-      handle: {
-        provider: "pi",
-        sessionId: "pi-session-1",
-        nativeHandle: sessionFile,
-        metadata: { cwd, ...metadata },
-      },
-      sessionFile,
-      header,
-      body,
-      originalBytes: readFileSync(sessionFile),
-    };
-  }
-
-  function readSessionCopy(sessionFile: string): { header: unknown; body: string } {
-    const content = readUtf8File(sessionFile);
-    const headerEnd = content.indexOf("\n");
-    return {
-      header: JSON.parse(content.slice(0, headerEnd)),
-      body: content.slice(headerEnd + 1),
-    };
-  }
-
-  function resumeArchived(
-    client: PiRpcAgentClient,
-    archived: ArchivedPiSession,
-    purpose: "history" | "interactive",
-    overrides: Partial<AgentSessionConfig> = {},
-  ): Promise<AgentSession> {
-    return client.resumeSession(archived.handle, overrides, undefined, { purpose });
-  }
-
-  function writeFakePiProcess(): {
-    command: [string, ...string[]];
-    readLaunches: () => Array<{ cwd: string; session: string | null }>;
-  } {
-    const dir = mkdtempSync(path.join(tmpdir(), "paseo-pi-process-"));
-    onTestFinished(() => rmSync(dir, { recursive: true, force: true }));
-    const scriptPath = path.join(dir, "fake-pi.cjs");
-    const launchesPath = path.join(dir, "launches.jsonl");
-    writeFileSync(
-      scriptPath,
-      `
-const fs = require("node:fs");
-const readline = require("node:readline");
-const [launchesPath, ...piArgs] = process.argv.slice(2);
-const sessionFlag = piArgs.indexOf("--session");
-const sessionFile = sessionFlag === -1 ? null : piArgs[sessionFlag + 1];
-fs.appendFileSync(launchesPath, JSON.stringify({ cwd: process.cwd(), session: sessionFile }) + "\\n");
-if (sessionFile) {
-  const header = JSON.parse(fs.readFileSync(sessionFile, "utf8").split("\\n", 1)[0]);
-  if (header.cwd && !fs.existsSync(header.cwd)) {
-    fs.writeSync(
-      2,
-      "Stored session working directory does not exist: " + header.cwd + "\\nSession file: " + sessionFile + "\\nCurrent working directory: " + process.cwd() + "\\n",
-    );
-    process.exit(1);
-  }
-}
-const models = [
-  { provider: "openrouter", id: "a" },
-  { provider: "openrouter", id: "b" },
-];
-const state = {
-  sessionId: "pi-session-1",
-  sessionFile,
-  model: models[0],
-  thinkingLevel: "medium",
-  isStreaming: false,
-  isCompacting: false,
-  messageCount: 0,
-  pendingMessageCount: 0,
-};
-const commands = [${JSON.stringify(BUILTIN_MCP_COMMAND)}];
-function handle(request) {
-  switch (request.type) {
-    case "get_state":
-      return state;
-    case "get_commands":
-      return { commands };
-    case "get_available_models":
-      return { models };
-    case "set_model":
-      fs.appendFileSync(
-        sessionFile,
-        JSON.stringify({ type: "model_change", id: "model-1", provider: request.provider, modelId: request.modelId }) + "\\n",
-      );
-      state.model = models.find((model) => model.id === request.modelId);
-      return state.model;
-    default:
-      return {};
-  }
-}
-readline.createInterface({ input: process.stdin }).on("line", (line) => {
-  const request = JSON.parse(line);
-  process.stdout.write(
-    JSON.stringify({ id: request.id, type: "response", command: request.type, success: true, data: handle(request) }) + "\\n",
-  );
-});
-`,
-    );
-    return {
-      command: [process.execPath, scriptPath, launchesPath],
-      readLaunches: () =>
-        readUtf8File(launchesPath)
-          .trim()
-          .split("\n")
-          .map((line) => JSON.parse(line) as { cwd: string; session: string | null }),
-    };
-  }
-
-  test.each([
-    ["is gone", createDeletedFolder],
-    ["is now a file", createFileWhereFolderWas],
-  ])(
-    "a history resume of an agent whose folder %s starts Pi from the home directory on a copy of its session",
-    async (_folderState, createFolder) => {
-      const archived = writeArchivedSession(createFolder());
-      const pi = new FakePi();
-
-      const session = await resumeArchived(createClient(pi), archived, "history");
-      onTestFinished(() => session.close());
-
-      expect(pi.recordedLaunches).toHaveLength(1);
-      const launch = pi.recordedLaunches[0]!;
-      expect(launch.cwd).toBe(homedir());
-      expect(launch.session).not.toBe(archived.sessionFile);
-      expect(readSessionCopy(launch.session!)).toEqual({
-        header: { ...archived.header, cwd: homedir() },
-        body: archived.body,
-      });
-    },
-  );
-
-  test("a history resume of an agent whose folder is gone removes its session copy on close and leaves the original unchanged", async () => {
-    const archived = writeArchivedSession(createDeletedFolder());
-    const pi = new FakePi();
-
-    const session = await resumeArchived(createClient(pi), archived, "history");
-    const sessionCopy = pi.recordedLaunches[0]!.session!;
-    expect(existsSync(sessionCopy)).toBe(true);
-    await session.close();
-
-    expect(existsSync(path.dirname(sessionCopy))).toBe(false);
-    expect(readFileSync(archived.sessionFile)).toEqual(archived.originalBytes);
-  });
-
-  test("a history resume of an agent whose folder is gone persists the original session file while Pi reports the copy", async () => {
-    const storedCwd = createDeletedFolder();
-    const archived = writeArchivedSession(storedCwd);
-    const pi = new FakePi();
-
-    const session = await resumeArchived(createClient(pi), archived, "history");
-    onTestFinished(() => session.close());
-    await session.getRuntimeInfo();
-
-    expect(pi.latestSession().state.sessionFile).toBe(pi.recordedLaunches[0]!.session);
-    expect(session.describePersistence()).toMatchObject({
-      nativeHandle: archived.sessionFile,
-      metadata: { cwd: storedCwd },
-    });
-  });
-
-  test("a history resume of an agent whose folder is gone removes its session copy when Pi fails to start", async () => {
-    const archived = writeArchivedSession(createDeletedFolder());
-    const pi = new FakePi();
-    pi.queueSessionSetup((session) => {
-      session.getStateError = new Error("Pi RPC process exited with code 1 and signal null");
-    });
-
-    await expect(resumeArchived(createClient(pi), archived, "history")).rejects.toThrow(
-      "Pi RPC process exited with code 1",
-    );
-
-    expect(pi.recordedLaunches).toHaveLength(1);
-    expect(pi.recordedLaunches[0]!.session).not.toBe(archived.sessionFile);
-    expect(existsSync(path.dirname(pi.recordedLaunches[0]!.session!))).toBe(false);
-  });
-
-  test("a history resume of an agent whose folder is gone checks MCP support from the home directory", async () => {
-    const archived = writeArchivedSession(createDeletedFolder());
-    const pi = new FakePi();
-    pi.queueCommands([BUILTIN_MCP_COMMAND]);
-
-    const session = await resumeArchived(createClient(pi), archived, "history", {
-      mcpServers: PASEO_MCP_SERVERS,
-    });
-    onTestFinished(() => session.close());
-
-    expect(pi.recordedLaunches.map((launch) => launch.cwd)).toEqual([homedir(), homedir()]);
-    expect(session.capabilities.supportsMcpServers).toBe(true);
-  });
-
-  test("an interactive resume of an agent whose folder is gone still fails in its stored folder", async () => {
-    const storedCwd = createDeletedFolder();
-    const archived = writeArchivedSession(storedCwd);
-    const pi = new FakePi();
-
-    await expect(resumeArchived(createClient(pi), archived, "interactive")).rejects.toThrow(
-      `Stored session working directory does not exist: ${storedCwd}`,
-    );
-
-    expect(pi.recordedLaunches).toMatchObject([{ cwd: storedCwd, session: archived.sessionFile }]);
-  });
-
-  test("a history resume of an agent whose folder exists keeps the stored folder and session file", async () => {
-    const storedCwd = createExistingFolder();
-    const archived = writeArchivedSession(storedCwd);
-    const pi = new FakePi();
-
-    const session = await resumeArchived(createClient(pi), archived, "history");
-    onTestFinished(() => session.close());
-
-    expect(pi.recordedLaunches).toMatchObject([{ cwd: storedCwd, session: archived.sessionFile }]);
-  });
-
-  test("a history resume of an agent whose folder is gone opens its session in a real Pi process started from the home directory", async () => {
-    const archived = writeArchivedSession(createDeletedFolder(), { model: "openrouter/b" });
-    const fakePiProcess = writeFakePiProcess();
-    const logger = pino({ level: "silent" });
-    const client = new PiRpcAgentClient({
-      logger,
-      runtime: new PiCliRuntime({ logger, command: fakePiProcess.command }),
-    });
-
-    const session = await resumeArchived(client, archived, "history", {
-      mcpServers: PASEO_MCP_SERVERS,
-    });
-    onTestFinished(() => session.close());
-
-    const launches = fakePiProcess.readLaunches();
-    const home = realpathSync.native(homedir());
-    expect(launches.map((launch) => realpathSync.native(launch.cwd))).toEqual([home, home]);
-    expect(session.capabilities.supportsMcpServers).toBe(true);
-    const sessionCopy = launches[1]!.session!;
-    expect(readUtf8File(sessionCopy)).toContain('"type":"model_change"');
-    expect(session.describePersistence()?.nativeHandle).toBe(archived.sessionFile);
-
-    await session.close();
-    expect(existsSync(path.dirname(sessionCopy))).toBe(false);
-    expect(readFileSync(archived.sessionFile)).toEqual(archived.originalBytes);
-  });
-});
-
 describe("transformPiModels", () => {
  test("normalizes labels that include the upstream provider prefix", () => {
    expect(
@@ -2,7 +2,7 @@ import { mapCustomMessageToToolCall } from "../custom-message.js";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, join, resolve as resolvePath } from "node:path";
+import { join, resolve as resolvePath } from "node:path";
 import type { Logger } from "pino";
 import stripAnsi from "strip-ansi";
 import { z } from "zod";
@@ -22,7 +22,6 @@ import {
  type AgentPersistenceHandle,
  type AgentPromptInput,
  type AgentProvider,
-  type AgentResumeSessionOptions,
  type AgentRunOptions,
  type AgentRunResult,
  type AgentRuntimeInfo,
@@ -76,13 +75,8 @@ import {
  piExtensionRuntimeBridge,
  type PiExtensionEventOutput,
 } from "./extensions/index.js";
-import { resolveResumeProcessCwd } from "../resume-process-cwd.js";
 import { revertPiConversation } from "./rewind.js";
-import {
-  copyPiSessionFileWithCwd,
-  listPiImportableSessions,
-  readPiImportSessionConfig,
-} from "./session-descriptor.js";
+import { listPiImportableSessions, readPiImportSessionConfig } from "./session-descriptor.js";
 import type { PiRuntime, PiRuntimeSession, PiStartSessionInput } from "./runtime.js";
 import type {
  PiAgentSessionEvent,
@@ -251,7 +245,6 @@ interface PiRpcAgentSessionOptions {
  initialState: PiSessionState;
  capabilities: AgentCapabilityFlags;
  currentModeId?: string | null;
-  persistedSessionFile?: string;
  cleanup?: () => void;
  extensionTimeoutMs?: number;
  logger: Logger;
@@ -499,14 +492,13 @@ function buildResumeConfig(

 function buildResumeStartInput(input: {
  resumeConfig: PiResumeConfig;
-  processCwd: string;
  sessionFile: string;
  launchContext: AgentLaunchContext | undefined;
  mcpConfigFile: PiTempFile | null;
  paseoExtension: PiTempFile | null;
 }): PiStartSessionInput {
  return {
-    cwd: input.processCwd,
+    cwd: input.resumeConfig.cwd,
    env: input.launchContext?.env,
    session: input.sessionFile,
    thinkingOptionId: normalizePiThinkingOption(input.resumeConfig.thinkingOptionId) ?? undefined,
@@ -626,19 +618,6 @@ function createPiMcpConfigFile(
  };
 }

-async function createPiSessionCopy(sessionFile: string, cwd: string): Promise<PiTempFile> {
-  const dir = mkdtempSync(join(tmpdir(), "paseo-pi-session-"));
-  const cleanup = () => rmSync(dir, { recursive: true, force: true });
-  const filePath = join(dir, basename(sessionFile));
-  try {
-    await copyPiSessionFileWithCwd({ sourceFile: sessionFile, targetFile: filePath, cwd });
-  } catch (error) {
-    cleanup();
-    throw error;
-  }
-  return { path: filePath, cleanup };
-}
-
 function createPiPaseoExtensionFile({
  systemPrompt,
  mcpServers = {},
@@ -1253,7 +1232,6 @@ export class PiRpcAgentSession implements AgentSession {
    this.capabilities = options.capabilities;
    this.provider = PI_PROVIDER;
    this.currentModeId = options.currentModeId ?? null;
-    this.persistedSessionFile = options.persistedSessionFile;
    this.cleanup = options.cleanup;
    this.extensionTimeoutMs = options.extensionTimeoutMs ?? DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS;
    this.logger = options.logger;
@@ -1284,7 +1262,6 @@ export class PiRpcAgentSession implements AgentSession {

  private readonly runtimeSession: PiRuntimeSession;
  private readonly config: AgentSessionConfig;
-  private readonly persistedSessionFile?: string;
  private readonly cleanup?: () => void;
  private readonly extensionTimeoutMs: number;

@@ -1519,7 +1496,7 @@ export class PiRpcAgentSession implements AgentSession {
    return {
      provider: this.provider,
      sessionId: this.state.sessionId,
-      nativeHandle: this.persistedSessionFile ?? this.state.sessionFile,
+      nativeHandle: this.state.sessionFile,
      metadata: {
        cwd: this.config.cwd,
        ...(this.config.model ? { model: this.config.model } : {}),
@@ -2668,7 +2645,6 @@ export class PiRpcAgentClient implements AgentClient {
    handle: AgentPersistenceHandle,
    overrides?: Partial<AgentSessionConfig>,
    launchContext?: AgentLaunchContext,
-    options?: AgentResumeSessionOptions,
  ): Promise<AgentSession> {
    const sessionFile = handle.nativeHandle;
    if (!sessionFile) {
@@ -2677,7 +2653,6 @@ export class PiRpcAgentClient implements AgentClient {

    const persistenceMetadata = parsePersistenceMetadata(handle.metadata);
    const resumeConfig = buildResumeConfig(persistenceMetadata, overrides, this.provider);
-    const processCwd = await resolveResumeProcessCwd(resumeConfig.cwd, options?.purpose);

    const providerOptions = PiProviderOptionsSchema.parse(
      resumeConfig.config.providerOptions ?? {},
@@ -2688,7 +2663,7 @@ export class PiRpcAgentClient implements AgentClient {
      ...launchContext?.env,
    };
    const mcp = await this.prepareMcpInjection(
-      processCwd,
+      resumeConfig.cwd,
      resumeConfig.config.mcpServers,
      mcpEnv,
      runtime,
@@ -2701,29 +2676,20 @@ export class PiRpcAgentClient implements AgentClient {
      ),
      mcpServers: mcp?.kind === "builtin" ? mcp.servers : undefined,
    });
-    const tempFiles = mcpConfigFile ? [mcpConfigFile, paseoExtension] : [paseoExtension];
-    const cleanupTempFiles = () => {
-      for (const tempFile of tempFiles) tempFile.cleanup();
-    };
-    let sessionCopy: PiTempFile | null = null;
    let runtimeSession: PiRuntimeSession;
    try {
-      if (processCwd !== resumeConfig.cwd) {
-        sessionCopy = await createPiSessionCopy(sessionFile, processCwd);
-        tempFiles.push(sessionCopy);
-      }
      runtimeSession = await runtime.startSession(
        buildResumeStartInput({
          resumeConfig,
-          processCwd,
-          sessionFile: sessionCopy?.path ?? sessionFile,
+          sessionFile,
          launchContext,
          mcpConfigFile,
          paseoExtension,
        }),
      );
    } catch (error) {
-      cleanupTempFiles();
+      mcpConfigFile?.cleanup();
+      paseoExtension?.cleanup();
      throw error;
    }
    try {
@@ -2736,15 +2702,15 @@ export class PiRpcAgentClient implements AgentClient {
        },
        initialState,
        capabilities: capabilitiesForSession(mcp !== null),
-        persistedSessionFile: sessionCopy ? sessionFile : undefined,
-        cleanup: cleanupTempFiles,
+        cleanup: combineCleanup([mcpConfigFile?.cleanup, paseoExtension?.cleanup]),
        extensionTimeoutMs: providerOptions.extensionTimeoutMs,
        logger: this.logger,
        usagePollScheduler: this.usagePollScheduler,
      });
    } catch (error) {
      await runtimeSession.close().catch(() => undefined);
-      cleanupTempFiles();
+      mcpConfigFile?.cleanup();
+      paseoExtension?.cleanup();
      throw error;
    }
  }
@@ -1,13 +1,9 @@
-import { mkdtemp, mkdir, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { mkdtemp, mkdir, utimes, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { expect, onTestFinished, test } from "vitest";
+import { expect, test } from "vitest";

-import {
-  copyPiSessionFileWithCwd,
-  listPiImportableSessions,
-  readPiImportSessionConfig,
-} from "./session-descriptor.js";
+import { listPiImportableSessions, readPiImportSessionConfig } from "./session-descriptor.js";

 async function writeSession(root: string, lines: unknown[]): Promise<string> {
  const sessionsDir = path.join(root, "sessions", "project");
@@ -220,97 +216,3 @@ test("Pi import config preserves thinking before a later model in large sessions
    thinkingOptionId: "low",
  });
 });
-
-test("a Pi session copy names the new cwd in its header and keeps every later byte", async () => {
-  const root = await mkdtemp(path.join(tmpdir(), "paseo-pi-session-copy-"));
-  onTestFinished(() => rm(root, { recursive: true, force: true }));
-  const header = {
-    type: "session",
-    version: 3,
-    id: "pi-session-1",
-    timestamp: "2026-01-01T00:00:00.000Z",
-    cwd: path.join(root, "removed-worktree"),
-  };
-  const body = Buffer.from(
-    Array.from(
-      { length: 2_000 },
-      (_, index) =>
-        `${JSON.stringify({ type: "message", id: `entry-${index}`, message: { role: "user", content: `café ☕ ${index}` } })}\n`,
-    ).join(""),
-  );
-  expect(body.length).toBeGreaterThan(64 * 1024);
-  const sourceFile = path.join(root, "source.jsonl");
-  const targetFile = path.join(root, "copy.jsonl");
-  await writeFile(sourceFile, Buffer.concat([Buffer.from(`${JSON.stringify(header)}\n`), body]));
-
-  await copyPiSessionFileWithCwd({ sourceFile, targetFile, cwd: "/home/user" });
-
-  const copy = await readFile(targetFile);
-  const headerEnd = copy.indexOf(0x0a);
-  expect(JSON.parse(copy.subarray(0, headerEnd).toString("utf8"))).toEqual({
-    ...header,
-    cwd: "/home/user",
-  });
-  expect(copy.subarray(headerEnd + 1).equals(body)).toBe(true);
-});
-
-test("a Pi session copy refuses a file without a session header", async () => {
-  const root = await mkdtemp(path.join(tmpdir(), "paseo-pi-session-copy-"));
-  onTestFinished(() => rm(root, { recursive: true, force: true }));
-  const sourceFile = path.join(root, "source.jsonl");
-  await writeFile(sourceFile, `${JSON.stringify({ type: "message", id: "entry-1" })}\n`);
-
-  await expect(
-    copyPiSessionFileWithCwd({ sourceFile, targetFile: path.join(root, "copy.jsonl"), cwd: "/" }),
-  ).rejects.toThrow(`Pi session file has no session header: ${sourceFile}`);
-});
-
-const COPY_BODY = [
-  { type: "message", id: "entry-1", message: { role: "user", content: "café ☕" } },
-  { type: "message", id: "entry-2", message: { role: "assistant", content: "Dans la cuisine." } },
-]
-  .map((entry) => `${JSON.stringify(entry)}\n`)
-  .join("");
-
-const COPY_HEADER = {
-  type: "session",
-  version: 3,
-  id: "pi-session-1",
-  timestamp: "2026-01-01T00:00:00.000Z",
-  cwd: "/removed-worktree",
-};
-
-async function copySessionContent(content: string): Promise<Buffer> {
-  const root = await mkdtemp(path.join(tmpdir(), "paseo-pi-session-copy-"));
-  onTestFinished(() => rm(root, { recursive: true, force: true }));
-  const sourceFile = path.join(root, "source.jsonl");
-  const targetFile = path.join(root, "copy.jsonl");
-  await writeFile(sourceFile, content);
-  await copyPiSessionFileWithCwd({ sourceFile, targetFile, cwd: "/home/user" });
-  return readFile(targetFile);
-}
-
-test.each([
-  ["a header line longer than 64 KiB", "", { ...COPY_HEADER, padding: "x".repeat(70 * 1024) }],
-  ["a header with an empty cwd", "", { ...COPY_HEADER, cwd: "" }],
-  ["blank lines before the header", "\n\r\n", COPY_HEADER],
-])("a Pi session copy accepts %s", async (_headerShape, prefix, header) => {
-  const copy = await copySessionContent(`${prefix}${JSON.stringify(header)}\n${COPY_BODY}`);
-
-  const headerEnd = copy.indexOf(0x0a);
-  expect(JSON.parse(copy.subarray(0, headerEnd).toString("utf8"))).toEqual({
-    ...header,
-    cwd: "/home/user",
-  });
-  expect(copy.subarray(headerEnd + 1).equals(Buffer.from(COPY_BODY))).toBe(true);
-});
-
-test("a Pi session copy reports a missing session file", async () => {
-  const root = await mkdtemp(path.join(tmpdir(), "paseo-pi-session-copy-"));
-  onTestFinished(() => rm(root, { recursive: true, force: true }));
-  const sourceFile = path.join(root, "missing.jsonl");
-
-  await expect(
-    copyPiSessionFileWithCwd({ sourceFile, targetFile: path.join(root, "copy.jsonl"), cwd: "/" }),
-  ).rejects.toThrow(`Pi session file is missing: ${sourceFile}`);
-});
@@ -1,8 +1,7 @@
-import { createReadStream, createWriteStream, type Dirent } from "node:fs";
-import { open, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import { open, readdir, readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { pipeline } from "node:stream/promises";

 import type {
  ImportableProviderSession,
@@ -19,7 +18,6 @@ const PI_SESSION_DIR_ENV = "PI_CODING_AGENT_SESSION_DIR";
 const HEAD_BYTES = 64 * 1024;
 const TAIL_BYTES = 256 * 1024;
 const FULL_SCAN_LINE_LIMIT = 2_000;
-const PI_SESSION_HEADER_SCAN_BYTES = 1024 * 1024;
 // Rank all discovered files cheaply, then parse only a bounded recent window.
 const IMPORT_CANDIDATE_OVERSCAN = 40;
 const IMPORT_CANDIDATE_MIN = 400;
@@ -102,59 +100,6 @@ export async function listPiImportableSessions(
  );
 }

-export async function copyPiSessionFileWithCwd(input: {
-  sourceFile: string;
-  targetFile: string;
-  cwd: string;
-}): Promise<void> {
-  const found = findSessionHeaderLine(
-    await readSessionFileStart(input.sourceFile, PI_SESSION_HEADER_SCAN_BYTES),
-  );
-  if (!found) {
-    throw new Error(`Pi session file has no session header: ${input.sourceFile}`);
-  }
-  await writeFile(input.targetFile, `${JSON.stringify({ ...found.header, cwd: input.cwd })}\n`, {
-    mode: 0o600,
-  });
-  await pipeline(
-    createReadStream(input.sourceFile, { start: found.bodyStart }),
-    createWriteStream(input.targetFile, { flags: "a" }),
-  );
-}
-
-function findSessionHeaderLine(
-  scanned: Buffer,
-): { header: Record<string, unknown>; bodyStart: number } | null {
-  let lineStart = 0;
-  while (lineStart < scanned.length) {
-    const newline = scanned.indexOf(0x0a, lineStart);
-    const bodyStart = newline === -1 ? scanned.length : newline + 1;
-    const line = scanned.subarray(lineStart, bodyStart).toString("utf8").trim();
-    if (line) {
-      const header = parseJsonRecord(line);
-      return header?.type === "session" ? { header, bodyStart } : null;
-    }
-    lineStart = bodyStart;
-  }
-  return null;
-}
-
-async function readSessionFileStart(filePath: string, maxBytes: number): Promise<Buffer> {
-  const handle = await open(filePath, "r").catch((error: unknown) => {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      throw new Error(`Pi session file is missing: ${filePath}`);
-    }
-    throw error;
-  });
-  try {
-    const buffer = Buffer.alloc(maxBytes);
-    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
-    return buffer.subarray(0, bytesRead);
-  } finally {
-    await handle.close().catch(() => undefined);
-  }
-}
-
 export async function readPiImportSessionConfig(filePath: string): Promise<PiImportSessionConfig> {
  const descriptor = await readPiSessionDescriptor(filePath);
  if (!descriptor) return {};
@@ -1,5 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
-
 import type {
  PiRuntime,
  PiRuntimeLaunch,
@@ -77,12 +75,6 @@ export class FakePi implements PiRuntime {
    const session = new FakePiSession(launch, this.removedModels);
    session.commands = this.queuedCommands.shift() ?? [];
    this.queuedSessionSetups.shift()?.(session);
-    const missingSessionCwd = launch.noSession ? null : readMissingSessionCwd(launch.session);
-    if (missingSessionCwd !== null) {
-      session.getStateError = new Error(
-        `Pi RPC process exited with code 1 and signal null\nStored session working directory does not exist: ${missingSessionCwd}\nSession file: ${launch.session}\nCurrent working directory: ${launch.cwd}`,
-      );
-    }
    this.sessions.push(session);
    return session;
  }
@@ -109,27 +101,6 @@ export class FakePi implements PiRuntime {
  }
 }

-function readMissingSessionCwd(sessionFile: string | undefined): string | null {
-  if (!sessionFile || !existsSync(sessionFile)) {
-    return null;
-  }
-  const [headerLine = ""] = readFileSync(sessionFile, "utf8").split("\n", 1);
-  let header: unknown;
-  try {
-    header = JSON.parse(headerLine);
-  } catch {
-    return null;
-  }
-  if (typeof header !== "object" || header === null || !("cwd" in header)) {
-    return null;
-  }
-  const { type, cwd } = header as { type?: unknown; cwd?: unknown };
-  if (type !== "session" || typeof cwd !== "string" || !cwd || existsSync(cwd)) {
-    return null;
-  }
-  return cwd;
-}
-
 export class FakePiSession implements PiRuntimeSession {
  readonly environment: Record<string, string>;
  readonly prompts: Array<{ message: string; imageCount: number }> = [];
@@ -1,26 +0,0 @@
-import { stat } from "node:fs/promises";
-import { homedir } from "node:os";
-
-import type { AgentResumePurpose } from "../agent-sdk-types.js";
-
-export async function resolveResumeProcessCwd(
-  cwd: string,
-  purpose: AgentResumePurpose | undefined,
-): Promise<string> {
-  if (purpose !== "history" || (await isDirectory(cwd))) {
-    return cwd;
-  }
-  return homedir();
-}
-
-async function isDirectory(target: string): Promise<boolean> {
-  try {
-    return (await stat(target)).isDirectory();
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code === "ENOENT" || code === "ENOTDIR") {
-      return false;
-    }
-    throw error;
-  }
-}
@@ -1,30 +0,0 @@
-/** A Vitest asymmetric matcher for one provider turn id. */
-export interface TurnIdMatcher {
-  asymmetricMatch(actual: unknown): boolean;
-  toString(): string;
-  toAsymmetricMatcher(): string;
-}
-
-/**
- * Matches the turn ids one provider session issues. Each session mixes a random nonce into its
- * ids, so the first id seen binds that nonce and every later match must be the exact id
- * `<owner>-turn-<nonce>-<ordinal>`. Two events of one turn therefore match only when their ids
- * are identical. Create one per test.
- */
-export function sessionTurnIds(owner: string): (ordinal: number) => TurnIdMatcher {
-  let nonce: string | null = null;
-  const pattern = new RegExp(`^${owner}-turn-([0-9a-f]+)-(\\d+)$`);
-  return (ordinal) => {
-    const describe = () => `${owner}-turn-${nonce ?? "<nonce>"}-${ordinal}`;
-    return {
-      asymmetricMatch(actual) {
-        const match = typeof actual === "string" ? pattern.exec(actual) : null;
-        if (!match || Number(match[2]) !== ordinal) return false;
-        nonce ??= match[1]!;
-        return match[1] === nonce;
-      },
-      toString: describe,
-      toAsymmetricMatcher: describe,
-    };
-  };
-}
@@ -1590,7 +1590,7 @@ function createToolCatalog(
    {
      title: "Create agent",
      description:
-        "Create an agent. Agent-scoped creation defaults to your workspace and creates your subagent. Top-level creation without workspaceId creates a new local workspace. Requires provider/model (for example codex/gpt-5.4) and an initial prompt. For a different provider, set settings.modeId from inspect_provider; omission is accepted for targets with no modes and for unattended execution supported by the target. Do not guess; call list_providers and list_models first if uncertain.",
+        "Create an agent. Agent-scoped creation defaults to your workspace and creates your subagent. Top-level creation without workspaceId creates a new local workspace. Requires provider/model (for example codex/gpt-5.4) and an initial prompt. Do not guess; call list_providers and list_models first if uncertain.",
      inputSchema: createAgentInputSchema,
      outputSchema: {
        agentId: z.string(),
@@ -1,13 +0,0 @@
-import { randomBytes } from "node:crypto";
-
-/**
- * Turn ids stay unique for an agent's whole life. The daemon keeps every turn's rows while
- * idle runtime collection closes the provider session, and the next prompt reopens the agent
- * as a new session instance whose ordinals start over. Each instance therefore mixes its own
- * nonce into the ids it issues; the ordinal keeps the sequence readable in logs and tests.
- */
-export function createTurnIdSequence(firstOrdinal: number): (owner: string) => string {
-  const instance = randomBytes(6).toString("hex");
-  let ordinal = firstOrdinal;
-  return (owner) => `${owner}-turn-${instance}-${ordinal++}`;
-}
@@ -670,11 +670,11 @@ describe("paseo daemon bootstrap", () => {

  test("rolls back standalone listener without starting plugins when main listen fails", async () => {
    const mainPort = await findFreePort();
+    const standalonePort = await findFreePort();
    const occupiedMain = http.createServer((_req, res) => {
      res.end("occupied-main");
    });
    await new Promise<void>((resolve) => occupiedMain.listen(mainPort, "127.0.0.1", resolve));
-    const standalonePort = await findFreePort();

    const paseoHomeRoot = await mkdtemp(path.join(os.tmpdir(), "paseo-main-rollback-"));
    const paseoHome = path.join(paseoHomeRoot, ".paseo");
@@ -600,7 +600,7 @@ function createInitialMutableDaemonConfig(config: ResolvedDaemonSettings): Mutab
    autoArchiveAfterMerge: config.autoArchiveAfterMerge ?? false,
    enableTerminalAgentHooks: config.enableTerminalAgentHooks ?? false,
    idleRuntimeCleanup: config.idleRuntimeCleanup !== false,
-    resumeOnStartup: config.resumeOnStartup !== false,
+    resumeOnStartup: config.resumeOnStartup === true,
    resumePrompt: config.resumePrompt ?? "Resume working.",
    appendSystemPrompt: config.appendSystemPrompt ?? "",
    pluginsEnabled: config.pluginsEnabled ?? false,
@@ -1047,7 +1047,7 @@ export async function createPaseoDaemon(
  const restartRecovery = createRestartRecovery({
    storage: agentStorage,
    settings: () => ({
-      enabled: daemonConfigStore.get().resumeOnStartup !== false,
+      enabled: daemonConfigStore.get().resumeOnStartup === true,
      prompt: daemonConfigStore.get().resumePrompt ?? "Resume working.",
    }),
    eligible: async (record) =>
@@ -40,6 +40,24 @@ describe("server config", () => {
    expect(blockingMs).toBeLessThan(50);
  });

+  test.each([undefined, false, true])(
+    "restart recovery requires explicit opt-in (%s)",
+    async (enabled) => {
+      const paseoHome = await mkdtemp(path.join(os.tmpdir(), "paseo-config-recovery-"));
+      roots.push(paseoHome);
+      await writeFile(
+        path.join(paseoHome, "config.json"),
+        JSON.stringify({
+          version: 1,
+          agents: { resumeOnStartup: enabled, resumePrompt: "Continue exactly.\n" },
+        }),
+      );
+      const config = loadConfig(paseoHome, { env: {} });
+      expect(config.resumeOnStartup).toBe(enabled === true);
+      expect(config.resumePrompt).toBe("Continue exactly.\n");
+    },
+  );
+
  test("records when the daemon is managed by Paseo Desktop", async () => {
    const paseoHome = await mkdtemp(path.join(os.tmpdir(), "paseo-config-desktop-managed-"));
    roots.push(paseoHome);
@@ -839,7 +839,7 @@ function resolveSpeechOverrideControlledPaths(

 function resolveRestartRecoveryConfig(agents: PersistedConfig["agents"]) {
  return {
-    resumeOnStartup: agents?.resumeOnStartup ?? true,
+    resumeOnStartup: agents?.resumeOnStartup ?? false,
    resumePrompt: agents?.resumePrompt ?? "Resume working.",
  };
 }
@@ -183,7 +183,7 @@ test("ordinary routed APIs isolate scopes and enforce one-hop, disable and origi
  await paseo.dispose();
 });

-test("routed authority isolates simultaneous sessions and preserves ordinary permission RPC errors", async () => {
+test("routed authority is bounded by the caller, with isolated simultaneous sessions", async () => {
  const b = await daemon();
  const a = await daemon();
  const owner = await api(a);
@@ -210,16 +210,33 @@ test("routed authority isolates simultaneous sessions and preserves ordinary per
    code: "permission_denied",
  });
  expect((await owner.paseo.hosts.list()).hosts).toHaveLength(1);
-  const directClient = createHostClient(`127.0.0.1:${b.port}`, {
-    clientId: crypto.randomUUID(),
-    sessionPermissions: ["daemon.read", "workspace.read"],
-    reconnect: { enabled: false },
-  });
-  await directClient.connect();
-  const direct = createPaseoApi(directClient);
+  await remote.dispose();
+});
+
+test("SDK host clients preserve ordinary permission RPC errors", async () => {
+  const b = await daemon();
+  const a = await daemon();
+  const owner = await api(a);
+  await owner.paseo.hosts.add({ connection: `127.0.0.1:${b.port}` });
+  const serverId = (await online(owner.paseo)).hosts[0]!.serverId!;
+  const clients = [a, b].map((host) =>
+    createHostClient(`127.0.0.1:${host.port}`, {
+      clientId: crypto.randomUUID(),
+      sessionPermissions: ["daemon.read", "workspace.read"],
+      reconnect: { enabled: false },
+    }),
+  );
+  for (const client of clients) {
+    cleanup.push(() => client.close());
+    await client.connect();
+  }
+  const origin = createPaseoApi(clients[0]!);
+  const direct = createPaseoApi(clients[1]!);
+  const remote = await origin.hosts.client(serverId);
  cleanup.push(async () => {
+    await remote.dispose();
    await direct.dispose();
-    await directClient.close();
+    await origin.dispose();
  });
  const input = { source: { kind: "directory" as const, path: b.staticDir } };
  const directError = (await direct.workspaces.create(input).catch((error: unknown) => error)) as {
@@ -230,7 +247,6 @@ test("routed authority isolates simultaneous sessions and preserves ordinary per
  };
  expect(directError.code).toBe("access_denied");
  expect(remoteError.code).toBe(directError.code);
-  await remote.dispose();
 });

 test("distinct origin sessions cannot collide through a caller-selected route scope, including terminal binary output", async () => {
@@ -768,211 +784,6 @@ test("old capabilities fail before execution and authentication errors recover t
  expect((await online(paseo)).hosts[0]!.serverId).toBe(b.daemon.getServerId());
 });

-async function updatableDestination() {
-  let features: { connectedHosts: boolean; hostMultiplexing: boolean } | undefined;
-  let holding = false;
-  const held: (() => void)[] = [];
-  let connections = 0;
-  const http = createServer();
-  const ws = new WebSocketServer({ server: http });
-  ws.on("connection", (socket) => {
-    connections++;
-    socket.on("message", (data) => {
-      const frame = JSON.parse(data.toString());
-      if (frame.type === "ping") socket.send(JSON.stringify({ type: "pong" }));
-      if (frame.type !== "hello") return;
-      const reply = () =>
-        socket.send(
-          JSON.stringify({
-            type: "session",
-            message: {
-              type: "status",
-              payload: {
-                status: "server_info",
-                serverId: "srv_updated",
-                hostname: "updated",
-                version: "0.12.0",
-                ...(features ? { features } : {}),
-              },
-            },
-          }),
-        );
-      if (holding) held.push(reply);
-      else reply();
-    });
-  });
-  http.listen(0, "127.0.0.1");
-  await once(http, "listening");
-  cleanup.push(async () => {
-    for (const socket of ws.clients) socket.terminate();
-    await new Promise<void>((resolve) => ws.close(() => resolve()));
-    await new Promise<void>((resolve) => http.close(() => resolve()));
-  });
-  const address = http.address();
-  if (!address || typeof address === "string") throw new Error("Missing destination port");
-  return {
-    port: address.port,
-    connections: () => connections,
-    hold: () => {
-      holding = true;
-    },
-    update: () => {
-      features = { connectedHosts: true, hostMultiplexing: true };
-      holding = false;
-      for (const reply of held.splice(0)) reply();
-    },
-  };
-}
-async function capabilityRetry(paseo: ReturnType<typeof createPaseoApi>): Promise<number> {
-  let retryAt = "";
-  await expect
-    .poll(
-      async () => {
-        const row = (await paseo.hosts.list()).hosts[0];
-        retryAt = row?.nextRetryAt ?? "";
-        return row;
-      },
-      { timeout: 5000 },
-    )
-    .toMatchObject({
-      status: "offline",
-      nextRetryAt: expect.any(String),
-      error: { code: "unsupported_capability" },
-    });
-  return Date.parse(retryAt);
-}
-
-test("a destination updated past unsupported_capability keeps its guidance while retrying and comes online, while duplicate_host stays terminal", async () => {
-  const destination = await updatableDestination();
-  const a = await daemon();
-  const { paseo } = await api(a);
-  const host = await paseo.hosts.add({ connection: `127.0.0.1:${destination.port}` });
-  await capabilityRetry(paseo);
-  destination.hold();
-  await expect
-    .poll(async () => (await paseo.hosts.list()).hosts[0], { timeout: 5000 })
-    .toMatchObject({ status: "connecting", error: { code: "unsupported_capability" } });
-  await expect(paseo.hosts.client("srv_updated")).rejects.toMatchObject({
-    code: "unsupported_capability",
-  });
-  destination.update();
-  expect((await online(paseo)).hosts[0]).toMatchObject({
-    registrationId: host.registrationId,
-    serverId: "srv_updated",
-    nextRetryAt: null,
-    error: null,
-  });
-  await paseo.hosts.add({ connection: `ws://127.0.0.1:${destination.port}/ws` });
-  await expect
-    .poll(async () => (await paseo.hosts.list()).hosts[1], { timeout: 5000 })
-    .toMatchObject({ status: "error", nextRetryAt: null, error: { code: "duplicate_host" } });
-});
-
-test("disabling or removing a host cancels its pending capability retry", async () => {
-  const destination = await updatableDestination();
-  const a = await daemon();
-  const { paseo } = await api(a);
-  const host = await paseo.hosts.add({ connection: `127.0.0.1:${destination.port}` });
-  let retryAt = await capabilityRetry(paseo);
-  let connections = destination.connections();
-  await paseo.hosts.update(host.registrationId, { enabled: false });
-  await new Promise((resolve) => setTimeout(resolve, retryAt - Date.now() + 500));
-  expect(destination.connections()).toBe(connections);
-  await paseo.hosts.update(host.registrationId, { enabled: true });
-  retryAt = await capabilityRetry(paseo);
-  connections = destination.connections();
-  await paseo.hosts.remove(host.registrationId);
-  await new Promise((resolve) => setTimeout(resolve, retryAt - Date.now() + 500));
-  expect(destination.connections()).toBe(connections);
-});
-
-import {
-  createDaemonChannel,
-  exportPublicKey,
-  generateKeyPair,
-  openDaemonSecureChannel,
-  type Transport,
-} from "@getpaseo/relay/e2ee";
-test("a capability retry over a relay keeps the protected endpoint security it negotiated", async () => {
-  const keys = generateKeyPair();
-  const legacyReceived: unknown[] = [];
-  let connections = 0;
-  let retryClosed = false;
-  const http = createServer();
-  const ws = new WebSocketServer({ server: http });
-  ws.on("connection", (socket) => {
-    connections++;
-    const wire: Transport = {
-      send: (data) => socket.send(data),
-      close: (code, reason) => socket.close(code, reason),
-      onmessage: null,
-      onclose: null,
-      onerror: null,
-    };
-    socket.on("message", (data, isBinary) => {
-      const bytes = Buffer.from(data as Buffer);
-      wire.onmessage?.({
-        data: isBinary
-          ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
-          : bytes.toString(),
-        isBinary,
-      });
-    });
-    socket.on("close", (code, reason) => wire.onclose?.(code, reason.toString()));
-    if (connections > 1) {
-      socket.on("close", () => {
-        retryClosed = true;
-      });
-      void createDaemonChannel(wire, keys, {
-        onmessage: (data) => legacyReceived.push(data),
-      }).catch(() => {});
-      return;
-    }
-    const channel = openDaemonSecureChannel(wire, {
-      daemonKeyPair: keys,
-      events: {
-        onmessage: (data) => {
-          if (typeof data !== "string" || JSON.parse(data).type !== "hello") return;
-          void channel.then((secure) =>
-            secure.send(
-              JSON.stringify({
-                type: "session",
-                message: {
-                  type: "status",
-                  payload: {
-                    status: "server_info",
-                    serverId: "srv_relayed",
-                    hostname: "relayed",
-                    version: "0.12.0",
-                  },
-                },
-              }),
-            ),
-          );
-        },
-      },
-    });
-    void channel.catch(() => {});
-  });
-  http.listen(0, "127.0.0.1");
-  await once(http, "listening");
-  cleanup.push(async () => {
-    for (const socket of ws.clients) socket.terminate();
-    await new Promise<void>((resolve) => ws.close(() => resolve()));
-    await new Promise<void>((resolve) => http.close(() => resolve()));
-  });
-  const address = http.address();
-  if (!address || typeof address === "string") throw new Error("Missing relay port");
-  const a = await daemon();
-  const { paseo } = await api(a);
-  await paseo.hosts.add({
-    connection: `relay://127.0.0.1:${address.port}/srv_relayed?key=${encodeURIComponent(exportPublicKey(keys.publicKey))}`,
-  });
-  await capabilityRetry(paseo);
-  await expect.poll(() => retryClosed, { timeout: 15000 }).toBe(true);
-  expect(legacyReceived).toEqual([]);
-});
-
 test("an unreachable saved target becomes online after its daemon starts without being added again", async () => {
  const reservation = createServer();
  reservation.listen(0, "127.0.0.1");
@@ -7,12 +7,10 @@ import { z } from "zod";
 import {
  createHostClient,
  createHostChannelTransport,
-  createHostTransportFactory,
  parseHostTarget,
  HostTransportBudget,
 } from "@getpaseo/client/node";
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
-import type { DaemonTransportFactory } from "@getpaseo/client/internal/daemon-client-transport-types";
 import {
  HostSummarySchema,
  HostAddSchema,
@@ -237,30 +235,23 @@ export class ConnectedHosts {
      if (route.registrationId === id)
        route.close(code, "Host access was disabled, replaced or removed");
  }
-  private start(
-    row: Saved,
-    resume?: { failures: number; transports: DaemonTransportFactory },
-  ): void {
+  private start(row: Saved): void {
    if (!row.enabled || this.closed) return;
-    const transports =
-      resume?.transports ??
-      createHostTransportFactory(row.connection, this.budget, {
-        webSocketAgent: webSocketProxyAgent,
-      });
    let stopped = false;
-    let attempts = resume?.failures ?? 0;
-    let retry: ReturnType<typeof setTimeout> | undefined;
-    const client = createHostClient(row.connection, {
-      clientId: `host-link-${this.self.serverId}-${row.registrationId}`,
-      connectTimeoutMs: 10000,
-      transportFactory: transports,
-    });
+    const client = createHostClient(
+      row.connection,
+      {
+        clientId: `host-link-${this.self.serverId}-${row.registrationId}`,
+        connectTimeoutMs: 10000,
+        webSocketAgent: webSocketProxyAgent,
+      },
+      this.budget,
+    );
    const live: Live = {
      client,
      accepted: false,
      stop: () => {
        stopped = true;
-        clearTimeout(retry);
        void client.close();
      },
    };
@@ -294,7 +285,7 @@ export class ConnectedHosts {
        if (info.features?.connectedHosts !== true || info.features?.hostMultiplexing !== true)
          throw new HostError(
            "unsupported_capability",
-            "Update the destination daemon to use connected hosts; retrying automatically.",
+            "Update the destination daemon to use connected hosts.",
          );
        // Pin and persist under the same writer as management to prevent discovery races.
        await this.mutate(async () => {
@@ -313,22 +304,16 @@ export class ConnectedHosts {
          if (stopped || client.getLastServerInfoMessage() !== info || !client.isConnected) return;
          Object.assign(row, next);
          live.accepted = true;
-          attempts = 0;
          this.changed();
        });
      } catch (error) {
        if (stopped) return;
+        row.status = "error";
        row.error = connectionFailure(error, client.authFailureReason !== null) ?? {
          code: "host_offline",
          message: "Host connection failed",
        };
-        if (terminalFailures.has(row.error.code)) {
-          row.status = "error";
-          row.nextRetryAt = null;
-        } else {
-          stopped = true;
-          retry = this.scheduleAcceptanceRetry(row, attempts, transports);
-        }
+        row.nextRetryAt = null;
        this.changed();
        await client.close();
      }
@@ -344,17 +329,18 @@ export class ConnectedHosts {
        if (route.registrationId === row.registrationId) route.close();
      row.status = state.status === "connecting" ? "connecting" : "offline";
      row.nextRetryAt = state.status === "disconnected" ? (state.nextRetryAt ?? null) : null;
-      if (state.status === "disconnected")
-        row.error = connectionFailure(
-          Object.assign(new Error("Check the SSH configuration and daemon credentials"), {
-            code: state.failureCode,
-          }),
-          client.authFailureReason !== null,
-        ) ?? {
-          code: "host_offline",
-          message: "Cannot reach host. Check the connection; retrying automatically.",
-        };
-      else if (row.error?.code !== "unsupported_capability") row.error = null;
+      row.error =
+        state.status === "disconnected"
+          ? (connectionFailure(
+              Object.assign(new Error("Check the SSH configuration and daemon credentials"), {
+                code: state.failureCode,
+              }),
+              client.authFailureReason !== null,
+            ) ?? {
+              code: "host_offline",
+              message: "Cannot reach host. Check the connection; retrying automatically.",
+            })
+          : null;
      if (row.error?.code === "authentication_failed") {
        row.status = "error";
        row.nextRetryAt = null;
@@ -365,18 +351,6 @@ export class ConnectedHosts {
    });
    void client.connect().catch(() => {});
  }
-  private scheduleAcceptanceRetry(
-    row: Saved,
-    failures: number,
-    transports: DaemonTransportFactory,
-  ): ReturnType<typeof setTimeout> {
-    const delay = acceptanceRetryDelayMs(failures);
-    row.status = "offline";
-    row.nextRetryAt = new Date(Date.now() + delay).toISOString();
-    const retry = setTimeout(() => this.start(row, { failures: failures + 1, transports }), delay);
-    retry.unref();
-    return retry;
-  }
  async openRoute(input: {
    serverId: string;
    scopeId: string;
@@ -557,20 +531,6 @@ export class ConnectedHosts {
  }
 }

-const ACCEPTANCE_RETRY_BASE_MS = 1500;
-const ACCEPTANCE_RETRY_MAX_MS = 30_000;
-
-function acceptanceRetryDelayMs(failures: number): number {
-  return Math.min(ACCEPTANCE_RETRY_BASE_MS * 2 ** failures, ACCEPTANCE_RETRY_MAX_MS);
-}
-
-const terminalFailures = new Set([
-  "server_id_mismatch",
-  "self_host",
-  "duplicate_host",
-  "authentication_failed",
-]);
-
 function connectionFailure(error: unknown, authenticationFailed: boolean): HostSummary["error"] {
  if (error instanceof HostError) return { code: error.code, message: error.message };
  if (error instanceof Error && "code" in error && error.code === "authentication_failed")
@@ -88,9 +88,13 @@ test.each(["uncommitted", "base", "commit"] as const)(
  60_000,
 );

-test.each(["single", "batch", "rename"] as const)(
-  "%s diff includes hunks from a repository subdirectory before and after commit",
-  async (shape) => {
+test.each(
+  (["uncommitted", "base"] as const).flatMap((mode) =>
+    (["single", "batch", "rename"] as const).map((shape) => ({ mode, shape })),
+  ),
+)(
+  "$mode $shape diff includes hunks from a repository subdirectory",
+  async ({ mode, shape }) => {
    const ctx = await createDaemonTestContext();
    const cwd = mkdtempSync(join(tmpdir(), "checkout-diff-subdirectory-"));

@@ -108,7 +112,9 @@ test.each(["single", "batch", "rename"] as const)(
      }
      git(cwd, "add", ".");
      git(cwd, "-c", "commit.gpgsign=false", "commit", "-m", "initial");
-      git(cwd, "checkout", "-b", "feature");
+      if (mode === "base") {
+        git(cwd, "checkout", "-b", "feature");
+      }
      const filename = shape === "rename" ? "renamed.txt" : "normal.txt";
      if (shape === "rename") {
        git(cwd, "mv", "sub/normal.txt", `sub/${filename}`);
@@ -117,38 +123,36 @@ test.each(["single", "batch", "rename"] as const)(
      if (shape === "batch") {
        writeFileSync(join(cwd, "sibling.txt"), "new sibling\n");
      }
-      async function expectSubdirectoryDiff(mode: "uncommitted" | "base") {
-        const compare = { mode, baseRef: "main" };
-        const rootDiff = await ctx.client.getCheckoutDiff(cwd, compare);
-        const subdirectoryDiff = await ctx.client.getCheckoutDiff(subdirectory, compare);
-        const subscription = ctx.client.observeCheckoutDiff(subdirectory, compare);
-        const liveDiff = await subscription.ready;
-        await subscription.release();
-
-        expect(rootDiff.error).toBeNull();
-        expect(subdirectoryDiff.error).toBeNull();
-        expect(liveDiff.error).toBeNull();
-        expect(liveDiff.files).toEqual(rootDiff.files);
-        expect(rootDiff.files).toHaveLength(shape === "batch" ? 2 : 1);
-        const file = rootDiff.files.find((candidate) => candidate.path === `sub/${filename}`);
-        expect(file).toMatchObject({
-          additions: 1,
-          deletions: 1,
-          ...(shape === "rename" ? { oldPath: "sub/normal.txt" } : {}),
-        });
-        expect(file?.hunks.flatMap((hunk) => hunk.lines)).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({ type: "remove", content: "before" }),
-            expect.objectContaining({ type: "add", content: "after" }),
-          ]),
-        );
-        expect(subdirectoryDiff.files).toEqual(rootDiff.files);
+      if (mode === "base") {
+        git(cwd, "add", ".");
+        git(cwd, "-c", "commit.gpgsign=false", "commit", "-m", "edit");
      }

-      await expectSubdirectoryDiff("uncommitted");
-      git(cwd, "add", ".");
-      git(cwd, "-c", "commit.gpgsign=false", "commit", "-m", "edit");
-      await expectSubdirectoryDiff("base");
+      const compare = { mode, baseRef: "main" };
+      const rootDiff = await ctx.client.getCheckoutDiff(cwd, compare);
+      const subdirectoryDiff = await ctx.client.getCheckoutDiff(subdirectory, compare);
+      const subscription = ctx.client.observeCheckoutDiff(subdirectory, compare);
+      const liveDiff = await subscription.ready;
+      await subscription.release();
+
+      expect(rootDiff.error).toBeNull();
+      expect(subdirectoryDiff.error).toBeNull();
+      expect(liveDiff.error).toBeNull();
+      expect(liveDiff.files).toEqual(rootDiff.files);
+      expect(rootDiff.files).toHaveLength(shape === "batch" ? 2 : 1);
+      const file = rootDiff.files.find((candidate) => candidate.path === `sub/${filename}`);
+      expect(file).toMatchObject({
+        additions: 1,
+        deletions: 1,
+        ...(shape === "rename" ? { oldPath: "sub/normal.txt" } : {}),
+      });
+      expect(file?.hunks.flatMap((hunk) => hunk.lines)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ type: "remove", content: "before" }),
+          expect.objectContaining({ type: "add", content: "after" }),
+        ]),
+      );
+      expect(subdirectoryDiff.files).toEqual(rootDiff.files);
    } finally {
      await ctx.cleanup();
      rmSync(cwd, { recursive: true, force: true });
@@ -1,67 +0,0 @@
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import path from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { expect, test } from "vitest";
-import { createDaemonTestContext } from "../test-utils/index.js";
-
-test("an attended MCP caller can discover and supply a cross-provider child mode", async () => {
-  const artifacts = path.join(process.cwd(), ".artifacts");
-  await mkdir(artifacts, { recursive: true });
-  const root = await mkdtemp(path.join(artifacts, "create-agent-mode-"));
-  const ctx = await createDaemonTestContext({ paseoHomeRoot: root, mcpEnabled: true });
-  const mcp = new Client({ name: "mode-contract-test", version: "1" });
-  try {
-    const parent = await ctx.client.createAgent({
-      provider: "claude",
-      cwd: root,
-      modeId: "default",
-      title: "Attended parent",
-    });
-    await mcp.connect(
-      new StreamableHTTPClientTransport(
-        new URL(`http://127.0.0.1:${ctx.daemon.port}/mcp/agents?callerAgentId=${parent.id}`),
-      ),
-    );
-    const { tools } = await mcp.listTools();
-    const create = tools.find((tool) => tool.name === "create_agent");
-    expect.soft(create?.description).toContain("settings.modeId");
-
-    const args = {
-      provider: "codex/gpt-5.4-mini",
-      title: "Cross-provider child",
-      initialPrompt: "Reply with OK",
-    };
-    const refused = await mcp.callTool({ name: "create_agent", arguments: args });
-    expect(refused.isError).toBe(true);
-    expect.soft(refused.content).toEqual([
-      expect.objectContaining({
-        type: "text",
-        text: expect.stringContaining("Pass an explicit mode in settings.modeId"),
-      }),
-    ]);
-    expect((await ctx.client.fetchAgents({ subscribe: {} })).entries).toHaveLength(1);
-
-    const inspected = await mcp.callTool({
-      name: "inspect_provider",
-      arguments: { provider: "codex" },
-    });
-    expect(inspected.isError).not.toBe(true);
-    expect(inspected.structuredContent).toMatchObject({
-      modes: expect.arrayContaining([expect.objectContaining({ id: "auto" })]),
-    });
-    const created = await mcp.callTool({
-      name: "create_agent",
-      arguments: { ...args, settings: { modeId: "auto" } },
-    });
-    expect(created.isError).not.toBe(true);
-    expect(created.structuredContent).toMatchObject({ type: "codex", currentModeId: "auto" });
-    const childId = (created.structuredContent as { agentId: string }).agentId;
-    expect((await ctx.client.fetchAgent(childId))?.agent.currentModeId).toBe("auto");
-    expect((await ctx.client.waitForFinish(childId, 5000)).status).toBe("idle");
-  } finally {
-    await mcp.close();
-    await ctx.cleanup();
-    await rm(root, { recursive: true, force: true });
-  }
-}, 30_000);
@@ -134,7 +134,7 @@ test.each([false, true])(
    let client: DaemonClient | undefined;
    let mcp: Client | undefined;
    try {
-      const first = await restartFixture(root);
+      const first = await restartFixture(root, { resumeOnStartup: true });
      processes.push(first.child);
      client = new DaemonClient({ url: `ws://127.0.0.1:${first.port}/ws`, appVersion: "0.13.0" });
      await client.connect();
@@ -182,7 +182,7 @@ test.each([false, true])(
      await client.close();
      client = undefined;
      await stopFixture(first.child, abrupt);
-      const second = await restartFixture(root);
+      const second = await restartFixture(root, { resumeOnStartup: true });
      processes.push(second.child);
      await expect.poll(() => readPrompts(root), { timeout: 15000 }).toHaveLength(1);
      const prompts = await readPrompts(root);
@@ -222,7 +222,7 @@ test.each([false, true])(
      await client.close();
      client = undefined;
      await stopFixture(second.child, false);
-      const third = await restartFixture(root);
+      const third = await restartFixture(root, { resumeOnStartup: true });
      processes.push(third.child);
      expect(await readPrompts(root)).toHaveLength(1);
      expect(
@@ -243,7 +243,7 @@ test.each([false, true])(
  60000,
 );

-test.each([false, true])(
+test.each([undefined, false, true])(
  "host restart recovery settings (enabled=%s)",
  async (enabled) => {
    const root = await mkdtemp(path.join(tmpdir(), "resume-settings-process-"));
@@ -314,7 +314,7 @@ test("a provider that is slow to reopen does not hold daemon startup", async ()
  const processes: ChildProcess[] = [];
  let client: DaemonClient | undefined;
  try {
-    const first = await restartFixture(root);
+    const first = await restartFixture(root, { resumeOnStartup: true });
    processes.push(first.child);
    client = new DaemonClient({ url: `ws://127.0.0.1:${first.port}/ws`, appVersion: "0.13.0" });
    await client.connect();
@@ -338,7 +338,7 @@ test("a provider that is slow to reopen does not hold daemon startup", async ()
    client = undefined;
    await stopFixture(first.child, false);

-    const second = await restartFixture(root, {}, { holdResume: true });
+    const second = await restartFixture(root, { resumeOnStartup: true }, { holdResume: true });
    processes.push(second.child);
    client = new DaemonClient({ url: `ws://127.0.0.1:${second.port}/ws`, appVersion: "0.13.0" });
    await client.connect();
@@ -102,52 +102,53 @@ describe("daemon E2E", () => {
      },
    );

-    test("downloads ASCII and Unicode filenames through one workspace", async () => {
-      const cwd = tmpCwd();
-      try {
-        const agent = await ctx.client.createAgent({
-          provider: "codex",
-          model: CODEX_TEST_MODEL,
-          thinkingOptionId: CODEX_TEST_THINKING_OPTION_ID,
-          cwd,
-          title: "Download Token Test Agent",
-        });
-
-        expect(agent.id).toMatch(
-          /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
-        );
-
-        for (const { fileName, disposition } of [
-          { fileName: "download.txt", disposition: 'attachment; filename="download.txt"' },
-          {
-            fileName: "café.txt",
-            disposition: "attachment; filename=\"caf?.txt\"; filename*=UTF-8''caf%C3%A9.txt",
-          },
-          {
-            fileName: "中文报告 (最终版).txt",
-            disposition:
-              "attachment; filename=\"???? (???).txt\"; filename*=UTF-8''%E4%B8%AD%E6%96%87%E6%8A%A5%E5%91%8A%20%28%E6%9C%80%E7%BB%88%E7%89%88%29.txt",
-          },
-          {
-            fileName: "報告書.md",
-            disposition:
-              "attachment; filename=\"???.md\"; filename*=UTF-8''%E5%A0%B1%E5%91%8A%E6%9B%B8.md",
-          },
-          {
-            fileName: "보고서.txt",
-            disposition:
-              "attachment; filename=\"???.txt\"; filename*=UTF-8''%EB%B3%B4%EA%B3%A0%EC%84%9C.txt",
-          },
-          {
-            fileName: "report-📄.txt",
-            disposition:
-              "attachment; filename=\"report-??.txt\"; filename*=UTF-8''report-%F0%9F%93%84.txt",
-          },
-        ]) {
+    test.each([
+      { fileName: "download.txt", disposition: 'attachment; filename="download.txt"' },
+      {
+        fileName: "café.txt",
+        disposition: "attachment; filename=\"caf?.txt\"; filename*=UTF-8''caf%C3%A9.txt",
+      },
+      {
+        fileName: "中文报告 (最终版).txt",
+        disposition:
+          "attachment; filename=\"???? (???).txt\"; filename*=UTF-8''%E4%B8%AD%E6%96%87%E6%8A%A5%E5%91%8A%20%28%E6%9C%80%E7%BB%88%E7%89%88%29.txt",
+      },
+      {
+        fileName: "報告書.md",
+        disposition:
+          "attachment; filename=\"???.md\"; filename*=UTF-8''%E5%A0%B1%E5%91%8A%E6%9B%B8.md",
+      },
+      {
+        fileName: "보고서.txt",
+        disposition:
+          "attachment; filename=\"???.txt\"; filename*=UTF-8''%EB%B3%B4%EA%B3%A0%EC%84%9C.txt",
+      },
+      {
+        fileName: "report-📄.txt",
+        disposition:
+          "attachment; filename=\"report-??.txt\"; filename*=UTF-8''report-%F0%9F%93%84.txt",
+      },
+    ])(
+      "issues token over WS and downloads $fileName via HTTP",
+      async ({ fileName, disposition }) => {
+        const cwd = tmpCwd();
+        try {
          const filePath = path.join(cwd, fileName);
-          const fileContents = `download test payload: ${fileName}`;
+          const fileContents = "download test payload";
          writeFileSync(filePath, fileContents, "utf-8");

+          const agent = await ctx.client.createAgent({
+            provider: "codex",
+            model: CODEX_TEST_MODEL,
+            thinkingOptionId: CODEX_TEST_THINKING_OPTION_ID,
+            cwd,
+            title: "Download Token Test Agent",
+          });
+
+          expect(agent.id).toMatch(
+            /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+          );
+
          const tokenResponse = await ctx.client.requestDownloadToken(cwd, fileName);

          expect(tokenResponse.error).toBeNull();
@@ -166,11 +167,12 @@ describe("daemon E2E", () => {

          const body = await response.text();
          expect(body).toBe(fileContents);
+        } finally {
+          rmSync(cwd, { recursive: true, force: true });
        }
-      } finally {
-        rmSync(cwd, { recursive: true, force: true });
-      }
-    }, 60000);
+      },
+      60000,
+    );

    test("rejects invalid token", async () => {
      const response = await fetch(
@@ -1,129 +0,0 @@
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import path from "node:path";
-import type { FormInfo } from "@opencode/client";
-import { expect, test } from "vitest";
-
-import { createTestLogger } from "../../test-utils/test-logger.js";
-import { OpenCodeV2AgentClient } from "../agent/providers/opencode/v2/agent.js";
-import { V2Harness } from "../agent/providers/opencode/test-utils/v2-harness.js";
-import { createTestAgentClients } from "../test-utils/fake-agent-client.js";
-import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
-import { DaemonClient } from "../test-utils/daemon-client.js";
-
-async function createQuestionHarness() {
-  const artifacts = path.resolve(".artifacts");
-  await mkdir(artifacts, { recursive: true });
-  const root = await mkdtemp(path.join(artifacts, "peer-permissions-"));
-  const runtime = new V2Harness();
-  runtime.autoComplete = false;
-  runtime.api.model.list = async () => ({ location: runtime.info.location, data: [] });
-  runtime.api.provider.list = async () => ({
-    location: runtime.info.location,
-    data: [{ id: "test", name: "Test", activation: "enabled", package: "test" }],
-  });
-  let form: FormInfo | null = null;
-  const answers: Array<Record<string, unknown>> = [];
-  runtime.api.session.form.list = async () => (form ? [form] : []);
-  runtime.api.session.form.cancel = async () => {
-    form = null;
-    runtime.finishExecution("interrupted");
-  };
-  runtime.api.session.form.reply = async ({ answer }) => {
-    answers.push(answer);
-    form = null;
-    runtime.finishExecution();
-  };
-  // A steer is admitted to the existing execution, rather than starting another one.
-  runtime.prompt = async (input) => {
-    runtime.prompts.push(input.text);
-    if (runtime.prompts.length === 1) runtime.startExecution();
-  };
-  const provider = new OpenCodeV2AgentClient({
-    logger: createTestLogger(),
-    runtime: runtime.runtime,
-  });
-  const daemon = await createTestPaseoDaemon({
-    agentClients: { ...createTestAgentClients(), opencode: provider },
-    paseoHomeRoot: path.join(root, "daemon"),
-    staticDir: path.join(root, "static"),
-    cleanup: false,
-  });
-  const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
-  try {
-    await client.connect();
-    await client.fetchAgents({ subscribe: {} });
-    const recipient = await client.createAgent({
-      provider: "opencode",
-      cwd: root,
-      title: "Waiting for a human answer",
-    });
-    const sender = await client.createAgent({ provider: "claude", cwd: root });
-    await client.sendMessage(recipient.id, "Ask which color to use");
-    await expect.poll(() => runtime.prompts).toHaveLength(1);
-    form = {
-      id: "color-question",
-      sessionID: "session",
-      title: "Color",
-      fields: [{ key: "color", title: "Color", type: "string" }],
-    };
-    runtime.push({ id: "question-created", created: 2, type: "form.created", data: { form } });
-    await client.waitForAgentUpsert(recipient.id, (agent) =>
-      (agent.pendingPermissions ?? []).some((request) => request.id === "color-question"),
-    );
-    return {
-      client,
-      recipient,
-      sender,
-      answers,
-      async close() {
-        await client.close();
-        await daemon.close();
-        await rm(root, { recursive: true, force: true });
-      },
-    };
-  } catch (error) {
-    await client.close();
-    await daemon.close();
-    await rm(root, { recursive: true, force: true });
-    throw error;
-  }
-}
-
-test("an agent-sourced steer leaves the question pending and answerable", async () => {
-  const { client, recipient, sender, answers, close } = await createQuestionHarness();
-  try {
-    await client.sendAgentMessage(recipient.id, "Peer status check", {
-      sourceAgentId: sender.id,
-    });
-    // The public wait includes admitted message delivery before reporting permission status.
-    const waiting = await client.waitForFinish(recipient.id);
-    expect(waiting.status).toBe("permission");
-    expect(waiting.final?.pendingPermissions).toMatchObject([
-      { id: "color-question", kind: "question" },
-    ]);
-    await client.respondToPermission(recipient.id, "color-question", {
-      behavior: "allow",
-      updatedInput: { answers: { Color: "Blue" } },
-    });
-    await client.waitForAgentUpsert(
-      recipient.id,
-      (agent) => (agent.pendingPermissions ?? []).length === 0 && agent.status === "idle",
-    );
-    expect(answers).toEqual([{ color: "Blue" }]);
-  } finally {
-    await close();
-  }
-});
-
-test("a human steer still dismisses the question", async () => {
-  const { client, recipient, answers, close } = await createQuestionHarness();
-  try {
-    await client.sendAgentMessage(recipient.id, "Use red instead", { activeTurnBehavior: "steer" });
-    const finished = await client.waitForFinish(recipient.id);
-    expect(finished.status).toBe("idle");
-    expect(finished.final?.pendingPermissions ?? []).toEqual([]);
-    expect(answers).toEqual([]);
-  } finally {
-    await close();
-  }
-});
@@ -20,7 +20,6 @@ import { DaemonConfigStore } from "../daemon-config-store.js";
 import { PluginService } from "./index.js";
 import { BuiltinPluginLoader } from "./builtin/index.js";
 import { ManagedPluginSources } from "./managed-source.js";
-import type { PluginProviderMetadata } from "./plugin-process-protocol.js";
 import {
  startNpmRegistry,
  npmPluginPackages,
@@ -180,55 +179,6 @@ function createPluginSelectivePausedRuntime(pausedPluginId: string) {
  return { runtime, started, releaseStart, starts };
 }

-function createGatedRuntime(providers: Record<string, readonly PluginProviderMetadata[]> = {}) {
-  const gates = new Map<string, PromiseWithResolvers<void>>();
-  const gate = (pluginId: string) => {
-    const existing = gates.get(pluginId);
-    if (existing) return existing;
-    const created = Promise.withResolvers<void>();
-    gates.set(pluginId, created);
-    return created;
-  };
-  const begun: string[] = [];
-  const running = new Set<string>();
-  const runtime: TestPluginRuntime = {
-    ...emptyUsageRuntime,
-    catalog: () => [...running].map((id) => ({ id, clientBundle: "bundle" })),
-    invoke: async () => undefined,
-    getLogs: () => [],
-    clearLogs: () => undefined,
-    getProviderRegistrations: (pluginId) =>
-      running.has(pluginId) ? (providers[pluginId] ?? []) : [],
-    startPlugin: async (pluginId) => {
-      begun.push(pluginId);
-      await gate(pluginId).promise;
-      running.add(pluginId);
-    },
-    stopPluginById: async (pluginId) => running.delete(pluginId),
-    stopAll: async () => {
-      running.clear();
-    },
-    subscribe: () => () => undefined,
-    bindPaseoSessionHost: () => undefined,
-  };
-  return {
-    runtime,
-    begun,
-    finish: (pluginId: string) => gate(pluginId).resolve(),
-    fail: (pluginId: string, error: Error) => gate(pluginId).reject(error),
-  };
-}
-
-function nextNotification(service: PluginService, pluginId: string): Promise<void> {
-  return new Promise((resolve) => {
-    const unsubscribe = service.subscribe((notified) => {
-      if (notified !== pluginId) return;
-      unsubscribe();
-      resolve();
-    });
-  });
-}
-
 describe("PluginService", () => {
  it.each([
    { shadow: false, runtime: "subprocess" },
@@ -422,127 +372,15 @@ describe("PluginService", () => {
      "startup-first": { source: "directory", path: first },
      "startup-second": { source: "directory", path: second },
    });
-    const notifications: { pluginId: string; running: boolean }[] = [];
-    service.subscribe((pluginId) =>
-      notifications.push({ pluginId, running: catalogIds(service).includes(pluginId) }),
-    );
+    const snapshots: string[][] = [];
+    service.subscribe(() => snapshots.push(catalogIds(service)));

    await service.start();

-    expect(notifications).toEqual([
-      { pluginId: "startup-first", running: true },
-      { pluginId: "startup-second", running: true },
-    ]);
-    expect(catalogIds(service)).toEqual(["startup-first", "startup-second"]);
+    expect(snapshots).toEqual([["startup-first"], ["startup-first", "startup-second"]]);
    await service.stopAllPlugins();
  }, 20_000);

-  it("starts configured plugins concurrently and publishes them in config order", async () => {
-    const home = await mkdtemp(path.join(tmpdir(), "paseo-plugin-home-"));
-    roots.push(home);
-    const gated = createGatedRuntime();
-    const service = createService(
-      home,
-      {
-        alpha: { source: "directory", path: "/plugins/alpha" },
-        beta: { source: "directory", path: "/plugins/beta" },
-        gamma: { source: "directory", path: "/plugins/gamma" },
-      },
-      { runtime: gated.runtime },
-    );
-    const notified: string[] = [];
-    service.subscribe((pluginId) => notified.push(pluginId));
-    let started = false;
-    const starting = (async () => {
-      await service.start();
-      started = true;
-    })();
-
-    await expect.poll(() => gated.begun).toEqual(["alpha", "beta", "gamma"]);
-
-    gated.finish("gamma");
-    const alphaPublished = nextNotification(service, "alpha");
-    gated.finish("alpha");
-    await alphaPublished;
-    expect(notified).toEqual(["alpha"]);
-    expect(started).toBe(false);
-
-    gated.finish("beta");
-    await starting;
-    expect(notified).toEqual(["alpha", "beta", "gamma"]);
-    expect(catalogIds(service)).toEqual(["alpha", "beta", "gamma"]);
-    await service.stopAllPlugins();
-  });
-
-  it("starts the other configured plugins when one fails while they are still starting", async () => {
-    const home = await mkdtemp(path.join(tmpdir(), "paseo-plugin-home-"));
-    roots.push(home);
-    const gated = createGatedRuntime();
-    const service = createService(
-      home,
-      {
-        broken: { source: "directory", path: "/plugins/broken" },
-        healthy: { source: "directory", path: "/plugins/healthy" },
-      },
-      { runtime: gated.runtime },
-    );
-    const notified: string[] = [];
-    service.subscribe((pluginId) => notified.push(pluginId));
-    const starting = service.start();
-
-    await expect.poll(() => gated.begun).toEqual(["broken", "healthy"]);
-    const brokenPublished = nextNotification(service, "broken");
-    gated.fail("broken", new Error("startup exploded"));
-    await brokenPublished;
-    gated.finish("healthy");
-    await starting;
-
-    expect(notified).toEqual(["broken", "healthy"]);
-    expect(catalogIds(service)).toEqual(["healthy"]);
-    expect(await service.listPlugins()).toMatchObject([
-      { id: "broken", status: "failed", error: "startup exploded" },
-      { id: "healthy", status: "running" },
-    ]);
-    await service.stopAllPlugins();
-  });
-
-  it("keeps a provider ID with the plugin listed first when both start at once", async () => {
-    const home = await mkdtemp(path.join(tmpdir(), "paseo-plugin-home-"));
-    roots.push(home);
-    const gated = createGatedRuntime({
-      first: [{ id: "shared-agent", label: "First agent" }],
-      second: [{ id: "shared-agent", label: "Second agent" }],
-    });
-    const service = createService(
-      home,
-      {
-        first: { source: "directory", path: "/plugins/first" },
-        second: { source: "directory", path: "/plugins/second" },
-      },
-      { runtime: gated.runtime },
-    );
-    const starting = service.start();
-
-    await expect.poll(() => gated.begun).toEqual(["first", "second"]);
-    gated.finish("second");
-    gated.finish("first");
-    await starting;
-
-    expect(service.getProviderRegistrations()).toMatchObject([
-      { id: "shared-agent", label: "First agent" },
-    ]);
-    expect(catalogIds(service)).toEqual(["first"]);
-    expect(await service.listPlugins()).toMatchObject([
-      { id: "first", status: "running" },
-      {
-        id: "second",
-        status: "failed",
-        error: 'Plugin second cannot register provider ID "shared-agent" twice',
-      },
-    ]);
-    await service.stopAllPlugins();
-  });
-
  it("uses an explicit config key, exposes reload failure, and retries from disk", async () => {
    const home = await mkdtemp(path.join(tmpdir(), "paseo-plugin-home-"));
    roots.push(home);
@@ -230,18 +230,11 @@ export class PluginService {
      }
    });
    if (config.pluginsEnabled === true) {
-      let earlierPublished: Promise<unknown> = Promise.resolve();
-      await Promise.all(
-        Object.entries(config.plugins ?? {})
-          .filter(([, source]) => source.enabled !== false)
-          .map(async ([pluginId]) => {
-            const publishTurn = earlierPublished;
-            const starting = this.startConfigured(pluginId, publishTurn);
-            earlierPublished = Promise.all([publishTurn, starting]);
-            await starting;
-            this.notify(pluginId);
-          }),
-      );
+      for (const [pluginId, source] of Object.entries(config.plugins ?? {})) {
+        if (source.enabled === false) continue;
+        await this.startConfigured(pluginId);
+        this.notify(pluginId);
+      }
    }
    this.configStore.onFieldChange("pluginsEnabled", (value) => {
      this.handleGlobalSwitch(value === true);
@@ -567,12 +560,12 @@ export class PluginService {
    }).catch((error) => this.logger.error({ err: error }, "Failed to enable plugins"));
  }

-  private async startConfigured(pluginId: string, publishTurn?: Promise<unknown>): Promise<void> {
+  private async startConfigured(pluginId: string): Promise<void> {
    const source = this.configStore.get().plugins?.[pluginId];
    if (!source || source.enabled === false || !this.canPublish(pluginId)) return;
    this.errors.delete(pluginId);
    try {
-      await this.startPlugin(pluginId, source.path, publishTurn);
+      await this.startPlugin(pluginId, source.path);
    } catch (error) {
      if (this.canPublish(pluginId)) this.recordFailure(pluginId, error);
    }
@@ -601,13 +594,8 @@ export class PluginService {
    );
  }

-  private async startPlugin(
-    pluginId: string,
-    sourcePath: string,
-    publishTurn?: Promise<unknown>,
-  ): Promise<void> {
+  private async startPlugin(pluginId: string, sourcePath: string): Promise<void> {
    await this.runtime.startPlugin(pluginId, sourcePath, () => this.canPublish(pluginId));
-    await publishTurn;
    try {
      await this.publishProviderRegistrations(pluginId, sourcePath);
      this.publishUsageSources(pluginId);
@@ -61,24 +61,10 @@ describe("managed Git plugin sources", () => {
    roots.push(home);
    const sources = new ManagedPluginSources(home);

-    // Own the failure response instead of relying on a closed port and OS connect timing.
-    const server = createServer((_request, response) => {
-      response.writeHead(500, { "Content-Type": "text/plain" });
-      response.end("clone rejected for oauth2:super-secret\n");
+    const failure = sources.prepareInstall({
+      source: "git:https://oauth2:super-secret@127.0.0.1:1/missing.git",
    });
-    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-    const address = server.address() as { port: number };
-    try {
-      const failure = sources.prepareInstall({
-        source: `git:http://oauth2:super-secret@127.0.0.1:${address.port}/missing.git`,
-      });
-      await expect(failure).rejects.toThrow("500");
-      await expect(failure).rejects.toThrow("clone rejected for [redacted]:[redacted]");
-      await expect(failure).rejects.not.toThrow(/oauth2|super-secret/);
-    } finally {
-      server.closeAllConnections();
-      await new Promise<void>((resolve) => server.close(() => resolve()));
-    }
+    await expect(failure).rejects.not.toThrow(/oauth2|super-secret/);
  });

  it("normalizes explicit GitHub and Git identifiers to the same Git source", async () => {
@@ -1,9 +1,7 @@
-import { type EventEmitter, once } from "node:events";
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import http from "node:http";
 import net from "node:net";
-import type { Duplex } from "node:stream";
 import express from "express";
 import { describe, expect, it } from "vitest";
 import pino from "pino";
@@ -334,39 +332,48 @@ describe("service proxy subsystem shape", () => {
  });
 });

-interface ProxiedServiceFixture {
+interface ForwardedFixture {
  upstreamPort: number;
  daemonPort: number;
-  daemon: http.Server;
  hostname: string;
  close(): Promise<void>;
 }

 /**
- * Runs a real workspace service behind a real daemon listener that serves the
- * service proxy for both HTTP and upgrades.
+ * Runs a real workspace service behind a real daemon listener. The upstream
+ * echoes the headers it received so tests can assert what actually crossed the
+ * proxy, not what a helper returned.
 */
-async function startProxiedService(
-  upstream: http.Server,
-  options: { upstreamHost?: string; logger?: pino.Logger } = {},
-): Promise<ProxiedServiceFixture> {
-  const { upstreamHost = "127.0.0.1", logger: proxyLogger = logger } = options;
-  // Upgraded sockets keep the server alive; close() alone would hang.
-  const sockets = new Set<net.Socket>();
-  function trackConnections(server: http.Server) {
-    server.on("connection", (socket: net.Socket) => {
-      sockets.add(socket);
-      socket.once("close", () => sockets.delete(socket));
+async function startForwardedHeadersFixture(upstreamHost = "127.0.0.1"): Promise<ForwardedFixture> {
+  const upstream = http.createServer((req, res) => {
+    let body = "";
+    req.on("data", (chunk: Buffer) => {
+      body += chunk.toString();
    });
-  }
-  trackConnections(upstream);
+    req.on("end", () => {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ...req.headers, method: req.method, url: req.url, body }));
+    });
+  });
+  const upgradeSockets: net.Socket[] = [];
+  upstream.on("upgrade", (req, socket) => {
+    upgradeSockets.push(socket);
+    // The client resets this connection once it has the echo, so the reset
+    // reaches us as an 'error'. A raw upgrade socket has no default handler —
+    // without this the event goes unhandled and takes down the test process.
+    socket.on("error", () => socket.destroy());
+    const payload = JSON.stringify(req.headers);
+    socket.write(
+      `HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nX-Echo-Length: ${payload.length}\r\n\r\n${payload}`,
+    );
+  });
  await new Promise<void>((resolve, reject) => {
    upstream.once("error", reject);
    upstream.listen(0, upstreamHost, resolve);
  });
  const upstreamPort = (upstream.address() as net.AddressInfo).port;

-  const serviceProxy = createServiceProxySubsystem({ logger: proxyLogger });
+  const serviceProxy = createServiceProxySubsystem({ logger });
  const route = serviceProxy.registerWorkspaceService({
    workspaceId: "workspace-a",
    projectSlug: "repo",
@@ -383,51 +390,24 @@ async function startProxiedService(
    res.status(404).send("404 Not Found");
  });
  const daemon = http.createServer(app);
-  trackConnections(daemon);
  daemon.on("upgrade", serviceProxy.upgradeHandler({ passthroughUnknown: false }));
  await new Promise<void>((resolve) => daemon.listen(daemonPort, "127.0.0.1", resolve));

  return {
    upstreamPort,
    daemonPort,
-    daemon,
    hostname: route.hostname,
    async close() {
-      for (const socket of sockets) socket.destroy();
+      // Upgraded sockets keep the server alive; close() alone would hang.
+      for (const socket of upgradeSockets) socket.destroy();
+      daemon.closeAllConnections();
      await new Promise<void>((resolve) => daemon.close(() => resolve()));
+      upstream.closeAllConnections();
      await new Promise<void>((resolve) => upstream.close(() => resolve()));
    },
  };
 }

-/**
- * The upstream echoes the headers it received so tests can assert what
- * actually crossed the proxy, not what a helper returned.
- */
-function startForwardedHeadersFixture(upstreamHost = "127.0.0.1"): Promise<ProxiedServiceFixture> {
-  const upstream = http.createServer((req, res) => {
-    let body = "";
-    req.on("data", (chunk: Buffer) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      res.writeHead(200, { "content-type": "application/json" });
-      res.end(JSON.stringify({ ...req.headers, method: req.method, url: req.url, body }));
-    });
-  });
-  upstream.on("upgrade", (req, socket) => {
-    // The client resets this connection once it has the echo, so the reset
-    // reaches us as an 'error'. A raw upgrade socket has no default handler —
-    // without this the event goes unhandled and takes down the test process.
-    socket.on("error", () => socket.destroy());
-    const payload = JSON.stringify(req.headers);
-    socket.write(
-      `HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nX-Echo-Length: ${payload.length}\r\n\r\n${payload}`,
-    );
-  });
-  return startProxiedService(upstream, { upstreamHost });
-}
-
 function upgradeThroughProxy(
  port: number,
  host: string,
@@ -671,198 +651,3 @@ describe("service proxy forwarded headers", () => {
    }
  });
 });
-
-function closed(emitter: EventEmitter): Promise<void> {
-  return new Promise((resolve) => {
-    emitter.once("close", () => resolve());
-  });
-}
-
-async function within<T>(promise: Promise<T>, ms: number, failure: string): Promise<T> {
-  let timer: NodeJS.Timeout | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(() => reject(new Error(`${failure} after ${ms}ms`)), ms);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function requestThroughProxy(
-  fixture: ProxiedServiceFixture,
-  requestPath: string,
-): http.ClientRequest {
-  return http.get({
-    hostname: "127.0.0.1",
-    port: fixture.daemonPort,
-    path: requestPath,
-    headers: { host: fixture.hostname },
-  });
-}
-
-const STRAY_WARNING_GRACE_MS = 100;
-
-function createUpgradeUpstream(onUpgrade: (socket: Duplex) => void): http.Server {
-  const upstream = http.createServer();
-  upstream.on("upgrade", (_req, socket) => {
-    socket.on("error", () => socket.destroy());
-    socket.on("end", () => socket.end());
-    socket.write(
-      "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n",
-    );
-    onUpgrade(socket);
-  });
-  return upstream;
-}
-
-function openUpgradeThroughProxy(fixture: ProxiedServiceFixture): Promise<net.Socket> {
-  return new Promise((resolve, reject) => {
-    const socket = net.connect({ host: "127.0.0.1", port: fixture.daemonPort }, () => {
-      const lines = [
-        "GET /ws HTTP/1.1",
-        `Host: ${fixture.hostname}`,
-        "Upgrade: websocket",
-        "Connection: Upgrade",
-        "",
-        "",
-      ];
-      socket.write(lines.join("\r\n"));
-    });
-    let raw = "";
-    socket.on("data", (chunk: Buffer) => {
-      raw += chunk.toString();
-      if (raw.includes("\r\n\r\n")) resolve(socket);
-    });
-    socket.on("close", () => reject(new Error("upgrade closed before the 101 arrived")));
-    socket.on("error", reject);
-  });
-}
-
-describe("service proxy connection teardown", () => {
-  it("closes the upstream connection when a client leaves an event stream", async () => {
-    const upstreamResponse = Promise.withResolvers<http.ServerResponse>();
-    const upstream = http.createServer((_req, res) => {
-      res.writeHead(200, { "content-type": "text/event-stream" });
-      res.write("data: open\n\n");
-      upstreamResponse.resolve(res);
-    });
-    const fixture = await startProxiedService(upstream);
-    try {
-      const request = requestThroughProxy(fixture, "/events");
-      const [response] = (await once(request, "response")) as [http.IncomingMessage];
-      await once(response, "data");
-      const upstreamClosed = closed(await upstreamResponse.promise);
-
-      request.destroy();
-
-      await within(upstreamClosed, 1000, "the service still holds the event stream");
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-
-  it("aborts the upstream request when a client leaves before the response starts", async () => {
-    const warnings: unknown[] = [];
-    const proxyLogger = pino(
-      { level: "warn" },
-      { write: (line: string) => warnings.push(JSON.parse(line)) },
-    );
-    const upstreamResponse = Promise.withResolvers<http.ServerResponse>();
-    const upstream = http.createServer((_req, res) => {
-      upstreamResponse.resolve(res);
-    });
-    const fixture = await startProxiedService(upstream, { logger: proxyLogger });
-    try {
-      const request = requestThroughProxy(fixture, "/slow");
-      request.on("error", () => undefined);
-      const upstreamClosed = closed(await upstreamResponse.promise);
-
-      request.destroy();
-
-      await within(upstreamClosed, 1000, "the service still holds the abandoned request");
-      await new Promise((resolve) => setTimeout(resolve, STRAY_WARNING_GRACE_MS));
-      expect(warnings).toEqual([]);
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-
-  it("lets a complete response finish without resetting the service", async () => {
-    const upstreamResponse = Promise.withResolvers<http.ServerResponse>();
-    const upstream = http.createServer((_req, res) => {
-      res.writeHead(200, { "content-type": "text/plain" });
-      res.write("first;");
-      upstreamResponse.resolve(res);
-    });
-    const fixture = await startProxiedService(upstream);
-    try {
-      const response = httpGet(fixture.daemonPort, fixture.hostname, { path: "/" });
-      const res = await upstreamResponse.promise;
-      const upstreamClosed = closed(res);
-
-      res.end("second");
-
-      await expect(response).resolves.toEqual({ status: 200, body: "first;second" });
-      await within(upstreamClosed, 1000, "the service response never closed");
-      expect(res.writableFinished).toBe(true);
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-
-  it("closes the upstream WebSocket when the daemon drops the client socket", async () => {
-    const upstreamSocket = Promise.withResolvers<Duplex>();
-    const fixture = await startProxiedService(
-      createUpgradeUpstream((socket) => upstreamSocket.resolve(socket)),
-    );
-    const daemonSide = Promise.withResolvers<Duplex>();
-    fixture.daemon.on("upgrade", (_req, socket) => daemonSide.resolve(socket));
-    try {
-      const client = await openUpgradeThroughProxy(fixture);
-      const upstreamClosed = closed(await upstreamSocket.promise);
-
-      (await daemonSide.promise).destroy();
-
-      await within(upstreamClosed, 1000, "the service still holds the WebSocket");
-      client.destroy();
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-
-  it("closes the upstream WebSocket when the client disconnects", async () => {
-    const upstreamSocket = Promise.withResolvers<Duplex>();
-    const fixture = await startProxiedService(
-      createUpgradeUpstream((socket) => upstreamSocket.resolve(socket)),
-    );
-    try {
-      const client = await openUpgradeThroughProxy(fixture);
-      const upstreamClosed = closed(await upstreamSocket.promise);
-
-      client.destroy();
-
-      await within(upstreamClosed, 1000, "the service still holds the WebSocket");
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-
-  it("closes the client WebSocket when the service closes it", async () => {
-    const upstreamSocket = Promise.withResolvers<Duplex>();
-    const fixture = await startProxiedService(
-      createUpgradeUpstream((socket) => upstreamSocket.resolve(socket)),
-    );
-    try {
-      const client = await openUpgradeThroughProxy(fixture);
-      const clientClosed = closed(client);
-
-      (await upstreamSocket.promise).destroy();
-
-      await within(clientClosed, 1000, "the client WebSocket is still open");
-    } finally {
-      await fixture.close();
-    }
-  }, 5000);
-});
@@ -342,14 +342,7 @@ function proxyHttpRequest({
      proxyRes.pipe(res, { end: true });
    },
  );
-  let clientClosed = false;
-  res.on("close", () => {
-    if (res.writableFinished) return;
-    clientClosed = true;
-    proxyReq.destroy();
-  });
  proxyReq.on("error", (err) => {
-    if (clientClosed) return;
    logger.warn(
      { err, hostname: route.hostname, port: route.port },
      "Service proxy: upstream unreachable",
@@ -406,9 +399,6 @@ function proxyUpgradeRequest({
  socket.on("error", () => {
    targetSocket.destroy();
  });
-  socket.on("close", () => {
-    targetSocket.destroy();
-  });
 }

 function sameRouteOwner(left: ServiceProxyRouteEntry, right: ServiceProxyRouteEntry): boolean {
@@ -8318,7 +8318,7 @@ export class Session {
            },
            activeTurnBehavior: msg.activeTurnBehavior ?? "steer",
            sessionMode: msg.sessionMode,
-            clearPendingPermissions: false,
+            clearPendingPermissions: true,
          });
          deliveryStatus = "queued";
          queued();
@@ -95,13 +95,7 @@ it("accepts terminalId and token reports through the route into the tracker", as
    command: process.execPath,
    args: [
      "-e",
-      `
-        const fs = require("node:fs");
-        const envPath = ${JSON.stringify(envPath)};
-        fs.writeFileSync(envPath + ".tmp", JSON.stringify({ terminalId: process.env.PASEO_TERMINAL_ID, token: process.env.PASEO_ACTIVITY_TOKEN, url: process.env.PASEO_TERMINAL_ACTIVITY_URL }));
-        fs.renameSync(envPath + ".tmp", envPath);
-        setInterval(() => {}, 1000);
-      `,
+      `require("node:fs").writeFileSync(${JSON.stringify(envPath)}, JSON.stringify({ terminalId: process.env.PASEO_TERMINAL_ID, token: process.env.PASEO_ACTIVITY_TOKEN, url: process.env.PASEO_TERMINAL_ACTIVITY_URL })); setInterval(() => {}, 1000);`,
    ],
  });
  await waitForCondition(() => existsSync(envPath), 10000);
@@ -22,7 +22,6 @@ import type {
  FetchCatalogOptions,
 } from "../agent/agent-sdk-types.js";
 import type { AgentPermissionRequest, AgentPermissionResponse } from "../agent/agent-sdk-types.js";
-import { createTurnIdSequence } from "../agent/turn-ids.js";
 import { isLikelyExternalToolName } from "@getpaseo/protocol/tool-name-normalization";

 const TEST_CAPABILITIES: AgentCapabilityFlags = {
@@ -343,7 +342,7 @@ class FakeAgentSession implements AgentSession {
  private permissionGate: Deferred<AgentPermissionResponse> | null = null;
  private readonly historyPath: string;
  private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
-  private readonly nextTurnId = createTurnIdSequence(0);
+  private nextTurnOrdinal = 0;
  private activeForegroundTurnId: string | null = null;

  readonly steerActiveTurn: AgentSession["steerActiveTurn"];
@@ -456,7 +455,7 @@ class FakeAgentSession implements AgentSession {
      throw new Error("A foreground turn is already active");
    }

-    const turnId = this.nextTurnId("fake");
+    const turnId = `fake-turn-${this.nextTurnOrdinal++}`;
    this.activeForegroundTurnId = turnId;
    this.onStartTurn?.(prompt, this.config);

@@ -1,4 +1,3 @@
-import { flushGitCommandTrace } from "../utils/git-command-trace.js";
 import { createWorkspaceRuntimeStore } from "./workspace-runtime-store/index.js";
 import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -731,103 +730,3 @@ test("Git event identity retains a symlink's literal target before canonicalizin
    rmSync(root, { recursive: true, force: true });
  }
 });
-
-test.skipIf(process.platform !== "linux")(
-  "missing folders stop degraded Git polling and explicit refreshes, then recover",
-  async () => {
-    const artifacts = path.resolve(".artifacts");
-    mkdirSync(artifacts, { recursive: true });
-    const root = mkdtempSync(path.join(artifacts, "workspace-git-missing-"));
-    const cwd = path.join(root, "repo");
-    const initializeRepo = (branch: string) => {
-      mkdirSync(cwd);
-      execFileSync("git", ["init", "-b", branch], { cwd, stdio: "pipe" });
-      writeFileSync(path.join(cwd, "README.md"), "fixture\n");
-      execFileSync("git", ["add", "."], { cwd, stdio: "pipe" });
-      execFileSync(
-        "git",
-        [
-          "-c",
-          "user.name=Test",
-          "-c",
-          "user.email=test@example.invalid",
-          "-c",
-          "commit.gpgsign=false",
-          "commit",
-          "-m",
-          "fixture",
-        ],
-        { cwd, stdio: "pipe" },
-      );
-    };
-    initializeRepo("main");
-    // Exceed the real Linux observer's directory limit to enter degraded polling.
-    // No watcher errors or Git responses are injected.
-    for (let index = 0; index < 5100; index++) {
-      mkdirSync(path.join(cwd, `generated-${index}`));
-    }
-    const trace = path.join(root, "git.jsonl");
-    writeFileSync(trace, "");
-    const previousTrace = process.env.PASEO_GIT_TRACE_FILE;
-    process.env.PASEO_GIT_TRACE_FILE = trace;
-    let degraded = false;
-    let suspended = false;
-    const logger = pino(
-      { level: "warn" },
-      {
-        write(line) {
-          const message = JSON.parse(line).msg;
-          if (message === "Failed to start working tree watcher; using degraded polling")
-            degraded = true;
-          if (
-            message ===
-            "Workspace folder no longer exists; suspended git observation until it is back"
-          )
-            suspended = true;
-        },
-      },
-    );
-    const service = new WorkspaceGitServiceImpl({ logger, paseoHome: path.join(root, "home") });
-    const subscription = service.registerWorkspace({ cwd }, () => {});
-    const commandCount = async () => {
-      await flushGitCommandTrace();
-      return readFileSync(trace, "utf8").trim().split("\n").filter(Boolean).length;
-    };
-    try {
-      await expect
-        .poll(() => degraded && service.getMetrics().workspaceRefreshInFlightCount === 0, {
-          timeout: 15_000,
-        })
-        .toBe(true);
-      rmSync(cwd, { recursive: true, force: true });
-      await expect.poll(() => suspended, { timeout: 15_000 }).toBe(true);
-      await expect.poll(() => service.getMetrics().workspaceRefreshInFlightCount).toBe(0);
-      const commandsWhileMissing = await commandCount();
-      await service.getSnapshot(cwd, {
-        force: true,
-        includeForge: false,
-        reason: "refresh-button",
-      });
-      await service.refresh(cwd);
-      expect(await commandCount()).toBe(commandsWhileMissing);
-      await new Promise((resolve) => setTimeout(resolve, 16_000));
-      expect(await commandCount()).toBe(commandsWhileMissing);
-
-      initializeRepo("restored");
-      const snapshot = await service.getSnapshot(cwd, {
-        force: true,
-        includeForge: false,
-        reason: "refresh-button",
-      });
-      expect(snapshot.git).toMatchObject({ isGit: true, currentBranch: "restored" });
-      await expect.poll(() => service.getMetrics().repositoryWorkspaceLinkCount).toBe(1);
-    } finally {
-      subscription.unsubscribe();
-      await service.dispose();
-      if (previousTrace === undefined) delete process.env.PASEO_GIT_TRACE_FILE;
-      else process.env.PASEO_GIT_TRACE_FILE = previousTrace;
-      rmSync(root, { recursive: true, force: true });
-    }
-  },
-  60_000,
-);
@@ -244,7 +244,6 @@ function createService(
        filterEvents: (events) => events,
        verify: vi.fn(async () => {}),
      })),
-      workspaceFolderExists: vi.fn(async () => true),
      ...overrides,
    } as never,
  });
@@ -1,7 +1,5 @@
 import { createWorkspaceRuntimeStore } from "./workspace-runtime-store/index.js";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { existsSync } from "node:fs";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path, { join } from "node:path";
 import type pino from "pino";
@@ -12,14 +10,11 @@ import type {
  PullRequestStatusResult,
 } from "../utils/checkout-git.js";
 import {
-  BACKGROUND_GIT_FETCH_INTERVAL_MS,
-  WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS,
  WORKSPACE_GIT_OBSERVATION_SETUP_CONCURRENCY,
  WORKSPACE_GIT_REFRESH_CONCURRENCY,
  WORKSPACE_GIT_WATCHER_SUBSCRIBE_TIMEOUT_MS,
  WorkspaceGitServiceImpl,
  type WorkspaceGitRuntimeSnapshot,
-  workspaceFolderExists,
 } from "./workspace-git-service.js";

 const REPO_CWD = path.resolve("/tmp/repo");
@@ -28,7 +23,6 @@ function createLogger() {
  const logger = {
    child: () => logger,
    debug: vi.fn(),
-    info: vi.fn(),
    warn: vi.fn(),
  };
  return logger;
@@ -257,7 +251,7 @@ function createGitHubServiceStub(): ForgeService {
 interface CreateServiceTestOptions {
  subscribe?: ReturnType<typeof vi.fn>;
  getCheckoutStatus?: ReturnType<typeof vi.fn>;
-  getCheckoutSnapshotFacts?: (cwd: string) => Promise<CheckoutSnapshotFacts>;
+  getCheckoutSnapshotFacts?: ReturnType<typeof vi.fn>;
  getCheckoutShortstat?: ReturnType<typeof vi.fn>;
  getCheckoutWorktreeState?: ReturnType<typeof vi.fn>;
  getPullRequestStatus?: ReturnType<typeof vi.fn>;
@@ -267,7 +261,6 @@ interface CreateServiceTestOptions {
  runGitFetch?: ReturnType<typeof vi.fn>;
  runGitCommand?: ReturnType<typeof vi.fn>;
  getWorkspaceGitSelfHealPhaseMs?: (cwd: string) => number;
-  workspaceFolderExists?: (cwd: string) => Promise<boolean>;
  now?: () => Date;
 }

@@ -301,7 +294,6 @@ function buildDefaultTestServiceDeps() {
      signal: null,
    })),
    getWorkspaceGitSelfHealPhaseMs: vi.fn(() => 30_000),
-    workspaceFolderExists: vi.fn(async () => true),
    createWatcherLivenessCanary: vi.fn(() => ({
      path: "",
      filterEvents: (events) => events,
@@ -332,145 +324,6 @@ function createService(options?: CreateServiceTestOptions) {
  });
 }

-type WatchCallback = (error: Error | null, events: Array<{ path: string; type: "update" }>) => void;
-
-interface FolderBackedGitOptions {
-  facts?: (cwd: string) => CheckoutSnapshotFacts;
-  unwatchableDirectories?: string[];
-  heldWatch?: { directory: string; release: Promise<void> };
-}
-
-function createFolderBackedGit(options?: FolderBackedGitOptions) {
-  const watchCallbacks = new Map<string, WatchCallback>();
-  const subscribe = vi.fn(async (directory: string, callback: WatchCallback) => {
-    if (!existsSync(directory) || options?.unwatchableDirectories?.includes(directory)) {
-      throw new Error(`Cannot watch ${directory}`);
-    }
-    if (options?.heldWatch?.directory === directory) {
-      await options.heldWatch.release;
-    }
-    watchCallbacks.set(directory, callback);
-    return createAsyncSubscription();
-  });
-  const getCheckoutSnapshotFacts = vi.fn(
-    async (cwd: string): Promise<CheckoutSnapshotFacts> =>
-      existsSync(cwd) ? (options?.facts ?? createCheckoutSnapshotFacts)(cwd) : { isGit: false },
-  );
-  const getCheckoutStatus = vi.fn(async (cwd: string) =>
-    existsSync(cwd) ? createCheckoutStatus(cwd) : ({ isGit: false } as const),
-  );
-  const getCheckoutShortstat = vi.fn(async (_cwd: string) => ({ additions: 1, deletions: 0 }));
-  const getCheckoutWorktreeState = vi.fn(async (_cwd: string) => ({
-    isDirty: false,
-    diffStat: { additions: 1, deletions: 0 },
-  }));
-  const runGitCommand = vi.fn(async (args: string[], runOptions: { cwd: string }) => ({
-    stdout: args[0] === "rev-parse" ? `${runOptions.cwd}\n` : "",
-    stderr: "",
-    truncated: false,
-    exitCode: 0,
-    signal: null,
-  }));
-  const runGitFetch = vi.fn(async (_cwd: string) => ({ changes: [], error: null }));
-  const callsIn = (fake: ReturnType<typeof vi.fn>, cwd: string) =>
-    fake.mock.calls.filter(([calledCwd]) => calledCwd === cwd).length;
-
-  return {
-    deps: {
-      subscribe,
-      getCheckoutSnapshotFacts,
-      getCheckoutStatus,
-      getCheckoutShortstat,
-      getCheckoutWorktreeState,
-      runGitCommand,
-      runGitFetch,
-      workspaceFolderExists: async (cwd: string) => existsSync(cwd),
-      now: () => new Date(),
-    },
-    watchCallbackFor(directory: string): WatchCallback {
-      const callback = watchCallbacks.get(directory);
-      if (!callback) {
-        throw new Error(`No watcher was started for ${directory}`);
-      }
-      return callback;
-    },
-    watchAttemptsFor: (directory: string) => callsIn(subscribe, directory),
-    pollsOf: (cwd: string) => callsIn(getCheckoutShortstat, cwd),
-    fetchesIn: (cwd: string) => callsIn(runGitFetch, cwd),
-    gitCommandsIn(cwd: string): number {
-      const cwdCommands = [
-        getCheckoutSnapshotFacts,
-        getCheckoutStatus,
-        getCheckoutShortstat,
-        getCheckoutWorktreeState,
-        runGitFetch,
-      ].reduce((count, fake) => count + callsIn(fake, cwd), 0);
-      const commandsRunInCwd = runGitCommand.mock.calls.filter(
-        ([, runOptions]) => runOptions.cwd === cwd,
-      ).length;
-      return cwdCommands + commandsRunInCwd;
-    },
-  };
-}
-
-function linkedWorktreeFacts(gitCommonDir: string) {
-  return (cwd: string): CheckoutSnapshotFacts => ({
-    ...createCheckoutSnapshotFacts(cwd),
-    absoluteGitDir: join(gitCommonDir, "worktrees", path.basename(cwd)),
-    gitCommonDir,
-  });
-}
-
-const SETTLE_ATTEMPTS = 1_000;
-
-async function settle(assertion: () => void): Promise<void> {
-  let lastFailure: unknown = null;
-  for (let attempt = 0; attempt < SETTLE_ATTEMPTS; attempt += 1) {
-    try {
-      assertion();
-      return;
-    } catch (failure) {
-      lastFailure = failure;
-    }
-    await vi.advanceTimersByTimeAsync(0);
-  }
-  throw lastFailure;
-}
-
-async function waitForRefreshesToSettle(service: WorkspaceGitServiceImpl): Promise<void> {
-  await settle(() => {
-    expect(service.getMetrics().workspaceRefreshInFlightCount).toBe(0);
-  });
-}
-
-async function waitForObservationToSettle(
-  service: WorkspaceGitServiceImpl,
-  repositoryWorkspaceLinkCount: number,
-): Promise<void> {
-  await settle(() => {
-    const metrics = service.getMetrics();
-    expect(metrics.repositoryWorkspaceLinkCount).toBe(repositoryWorkspaceLinkCount);
-    expect(metrics.workspaceObservationSetupInFlightCount).toBe(0);
-    expect(metrics.workspaceRefreshInFlightCount).toBe(0);
-  });
-}
-
-async function advanceThroughDegradedPolls(service: WorkspaceGitServiceImpl): Promise<void> {
-  for (const delayMs of [5_000, 10_000, 20_000, 40_000, 60_000, 60_000]) {
-    await vi.advanceTimersByTimeAsync(delayMs);
-    await waitForRefreshesToSettle(service);
-  }
-}
-
-async function advanceThroughWorkingTreeRecoveryAttempts(
-  service: WorkspaceGitServiceImpl,
-): Promise<void> {
-  for (const delayMs of [30_000, 60_000, 120_000]) {
-    await vi.advanceTimersByTimeAsync(delayMs);
-    await waitForRefreshesToSettle(service);
-  }
-}
-
 describe("WorkspaceGitServiceImpl", () => {
  beforeEach(() => {
    vi.useFakeTimers();
@@ -1700,460 +1553,3 @@ describe("WorkspaceGitServiceImpl", () => {
    service.dispose();
  });
 });
-
-describe("WorkspaceGitServiceImpl with workspace folders that no longer exist", () => {
-  const temporaryFolders: string[] = [];
-
-  async function createTemporaryFolder(): Promise<string> {
-    const folder = await mkdtemp(join(os.tmpdir(), "paseo-workspace-git-"));
-    temporaryFolders.push(folder);
-    return folder;
-  }
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(async () => {
-    vi.useRealTimers();
-    await Promise.all(
-      temporaryFolders.splice(0).map((folder) => rm(folder, { recursive: true, force: true })),
-    );
-  });
-
-  test("polling stops for a workspace whose folder no longer exists", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const subscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-
-    await rm(workspace, { recursive: true, force: true });
-    const gitCommandsAtDeletion = git.gitCommandsIn(workspace);
-    await advanceThroughDegradedPolls(service);
-
-    expect(git.gitCommandsIn(workspace)).toBe(gitCommandsAtDeletion);
-    expect(service.getMetrics()).toMatchObject({
-      repositoryTargetCount: 0,
-      workingTreeWatchTargetCount: 0,
-    });
-    expect(vi.getTimerCount()).toBe(1);
-
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a deleted worktree leaves its shared repository polling and fetch to the surviving worktree", async () => {
-    const gitCommonDir = join(await createTemporaryFolder(), ".git");
-    const deletedWorktree = await createTemporaryFolder();
-    const survivingWorktree = await createTemporaryFolder();
-    const git = createFolderBackedGit({ facts: linkedWorktreeFacts(gitCommonDir) });
-    let survivingWorktreeEdits = 0;
-    git.deps.getCheckoutShortstat.mockImplementation(async (cwd: string) => ({
-      additions: cwd === survivingWorktree ? ++survivingWorktreeEdits : 1,
-      deletions: 0,
-    }));
-    const service = createService(git.deps);
-    const deletedSubscription = service.registerWorkspace({ cwd: deletedWorktree }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    const survivingSubscription = service.registerWorkspace({ cwd: survivingWorktree }, vi.fn());
-    await waitForObservationToSettle(service, 2);
-
-    await rm(deletedWorktree, { recursive: true, force: true });
-    await vi.advanceTimersByTimeAsync(60_000);
-    await waitForRefreshesToSettle(service);
-    const deletedWorktreeCommands = git.gitCommandsIn(deletedWorktree);
-
-    for (let tick = 0; tick < 3; tick += 1) {
-      const survivingWorktreePolls = git.pollsOf(survivingWorktree);
-      await vi.advanceTimersByTimeAsync(5_000);
-      await settle(() => {
-        expect(git.pollsOf(survivingWorktree)).toBe(survivingWorktreePolls + 1);
-      });
-    }
-    expect(git.gitCommandsIn(deletedWorktree)).toBe(deletedWorktreeCommands);
-
-    const fetchesBefore = git.deps.runGitFetch.mock.calls.length;
-    await vi.advanceTimersByTimeAsync(2 * BACKGROUND_GIT_FETCH_INTERVAL_MS);
-    expect(git.deps.runGitFetch.mock.calls.slice(fetchesBefore).map(([cwd]) => cwd)).toEqual([
-      survivingWorktree,
-      survivingWorktree,
-    ]);
-    expect(git.gitCommandsIn(deletedWorktree)).toBe(deletedWorktreeCommands);
-
-    deletedSubscription.unsubscribe();
-    survivingSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("deleting every worktree of a repository stops its polling and background fetch", async () => {
-    const gitCommonDir = join(await createTemporaryFolder(), ".git");
-    const firstWorktree = await createTemporaryFolder();
-    const secondWorktree = await createTemporaryFolder();
-    const git = createFolderBackedGit({ facts: linkedWorktreeFacts(gitCommonDir) });
-    const service = createService(git.deps);
-    const firstSubscription = service.registerWorkspace({ cwd: firstWorktree }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    const secondSubscription = service.registerWorkspace({ cwd: secondWorktree }, vi.fn());
-    await waitForObservationToSettle(service, 2);
-
-    await rm(firstWorktree, { recursive: true, force: true });
-    await rm(secondWorktree, { recursive: true, force: true });
-    const commandsAtDeletion = [
-      git.gitCommandsIn(firstWorktree),
-      git.gitCommandsIn(secondWorktree),
-    ];
-    await advanceThroughDegradedPolls(service);
-
-    expect([git.gitCommandsIn(firstWorktree), git.gitCommandsIn(secondWorktree)]).toEqual(
-      commandsAtDeletion,
-    );
-    expect(service.getMetrics()).toMatchObject({
-      repositoryTargetCount: 0,
-      workingTreeWatchTargetCount: 0,
-    });
-    expect(vi.getTimerCount()).toBe(2);
-
-    firstSubscription.unsubscribe();
-    secondSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("working tree fallback polling and watcher recovery stop for a workspace whose folder no longer exists", async () => {
-    const workspace = await createTemporaryFolder();
-    await mkdir(join(workspace, ".git"));
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const subscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-
-    await rm(workspace, { recursive: true, force: true });
-    git.watchCallbackFor(workspace)(new Error("watched directory was deleted"), []);
-    await vi.advanceTimersByTimeAsync(1_000);
-    await waitForRefreshesToSettle(service);
-    const commandsAfterWatcherError = git.gitCommandsIn(workspace);
-    const watchAttemptsAfterWatcherError = git.watchAttemptsFor(workspace);
-    await advanceThroughDegradedPolls(service);
-
-    expect(git.gitCommandsIn(workspace)).toBe(commandsAfterWatcherError);
-    expect(git.watchAttemptsFor(workspace)).toBe(watchAttemptsAfterWatcherError);
-    expect(vi.getTimerCount()).toBe(1);
-
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a workspace whose folder comes back resumes polling on its next subscription", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const firstSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    await rm(workspace, { recursive: true, force: true });
-    const commandsWhileMissing = git.gitCommandsIn(workspace);
-    await advanceThroughDegradedPolls(service);
-    expect(git.gitCommandsIn(workspace)).toBe(commandsWhileMissing);
-
-    await mkdir(workspace);
-    const secondSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    const pollsAfterResume = git.pollsOf(workspace);
-    await vi.advanceTimersByTimeAsync(5_000);
-    await waitForRefreshesToSettle(service);
-
-    expect(git.pollsOf(workspace)).toBe(pollsAfterResume + 1);
-
-    firstSubscription.unsubscribe();
-    secondSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a suspended workspace costs no git while its folder is missing, even when a refresh is requested", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const subscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    await rm(workspace, { recursive: true, force: true });
-    await advanceThroughDegradedPolls(service);
-    const commandsWhileMissing = git.gitCommandsIn(workspace);
-
-    for (let probe = 0; probe < 10; probe += 1) {
-      await vi.advanceTimersByTimeAsync(WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS);
-      await waitForRefreshesToSettle(service);
-    }
-    service.scheduleRefreshForCwd(workspace);
-    service.onWorkspaceStateMayHaveChanged(workspace);
-    await vi.advanceTimersByTimeAsync(5_000);
-    await waitForRefreshesToSettle(service);
-
-    expect(git.gitCommandsIn(workspace)).toBe(commandsWhileMissing);
-    expect(vi.getTimerCount()).toBe(1);
-
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a suspended worktree resumes polling and its repository fetch once its folder is back, without a new subscription", async () => {
-    const gitCommonDir = join(await createTemporaryFolder(), ".git");
-    const worktree = await createTemporaryFolder();
-    const git = createFolderBackedGit({ facts: linkedWorktreeFacts(gitCommonDir) });
-    const service = createService(git.deps);
-    const subscription = service.registerWorkspace({ cwd: worktree }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    await rm(worktree, { recursive: true, force: true });
-    await advanceThroughDegradedPolls(service);
-    await waitForObservationToSettle(service, 0);
-
-    await mkdir(worktree);
-    const fetchesBeforeRestore = git.fetchesIn(worktree);
-    await vi.advanceTimersByTimeAsync(WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS);
-    await waitForObservationToSettle(service, 1);
-    expect(git.fetchesIn(worktree)).toBe(fetchesBeforeRestore + 1);
-
-    const pollsAfterRestore = git.pollsOf(worktree);
-    await vi.advanceTimersByTimeAsync(5_000);
-    await waitForRefreshesToSettle(service);
-    expect(git.pollsOf(worktree)).toBe(pollsAfterRestore + 1);
-
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a forced snapshot resumes a suspended workspace whose folder is back", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const subscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    await rm(workspace, { recursive: true, force: true });
-    await advanceThroughDegradedPolls(service);
-    await waitForObservationToSettle(service, 0);
-
-    await mkdir(workspace);
-    const snapshot = await service.getSnapshot(workspace, {
-      force: true,
-      reason: "refresh-button",
-    });
-    await waitForObservationToSettle(service, 1);
-
-    expect(snapshot.git.isGit).toBe(true);
-
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a resumed workspace rebuilds observation from fresh facts, not the non-git facts cached while its folder was gone", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const firstSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    await rm(workspace, { recursive: true, force: true });
-    service.onWorkspaceStateMayHaveChanged(workspace);
-    await vi.advanceTimersByTimeAsync(1_000);
-    await waitForRefreshesToSettle(service);
-    expect((await service.getSnapshot(workspace)).git.isGit).toBe(false);
-    await advanceThroughDegradedPolls(service);
-    await waitForObservationToSettle(service, 0);
-
-    await mkdir(workspace);
-    const secondSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-
-    expect((await service.getSnapshot(workspace)).git.isGit).toBe(true);
-
-    firstSubscription.unsubscribe();
-    secondSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("resuming waits for an observation setup that was still running when the folder vanished", async () => {
-    const workspace = await createTemporaryFolder();
-    const gitDir = join(workspace, ".git");
-    await mkdir(gitDir);
-    const metadataWatchRelease = createDeferred<void>();
-    const git = createFolderBackedGit({
-      unwatchableDirectories: [workspace],
-      heldWatch: { directory: gitDir, release: metadataWatchRelease.promise },
-    });
-    const service = createService(git.deps);
-    const firstSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await settle(() => {
-      expect(git.watchAttemptsFor(gitDir)).toBe(1);
-    });
-
-    await rm(workspace, { recursive: true, force: true });
-    await vi.advanceTimersByTimeAsync(5_000);
-    await settle(() => {
-      expect(service.getMetrics()).toMatchObject({
-        repositoryTargetCount: 0,
-        workingTreeWatchTargetCount: 0,
-      });
-    });
-    await mkdir(workspace);
-    const secondSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    metadataWatchRelease.resolve();
-    await waitForObservationToSettle(service, 1);
-
-    expect(service.getMetrics().workingTreeWatchTargetCount).toBe(1);
-
-    firstSubscription.unsubscribe();
-    secondSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("an open working tree watch neither notifies nor recovers while its folder is missing, and picks up once it is back", async () => {
-    const workspace = await createTemporaryFolder();
-    await mkdir(join(workspace, ".git"));
-    const git = createFolderBackedGit();
-    const service = createService(git.deps);
-    const workspaceSubscription = service.registerWorkspace({ cwd: workspace }, vi.fn());
-    await waitForObservationToSettle(service, 1);
-    const diffListener = vi.fn();
-    const diffWatch = await service.requestWorkingTreeWatch(workspace, diffListener);
-
-    await rm(workspace, { recursive: true, force: true });
-    git.watchCallbackFor(workspace)(new Error("watched directory was deleted"), []);
-    await vi.advanceTimersByTimeAsync(1_000);
-    await waitForRefreshesToSettle(service);
-    const commandsAfterWatcherError = git.gitCommandsIn(workspace);
-    const notificationsAfterWatcherError = diffListener.mock.calls.length;
-    const watchAttemptsAfterWatcherError = git.watchAttemptsFor(workspace);
-    await advanceThroughWorkingTreeRecoveryAttempts(service);
-
-    expect(git.gitCommandsIn(workspace)).toBe(commandsAfterWatcherError);
-    expect(diffListener.mock.calls.length).toBe(notificationsAfterWatcherError);
-    expect(git.watchAttemptsFor(workspace)).toBe(watchAttemptsAfterWatcherError);
-    expect(service.getMetrics().workingTreeWatchTargetCount).toBe(1);
-
-    await mkdir(join(workspace, ".git"), { recursive: true });
-    await vi.advanceTimersByTimeAsync(60_000);
-    await waitForRefreshesToSettle(service);
-    expect(diffListener.mock.calls.length).toBe(notificationsAfterWatcherError + 1);
-
-    await vi.advanceTimersByTimeAsync(240_000);
-    await waitForRefreshesToSettle(service);
-    expect(git.watchAttemptsFor(workspace)).toBe(watchAttemptsAfterWatcherError + 1);
-    const notificationsAfterResubscribe = diffListener.mock.calls.length;
-    await vi.advanceTimersByTimeAsync(120_000);
-    await waitForRefreshesToSettle(service);
-    expect(diffListener.mock.calls.length).toBe(notificationsAfterResubscribe);
-
-    diffWatch.unsubscribe();
-    workspaceSubscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("a refresh crossing suspension preserves the cached snapshot and drops queued work", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const started = createDeferred<void>();
-    const release = createDeferred<void>();
-    let holdNextRead = false;
-    let factsReads = 0;
-    const service = createService({
-      ...git.deps,
-      getCheckoutSnapshotFacts: async (cwd: string) => {
-        factsReads++;
-        if (holdNextRead) {
-          holdNextRead = false;
-          started.resolve();
-          await release.promise;
-        }
-        return git.deps.getCheckoutSnapshotFacts(cwd);
-      },
-    });
-    const updates: WorkspaceGitRuntimeSnapshot[] = [];
-    const subscription = service.registerWorkspace({ cwd: workspace }, (snapshot) =>
-      updates.push(snapshot),
-    );
-    await waitForObservationToSettle(service, 1);
-    const cached = await service.getSnapshot(workspace);
-    holdNextRead = true;
-    const active = service.getSnapshot(workspace, {
-      force: true,
-      includeForge: false,
-      reason: "overlapping-refresh",
-    });
-    await started.promise;
-    const queued = service.getSnapshot(workspace, {
-      force: true,
-      includeForge: true,
-      reason: "queued-refresh",
-    });
-    await rm(workspace, { recursive: true, force: true });
-    await vi.advanceTimersByTimeAsync(5_000);
-    await settle(() => expect(service.getMetrics().repositoryWorkspaceLinkCount).toBe(0));
-    const readsAtSuspension = factsReads;
-    const updatesAtSuspension = updates.length;
-    release.resolve();
-    expect(await active).toEqual(cached);
-    expect(await queued).toEqual(cached);
-    expect(await service.getSnapshot(workspace)).toEqual(cached);
-    expect(updates).toHaveLength(updatesAtSuspension);
-    expect(factsReads).toBe(readsAtSuspension);
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("restoration settles a suspended refresh before reloading facts", async () => {
-    const workspace = await createTemporaryFolder();
-    const git = createFolderBackedGit();
-    const staleFacts = createDeferred<CheckoutSnapshotFacts>();
-    const started = createDeferred<void>();
-    let holdNextRead = false;
-    const service = createService({
-      ...git.deps,
-      getCheckoutSnapshotFacts: async (cwd: string) => {
-        if (holdNextRead) {
-          holdNextRead = false;
-          started.resolve();
-          return staleFacts.promise;
-        }
-        return git.deps.getCheckoutSnapshotFacts(cwd);
-      },
-    });
-    const updates: WorkspaceGitRuntimeSnapshot[] = [];
-    const subscription = service.registerWorkspace({ cwd: workspace }, (snapshot) =>
-      updates.push(snapshot),
-    );
-    await waitForObservationToSettle(service, 1);
-    const cached = await service.getSnapshot(workspace);
-    holdNextRead = true;
-    const active = service.getSnapshot(workspace, {
-      force: true,
-      includeForge: false,
-      reason: "overlapping-refresh",
-    });
-    await started.promise;
-    await rm(workspace, { recursive: true, force: true });
-    await vi.advanceTimersByTimeAsync(5_000);
-    await settle(() => expect(service.getMetrics().repositoryWorkspaceLinkCount).toBe(0));
-    const updatesAtSuspension = updates.length;
-    await mkdir(workspace);
-    const restored = service.getSnapshot(workspace, {
-      force: true,
-      includeForge: false,
-      reason: "folder-returned",
-    });
-    await vi.advanceTimersByTimeAsync(0);
-    staleFacts.resolve({ isGit: false });
-    expect(await active).toEqual(cached);
-    expect((await restored).git.isGit).toBe(true);
-    expect(updates.slice(updatesAtSuspension).every((snapshot) => snapshot.git.isGit)).toBe(true);
-    await waitForObservationToSettle(service, 1);
-    subscription.unsubscribe();
-    await service.dispose();
-  });
-
-  test("workspaceFolderExists reports a missing folder and a path under a file as missing", async () => {
-    const folder = await createTemporaryFolder();
-    const file = join(folder, "file.txt");
-    await writeFile(file, "");
-
-    expect(await workspaceFolderExists(folder)).toBe(true);
-    expect(await workspaceFolderExists(join(folder, "missing"))).toBe(false);
-    expect(await workspaceFolderExists(join(file, "nested"))).toBe(false);
-  });
-});
@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { LRUCache } from "lru-cache";
 import { CheckoutDiffCache } from "./checkout-diff-cache.js";
@@ -74,7 +74,7 @@ import { checkoutLiteFromGitSnapshot } from "./workspace-registry-model.js";
 import { createWatcherLivenessCanary } from "./watcher-liveness-canary.js";

 const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 1_000;
-export const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180_000;
+const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180_000;
 const FETCH_METADATA_ECHO_TTL_MS = 5_000;
 export const WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS = 60_000;
 const FORGE_PR_STATUS_POLL_FAST_INTERVAL_MS = 20_000;
@@ -384,7 +384,6 @@ interface WorkspaceGitServiceDependencies {
  runGitCommand: typeof runGitCommand;
  getWorkspaceGitSelfHealPhaseMs: typeof getWorkspaceGitObservationReensurePhaseMs;
  createWatcherLivenessCanary: typeof createWatcherLivenessCanary;
-  workspaceFolderExists: (cwd: string) => Promise<boolean>;
  now: () => Date;
 }

@@ -436,8 +435,6 @@ interface WorkspaceGitTarget {
  repoGitRoot: string | null;
  observationSetupPromise: Promise<void> | null;
  observationSetupComplete: boolean;
-  folderMissing: boolean;
-  folderRestorePromise: Promise<void> | null;
  closed: boolean;
 }

@@ -574,21 +571,10 @@ function buildDefaultWorkspaceGitServiceDeps(
    runGitCommand,
    getWorkspaceGitSelfHealPhaseMs: getWorkspaceGitObservationReensurePhaseMs,
    createWatcherLivenessCanary,
-    workspaceFolderExists,
    now: () => new Date(),
  };
 }

-export async function workspaceFolderExists(cwd: string): Promise<boolean> {
-  try {
-    await stat(cwd);
-    return true;
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    return code !== "ENOENT" && code !== "ENOTDIR";
-  }
-}
-
 function resolveWorkspaceGitServiceDeps(
  subscribe: SubscribeToFileChanges,
  deps: Partial<WorkspaceGitServiceDependencies> | undefined,
@@ -674,9 +660,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    const cwd = resolve(params.cwd);
    const target = this.ensureWorkspaceTarget(cwd);
    target.listeners.add(listener);
-    if (target.folderMissing) {
-      void this.resumeWorkspaceIfFolderRestored(target);
-    }
    if (target.listeners.size === 1) {
      this.startWorkspaceSubscriptionTimers(target);
    }
@@ -768,9 +751,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    if (!request.force && target.latestSnapshot) {
      return target.latestSnapshot;
    }
-    if (target.folderMissing) {
-      await this.resumeWorkspaceIfFolderRestored(target);
-    }

    return this.requestWorkspaceSnapshot(target, request);
  }
@@ -992,9 +972,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    this.assertNotDisposed();
    cwd = resolve(cwd);
    const target = this.ensureWorkspaceTarget(cwd);
-    if (target.folderMissing) {
-      await this.resumeWorkspaceIfFolderRestored(target);
-    }
    await this.refreshWorkspaceTarget(target, {
      force: false,
      refreshStructure: true,
@@ -1028,14 +1005,9 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    this.assertNotDisposed();
    cwd = resolve(cwd);
    const target = this.workspaceTargets.get(cwd);
-    if (!target) {
-      return;
+    if (target) {
+      this.scheduleWorkspaceRefresh(target, { queueIfBusy: false });
    }
-    if (target.folderMissing) {
-      void this.resumeWorkspaceIfFolderRestored(target);
-      return;
-    }
-    this.scheduleWorkspaceRefresh(target, { queueIfBusy: false });
  }

  onWorkspaceStateMayHaveChanged(cwd: string): void {
@@ -1046,10 +1018,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
      return;
    }
    this.invalidateForge(normalizedCwd);
-    if (target.folderMissing) {
-      void this.resumeWorkspaceIfFolderRestored(target);
-      return;
-    }
    this.scheduleWorkspaceRefresh(target, {
      force: true,
      includeForge: true,
@@ -1259,8 +1227,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
      repoGitRoot: null,
      observationSetupPromise: null,
      observationSetupComplete: false,
-      folderMissing: false,
-      folderRestorePromise: null,
      closed: false,
    };

@@ -1392,7 +1358,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
  private isActiveObservedWorkspaceTarget(target: WorkspaceGitTarget): boolean {
    return (
      !target.closed &&
-      !target.folderMissing &&
      target.listeners.size > 0 &&
      this.workspaceTargets.get(target.cwd) === target
    );
@@ -1647,110 +1612,11 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    workspaceTarget: WorkspaceGitTarget,
    request: WorkspaceGitRefreshRequest,
  ): Promise<boolean> {
-    if (await this.suspendWorkspaceIfFolderMissing(workspaceTarget)) {
-      return false;
-    }
    const fingerprintBefore = workspaceTarget.latestFingerprint;
    await this.refreshWorkspaceTarget(workspaceTarget, request);
    return workspaceTarget.latestFingerprint !== fingerprintBefore;
  }

-  private async suspendWorkspaceIfFolderMissing(target: WorkspaceGitTarget): Promise<boolean> {
-    if (target.folderMissing) {
-      return true;
-    }
-    if (await this.deps.workspaceFolderExists(target.cwd)) {
-      return false;
-    }
-    this.suspendWorkspaceWithMissingFolder(target);
-    return true;
-  }
-
-  private suspendWorkspaceWithMissingFolder(target: WorkspaceGitTarget): void {
-    if (target.folderMissing || target.closed || this.workspaceTargets.get(target.cwd) !== target) {
-      return;
-    }
-    target.folderMissing = true;
-    if (target.refreshState.status === "in-flight") {
-      target.refreshState.queued = null;
-    }
-    this.detachWorkspaceFromRepoTarget(target);
-    target.repoGitRoot = null;
-    this.stopWorkspaceObservation(target);
-    target.observationSetupComplete = false;
-    this.scheduleMissingFolderProbe(target);
-    this.logger.warn(
-      { cwd: target.cwd },
-      "Workspace folder no longer exists; suspended git observation until it is back",
-    );
-  }
-
-  private isSuspendedWorkspaceTarget(target: WorkspaceGitTarget): boolean {
-    return (
-      target.folderMissing && !target.closed && this.workspaceTargets.get(target.cwd) === target
-    );
-  }
-
-  private scheduleMissingFolderProbe(target: WorkspaceGitTarget): void {
-    if (
-      !this.isSuspendedWorkspaceTarget(target) ||
-      target.observationReensureTimer ||
-      target.folderRestorePromise
-    ) {
-      return;
-    }
-    target.observationReensureTimer = setTimeout(() => {
-      target.observationReensureTimer = null;
-      void this.resumeWorkspaceIfFolderRestored(target);
-    }, WORKSPACE_GIT_OBSERVATION_REENSURE_INTERVAL_MS);
-  }
-
-  private resumeWorkspaceIfFolderRestored(target: WorkspaceGitTarget): Promise<void> {
-    if (!target.folderMissing) {
-      return Promise.resolve();
-    }
-    target.folderRestorePromise ??= this.resumeWorkspaceWithRestoredFolder(target).finally(() => {
-      target.folderRestorePromise = null;
-      this.scheduleMissingFolderProbe(target);
-    });
-    return target.folderRestorePromise;
-  }
-
-  private async resumeWorkspaceWithRestoredFolder(target: WorkspaceGitTarget): Promise<void> {
-    if (!(await this.deps.workspaceFolderExists(target.cwd))) {
-      return;
-    }
-    await target.observationSetupPromise;
-    if (target.refreshState.status === "in-flight") {
-      await target.refreshState.promise.catch(() => undefined);
-    }
-    if (!this.isSuspendedWorkspaceTarget(target)) {
-      return;
-    }
-    target.latestFacts = null;
-    target.folderMissing = false;
-    await this.refreshWorkspaceTarget(target, {
-      force: false,
-      refreshStructure: true,
-      refreshWorktree: true,
-      includeForge: false,
-      reason: "workspace-folder-restored",
-      queueIfBusy: true,
-      movedRemoteRefs: new Set(),
-    });
-    if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
-      return;
-    }
-    target.observationSetupComplete = false;
-    if (target.observationReensureTimer) {
-      clearTimeout(target.observationReensureTimer);
-      target.observationReensureTimer = null;
-    }
-    this.logger.info({ cwd: target.cwd }, "Workspace folder is back; resumed git observation");
-    this.startWorkspaceSubscriptionTimers(target);
-    this.scheduleWorkspaceObservationSetup(target);
-  }
-
  private startWorkingTreeWatchFallback(
    target: WorkingTreeWatchTarget,
    reason: WorkingTreeWatchFallbackReason,
@@ -1788,9 +1654,7 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
          return changed;
        }),
      );
-      if (await this.deps.workspaceFolderExists(target.watchPath)) {
-        this.notifyWorkingTreeConsumers(target);
-      }
+      this.notifyWorkingTreeConsumers(target);
      if (!target.closed && (target.subscription === null || target.repoRoot === null)) {
        target.fallbackPollQuietTickCount = changes.some(Boolean)
          ? 0
@@ -1867,10 +1731,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    if (target.closed || target.subscription) {
      return;
    }
-    if (!(await this.deps.workspaceFolderExists(target.watchPath))) {
-      this.scheduleWorkingTreeWatchRecovery(target);
-      return;
-    }
    await this.refreshWorkingTreeIgnoredDirectories(target);
    if (target.closed || target.subscription) {
      return;
@@ -2926,7 +2786,7 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
  }

  private updateForgePrStatusPollForTarget(target: WorkspaceGitTarget): void {
-    if (!this.isActiveObservedWorkspaceTarget(target)) {
+    if (target.listeners.size === 0) {
      this.stopForgePrStatusPollForTarget(target);
      return;
    }
@@ -3189,9 +3049,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    target: WorkspaceGitTarget,
    request: WorkspaceGitRefreshRequest,
  ): Promise<WorkspaceGitRuntimeSnapshot> {
-    if (target.folderMissing) {
-      return Promise.resolve(target.latestSnapshot ?? buildNotGitSnapshot(target.cwd));
-    }
    if (target.refreshState.status === "in-flight") {
      const active = target.refreshState.request;
      const addsWork =
@@ -3334,19 +3191,11 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
      try {
        const runRefreshGitCommand = createRunGitCommand(`workspace-refresh:${request.reason}`);
        const admittedSnapshot = await this.workspaceRefreshLimit(() => {
-          if (
-            target.closed ||
-            target.folderMissing ||
-            this.workspaceTargets.get(target.cwd) !== target
-          ) {
+          if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
            return null;
          }
          return this.refreshSnapshot(target, request, runRefreshGitCommand);
        });
-        if (target.folderMissing) {
-          failure = null;
-          break;
-        }
        if (!admittedSnapshot) {
          break;
        }
@@ -3360,10 +3209,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
        failure = { error };
      }

-      if (target.folderMissing) {
-        failure = null;
-        break;
-      }
      if (this.disposed || target.closed || this.workspaceTargets.get(target.cwd) !== target) {
        break;
      }
@@ -3659,7 +3504,7 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
    snapshot: WorkspaceGitRuntimeSnapshot,
    options?: { forceEmit?: boolean },
  ): void {
-    if (target.closed || target.folderMissing || this.workspaceTargets.get(target.cwd) !== target) {
+    if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
      return;
    }
    target.latestSnapshot = snapshot;
@@ -3815,25 +3660,21 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
  }

  private removeWorkspaceTarget(target: WorkspaceGitTarget): void {
-    this.detachWorkspaceFromRepoTarget(target);
+    if (target.repoGitRoot) {
+      const repoTarget = this.repoTargets.get(target.repoGitRoot);
+      repoTarget?.workspaceKeys.delete(target.cwd);
+      if (repoTarget && repoTarget.workspaceKeys.size === 0) {
+        this.closeRepoTarget(repoTarget);
+        this.repoTargets.delete(target.repoGitRoot);
+      } else if (repoTarget?.cwd === target.cwd) {
+        repoTarget.cwd = repoTarget.workspaceKeys.values().next().value ?? repoTarget.cwd;
+      }
+    }
+
    this.closeWorkspaceTarget(target);
    this.workspaceTargets.delete(target.cwd);
  }

-  private detachWorkspaceFromRepoTarget(target: WorkspaceGitTarget): void {
-    if (!target.repoGitRoot) {
-      return;
-    }
-    const repoTarget = this.repoTargets.get(target.repoGitRoot);
-    repoTarget?.workspaceKeys.delete(target.cwd);
-    if (repoTarget && repoTarget.workspaceKeys.size === 0) {
-      this.closeRepoTarget(repoTarget);
-      this.repoTargets.delete(target.repoGitRoot);
-    } else if (repoTarget?.cwd === target.cwd) {
-      repoTarget.cwd = repoTarget.workspaceKeys.values().next().value ?? repoTarget.cwd;
-    }
-  }
-
  private removeWorkingTreeWatchListener(cwd: string, listener: () => void): void {
    const target = this.workingTreeWatchTargets.get(cwd);
    if (!target) {
@@ -3878,11 +3719,6 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {

  private closeWorkspaceTarget(target: WorkspaceGitTarget): void {
    target.closed = true;
-    this.stopWorkspaceObservation(target);
-    target.listeners.clear();
-  }
-
-  private stopWorkspaceObservation(target: WorkspaceGitTarget): void {
    if (target.workingTreeWatchTarget) {
      this.removeWorkspaceWorkingTreeLink(target.workingTreeWatchTarget, target.cwd);
      target.workingTreeWatchTarget = null;
@@ -3891,12 +3727,12 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
      clearTimeout(target.debounceTimer);
      target.debounceTimer = null;
    }
-    target.pendingDebounceRequest = null;
    if (target.observationReensureTimer) {
      clearTimeout(target.observationReensureTimer);
      target.observationReensureTimer = null;
    }
    this.stopForgePrStatusPollForTarget(target);
+    target.listeners.clear();
  }

  private closeWorkingTreeWatchTarget(target: WorkingTreeWatchTarget): void {
@@ -1,6 +1,5 @@
 import { afterEach, describe, expect, it } from "vitest";
 import {
-  chmodSync,
  existsSync,
  mkdirSync,
  mkdtempSync,
@@ -55,7 +54,6 @@ function makeSources(bundleSource = "export {};\n"): {
  mkdirSync(native, { recursive: true });
  writeFileSync(path.join(native, "pty.node"), "native");
  writeFileSync(path.join(native, "spawn-helper"), "#!/bin/sh\n", { mode: 0o755 });
-  chmodSync(path.join(native, "spawn-helper"), 0o755);
  // Another platform's build is not copied.
  mkdirSync(path.join(nodePtyDirectory, "prebuilds", "other-platform"));
  return { bundleDirectory, nodePtyDirectory };
@@ -410,12 +410,7 @@ describe("createTerminal", () => {
          cwd: realpathSync(tmpdir()),
          cols: 500,
          command: process.execPath,
-          // Keep the PTY alive until the screen assertion; exit disposes its parser.
-          args: [
-            "-e",
-            "process.stdout.write(JSON.stringify(process.argv.slice(1))); setInterval(() => {}, 100000)",
-            nastyPrompt,
-          ],
+          args: ["-e", "process.stdout.write(JSON.stringify(process.argv.slice(1)))", nastyPrompt],
        }),
      );

@@ -70,7 +70,7 @@ import {
  TerminalWorkerIncompatibleError,
 } from "./terminal-worker-pool.js";
 import { connectTerminalWorker } from "./terminal-worker-client.js";
-import { launchTerminalWorker } from "./terminal-worker-launch.js";
+import { launchTerminalWorker, TerminalWorkerLaunchError } from "./terminal-worker-launch.js";

 type TerminalRow = TerminalState["grid"][number];

@@ -2658,3 +2658,34 @@ it.each([false, true])(
  },
  45000,
 );
+
+// Both Windows reports in #8766: the worker's process identity query (PowerShell there, `ps` here)
+// fails, the worker exits before writing its record, and the daemon used to exit with it.
+it.skipIf(isPlatform("win32"))(
+  "starts without a worker when the worker cannot read its own identity, and launches one once it can",
+  async () => {
+    const paseoHome = createTemporaryHome();
+    const binDir = mkdtempSync(join(tmpdir(), "worker-terminal-manager-no-ps-"));
+    temporaryDirs.push(binDir);
+    writeFileSync(join(binDir, "ps"), "#!/bin/sh\nexit 1\n", { mode: 0o755 });
+    const originalPath = process.env.PATH;
+    process.env.PATH = `${binDir}${delimiter}${originalPath ?? ""}`;
+    try {
+      manager = await startRealWorkerManager({ paseoHome });
+      expect(await workerRecords(paseoHome)).toEqual([]);
+      await expect(
+        manager.createTerminal({ workspaceId: "ws-no-identity", cwd: paseoHome }),
+      ).rejects.toThrow(TerminalWorkerLaunchError);
+      expect(await workerRecords(paseoHome)).toEqual([]);
+    } finally {
+      process.env.PATH = originalPath;
+    }
+
+    const terminal = trackTerminal(
+      await manager.createTerminal({ workspaceId: "ws-no-identity", cwd: paseoHome }),
+    );
+    expect(terminal.id).toBeTruthy();
+    expect((await workerRecords(paseoHome)).map((record) => record.pid)).toHaveLength(1);
+  },
+  30000,
+);
@@ -1269,8 +1269,17 @@ export async function startWorkerTerminalManager(
    try {
      current = await startCurrent();
    } catch (error) {
-      if (!(error instanceof NoTerminalWorkerAvailableError)) throw error;
-      logger.warn(error.message);
+      if (error instanceof NoTerminalWorkerAvailableError) {
+        logger.warn(error.message);
+      } else {
+        // The daemon starts without terminals rather than not at all. A worker that cannot start
+        // here (its process identity query failed, say) is launched again by the first terminal
+        // creation, which reports the same error if it still cannot.
+        logger.error(
+          { err: error },
+          "Terminal worker did not start; terminals are unavailable until one starts",
+        );
+      }
    }
  }

@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/website",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "private": true,
  "type": "module",
  "scripts": {
@@ -186,13 +186,7 @@ function insertDocByPath(nodes: DocsNavNode[], doc: Doc, stripTopDirectory = fal

  // A section's top-level directory and its category name the same thing, so
  // only directories below it become collapsible groups.
-  if (
-    stripTopDirectory &&
-    directories[0] &&
-    doc.frontmatter.category?.toLowerCase().endsWith(directories[0].toLowerCase())
-  ) {
-    directories.shift();
-  }
+  if (stripTopDirectory) directories.shift();

  let current = nodes;
  let parent: Extract<DocsNavNode, { type: "group" }> | undefined;
@@ -2,25 +2,6 @@ import { describe, expect, it } from "vitest";
 import { buildDocsNavTree, getDoc, getDocs, getLegacyDocsRedirect, parseHeadings } from "./docs";

 describe("plugin documentation", () => {
-  it.each(["en", "zh-CN"] as const)(
-    "nests local file copying under Git worktrees in %s",
-    (locale) => {
-      const workspaces = buildDocsNavTree(getDocs(locale)).find(
-        (node) => node.type === "category" && node.label === "Workspaces",
-      );
-      expect(workspaces).toMatchObject({
-        children: expect.arrayContaining([
-          expect.objectContaining({
-            type: "group",
-            href: "/docs/worktrees",
-            children: [expect.objectContaining({ href: "/docs/worktrees/worktreeinclude" })],
-          }),
-        ]),
-      });
-      expect(getDoc("worktrees/worktreeinclude", locale)).toBeDefined();
-    },
-  );
-
  it("groups current guides by task without version navigation", () => {
    const plugins = buildDocsNavTree(getDocs("en")).find(
      (node) => node.type === "category" && node.label === "Plugins",
@@ -4,7 +4,7 @@ import { expect, it } from "vitest";

 const docsRoot = path.resolve(import.meta.dirname, "../../../public-docs");

-it.each(["schedules.md", "schedules-cli.md", "mcp.md", "worktrees/index.md"])(
+it.each(["schedules.md", "schedules-cli.md", "mcp.md", "worktrees.md"])(
  "%s makes schedule run retention discoverable",
  async (file) => {
    const markdown = await readFile(path.join(docsRoot, file), "utf8");
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/builtin-plugins",
-  "version": "0.15.0-beta.1",
+  "version": "0.15.1",
  "private": true,
  "type": "module",
  "scripts": {
@@ -94,7 +94,7 @@ type PluginTurnOutcome =

 | Field        | Shape / meaning                                                                        |
 | ------------ | -------------------------------------------------------------------------------------- |
-| `turnId`     | Provider-reported `string` or `null`; unique for the agent's lifetime                  |
+| `turnId`     | Provider-reported `string` or `null`; can repeat after a session reopens               |
 | `timeline`   | Deprecated, always `[]`; fetch history with the SDK.                                   |
 | `request`    | SDK `AgentPermissionRequest`; `kind` is `tool`, `plan`, `question`, `mode`, or `other` |
 | `resolution` | SDK `AgentPermissionResponse`                                                          |
@@ -92,7 +92,7 @@ type PluginTurnOutcome =

 | 字段         | 结构 / 含义                                                                              |
 | ------------ | ---------------------------------------------------------------------------------------- |
-| `turnId`     | Provider 报告的 `string` 或 `null`；在 agent 的整个生命周期内唯一                        |
+| `turnId`     | Provider 报告的 `string` 或 `null`；会话重新打开后可能重复                               |
 | `timeline`   | 已弃用，始终为 `[]`；通过 SDK 获取历史。                                                 |
 | `request`    | SDK 的 `AgentPermissionRequest`；`kind` 为 `tool`、`plan`、`question`、`mode` 或 `other` |
 | `resolution` | SDK 的 `AgentPermissionResponse`                                                         |
@@ -84,7 +84,16 @@ Add `--forge <name>` when Paseo cannot infer the forge from the source checkout.

 ## Copy local files with .worktreeinclude

-Use [`.worktreeinclude`](/docs/worktrees/worktreeinclude) to copy selected gitignored files, such as `.env`, from your source checkout before setup runs.
+Create `.worktreeinclude` at the root of your source checkout to copy selected gitignored files into new worktrees:
+
+```gitignore
+.env
+config/*.local.json
+```
+
+Patterns use gitignore syntax. A file must match `.worktreeinclude` and be gitignored to be copied. Tracked files are never copied, and existing destination files are never overwritten. Without `.worktreeinclude`, no local files are copied. Symlinked directories and nested repositories inside an included path cause the copy to fail and abort worktree creation.
+
+The built-in `worktree-include` plugin copies from the checkout you create the worktree from, including when that checkout is another worktree. Copying finishes before setup, terminals, and the first agent. A copy failure aborts creation and removes the new worktree. Copies use copy-on-write clones on APFS and btrfs when supported, with a regular copy elsewhere.

 ## paseo.json

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mohamed Boudra	c4dc36272c	chore(release): cut 0.15.1	2026-11-05 03:27:21 +01:00
Mohamed Boudra	896f8efb64	docs(changelog): prepare 0.15.1	2026-11-05 03:01:38 +01:00
Mohamed Boudra	cc8cd7e3cc	fix(terminal): start the daemon when the terminal worker cannot start (#8810 ) On 0.15.0 the daemon launches the detached terminal worker while it is being created, and the worker refuses to start unless it can read its own birth time and command line (Windows PowerShell 5.1 `Get-CimInstance`, `ps` elsewhere). Any failure of that query used to escape startWorkerTerminalManager and take the whole daemon down with "Daemon failed to start (exit 1)", as two Windows machines hit after the update: one whose PowerShell 5.1 cannot load CimCmdlets, one where powershell.exe cannot be spawned at all. 0.14.0 never ran that query at startup. The launch error is now logged and the daemon starts without a current worker. The pool already launches one lazily on the first terminal creation, so that request reports the same error while the machine still cannot run the query, and terminals come back once it can. The identity requirement itself is unchanged: a worker without a verified identity is never written or adopted. (cherry picked from commit `8dfdb479ab`)	2026-11-05 02:59:14 +01:00
Mohamed Boudra	8938fde3c7	chore(release): cut 0.15.0	2026-11-03 06:08:53 +01:00
Mohamed Boudra	fd1cf594b1	docs(changelog): prepare 0.15.0	2026-11-03 05:34:45 +01:00
Mohamed Boudra	6c2a4e7ca6	Keep reconnecting and updating status visible in native chats (#8568 ) * fix(app): keep chat status toasts visible below floating headers Compact native chats extend beneath the floating header. Panel toasts need measured header clearance and a layer above its fade; placing them below the fade leaves an excessive gap. Keep dock overlays outside keyboard translation so opening the keyboard cannot move them offscreen. * test(app): verify rendered chat status spacing on native devices Measure the real header and toast bounds with the software keyboard closed and open. The former arithmetic helper test passed even when the viewport stopped consuming header clearance; the native regression fails against that broken production wiring. * test(app): exercise toast placement through host disconnection Observe the public reconnecting state with host connectivity interrupted externally. Keep native bounds and software keyboard assertions while removing runtime evaluation and private timeline-owner mutations. (cherry picked from commit `b92a34ab3d`)	2026-11-03 05:33:51 +01:00
paseo-bot[bot]	c06ea2d2e1	fix(relay): keep local E2E tests independent of production upstream (#8514 ) Wrangler local mode retains deployment vars, so relay readiness probes were forwarded to an unavailable upstream instead of the local Durable Object. Clear that binding only in the E2E launcher. Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com> (cherry picked from commit `b280ca5355`)	2026-11-03 04:51:13 +01:00
Mohamed Boudra	a53ac6c802	Make interrupted-agent recovery opt-in (#8619 ) * fix(agents): require opt-in for restart recovery Keep automatic interrupted-turn resumption off during further dogfooding. Preserve explicit opt-in and custom resume prompts. * test(settings): verify restart recovery opt-in persists * docs(agents): describe restart recovery opt-in (cherry picked from commit `6f6712be62`)	2026-11-03 04:21:27 +01:00
Mohamed Boudra	852fc2cd07	fix(release): use the keychain password for macOS signing setup (#8445 ) Backport the pinned packaging tool correction in the workflow so existing release tags can be rebuilt without changing their dependencies. (cherry picked from commit `891e62309c`)	2026-11-03 03:14:27 +01:00
Mohamed Boudra	8bd38fb236	chore(release): cut 0.15.0-beta.1	2026-11-01 06:19:33 +01:00
Mohamed Boudra	7e5ad53491	docs(changelog): prepare 0.15.0-beta.1	2026-11-01 06:11:09 +01:00
paseo-ai[bot]	a529578cd1	fix: update lockfile signatures and Nix hash [skip ci] (cherry picked from commit `b2666a0aec`)	2026-11-01 06:11:09 +01:00