fix(claude): keep the daemon responsive during conversation rewind

The SDK parses and copies the complete transcript while forking a Claude
conversation. Running that work in the daemon's event loop blocks all
connected clients, even though only one conversation is being rewound.

Run the fork in a worker, stream transcript records, and append in bounded
chunks. Preserve the SDK's fork content, transcript location, and error
fields. Share the existing compiler worker loader and verify that the
installed daemon closure contains and starts the rewind worker.

Retain Dominic Anaeto's implementation and regressions from #8444, rebased
onto main to include the correction for the moved worktrees documentation
page in the website test.

Fixes #8209

Co-authored-by: Dominic Anaeto <dominic.anaeto@gmail.com>

.github/workflows/desktop-release.yml

@@ -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: |

docs/connected-hosts.md

@@ -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

nix/desktop-package.nix

@@ -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 \

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-KN/AVZV/o0TleLLpmggSrdJqjFDJ/NJYVHiC54xb4jQ=
+sha256-CeT2PtYIAFwvBC9LIku8VkTl0pvKxYzSCn0QW2ManfU=

packages/app/e2e/browser/composer-recall.spec.ts

@@ -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 {

packages/app/src/terminal/runtime/terminal-emulator-runtime.browser.test.ts

@@ -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" },

packages/app/src/terminal/runtime/terminal-emulator-runtime.ts

@@ -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() === "?");
       }

packages/client/src/node/index.ts

@@ -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 }),
   });
 }

packages/desktop/package.json

@@ -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",

packages/server/src/server/agent/providers/claude/agent.import-titles.test.ts

@@ -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");
-  });
 });

packages/server/src/server/agent/providers/claude/agent.runtime-info.test.ts

@@ -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();
-    }
-  });
-});

packages/server/src/server/agent/providers/claude/agent.ts

@@ -2460,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
         ? {
@@ -6853,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 {
@@ -6937,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.
@@ -6947,6 +6909,7 @@ async function readClaudeRenamedSessionTitle(input: {
     }
     throw error;
   }
+  return readLastClaudeCustomTitle(content);
 }
 
 function normalizeImportablePromptPreview(text: string): string | null {

packages/server/src/server/agent/providers/claude/rewind-session-store.ts

@@ -0,0 +1,63 @@
+import { createReadStream } from "node:fs";
+import { appendFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import type { SessionStore, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
+
+const APPEND_CHUNK_LENGTH = 1 << 20;
+
+export function projectFolderSessionStore(projectFolder: string): SessionStore {
+  const transcriptPath = (sessionId: string) => path.join(projectFolder, `${sessionId}.jsonl`);
+  return {
+    async load({ sessionId }) {
+      const input = createReadStream(transcriptPath(sessionId), { encoding: "utf8" });
+      const lines = createInterface({ input, crlfDelay: Infinity });
+      const entries: SessionStoreEntry[] = [];
+      try {
+        for await (const line of lines) {
+          const entry = parseTranscriptEntry(line);
+          if (entry) entries.push(entry);
+        }
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+        throw error;
+      } finally {
+        lines.close();
+        input.destroy();
+      }
+      return entries;
+    },
+    async append({ sessionId }, entries) {
+      let chunk = "";
+      for (const entry of entries) {
+        chunk += `${JSON.stringify(entry)}\n`;
+        if (chunk.length >= APPEND_CHUNK_LENGTH) {
+          await appendFile(transcriptPath(sessionId), chunk, "utf8");
+          chunk = "";
+        }
+      }
+      await appendFile(transcriptPath(sessionId), chunk, "utf8");
+    },
+  };
+}
+
+function parseTranscriptEntry(line: string): SessionStoreEntry | null {
+  if (!line.trim()) return null;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    // Skip a line that is not JSON, as the SDK's own transcript reader does.
+    return null;
+  }
+  return isSessionStoreEntry(parsed) ? parsed : null;
+}
+
+function isSessionStoreEntry(value: unknown): value is SessionStoreEntry {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    typeof (value as { type?: unknown }).type === "string"
+  );
+}

packages/server/src/server/agent/providers/claude/rewind-worker.ts

@@ -0,0 +1,43 @@
+import path from "node:path";
+import { parentPort, workerData } from "node:worker_threads";
+import { forkSession } from "@anthropic-ai/claude-agent-sdk";
+import { projectFolderSessionStore } from "./rewind-session-store.js";
+
+export interface ClaudeForkRequest {
+  sessionId: string;
+  upToMessageId: string;
+  transcriptPath: string;
+}
+
+export type ClaudeForkReply =
+  | { kind: "forked"; sessionId: string }
+  | {
+      kind: "failed";
+      message: string;
+      stack: string | undefined;
+      properties: Record<string, unknown>;
+    };
+
+const port = parentPort!;
+const request: ClaudeForkRequest = workerData;
+try {
+  // On its own, the SDK looks for the session under the daemon's CLAUDE_CONFIG_DIR, while a
+  // provider can point Claude Code at another one. Forking through a store rooted at the
+  // transcript's folder reads the session where Claude Code wrote it and writes the fork beside it.
+  const fork = await forkSession(request.sessionId, {
+    upToMessageId: request.upToMessageId,
+    sessionStore: projectFolderSessionStore(path.dirname(request.transcriptPath)),
+  });
+  port.postMessage({ kind: "forked", sessionId: fork.sessionId } satisfies ClaudeForkReply);
+} catch (cause) {
+  const error = cause instanceof Error ? cause : new Error(String(cause));
+  const failure = { kind: "failed", message: error.message, stack: error.stack } as const;
+  try {
+    port.postMessage({ ...failure, properties: { ...error } } satisfies ClaudeForkReply);
+  } catch (cloneError) {
+    if (!(cloneError instanceof DOMException) || cloneError.name !== "DataCloneError") {
+      throw cloneError;
+    }
+    port.postMessage({ ...failure, properties: {} } satisfies ClaudeForkReply);
+  }
+}

packages/server/src/server/agent/providers/claude/rewind.test.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { subscribe, unsubscribe } from "node:diagnostics_channel";
 import {
   mkdirSync,
   mkdtempSync,
@@ -10,9 +11,11 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import { Worker } from "node:worker_threads";
 import { afterEach, describe, expect, test } from "vitest";
-import type { Query } from "@anthropic-ai/claude-agent-sdk";
+import { forkSession, type Query } from "@anthropic-ai/claude-agent-sdk";
 
+import { measureMainThreadWork } from "../../../../test-utils/main-thread-work.js";
 import {
   findSteeredMessageParent,
   revertClaudeConversation,
@@ -20,6 +23,7 @@ import {
   revertClaudeFiles,
   realClaudeRewindSdk,
 } from "./rewind.js";
+import { projectFolderSessionStore } from "./rewind-session-store.js";
 import { FakeClaudeSdk } from "./test-rewind-claude-sdk.js";
 
 describe("Claude rewind", () => {
@@ -278,8 +282,196 @@ describe("Claude rewind against the Claude SDK", () => {
       "tool output",
     ]);
   });
+
+  test("writes the fork beside the original and leaves the original untouched", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-fork-"));
+    const projectDir = path.join(tempRoot, "projects", "-repo");
+    mkdirSync(projectDir, { recursive: true });
+    const sessionId = randomUUID();
+    const firstUser = randomUUID();
+    const firstReply = randomUUID();
+    const secondUser = randomUUID();
+    const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`);
+    writeTranscript(transcriptPath, sessionId, [
+      { type: "user", uuid: firstUser, parentUuid: null, text: "first" },
+      { type: "assistant", uuid: firstReply, parentUuid: firstUser, text: "first reply" },
+      { type: "user", uuid: secondUser, parentUuid: firstReply, text: "second" },
+      { type: "assistant", uuid: randomUUID(), parentUuid: secondUser, text: "second reply" },
+    ]);
+    const original = readFileSync(transcriptPath, "utf8");
+
+    const fork = await realClaudeRewindSdk.forkSession(sessionId, {
+      upToMessageId: secondUser,
+      transcriptPath,
+    });
+
+    const forkPath = path.join(projectDir, `${fork.sessionId}.jsonl`);
+    expect(readdirSync(projectDir).sort()).toEqual(
+      [`${sessionId}.jsonl`, `${fork.sessionId}.jsonl`].sort(),
+    );
+    expect(readMessageTexts(forkPath)).toEqual(["first", "first reply", "second"]);
+    const forkSessionIds = readFileSync(forkPath, "utf8")
+      .trim()
+      .split("\n")
+      .map((line) => (JSON.parse(line) as { sessionId: string }).sessionId);
+    expect(forkSessionIds).toEqual([
+      fork.sessionId,
+      fork.sessionId,
+      fork.sessionId,
+      fork.sessionId,
+    ]);
+    expect(readFileSync(transcriptPath, "utf8")).toBe(original);
+  });
+
+  test("rejects with the SDK's own error when the transcript is missing", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-missing-"));
+    const sessionId = randomUUID();
+
+    await expect(
+      realClaudeRewindSdk.forkSession(sessionId, {
+        upToMessageId: randomUUID(),
+        transcriptPath: path.join(tempRoot, `${sessionId}.jsonl`),
+      }),
+    ).rejects.toThrow(new Error(`Session ${sessionId} not found`));
+  });
+
+  test("rejects with the name and message of the error the SDK raises", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-invalid-"));
+    const sessionId = randomUUID();
+    const sdkError = await forkSession(sessionId, { upToMessageId: "not-a-uuid" }).then(
+      () => null,
+      (error: Error) => error,
+    );
+    expect(sdkError).toBeInstanceOf(Error);
+
+    await expect(
+      realClaudeRewindSdk.forkSession(sessionId, {
+        upToMessageId: "not-a-uuid",
+        transcriptPath: path.join(tempRoot, `${sessionId}.jsonl`),
+      }),
+    ).rejects.toMatchObject({ name: sdkError?.name, message: sdkError?.message });
+  });
+
+  test("keeps a filesystem error's code when the fork fails in the worker", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-eisdir-"));
+    const sessionId = randomUUID();
+    const transcriptPath = path.join(tempRoot, `${sessionId}.jsonl`);
+    mkdirSync(transcriptPath);
+
+    await expect(
+      realClaudeRewindSdk.forkSession(sessionId, { upToMessageId: randomUUID(), transcriptPath }),
+    ).rejects.toMatchObject({ name: "Error", code: "EISDIR" });
+  });
+
+  test("forks one conversation at a time", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-queue-"));
+    const projectDir = path.join(tempRoot, "projects", "-repo");
+    mkdirSync(projectDir, { recursive: true });
+    const forks = [randomUUID(), randomUUID()].map((sessionId) => {
+      const user = randomUUID();
+      const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`);
+      writeTranscript(transcriptPath, sessionId, [
+        { type: "user", uuid: user, parentUuid: null, text: "first" },
+        { type: "assistant", uuid: randomUUID(), parentUuid: user, text: "first reply" },
+      ]);
+      return { sessionId, upToMessageId: user, transcriptPath };
+    });
+    const events: string[] = [];
+    let started = 0;
+    function recordWorker(message: unknown): void {
+      if (typeof message !== "object" || message === null || !("worker" in message)) return;
+      if (!(message.worker instanceof Worker)) return;
+      const fork = ++started;
+      events.push(`start ${fork}`);
+      message.worker.once("message", () => events.push(`reply ${fork}`));
+    }
+
+    subscribe("worker_threads", recordWorker);
+    try {
+      await Promise.all(
+        forks.map(({ sessionId, upToMessageId, transcriptPath }) =>
+          realClaudeRewindSdk.forkSession(sessionId, { upToMessageId, transcriptPath }),
+        ),
+      );
+    } finally {
+      unsubscribe("worker_threads", recordWorker);
+    }
+
+    expect(events).toEqual(["start 1", "reply 1", "start 2", "reply 2"]);
+  });
+
+  test("forks a long transcript without blocking the daemon's event loop", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-long-"));
+    const projectDir = path.join(tempRoot, "projects", "-repo");
+    mkdirSync(projectDir, { recursive: true });
+    const sessionId = randomUUID();
+    const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`);
+    const turns = 43_000;
+    const lastUser = writeLongTranscript(transcriptPath, sessionId, turns);
+
+    const { result: fork, blockingMs } = await measureMainThreadWork(
+      "claude fork main-thread work",
+      () => realClaudeRewindSdk.forkSession(sessionId, { upToMessageId: lastUser, transcriptPath }),
+    );
+
+    expect(blockingMs).toBeLessThan(50);
+    const forkLines = readFileSync(path.join(projectDir, `${fork.sessionId}.jsonl`), "utf8")
+      .trim()
+      .split("\n");
+    expect(forkLines).toHaveLength(turns * 2);
+    expect(JSON.parse(forkLines[turns * 2 - 2]!).forkedFrom).toEqual({
+      sessionId,
+      messageUuid: lastUser,
+    });
+  });
 });
 
+describe("Claude project folder session store", () => {
+  let root: string | null = null;
+
+  afterEach(() => {
+    if (root) rmSync(root, { recursive: true, force: true });
+    root = null;
+  });
+
+  test("appends entries after existing ones, byte for byte, and loads them back", async () => {
+    root = mkdtempSync(path.join(tmpdir(), "claude-rewind-store-"));
+    const store = projectFolderSessionStore(root);
+    const key = { projectKey: "-repo", sessionId: randomUUID() };
+    const transcriptPath = path.join(root, `${key.sessionId}.jsonl`);
+    const existing = { type: "user", uuid: randomUUID(), message: { content: "already there" } };
+    writeFileSync(transcriptPath, `${JSON.stringify(existing)}\n`);
+    const entries = Array.from({ length: 4_000 }, (_, index) => ({
+      type: "assistant",
+      uuid: randomUUID(),
+      message: { content: `reply ${index} ✓ ${"x".repeat(1_000)}` },
+    }));
+
+    await store.append(key, entries);
+
+    expect(readFileSync(transcriptPath, "utf8")).toBe(
+      [existing, ...entries].map((entry) => `${JSON.stringify(entry)}\n`).join(""),
+    );
+    expect(await store.load(key)).toEqual([existing, ...entries]);
+  });
+});
+
+function writeLongTranscript(transcriptPath: string, sessionId: string, turns: number): string {
+  const toolOutput = 'line 1: "quoted" output\twith\\escapes\n'.repeat(4);
+  const lines: TranscriptLine[] = [];
+  let parentUuid: string | null = null;
+  let lastUser = "";
+  for (let turn = 0; turn < turns; turn++) {
+    lastUser = randomUUID();
+    const reply = randomUUID();
+    lines.push({ type: "user", uuid: lastUser, parentUuid, text: `question ${turn}` });
+    lines.push({ type: "assistant", uuid: reply, parentUuid: lastUser, text: toolOutput });
+    parentUuid = reply;
+  }
+  writeTranscript(transcriptPath, sessionId, lines);
+  return lastUser;
+}
+
 test.runIf(process.platform === "linux")(
   "releases the transcript descriptor after an early steer match",
   async () => {

packages/server/src/server/agent/providers/claude/rewind.ts

@@ -1,13 +1,10 @@
 import { createReadStream } from "node:fs";
-import { appendFile, readFile } from "node:fs/promises";
-import path from "node:path";
 import { createInterface } from "node:readline";
-import {
-  forkSession as claudeForkSession,
-  type Query,
-  type SessionStore,
-  type SessionStoreEntry,
-} from "@anthropic-ai/claude-agent-sdk";
+import { Worker } from "node:worker_threads";
+import type { Query } from "@anthropic-ai/claude-agent-sdk";
+import pLimit from "p-limit";
+import { resolveWorkerEntrypoint } from "../../../../utils/worker-entrypoint.js";
+import type { ClaudeForkReply, ClaudeForkRequest } from "./rewind-worker.js";
 
 export interface ClaudeRewindSdk {
   forkSession(
@@ -16,60 +13,42 @@ export interface ClaudeRewindSdk {
   ): Promise<{ sessionId: string }>;
 }
 
-// On its own, the SDK looks for the session under the daemon's CLAUDE_CONFIG_DIR, while a
-// provider can point Claude Code at another one. Forking through a store rooted at the
-// transcript's folder reads the session where Claude Code wrote it and writes the fork beside it.
+const source = import.meta.url.endsWith(".ts");
+const workerUrl = new URL(source ? "./rewind-worker.ts" : "./rewind-worker.js", import.meta.url);
+const rewindWorker = resolveWorkerEntrypoint(workerUrl);
+const forks = pLimit(1);
+
 export const realClaudeRewindSdk: ClaudeRewindSdk = {
   forkSession: (sessionId, options) =>
-    claudeForkSession(sessionId, {
-      upToMessageId: options.upToMessageId,
-      sessionStore: projectFolderSessionStore(path.dirname(options.transcriptPath)),
-    }),
+    forks(() =>
+      forkInWorker({
+        sessionId,
+        upToMessageId: options.upToMessageId,
+        transcriptPath: options.transcriptPath,
+      }),
+    ),
 };
 
-function projectFolderSessionStore(projectFolder: string): SessionStore {
-  const transcriptPath = (sessionId: string) => path.join(projectFolder, `${sessionId}.jsonl`);
-  return {
-    async load({ sessionId }) {
-      let text: string;
-      try {
-        text = await readFile(transcriptPath(sessionId), "utf8");
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
-        throw error;
+function forkInWorker(request: ClaudeForkRequest): Promise<{ sessionId: string }> {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(rewindWorker.entrypoint, {
+      eval: rewindWorker.eval,
+      execArgv: [],
+      workerData: request,
+    });
+    worker.once("message", (reply: ClaudeForkReply) => {
+      void worker.terminate();
+      if (reply.kind === "forked") {
+        resolve({ sessionId: reply.sessionId });
+        return;
       }
-      return parseTranscriptEntries(text);
-    },
-    async append({ sessionId }, entries) {
-      const lines = entries.map((entry) => `${JSON.stringify(entry)}\n`).join("");
-      await appendFile(transcriptPath(sessionId), lines, "utf8");
-    },
-  };
-}
-
-function parseTranscriptEntries(text: string): SessionStoreEntry[] {
-  const entries: SessionStoreEntry[] = [];
-  for (const line of text.split("\n")) {
-    if (!line.trim()) continue;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      // Skip a line that is not JSON, as the SDK's own transcript reader does.
-      continue;
-    }
-    if (isSessionStoreEntry(parsed)) entries.push(parsed);
-  }
-  return entries;
-}
-
-function isSessionStoreEntry(value: unknown): value is SessionStoreEntry {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    typeof (value as { type?: unknown }).type === "string"
-  );
+      const error = new Error(reply.message);
+      error.stack = reply.stack;
+      reject(Object.assign(error, reply.properties));
+    });
+    worker.once("error", reject);
+    worker.once("exit", (code) => reject(new Error(`Claude rewind worker exited (code ${code})`)));
+  });
 }
 
 /**

packages/server/src/server/agent/providers/codex-app-server-agent.ts

@@ -150,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.
@@ -3485,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 }>
@@ -4448,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");
       }
@@ -5056,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;
@@ -5117,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();
@@ -6372,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",
@@ -6781,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
@@ -6944,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;
     }

packages/server/src/server/agent/providers/codex-interrupted-turn-terminals.test.ts

@@ -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);
-});

packages/server/src/server/connected-hosts/hosts.e2e.test.ts

@@ -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");

packages/server/src/server/connected-hosts/index.ts

@@ -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")

packages/server/src/server/daemon-e2e/checkout-diff-content.e2e.test.ts

@@ -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 });

packages/server/src/server/daemon-e2e/file-download.e2e.test.ts

@@ -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(

packages/server/src/server/daemon-e2e/peer-message-permissions.test.ts

@@ -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();
-  }
-});

packages/server/src/server/plugins/compiler.ts

@@ -1,8 +1,7 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
 import { Worker } from "node:worker_threads";
 import pLimit from "p-limit";
 import { ZodError } from "zod";
+import { resolveWorkerEntrypoint } from "../../utils/worker-entrypoint.js";
 import type * as build from "./compiler-build.js";
 import type { PluginManifest } from "./manifest.js";
 import type { CompilerReply } from "./compiler-worker.js";
@@ -37,9 +36,7 @@ const workerUrl = new URL(
 );
 // Resolve the development loader once at module initialization, never during a
 // compile request. Packaged workers execute ordinary JavaScript without tsx.
-const workerEntrypoint = source
-  ? `import(${JSON.stringify(pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm/api")).href)}).then(({ register }) => { register(); return import(${JSON.stringify(workerUrl.href)}); });`
-  : workerUrl;
+const compilerWorker = resolveWorkerEntrypoint(workerUrl);
 
 // Reuse the isolate during a build batch (notably daemon bootstrap), then release
 // TypeScript's heap when idle. Only this owner admits work or stops the worker.
@@ -74,7 +71,10 @@ class PluginCompiler {
   }
 
   private startWorker(): Worker {
-    const worker = new Worker(workerEntrypoint, { eval: source, execArgv: [] });
+    const worker = new Worker(compilerWorker.entrypoint, {
+      eval: compilerWorker.eval,
+      execArgv: [],
+    });
     this.worker = worker;
     // Keep error/exit ownership while idle too. The next caller gets a fresh
     // isolate after a crash; author build commands are never retried.

packages/server/src/server/plugins/index.posix.test.ts

@@ -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);

packages/server/src/server/plugins/index.ts

@@ -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);

packages/server/src/server/session.ts

@@ -8318,7 +8318,7 @@ export class Session {
             },
             activeTurnBehavior: msg.activeTurnBehavior ?? "steer",
             sessionMode: msg.sessionMode,
-            clearPendingPermissions: false,
+            clearPendingPermissions: true,
           });
           deliveryStatus = "queued";
           queued();

packages/server/src/server/workspace-git-service.observation.integration.test.ts

@@ -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,
-);

packages/server/src/server/workspace-git-service.observation.test.ts

@@ -244,7 +244,6 @@ function createService(
         filterEvents: (events) => events,
         verify: vi.fn(async () => {}),
       })),
-      workspaceFolderExists: vi.fn(async () => true),
       ...overrides,
     } as never,
   });

packages/server/src/server/workspace-git-service.test.ts

@@ -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);
-  });
-});

packages/server/src/server/workspace-git-service.ts

@@ -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 {

packages/server/src/terminal/terminal-worker-runtime.test.ts

@@ -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 };

packages/server/src/utils/test-fixtures/expand-tilde-worker.ts

@@ -0,0 +1,6 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { expandTilde } from "../path.js";
+
+const port = parentPort!;
+const input: string = workerData;
+port.postMessage(expandTilde(input));

packages/server/src/utils/worker-entrypoint.test.ts

@@ -0,0 +1,34 @@
+import { once } from "node:events";
+import { Worker } from "node:worker_threads";
+import { describe, expect, test } from "vitest";
+
+import { expandTilde } from "./path.js";
+import { resolveWorkerEntrypoint } from "./worker-entrypoint.js";
+
+describe("worker entrypoint", () => {
+  test("starts a compiled worker from its own URL", () => {
+    const entry = resolveWorkerEntrypoint(
+      new URL("file:///app/dist/server/server/plugins/compiler-worker.js"),
+    );
+
+    expect({ ...entry, entrypoint: String(entry.entrypoint) }).toEqual({
+      entrypoint: "file:///app/dist/server/server/plugins/compiler-worker.js",
+      eval: false,
+    });
+  });
+
+  test("runs a TypeScript worker, with its .js imports, through tsx", async () => {
+    const entry = resolveWorkerEntrypoint(
+      new URL("./test-fixtures/expand-tilde-worker.ts", import.meta.url),
+    );
+    const worker = new Worker(entry.entrypoint, {
+      eval: entry.eval,
+      execArgv: [],
+      workerData: "~/project",
+    });
+
+    const [expanded] = await once(worker, "message");
+
+    expect(expanded).toBe(expandTilde("~/project"));
+  });
+});

packages/server/src/utils/worker-entrypoint.ts

@@ -0,0 +1,16 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+
+export interface WorkerEntrypoint {
+  entrypoint: string | URL;
+  eval: boolean;
+}
+
+export function resolveWorkerEntrypoint(workerUrl: URL): WorkerEntrypoint {
+  if (!workerUrl.pathname.endsWith(".ts")) return { entrypoint: workerUrl, eval: false };
+  const tsxUrl = pathToFileURL(createRequire(import.meta.url).resolve("tsx/esm/api")).href;
+  return {
+    entrypoint: `import(${JSON.stringify(tsxUrl)}).then(({ register }) => { register(); return import(${JSON.stringify(workerUrl.href)}); });`,
+    eval: true,
+  };
+}

scripts/ci-workflow.test.mjs

@@ -680,46 +680,51 @@ test("macOS jobs use latest runners while preserving release architectures", ()
   assert.match(release, /runner: macos-26-intel\n\s+electron_arch: x64/);
 });
 
-test("Nix desktop packaging resolves the workspace-local builder", () => {
-  const source = readFileSync(new URL("nix/desktop-package.nix", repoRoot), "utf8");
-  const invocation = source.match(/^\s+([^\n]*electron-builder) \\\n/m)?.[1];
-  assert.ok(invocation, "Nix invokes the desktop packaging tool");
-  const directory = mkdtempSync(join(tmpdir(), "nix-builder-resolution-"));
+test("macOS signing repair keeps certificate and keychain passwords separate", () => {
+  const workflow = readFileSync(new URL(".github/workflows/desktop-release.yml", repoRoot), "utf8");
+  const match = workflow.match(/<<'KEYCHAIN_FIX'\n([\s\S]*?)\n          KEYCHAIN_FIX/);
+  assert.ok(match, "the release workflow repairs the pinned signing tool");
+  const script = match[1].replace(/^          /gm, "");
+  const original = [
+    "return await importCerts(keychainFile, certPaths, cscPasswords);",
+    "async function importCerts(keychainFile, paths, keyPasswords) {",
+    '["import", paths[i], "-P", password]',
+    '["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", password, keychainFile]',
+    "}",
+  ].join("\n");
+  const directory = mkdtempSync(join(tmpdir(), "signing-repair-"));
   try {
-    const desktop = join(directory, "packages/desktop");
-    mkdirSync(join(desktop, "node_modules/.bin"), { recursive: true });
-    mkdirSync(join(desktop, "node_modules/electron-builder"));
-    writeFileSync(
-      join(desktop, "node_modules/electron-builder/package.json"),
-      JSON.stringify({
-        name: "electron-builder",
-        version: "1.0.0",
-        bin: { "electron-builder": "../.bin/electron-builder" },
-      }),
-    );
-    writeFileSync(
-      join(directory, "package.json"),
-      JSON.stringify({ private: true, workspaces: ["packages/desktop"] }),
-    );
-    writeFileSync(
-      join(desktop, "package.json"),
-      JSON.stringify({
-        name: "desktop-fixture",
-        private: true,
-        devDependencies: { "electron-builder": "1.0.0" },
-      }),
-    );
-    writeFileSync(
-      join(desktop, "node_modules/.bin/electron-builder"),
-      '#!/bin/sh\nprintf "workspace-builder\\n"\n',
-      { mode: 0o755 },
-    );
-    const result = spawnSync("sh", ["-c", `${invocation} --version`], {
-      cwd: desktop,
-      encoding: "utf8",
-    });
-    assert.equal(result.status, 0, result.stderr);
-    assert.equal(result.stdout.trim(), "workspace-builder");
+    const packageDirectory = join(directory, "node_modules/app-builder-lib");
+    mkdirSync(join(packageDirectory, "out/codeSign"), { recursive: true });
+    const manifest = join(packageDirectory, "package.json");
+    const sourcePath = join(packageDirectory, "out/codeSign/macCodeSign.js");
+    for (const [version, source, succeeds] of [
+      ["26.8.1", original, true],
+      ["26.8.1", original.replace("cscPasswords);", "differentArguments);"), false],
+      ["26.18.0", original, false],
+    ]) {
+      writeFileSync(manifest, JSON.stringify({ name: "app-builder-lib", version }));
+      writeFileSync(sourcePath, source);
+      const result = spawnSync(process.execPath, ["-e", script], {
+        cwd: directory,
+        encoding: "utf8",
+      });
+      const actual = readFileSync(sourcePath, "utf8");
+      if (succeeds) {
+        assert.equal(result.status, 0, result.stderr);
+        assert.ok(
+          actual.includes("importCerts(keychainFile, certPaths, cscPasswords, keychainPassword)"),
+        );
+        assert.ok(
+          actual.includes("importCerts(keychainFile, paths, keyPasswords, keychainPassword)"),
+        );
+        assert.ok(actual.includes('["import", paths[i], "-P", password]'));
+        assert.ok(actual.includes('"-k", keychainPassword, keychainFile]'));
+      } else {
+        assert.notEqual(result.status, 0);
+        assert.equal(actual, source, "unexpected tool inputs must fail without a partial write");
+      }
+    }
   } finally {
     rmSync(directory, { recursive: true, force: true });
   }

scripts/trace-daemon-dist.test.mjs

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { cp, mkdtemp, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { cp, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -9,6 +10,12 @@ import { promisify } from "node:util";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const bridgeModule = "packages/server/dist/server/server/agent/providers/opencode/bridge.js";
+const claudeDist = "packages/server/dist/server/server/agent/providers/claude";
+const workerThreadEntrypoints = [
+  "packages/server/dist/server/server/plugins/compiler-worker.js",
+  `${claudeDist}/rewind-worker.js`,
+  `${claudeDist}/rewind-session-store.js`,
+];
 
 // Mirrors nix/package.nix's installPhase: copy every traced path into $out.
 async function installTracedDaemon(outRoot) {
@@ -17,12 +24,14 @@ async function installTracedDaemon(outRoot) {
     [path.join(repoRoot, "scripts/trace-daemon.mjs")],
     { cwd: repoRoot, maxBuffer: 64 * 1024 * 1024 },
   );
-  for (const file of stdout.split("\n").filter(Boolean)) {
+  const files = stdout.split("\n").filter(Boolean);
+  for (const file of files) {
     await cp(path.join(repoRoot, file), path.join(outRoot, file), {
       recursive: true,
       verbatimSymlinks: true,
     });
   }
+  return files;
 }
 
 test("traced daemon closure ships the OpenCode bridge plugin for every OpenCode version", async () => {
@@ -44,3 +53,32 @@ test("traced daemon closure ships the OpenCode bridge plugin for every OpenCode
     await rm(outRoot, { recursive: true, force: true });
   }
 });
+
+test("traced daemon closure ships the worker-thread entrypoints and what they load", async () => {
+  const outRoot = await mkdtemp(path.join(os.tmpdir(), "trace-daemon-dist-"));
+  try {
+    const files = await installTracedDaemon(outRoot);
+    for (const file of workerThreadEntrypoints) {
+      assert.ok(files.includes(file), `${file} is missing from the traced closure`);
+    }
+
+    const { realClaudeRewindSdk } = await import(
+      pathToFileURL(path.join(outRoot, claudeDist, "rewind.js")).href
+    );
+    const sessionId = randomUUID();
+    const user = randomUUID();
+    const transcriptPath = path.join(outRoot, `${sessionId}.jsonl`);
+    await writeFile(
+      transcriptPath,
+      `${JSON.stringify({ type: "user", uuid: user, parentUuid: null, sessionId, message: { role: "user", content: "first" } })}\n`,
+    );
+    const fork = await realClaudeRewindSdk.forkSession(sessionId, {
+      upToMessageId: user,
+      transcriptPath,
+    });
+    const forked = await readFile(path.join(outRoot, `${fork.sessionId}.jsonl`), "utf8");
+    assert.equal(JSON.parse(forked.split("\n")[0]).forkedFrom.messageUuid, user);
+  } finally {
+    await rm(outRoot, { recursive: true, force: true });
+  }
+});