test(app): name the split resize helper arguments

Divider drags store sizes per group id, apart from the layout tree. A group
keeps its id when panes are added, so after resizing a row and splitting it
again the stored list had fewer entries than panes, and dividers past its end
could not move. Use the dragged sizes only while they have one entry per pane.

Closes #5893

docs/agent-lifecycle.md

@@ -151,11 +151,12 @@ lifecycle queue. Resume chooses its history or interactive purpose from the dura
 entering that queue. Shutdown must finish before the manager releases runtime ownership; a failed
 close retains the runtime for cleanup and blocks replacement through that close operation.
 
-Authoritative timeline catch-up can use a runtime-only `history` resume purpose. For Codex, that
-purpose initializes a temporary app-server, reads the persisted thread and child histories, and
-releases the process before returning. It never loads, resumes, or unarchives a native thread,
-including legacy records whose native archive failed. The retained history session contains only
-the read results. Interactive resume remains responsible for repairing a provider session archived
+Authoritative timeline catch-up can use a runtime-only `history` resume purpose. The retained
+history session contains only the read results and must release its provider process once replay
+finishes. Codex reads the persisted thread and child histories on a temporary app-server and never
+loads, resumes, or unarchives a native thread, including legacy records whose native archive failed.
+ACP providers spawn the CLI, replay the session through `session/load`, and terminate the process
+before returning. Interactive resume remains responsible for repairing a provider session archived
 outside Paseo while its Paseo agent is active.
 
 Provider session connection owns every process it spawns until the session is registered with

packages/app/e2e/browser/pair-device-relay.spec.ts

@@ -1,6 +1,8 @@
 import { test } from "../support/fixtures";
 import { startIsolatedHostDaemon } from "../support/helpers/isolated-host-daemon";
 import {
+  expectPairingOffer,
+  expectCompletePairingQr,
   expectRelayConsent,
   openPairDeviceModal,
   preparePairingHost,
@@ -18,3 +20,20 @@ test("opens relay consent in browser web", async ({ page }) => {
     await daemon.close();
   }
 });
+
+test("keeps the pairing QR code inside its compact tile", async ({ page }, testInfo) => {
+  const daemon = await startIsolatedHostDaemon("pair-device-browser-compact", {
+    mutableRelay: { enabled: true },
+  });
+  try {
+    await preparePairingHost(page, daemon);
+    await page.setViewportSize({ width: 320, height: 568 });
+    await openPairDeviceModal(page);
+    await expectPairingOffer(page);
+
+    await expectCompletePairingQr(page);
+    await page.screenshot({ path: testInfo.outputPath("pairing-compact.png") });
+  } finally {
+    await daemon.close();
+  }
+});

packages/app/e2e/browser/split-pane-resize.spec.ts

@@ -0,0 +1,101 @@
+import { expect, type Locator, type Page } from "@playwright/test";
+import { test } from "../support/fixtures";
+import { runWorkspaceActionFromCommandCenter } from "../support/helpers/command-center-workspace-actions";
+import { clickNewChat, gotoWorkspace } from "../support/helpers/launcher";
+import { seedWorkspace } from "../support/helpers/seed-client";
+import { waitForWorkspaceTabsVisible } from "../support/helpers/workspace-tabs";
+
+const DRAG_DISTANCE = -40;
+
+function splitDividers(page: Page): Locator {
+  return page.getByTestId("workspace-split-resize-handle").filter({ visible: true });
+}
+
+async function dividerX(divider: Locator): Promise<number> {
+  const box = await divider.boundingBox();
+  if (!box) throw new Error("Divider has no bounding box");
+  return box.x;
+}
+
+async function dragDivider(divider: Locator, deltaX: number): Promise<void> {
+  const page = divider.page();
+  const box = await divider.boundingBox();
+  if (!box) throw new Error("Divider has no bounding box");
+  const x = box.x + box.width / 2;
+  const y = box.y + box.height / 2;
+  await page.mouse.move(x, y);
+  await page.mouse.down();
+  await page.mouse.move(x + deltaX / 2, y, { steps: 4 });
+  await page.mouse.move(x + deltaX, y, { steps: 4 });
+  await page.mouse.up();
+}
+
+async function expectDividerFollowsDrag({
+  page,
+  index,
+}: {
+  page: Page;
+  index: number;
+}): Promise<void> {
+  const divider = splitDividers(page).nth(index);
+  const before = await dividerX(divider);
+  await dragDivider(divider, DRAG_DISTANCE);
+  await expect
+    .poll(async () => (await dividerX(divider)) - before, {
+      message: `divider ${index + 1} should follow the drag`,
+    })
+    .toBeLessThan(DRAG_DISTANCE * 0.75);
+}
+
+async function splitRight({
+  page,
+  expectedDividers,
+}: {
+  page: Page;
+  expectedDividers: number;
+}): Promise<void> {
+  await runWorkspaceActionFromCommandCenter(page, "Split pane right");
+  await expect(splitDividers(page)).toHaveCount(expectedDividers);
+}
+
+test.describe("Split pane resize", () => {
+  test("every divider drags in a four-pane row", async ({ page }) => {
+    await page.setViewportSize({ width: 1600, height: 900 });
+    const workspace = await seedWorkspace({ repoPrefix: "split-resize-fresh-" });
+    try {
+      await gotoWorkspace(page, workspace.workspaceId);
+      await waitForWorkspaceTabsVisible(page);
+      await clickNewChat(page);
+      await splitRight({ page, expectedDividers: 1 });
+      await splitRight({ page, expectedDividers: 2 });
+      await splitRight({ page, expectedDividers: 3 });
+
+      for (const index of [0, 1, 2]) {
+        await expectDividerFollowsDrag({ page, index });
+      }
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+
+  test("every divider drags after panes are added to a resized row", async ({ page }) => {
+    await page.setViewportSize({ width: 1600, height: 900 });
+    const workspace = await seedWorkspace({ repoPrefix: "split-resize-grown-" });
+    try {
+      await gotoWorkspace(page, workspace.workspaceId);
+      await waitForWorkspaceTabsVisible(page);
+      await clickNewChat(page);
+      await splitRight({ page, expectedDividers: 1 });
+      await expectDividerFollowsDrag({ page, index: 0 });
+
+      await splitRight({ page, expectedDividers: 2 });
+      await splitRight({ page, expectedDividers: 3 });
+
+      for (const index of [0, 1, 2]) {
+        await expectDividerFollowsDrag({ page, index });
+      }
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+});

packages/app/e2e/mobile/pair-device/android.mjs

@@ -0,0 +1,43 @@
+// Start on Settings > Host > Pair device with relay enabled in the Android app.
+// node packages/app/e2e/mobile/pair-device/android.mjs <agent-device-session>
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+
+const [, , session] = process.argv;
+assert(session, "Pass the agent-device session for the connected Android app");
+
+function ad(...args) {
+  return execFileSync("agent-device", [...args, "--session", session], {
+    encoding: "utf8",
+    timeout: 60_000,
+  });
+}
+
+ad(
+  "press",
+  'label="Pair a device, Scan a QR code or copy a link to connect your phone to this host"',
+  "--settle",
+);
+ad("wait", "text", "Pairing QR code", "10000");
+const { data } = JSON.parse(ad("snapshot", "-i", "--json"));
+const sheet = data.nodes.find((node) => node.label === "Bottom Sheet");
+const qr = data.nodes.find((node) => node.label === "Pairing QR code");
+assert(sheet?.rect, "Pairing sheet must be visible");
+assert(qr?.rect, "Pairing QR code must be visible");
+assert(qr.rect.x > sheet.rect.x, "QR must have an unclipped left margin inside the sheet");
+assert(
+  qr.rect.x + qr.rect.width < sheet.rect.x + sheet.rect.width,
+  "QR must have an unclipped right margin inside the sheet",
+);
+assert(Math.abs(qr.rect.width - qr.rect.height) <= 1, "Complete QR must remain square");
+assert(qr.rect.y >= sheet.rect.y, "QR top must be visible inside the sheet");
+assert(
+  qr.rect.y + qr.rect.height <= sheet.rect.y + sheet.rect.height,
+  "QR bottom must be visible inside the sheet",
+);
+assert(
+  data.nodes.some((node) => node.label === "Copy" && node.enabled),
+  "Copy must remain available",
+);
+console.log("PASS: complete square QR fits inside the pairing sheet", qr.rect);
+ad("press", 'label="Close"', "--settle");

packages/app/e2e/support/helpers/pair-device.ts

@@ -220,3 +220,24 @@ export function expectDaemonPidUnchanged(
   expect(before).toBeDefined();
   expect(after).toBe(before);
 }
+
+export async function expectCompletePairingQr(page: Page): Promise<void> {
+  const qr = page.getByRole("img", { name: "Pairing QR code" });
+  await qr.scrollIntoViewIfNeeded();
+  // IntersectionObserver rounds fractional sheet/scroll coordinates.
+  await expect(qr).toBeInViewport({ ratio: 0.999 });
+  const bounds = await qr.evaluate((element) => {
+    const tile = element.parentElement;
+    if (!tile) throw new Error("Pairing QR tile is missing");
+    const qrRect = element.getBoundingClientRect();
+    const tileRect = tile.getBoundingClientRect();
+    return {
+      qr: { x: qrRect.x, y: qrRect.y, right: qrRect.right, bottom: qrRect.bottom },
+      tile: { x: tileRect.x, y: tileRect.y, right: tileRect.right, bottom: tileRect.bottom },
+    };
+  });
+  expect(bounds.qr.x).toBeGreaterThanOrEqual(bounds.tile.x);
+  expect(bounds.qr.y).toBeGreaterThanOrEqual(bounds.tile.y);
+  expect(bounds.qr.right).toBeLessThanOrEqual(bounds.tile.right);
+  expect(bounds.qr.bottom).toBeLessThanOrEqual(bounds.tile.bottom);
+}

packages/app/src/components/split-container.tsx

@@ -968,8 +968,12 @@ function SplitNodeView({
     groupId ? state.splitSizesByWorkspace[workspaceKey]?.[groupId] : undefined,
   );
   const groupChildren = node.kind === "group" ? node.group.children : EMPTY_SPLIT_NODES;
+  // Dragged sizes live per group id, apart from the layout tree, and a group keeps its id when
+  // panes are added or removed. They only apply while they still have one entry per child;
+  // otherwise the dividers past the end of the list could not move.
+  const layoutGroupSizes = node.kind === "group" ? node.group.sizes : EMPTY_SPLIT_SIZES;
   const groupSizes =
-    storedGroupSizes ?? (node.kind === "group" ? node.group.sizes : EMPTY_SPLIT_SIZES);
+    storedGroupSizes?.length === groupChildren.length ? storedGroupSizes : layoutGroupSizes;
   const visibleFlex = useMemo(
     () => resolveVisibleGroupFlex(groupChildren, groupSizes, maximizedPaneId),
     [groupChildren, groupSizes, maximizedPaneId],

packages/app/src/desktop/components/pair-device-section.tsx

@@ -80,7 +80,6 @@ export function PairDeviceSection({ serverId, onClose }: PairDeviceSectionProps)
         type: "svg",
         errorCorrectionLevel: "M",
         margin: 1,
-        width: 480,
       }),
     enabled: Boolean(pairingQuery.data?.url),
     dataShape: "value",
@@ -275,7 +274,8 @@ function PairingQr({ svg, isError }: { svg: string | null; isError: boolean }) {
     return (
       <SvgXml
         xml={svg}
-        style={styles.qrImage}
+        width="100%"
+        height="100%"
         accessibilityRole="image"
         accessibilityLabel={t("pairing.device.qrAccessibility")}
       />
@@ -365,10 +365,6 @@ const styles = StyleSheet.create((theme) => ({
     borderColor: theme.colors.border,
     backgroundColor: theme.colors.palette.white,
   },
-  qrImage: {
-    width: "100%",
-    height: "100%",
-  },
   linkRow: {
     flexDirection: "row",
     alignItems: "center",

packages/app/src/keyboard/keyboard-shortcuts.test.ts

@@ -1027,6 +1027,71 @@ describe("unassigned shortcuts", () => {
   });
 
   describe("matching", () => {
+    it("dispatches a captured Russian letter shortcut on the same key", () => {
+      const event = keyboardInput({ key: "и", code: "KeyB", ctrlKey: true });
+      const combo = keyboardEventToComboString(event as KeyboardEvent);
+      expect(combo).toBe("Ctrl+B");
+      const bindings = buildEffectiveBindings({
+        "sidebar-toggle-left-ctrl-period-non-mac": combo!,
+      });
+
+      expect(resolveShortcut({ event, context: desktopNonMac, bindings }).match?.action).toBe(
+        "sidebar.toggle.left",
+      );
+    });
+
+    it("dispatches a recorded dotted-uppercase letter with Shift held", () => {
+      const event = keyboardInput({ key: "İ", code: "KeyS", ctrlKey: true, shiftKey: true });
+      const combo = keyboardEventToComboString(event as KeyboardEvent);
+      expect(combo).toBe("Ctrl+Shift+S");
+      const bindings = buildEffectiveBindings({
+        "sidebar-toggle-left-ctrl-period-non-mac": combo!,
+      });
+      expect(resolveShortcut({ event, context: desktopNonMac, bindings }).match?.action).toBe(
+        "sidebar.toggle.left",
+      );
+    });
+
+    it.each(["и", "И", "β", "ش", "ב", "é"])(
+      "matches default and recorded letter bindings for unsupported letter %s",
+      (key) => {
+        const event = keyboardInput({ key, code: "KeyB", ctrlKey: true });
+        expectShortcutResolution({
+          event,
+          context: desktopNonMac,
+          action: "sidebar.toggle.left",
+        });
+        const combo = keyboardEventToComboString(event as KeyboardEvent);
+        expect(combo).toBe("Ctrl+B");
+        expect(
+          resolveShortcut({
+            event,
+            context: desktopNonMac,
+            bindings: buildEffectiveBindings({
+              "sidebar-toggle-left-ctrl-period-non-mac": combo!,
+            }),
+          }).match?.action,
+        ).toBe("sidebar.toggle.left");
+      },
+    );
+
+    it.each(["v", "†", "Dead", "Unidentified", ""])(
+      "does not match an unrelated character or named key %s by physical letter",
+      (key) => {
+        expectNoShortcutResolution({
+          event: { key, code: "KeyB", ctrlKey: true },
+          context: desktopNonMac,
+        });
+      },
+    );
+
+    it("does not match non-letter bindings by physical key for unsupported letters", () => {
+      expectNoShortcutResolution({
+        event: { key: "ю", code: "Period", ctrlKey: true },
+        context: desktopNonMac,
+      });
+    });
+
     it("dispatches a captured Dvorak binding on the same logical key", () => {
       const event = keyboardInput({ key: "b", code: "KeyN", metaKey: true });
       const combo = keyboardEventToComboString(event as KeyboardEvent);

packages/app/src/keyboard/keyboard-shortcuts.ts

@@ -1285,6 +1285,12 @@ function matchesKeyOrCode(combo: KeyCombo, event: KeyboardShortcutInput): boolea
   if (combo.shift === true && combo.shiftedKey !== undefined && eventKey === combo.shiftedKey) {
     return true;
   }
+  // Recording an unsupported letter (for example Cyrillic и on KeyB)
+  // stores its physical A-Z key. Dispatch must accept that same key without
+  // giving Latin layouts such as Dvorak a second physical-key binding.
+  if (/^[a-z]$/.test(combo.key) && /^\p{Letter}$/u.test(event.key) && !/^[a-z]$/.test(eventKey)) {
+    return event.code === combo.code;
+  }
   // macOS rewrites event.key when Option is held (Option+T -> "†",
   // Option+[ -> "“"), so Alt-bound letter / bracket bindings can only
   // match by event.code. Stay key-first for non-Alt bindings so Dvorak

packages/client/src/index.ts

@@ -1051,7 +1051,7 @@ async function waitForProvidersReady(
 
   try {
     await observation.ready;
-    signal.throwIfAborted();
+    if (signal.aborted) throw new Error("Paseo API is disposed");
     return await new Promise<PaseoProviderSnapshotResult>((resolve, reject) => {
       let settled = false;
       let requestId: string | null = null;

packages/highlight/src/__tests__/highlighter.test.ts

@@ -144,6 +144,34 @@ const title = "Hello";
     );
   });
 
+  it("highlights Astro markup containing only an empty expression", () => {
+    const code = "<p>{}</p>";
+
+    const tokens = highlightCode(code, "Empty.astro").flat();
+
+    expect(tokens.map((token) => token.text).join("")).toBe(code);
+    expect(tokens).toContainEqual({ text: "p", style: "tag" });
+  });
+
+  it.each([
+    "<p>{title} {} {title}</p>",
+    '<p class="{} {title}">{title}</p>',
+    "<p class={} title={title}>{title}</p>",
+  ])("highlights Astro containing an empty expression: %s", (markup) => {
+    const code = `---\nconst title = "Hello";\n---\n${markup}\n<style>.page { color: red; }</style>`;
+
+    const lines = highlightCode(code, "Empty.astro");
+
+    expect(lines).toHaveLength(code.split("\n").length);
+    for (const [index, tokens] of lines.entries()) {
+      expect(tokens.map((token) => token.text).join("")).toBe(code.split("\n")[index]);
+    }
+    expect(lines.flat()).toContainEqual({ text: "const", style: "keyword" });
+    expect(lines.flat()).toContainEqual({ text: "p", style: "tag" });
+    expect(lines.flat()).toContainEqual({ text: "color", style: "property" });
+    expect(lines.flat()).toContainEqual({ text: "title", style: "variable" });
+  });
+
   it("keeps an Astro expression open through nested template strings", () => {
     const code = "<p>{`a ${`}`} b`}</p>";
 

packages/highlight/src/astro/parser.ts

@@ -45,10 +45,12 @@ function maskExpressions(text: string): string {
 }
 
 function expressionOverlays(node: SyntaxNodeRef, input: Input): Range[] | null {
-  const overlays = findExpressions(input.read(node.from, node.to)).map(({ from, to }) => ({
-    from: node.from + from + 1,
-    to: node.from + to,
-  }));
+  const overlays = findExpressions(input.read(node.from, node.to))
+    .filter(({ from, to }) => to > from + 1)
+    .map(({ from, to }) => ({
+      from: node.from + from + 1,
+      to: node.from + to,
+    }));
   return overlays.length > 0 ? overlays : null;
 }
 

packages/server/src/server/agent/providers/acp-agent.ts

@@ -1750,6 +1750,7 @@ export class ACPAgentSession implements AgentSession, ACPClient {
   private fallbackAssistantMessageId: string | null = null;
   private closed = false;
   private historyPending = false;
+  private historyRuntimeReleased = false;
   private replayingHistory = false;
   private bootstrapThreadEventPending = false;
   private readonly terminateProcess: ProcessTerminator;
@@ -1867,11 +1868,38 @@ export class ACPAgentSession implements AgentSession, ACPClient {
       }
 
       await this.applyConfiguredOverrides();
+
+      if (this.resumePurpose === "history") {
+        await this.releaseHistoryRuntime();
+      }
     } catch (error) {
       await this.closeAfterInitializationFailure(error);
     }
   }
 
+  // History resumes exist to replay persisted events into the canonical
+  // timeline; the provider process is released once replay finishes so
+  // archived agents hold no resident runtime. Interactive work goes through
+  // reloadAgentSession, which spawns a fresh process.
+  private async releaseHistoryRuntime(): Promise<void> {
+    const child = this.child;
+    if (child) {
+      const result = await this.terminateProcess(child, {
+        gracefulTimeoutMs: 2_000,
+        forceTimeoutMs: 2_000,
+      });
+      if (result === "kill-timeout") {
+        // Keep the child registered so close() can retry the shutdown.
+        this.logger.warn("ACP history resume could not release the provider process");
+        return;
+      }
+    }
+    this.historyRuntimeReleased = true;
+    this.connection = null;
+    this.child = null;
+    this.settleCommandsReady();
+  }
+
   private async closeAfterInitializationFailure(error: unknown): Promise<never> {
     try {
       await this.close();
@@ -2841,7 +2869,7 @@ export class ACPAgentSession implements AgentSession, ACPClient {
     });
     const spawnError = rejectOnSpawnError(child, stderrChunks);
     child.once("exit", (code, signal) => {
-      if (this.closed) {
+      if (this.closed || this.historyRuntimeReleased) {
         return;
       }
       if (this.activeForegroundTurnId) {

packages/server/src/server/agent/providers/claude/agent.context-usage.local.e2e.test.ts

@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import pino from "pino";
 import { expect, test } from "vitest";
@@ -13,12 +13,18 @@ test.each([
   { placement: "delta", cacheTokens: 0 },
   { placement: "start", cacheTokens: 1_000 },
   { placement: "delta", cacheTokens: 1_000 },
+  { placement: "start", cacheTokens: 0, model: "glm-5.2[1m]" },
+  { placement: "start", cacheTokens: 0, model: "sonnet", resolvedModel: "glm-5.2[1m]" },
 ])(
-  "counts $placement input and $cacheTokens cached tokens through Claude Code",
-  async ({ placement, cacheTokens }) => {
+  "counts $placement input and $cacheTokens cached tokens through Claude Code ($model)",
+  async ({ placement, cacheTokens, model = "claude-sonnet-4-6", resolvedModel = model }) => {
     const cwd = await mkdtemp(path.resolve(".claude-context-usage-"));
     const configDir = path.join(cwd, "config");
     await mkdir(configDir);
+    await writeFile(
+      path.join(configDir, "settings.json"),
+      JSON.stringify({ env: { ANTHROPIC_DEFAULT_SONNET_MODEL: resolvedModel } }),
+    );
     let requestCount = 0;
     const server = createServer(async (request, response) => {
       for await (const chunk of request) {
@@ -45,7 +51,7 @@ test.each([
           id: `msg_context_usage_${requestCount}`,
           type: "message",
           role: "assistant",
-          model: "claude-sonnet-4-6",
+          model: resolvedModel,
           content: [],
           stop_reason: null,
           stop_sequence: null,
@@ -86,11 +92,9 @@ test.each([
         },
       },
     });
-    const session = await client.createSession(
-      { provider: "claude", cwd, model: "claude-sonnet-4-6" },
-      undefined,
-      { persistSession: false },
-    );
+    const session = await client.createSession({ provider: "claude", cwd, model }, undefined, {
+      persistSession: false,
+    });
     try {
       for (let turn = 0; turn < 2; turn++) {
         const events = await collectSessionTurnEvents(session, "say hello", {
@@ -111,7 +115,10 @@ test.each([
         expect(events).toContainEqual(
           expect.objectContaining({
             type: "usage_updated",
-            usage: expect.objectContaining({ contextWindowUsedTokens: expectedTokens }),
+            usage: expect.objectContaining({
+              contextWindowUsedTokens: expectedTokens,
+              contextWindowMaxTokens: resolvedModel.endsWith("[1m]") ? 1_000_000 : 200_000,
+            }),
           }),
         );
       }

packages/server/src/server/agent/providers/claude/agent.context-window.test.ts

@@ -0,0 +1,112 @@
+import { expect, test } from "vitest";
+import { createTestLogger } from "../../../../test-utils/test-logger.js";
+import { collectSessionTurnEvents } from "../test-utils/session-stream-adapter.js";
+import { ClaudeAgentClient } from "./agent.js";
+import type { ClaudeQueryFactory } from "./query.js";
+
+// A query dependency that speaks the same stream interface as Claude Code.
+// Each request repeats init so a second turn exercises runtime-limit retention.
+function contextQuery(runtimeModel: string, reportedLimit: number): ClaudeQueryFactory {
+  return ({ prompt }) => {
+    let model = runtimeModel;
+    const messages = (async function* () {
+      if (typeof prompt === "string") throw new Error("Expected streaming input");
+      for await (const _message of prompt) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: "context-session",
+          permissionMode: "default",
+          model,
+        };
+        yield {
+          type: "stream_event",
+          session_id: "context-session",
+          event: { type: "message_start", message: { usage: { input_tokens: 249_950 } } },
+        };
+        yield {
+          type: "stream_event",
+          session_id: "context-session",
+          event: { type: "message_delta", usage: { output_tokens: 50 } },
+        };
+        yield {
+          type: "result",
+          subtype: "success",
+          session_id: "context-session",
+          duration_ms: 1,
+          duration_api_ms: 1,
+          is_error: false,
+          num_turns: 1,
+          result: "done",
+          stop_reason: null,
+          total_cost_usd: 0,
+          usage: { input_tokens: 249_950, output_tokens: 50, cache_read_input_tokens: 0 },
+          modelUsage: { [model]: { contextWindow: reportedLimit } },
+          permission_denials: [],
+          uuid: "context-result",
+        };
+      }
+    })();
+    return Object.assign(messages, {
+      close: () => {
+        void messages.return();
+      },
+      interrupt: async () => undefined,
+      setModel: async (value: string) => {
+        model = value;
+      },
+      setPermissionMode: async () => undefined,
+      supportedModels: async () => [],
+      supportedCommands: async () => [],
+    }) as ReturnType<ClaudeQueryFactory>;
+  };
+}
+
+test.each([
+  { selected: "glm-5.2[1m]", runtime: "glm-5.2[1m]", expected: 1_000_000 },
+  { selected: "sonnet", runtime: "glm-5.2[1m]", expected: 1_000_000 },
+  { selected: "glm-5.2", runtime: "glm-5.2", expected: undefined },
+])(
+  "streams the context limit for $selected resolved as $runtime",
+  async ({ selected, runtime, expected }) => {
+    const client = new ClaudeAgentClient({
+      logger: createTestLogger(),
+      queryFactory: contextQuery(runtime, 800_000),
+      resolveBinary: async () => process.execPath,
+    });
+    const session = await client.createSession({
+      provider: "claude",
+      cwd: process.cwd(),
+      model: selected,
+    });
+    try {
+      const first = await collectSessionTurnEvents(session, "first turn");
+      const live = first.filter((event) => event.type === "usage_updated");
+      expect(live.map((event) => event.usage.contextWindowMaxTokens)).toEqual([expected, expected]);
+      expect(live.map((event) => event.usage.contextWindowUsedTokens)).toEqual([249_950, 250_000]);
+      expect(first).toContainEqual(
+        expect.objectContaining({
+          type: "turn_completed",
+          usage: expect.objectContaining({ contextWindowMaxTokens: 800_000 }),
+        }),
+      );
+
+      const second = await collectSessionTurnEvents(session, "second turn");
+      expect(
+        second
+          .filter((event) => event.type === "usage_updated")
+          .map((event) => event.usage.contextWindowMaxTokens),
+      ).toEqual([800_000, 800_000]);
+
+      await session.setModel?.("another-custom-model");
+      const switched = await collectSessionTurnEvents(session, "after model switch");
+      expect(
+        switched
+          .filter((event) => event.type === "usage_updated")
+          .map((event) => event.usage.contextWindowMaxTokens),
+      ).toEqual([undefined, undefined]);
+    } finally {
+      await session.close();
+    }
+  },
+);

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

@@ -2805,6 +2805,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 150,
           },
         }),
@@ -2840,7 +2841,13 @@ describe("ClaudeAgentSession context window usage", () => {
 
   test("selected 1M Claude models seed active context window usage from the catalog", async () => {
     const session = await createSessionForTurns(
-      [[createInitMessage(), createMessageStartEvent(), createSuccessResult()]],
+      [
+        [
+          { ...createInitMessage(), model: "claude-sonnet-5[1m]" },
+          createMessageStartEvent(),
+          createSuccessResult(),
+        ],
+      ],
       { model: "claude-sonnet-5[1m]" },
     );
 
@@ -2880,6 +2887,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 175,
           },
         }),
@@ -2922,6 +2930,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 20_300,
           },
         }),
@@ -2963,6 +2972,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 1_069,
           },
         }),
@@ -3026,6 +3036,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 55,
           },
         }),
@@ -3035,6 +3046,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 62,
           },
         }),
@@ -3072,6 +3084,7 @@ describe("ClaudeAgentSession context window usage", () => {
           type: "usage_updated",
           provider: "claude",
           usage: {
+            contextWindowMaxTokens: 200_000,
             contextWindowUsedTokens: 704,
           },
         }),

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

@@ -31,7 +31,7 @@ import {
   readTaskNotificationToolUseIdFromHistoryRecord,
 } from "./task-notification-tool-call.js";
 import {
-  findClaudeModel,
+  getClaudeContextWindowMaxTokens,
   getClaudeModelsWithSettings,
   normalizeClaudeRuntimeModelId,
   resolveConfiguredClaudeModel,
@@ -2240,7 +2240,7 @@ class ClaudeAgentSession implements AgentSession {
     this.resolveBinary = options.resolveBinary;
     this.rewindSdk = options.rewindSdk ?? realClaudeRewindSdk;
     this.contextUsage = new ClaudeContextUsageState(
-      findClaudeModel(this.config.model)?.contextWindowMaxTokens,
+      getClaudeContextWindowMaxTokens(this.config.model),
     );
     const handle = options.handle;
 
@@ -2572,7 +2572,7 @@ class ClaudeAgentSession implements AgentSession {
       await this.applyFastModeFeature(false, activeQuery);
     }
     this.contextUsage.setInitialContextWindowMaxTokens(
-      findClaudeModel(this.config.model)?.contextWindowMaxTokens,
+      getClaudeContextWindowMaxTokens(this.config.model),
     );
     this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
     this.lastRuntimeModel = null;
@@ -4821,6 +4821,12 @@ class ClaudeAgentSession implements AgentSession {
     this.observePermissionMode(message.permissionMode);
     this.persistence = null;
     if (message.model) {
+      const runtimeContextWindowMaxTokens = getClaudeContextWindowMaxTokens(message.model);
+      // Seed usage before the first result, including settings-resolved aliases.
+      // A repeated init for the same model must retain the SDK's reported limit.
+      if (message.model !== this.lastRuntimeModel && runtimeContextWindowMaxTokens !== undefined) {
+        this.contextUsage.setInitialContextWindowMaxTokens(runtimeContextWindowMaxTokens);
+      }
       const normalizedRuntimeModel = normalizeClaudeRuntimeModelId(message.model);
       this.logger.debug(
         { runtimeModel: message.model, normalizedRuntimeModel },

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

@@ -15,7 +15,27 @@ import {
 } from "./model-manifest.js";
 import { discoverClaudeModels } from "./model-discovery.js";
 import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
-import { findClaudeModel, getClaudeModels, normalizeClaudeRuntimeModelId } from "./models.js";
+import {
+  findClaudeModel,
+  getClaudeContextWindowMaxTokens,
+  getClaudeModels,
+  normalizeClaudeRuntimeModelId,
+} from "./models.js";
+
+describe("getClaudeContextWindowMaxTokens", () => {
+  it.each([
+    ["glm-5.2[1m]", 1_000_000],
+    [" glm-5.2[1M] ", 1_000_000],
+    ["claude-sonnet-4-6", 200_000],
+    ["claude-sonnet-4-6[1m]", 1_000_000],
+    ["glm-5.2", undefined],
+    ["glm-5.2[1m]-other", undefined],
+    [undefined, undefined],
+    [null, undefined],
+  ])("resolves %s to %s without guessing unknown models", (model, expected) => {
+    expect(getClaudeContextWindowMaxTokens(model)).toBe(expected);
+  });
+});
 
 const createdClaudeConfigDirs: string[] = [];
 

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

@@ -48,6 +48,15 @@ export function findClaudeModel(
   return getClaudeModels().find((model) => model.id === normalizedModelId);
 }
 
+export function getClaudeContextWindowMaxTokens(
+  modelId: string | null | undefined,
+): number | undefined {
+  if (modelId?.trim().toLowerCase().endsWith("[1m]")) {
+    return 1_000_000;
+  }
+  return findClaudeModel(modelId)?.contextWindowMaxTokens;
+}
+
 export async function getClaudeModelsWithSettings(
   logger: Logger,
   configDir: string,

packages/server/src/server/agent/providers/generic-acp-agent.archived-history.test.ts

@@ -1,4 +1,4 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
@@ -68,8 +68,60 @@ describe("GenericACPAgentClient archived history", () => {
       ).rejects.toThrow("ENOENT");
     });
   });
+
+  test("releases the provider process once an archived session's history is replayed", async () => {
+    await withFakeACPAgent(async ({ command, removedCwd, pidPath }) => {
+      const client = new GenericACPAgentClient({ logger: createTestLogger(), command });
+
+      const session = await client.resumeSession(
+        { provider: "acp", sessionId: "archived-session", metadata: { cwd: removedCwd } },
+        undefined,
+        undefined,
+        { purpose: "history" },
+      );
+      try {
+        const pid = Number(await readFile(pidPath, "utf8"));
+        expect(isProcessAlive(pid)).toBe(false);
+        expect(await collectTimelineText(session.streamHistory())).toEqual([
+          "user_message:What is in the README?",
+          "assistant_message:It describes the project.",
+        ]);
+      } finally {
+        await session.close();
+      }
+    });
+  });
+
+  test("keeps the provider process for an interactive resume", async () => {
+    await withFakeACPAgent(async ({ command, removedCwd, pidPath }) => {
+      await mkdir(removedCwd, { recursive: true });
+      const client = new GenericACPAgentClient({ logger: createTestLogger(), command });
+
+      const session = await client.resumeSession(
+        { provider: "acp", sessionId: "archived-session", metadata: { cwd: removedCwd } },
+        undefined,
+        undefined,
+        { purpose: "interactive" },
+      );
+      try {
+        const pid = Number(await readFile(pidPath, "utf8"));
+        expect(isProcessAlive(pid)).toBe(true);
+      } finally {
+        await session.close();
+      }
+    });
+  });
 });
 
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function collectTimelineText(events: AsyncGenerator<AgentStreamEvent>): Promise<string[]> {
   const text: string[] = [];
   for await (const event of events) {
@@ -88,17 +140,20 @@ async function withFakeACPAgent(
     command: [string, ...string[]];
     removedCwd: string;
     loadRequestsPath: string;
+    pidPath: string;
   }) => Promise<void>,
 ): Promise<void> {
   const testDir = await mkdtemp(path.join(tmpdir(), "paseo-acp-archived-history-"));
   try {
     const scriptPath = path.join(testDir, "fake-acp-agent.cjs");
     const loadRequestsPath = path.join(testDir, "load-requests.json");
+    const pidPath = path.join(testDir, "agent.pid");
     await writeFile(scriptPath, fakeACPAgentScript, "utf8");
     await run({
-      command: [process.execPath, scriptPath, loadRequestsPath],
+      command: [process.execPath, scriptPath, loadRequestsPath, pidPath],
       removedCwd: path.join(testDir, "removed-worktree"),
       loadRequestsPath,
+      pidPath,
     });
   } finally {
     await rm(testDir, { recursive: true, force: true });
@@ -110,6 +165,10 @@ const fs = require("node:fs");
 const readline = require("node:readline");
 
 const loadRequestsPath = process.argv[2];
+const pidPath = process.argv[3];
+if (pidPath) {
+  fs.writeFileSync(pidPath, String(process.pid));
+}
 const loadRequests = [];
 const rl = readline.createInterface({ input: process.stdin });
 

packages/server/src/server/daemon-e2e/filesystem.e2e.test.ts

@@ -1,7 +1,16 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync, symlinkSync, readdirSync } from "fs";
+import { describe, test, expect, beforeEach, afterEach, onTestFinished } from "vitest";
+import {
+  mkdtempSync,
+  writeFileSync,
+  rmSync,
+  mkdirSync,
+  symlinkSync,
+  readdirSync,
+  readlinkSync,
+} from "fs";
 import { tmpdir } from "os";
 import path from "path";
+import { execFileSync } from "node:child_process";
 import { createDaemonTestContext, type DaemonTestContext } from "../test-utils/index.js";
 
 function tmpCwd(): string {
@@ -387,6 +396,84 @@ describe("file explorer", () => {
     }
   });
 
+  test.skipIf(process.platform === "win32")(
+    "duplicating a folder keeps relative symlinks inside the copy",
+    async () => {
+      const cwd = tmpCwd();
+      try {
+        mkdirSync(path.join(cwd, "template"));
+        writeFileSync(path.join(cwd, "template", "data.txt"), "original payload\n");
+        symlinkSync("data.txt", path.join(cwd, "template", "alias.txt"));
+
+        const duplicated = await ctx.client.duplicateFileEntry({ cwd, path: "template" });
+        expect(duplicated).toMatchObject({
+          duplicatedPath: "template copy",
+          success: true,
+          error: null,
+        });
+        expect(readlinkSync(path.join(cwd, "template copy", "alias.txt"))).toBe("data.txt");
+
+        const copiedTarget = await ctx.client.readFile(cwd, "template copy/data.txt");
+        const targetWrite = await ctx.client.writeFile({
+          cwd,
+          path: "template copy/data.txt",
+          content: "copy payload\n",
+          expectedModifiedAt: copiedTarget.modifiedAt,
+          expectedRevision: copiedTarget.revision,
+        });
+        expect(targetWrite.status).toBe("written");
+        const copiedAlias = await ctx.client.readFile(cwd, "template copy/alias.txt");
+        expect(new TextDecoder().decode(copiedAlias.bytes)).toBe("copy payload\n");
+
+        const aliasWrite = await ctx.client.writeFile({
+          cwd,
+          path: "template copy/alias.txt",
+          content: "edited through copied alias\n",
+          expectedModifiedAt: copiedAlias.modifiedAt,
+          expectedRevision: copiedAlias.revision,
+        });
+        expect(aliasWrite.status).toBe("written");
+        const original = await ctx.client.readFile(cwd, "template/data.txt");
+        expect(new TextDecoder().decode(original.bytes)).toBe("original payload\n");
+        const editedCopy = await ctx.client.readFile(cwd, "template copy/data.txt");
+        expect(new TextDecoder().decode(editedCopy.bytes)).toBe("edited through copied alias\n");
+
+        const deleted = await ctx.client.deleteFileEntry({ cwd, path: "template" });
+        expect(deleted).toMatchObject({ success: true, error: null });
+        const survivingAlias = await ctx.client.readFile(cwd, "template copy/alias.txt");
+        expect(new TextDecoder().decode(survivingAlias.bytes)).toBe(
+          "edited through copied alias\n",
+        );
+      } finally {
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+  );
+
+  test.skipIf(process.platform === "win32")(
+    "duplicating a file symlink preserves an explicit absolute target",
+    async () => {
+      const cwd = tmpCwd();
+      const targetPath = path.join(cwd, "data.txt");
+      try {
+        writeFileSync(targetPath, "absolute target payload\n");
+        symlinkSync(targetPath, path.join(cwd, "alias.txt"));
+
+        const duplicated = await ctx.client.duplicateFileEntry({ cwd, path: "alias.txt" });
+        expect(duplicated).toMatchObject({
+          duplicatedPath: "alias copy.txt",
+          success: true,
+          error: null,
+        });
+        expect(readlinkSync(path.join(cwd, "alias copy.txt"))).toBe(targetPath);
+        const copy = await ctx.client.readFile(cwd, "alias copy.txt");
+        expect(new TextDecoder().decode(copy.bytes)).toBe("absolute target payload\n");
+      } finally {
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+  );
+
   test("lists directory contents", async () => {
     const cwd = tmpCwd();
 
@@ -489,3 +576,63 @@ describe("file explorer", () => {
     rmSync(cwd, { recursive: true, force: true });
   }, 60000); // 1 minute timeout
 });
+
+describe("commit file diffs", () => {
+  test.each([".", "apps/web"])("opens committed files from %s workspaces", async (relativePath) => {
+    const cwd = tmpCwd();
+    onTestFinished(() =>
+      rmSync(cwd, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }),
+    );
+    const workspace = path.join(cwd, relativePath);
+    const filePath = "apps/web/notes.txt";
+    function git(args: string[]): string {
+      return execFileSync("git", args, { cwd, encoding: "utf8" });
+    }
+    git(["init", "-b", "main"]);
+    git(["config", "user.name", "Test"]);
+    git(["config", "user.email", "test@example.com"]);
+    git(["config", "core.autocrlf", "false"]);
+    mkdirSync(path.join(cwd, "apps", "web"), { recursive: true });
+    writeFileSync(path.join(cwd, filePath), "before\n");
+    writeFileSync(path.join(cwd, "apps/web/untouched.txt"), "unchanged\n");
+    git(["add", "."]);
+    git(["-c", "commit.gpgsign=false", "commit", "-m", "initial"]);
+    git(["checkout", "-b", "feature"]);
+    writeFileSync(path.join(cwd, filePath), "after\n");
+    git(["add", "."]);
+    git(["-c", "commit.gpgsign=false", "commit", "-m", "edit"]);
+    const sha = git(["rev-parse", "HEAD"]).trim();
+
+    const history = await ctx.client.listCheckoutCommits(workspace);
+    const commit = history.commits.find((entry) => entry.sha === sha);
+    expect(commit?.files).toEqual([
+      { path: filePath, additions: 1, deletions: 1, status: "modified" },
+    ]);
+    const result = await ctx.client.getCommitFileDiff(workspace, sha, filePath);
+    expect(result).toEqual({
+      file: {
+        path: filePath,
+        isNew: false,
+        isDeleted: false,
+        additions: 1,
+        deletions: 1,
+        hunks: [
+          {
+            oldStart: 1,
+            oldCount: 1,
+            newStart: 1,
+            newCount: 1,
+            lines: [
+              { type: "header", content: "@@ -1 +1 @@" },
+              { type: "remove", content: "before" },
+              { type: "add", content: "after" },
+            ],
+          },
+        ],
+      },
+    });
+    expect(await ctx.client.getCommitFileDiff(workspace, sha, "apps/web/untouched.txt")).toEqual({
+      file: null,
+    });
+  });
+});

packages/server/src/server/daemon-e2e/project-becomes-git.e2e.test.ts

@@ -1,6 +1,6 @@
 import { execFile as execFileCallback } from "node:child_process";
 import { mkdtempSync, realpathSync } from "node:fs";
-import { readFile, rm } from "node:fs/promises";
+import { readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -63,10 +63,12 @@ test("an empty project becomes Git without changing its identity or creating a w
   cleanupClients.add(client);
   await client.connect();
   await client.fetchAgents({ subscribe: {} });
+  const projectEvents = client.observeEvents(["project.update"]);
+  await projectEvents.ready;
 
   const added = await client.addProject(projectRoot);
 
-  expect(added).toEqual({
+  expect(added).toMatchObject({
     requestId: expect.any(String),
     project: {
       projectId: expect.stringMatching(/^prj_[0-9a-f]{16}$/),
@@ -77,7 +79,11 @@ test("an empty project becomes Git without changing its identity or creating a w
     },
     error: null,
   });
-  const project = added.project!;
+  const {
+    projectIconRevision: _icon,
+    projectCustomIconRevision: _customIcon,
+    ...project
+  } = added.project!;
   const beforeGitInit = await client.fetchWorkspaces({ filter: { projectId: project.projectId } });
   expect(beforeGitInit).toMatchObject({ entries: [], emptyProjects: [project] });
 
@@ -96,15 +102,15 @@ test("an empty project becomes Git without changing its identity or creating a w
     label: "project.update after git init",
   });
 
-  expect(update).toEqual({
+  expect(update).toMatchObject({
     kind: "upsert",
-    project: { ...project, projectKind: "git" },
+    project: { ...project, projectKind: "git", projectKey: expect.any(String) },
   });
 
   const afterGitInit = await client.fetchWorkspaces({ filter: { projectId: project.projectId } });
   expect(afterGitInit).toMatchObject({
     entries: [],
-    emptyProjects: [{ ...project, projectKind: "git" }],
+    emptyProjects: [{ ...project, projectKind: "git", projectKey: expect.any(String) }],
   });
 
   const persistedProjects = JSON.parse(
@@ -119,5 +125,72 @@ test("an empty project becomes Git without changing its identity or creating a w
     createdAt: expect.any(String),
     updatedAt: expect.any(String),
     archivedAt: null,
+    projectKey: expect.any(String),
+    customIconRevision: null,
   });
 }, 30_000);
+
+test("a failed worktree attempt before git init does not prevent creation afterward", async () => {
+  const projectRoot = realpathSync(mkdtempSync(path.join(os.tmpdir(), "paseo-init-worktree-")));
+  const paseoHomeRoot = realpathSync(mkdtempSync(path.join(os.tmpdir(), "paseo-init-home-")));
+  cleanupPaths.add(projectRoot);
+  cleanupPaths.add(paseoHomeRoot);
+  await writeFile(path.join(projectRoot, "README.md"), "hi\n");
+
+  const daemon = await createTestPaseoDaemon({ paseoHomeRoot, cleanup: false });
+  cleanupDaemons.add(daemon);
+  const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+  cleanupClients.add(client);
+  await client.connect();
+  await client.fetchAgents({ subscribe: {} });
+  const projectEvents = client.observeEvents(["project.update"]);
+  await projectEvents.ready;
+  const added = await client.addProject(projectRoot);
+  expect(added.project?.projectKind).toBe("non_git");
+  const source = {
+    kind: "worktree" as const,
+    cwd: projectRoot,
+    projectId: added.project!.projectId,
+    action: "branch-off" as const,
+    refName: "main",
+    branchName: "after-init",
+    worktreeSlug: "after-init",
+  };
+  const before = await client.createWorkspace({ source });
+  expect(before.error).toBe("Create worktree requires a git repository");
+
+  const gitProjectUpdate = waitForProjectUpdate(
+    client,
+    (payload) =>
+      payload.kind === "upsert" &&
+      payload.project.projectId === added.project!.projectId &&
+      payload.project.projectKind === "git",
+  );
+  await execFile("git", ["init", "-b", "main"], { cwd: projectRoot });
+  await execFile("git", ["add", "README.md"], { cwd: projectRoot });
+  await execFile(
+    "git",
+    [
+      "-c",
+      "user.name=Paseo Test",
+      "-c",
+      "user.email=test@getpaseo.dev",
+      "-c",
+      "commit.gpgSign=false",
+      "commit",
+      "-m",
+      "initial",
+    ],
+    { cwd: projectRoot },
+  );
+  await withTimeout({ promise: gitProjectUpdate, timeoutMs: 10_000, label: "project becomes Git" });
+  const projects = await client.fetchWorkspaces({
+    filter: { projectId: added.project!.projectId },
+  });
+  expect(projects.emptyProjects[0]?.projectKind).toBe("git");
+
+  const created = await client.createWorkspace({ source });
+  expect(created.error).toBeNull();
+  expect(created.workspace?.workspaceKind).toBe("worktree");
+  expect(created.workspace?.projectId).toBe(added.project!.projectId);
+}, 30_000);

packages/server/src/server/file-explorer/service.ts

@@ -669,6 +669,7 @@ export async function duplicateExplorerEntry({
       errorOnExist: true,
       force: false,
       preserveTimestamps: true,
+      verbatimSymlinks: true,
     });
     return { status: "ok", path: normalizeRelativePath({ root, targetPath }) };
   } catch (error) {

packages/server/src/server/file-observer/index.test.ts

@@ -236,7 +236,8 @@ test("observes a thousand concurrent writes and remains healthy after delete and
   const deletions = expectFileChanges(removedPaths, "delete");
   const movedFiles = expectFileChanges(movedPaths);
   const recovery = expectFileChanges([sentinel]);
-  const subscription = await subscribeToFileChanges(root, (error, events) => {
+  const observer = createObserver();
+  const subscription = await observer.subscribe(root, (error, events) => {
     expect(error).toBeNull();
     for (const event of events) {
       population.record(event);
@@ -254,9 +255,18 @@ test("observes a thousand concurrent writes and remains healthy after delete and
   await Promise.all(paths.map((path, index) => writeFile(path, `${index}`)));
   await writes.complete;
 
-  // A native watcher may recover coalesced paths through its safety audit.
-  // Completion comes from the delivered deletions, not an idle diagnostic or
-  // a deadline shorter than that recovery cycle.
+  // The first notice for each write can arrive before its remaining
+  // classifications. Drain those deliveries before starting a separate deletion
+  // phase, so a late create cannot coalesce with the expected delete as update.
+  await expect
+    .poll(() => observer.getDiagnostics(), { timeout: 10_000 })
+    .toMatchObject({
+      pendingEventCount: 0,
+      pendingClassificationCount: 0,
+      reconciliationInFlightCount: 0,
+    });
+
+  // Completion still requires the delivered deletion notices.
   await Promise.all(removedPaths.map((path) => rm(path)));
   await deletions.complete;
 

packages/server/src/server/plugins/plugin-paseo-api.e2e.test.ts

@@ -1,3 +1,7 @@
+import { createRequire } from "node:module";
+import { runInNewContext } from "node:vm";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
 import { EventEmitter, once } from "node:events";
 import { resolveDaemonVersion } from "../daemon-version.js";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
@@ -15,6 +19,59 @@ afterEach(async () => {
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
+test.each(["React Native", "native"])(
+  "provider readiness works with %s AbortController",
+  async (runtime) => {
+    const require = createRequire(import.meta.url);
+    const reactNativeRequire = createRequire(require.resolve("react-native/package.json"));
+    const { AbortController: ReactNativeAbortController } = reactNativeRequire(
+      "abort-controller/dist/abort-controller",
+    );
+    const bundle = await build({
+      entryPoints: [fileURLToPath(new URL("../../../../client/src/index.ts", import.meta.url))],
+      bundle: true,
+      write: false,
+      format: "iife",
+      globalName: "paseoSdk",
+      platform: "browser",
+    });
+    // A separate runtime starts with React Native's real abort implementation.
+    // Node's globals and the daemon's runtime remain unchanged.
+    const sdk: typeof import("@getpaseo/client") = runInNewContext(
+      `${bundle.outputFiles[0]!.text}\npaseoSdk`,
+      {
+        AbortController: runtime === "React Native" ? ReactNativeAbortController : AbortController,
+        setTimeout,
+        clearTimeout,
+        queueMicrotask,
+        TextEncoder,
+        TextDecoder,
+      },
+    );
+    const daemon = await createTestPaseoDaemon({ mcpEnabled: false });
+    const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+    const api = sdk.createPaseoApi(client);
+    try {
+      await client.connect();
+      const snapshot = await api.providers.waitForReady({ cwd: daemon.staticDir });
+      expect(snapshot.entries.length).toBeGreaterThan(0);
+      expect(snapshot.entries.every((entry) => entry.status !== "loading")).toBe(true);
+      const waiting = api.providers.waitForReady({ cwd: daemon.staticDir });
+      const canceled = expect(waiting).rejects.toThrow(/disposed|released/);
+      await api.dispose();
+      await canceled;
+      const { diagnostic } = await client.collectDiagnostics();
+      expect(diagnostic).toContain("Source registrations: 0");
+      expect(diagnostic).toContain("Producer listeners: 0");
+      expect(() => api.providers.waitForReady()).toThrow("disposed");
+    } finally {
+      await api.dispose();
+      await client.close();
+      await daemon.close();
+    }
+  },
+);
+
 test("plugin handlers create workspaces and agents through their Paseo API", async () => {
   const pluginDirectory = await mkdtemp(path.join(tmpdir(), "paseo-api-plugin-"));
   const workspaceDirectory = await mkdtemp(path.join(tmpdir(), "paseo-api-workspace-"));

packages/server/src/server/utils/diff-highlighter.test.ts

@@ -625,6 +625,28 @@ describe("highlightDiffFromHunks", () => {
 });
 
 describe("highlightDiffWithFileContent", () => {
+  it("renders an Astro diff with an empty expression and keeps surrounding highlighting", async () => {
+    const diff = ASTRO_DIFF.replace("{title}", "{title} {}");
+    const file = parseDiff(diff)[0];
+    const highlighted = await highlightDiffWithFileContent(file, ".", {
+      oldFileContent:
+        '---\nconst title = "Hello";\n---\n<main class="page">\n  <h1>{title} {}</h1>\n</main>',
+      newFileContent:
+        '---\nconst title = "Hello, Astro";\n---\n<main class="page">\n  <h1>{title} {}</h1>\n</main>',
+    });
+
+    expect(highlighted.hunks[0].lines.find((line) => line.type === "add")?.tokens).toContainEqual({
+      text: '"Hello, Astro"',
+      style: "string",
+    });
+    expect(highlighted.hunks[0].lines.map(({ content }) => content)).toEqual(
+      file.hunks[0].lines.map(({ content }) => content),
+    );
+    expect(
+      highlightDiffFromHunks(file).hunks[0].lines.find((line) => line.type === "add")?.tokens,
+    ).toContainEqual({ text: '"Hello, Astro"', style: "string" });
+  });
+
   it("leaves files with an oversized line unhighlighted", async () => {
     const oversizedLine = `const payload = "${"x".repeat(10_001)}";`;
     const [file] = parseDiff(

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

@@ -63,6 +63,27 @@ afterEach(async () => {
   }
 });
 
+test("a fresh checkout read makes a newly initialized repository available to cached readers", async () => {
+  const root = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-checkout-init-")));
+  const repo = path.join(root, "repo");
+  mkdirSync(repo);
+  const service = new WorkspaceGitServiceImpl({
+    logger: pino({ enabled: false }),
+    paseoHome: path.join(root, "home"),
+  });
+  cleanup.push(async () => {
+    await service.dispose();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  expect((await service.getSnapshot(repo, { includeForge: false })).git.isGit).toBe(false);
+  execFileSync("git", ["init", "-b", "main"], { cwd: repo, stdio: "pipe" });
+
+  expect((await service.getCheckout(repo)).isGit).toBe(true);
+  const repoRoot = await service.resolveRepoRoot(repo);
+  expect(realpathSync.native(repoRoot)).toBe(realpathSync.native(repo));
+}, 30_000);
+
 test("recursive observation updates tracked state and prunes ignored storms", async () => {
   const tempDir = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-git-observation-")));
   const repoDir = path.join(tempDir, "repo");

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

@@ -765,6 +765,16 @@ export class WorkspaceGitServiceImpl implements WorkspaceGitService {
       worktreesRoot: this.worktreesRoot,
       logger: this.logger,
     });
+    const cached = this.peekSnapshot(normalizedCwd);
+    if (cached && cached.git.isGit !== status.isGit) {
+      // A fresh checkout read discovered a repository transition. Keep the
+      // shared snapshot current before exposing the new project capability.
+      await this.getSnapshot(normalizedCwd, {
+        force: true,
+        includeForge: false,
+        reason: "checkout-classification-changed",
+      });
+    }
     if (!status.isGit) {
       return checkoutLiteFromGitSnapshot(normalizedCwd, {
         isGit: false,

packages/server/src/utils/checkout-git.ts

@@ -2665,10 +2665,11 @@ export async function getCommitFileDiff({
   sha: string;
   path: string;
 }): Promise<ParsedDiffFile | null> {
+  const worktreeRoot = await requireGitWorktreeRoot(cwd);
   const { stdout } = await runGitCommand(
     ["show", sha, "--format=", "--diff-merges=first-parent", ...GIT_PATCH_FORMAT_ARGS, "--", path],
     {
-      cwd,
+      cwd: worktreeRoot,
       envOverlay: READ_ONLY_GIT_ENV,
     },
   );
@@ -2677,9 +2678,9 @@ export async function getCommitFileDiff({
     return null;
   }
 
-  const parsedFiles = await parseAndHighlightDiff(stdout, cwd, {
-    getOldFileContent: (file) => readGitFileContentAtRef(cwd, `${sha}^`, file.path),
-    getNewFileContent: (file) => readGitFileContentAtRef(cwd, sha, file.path),
+  const parsedFiles = await parseAndHighlightDiff(stdout, worktreeRoot, {
+    getOldFileContent: (file) => readGitFileContentAtRef(worktreeRoot, `${sha}^`, file.path),
+    getNewFileContent: (file) => readGitFileContentAtRef(worktreeRoot, sha, file.path),
   });
 
   // `--` scopes the diff to a single pathspec, so there is at most one real