chore: update deps, fix pane size storage, harden claude sdk session

- bump dependencies in package.json and pnpm-lock.yaml
- add tests and fixes for renderer pane size storage
- update viewSlice for pane size handling
- harden claude sdkSession with additional tests and logic

Author: SDSLeon

package.json

@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",
-    "@anthropic-ai/claude-agent-sdk": "^0.2.139",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.142",
     "@chenglou/pretext": "^0.0.6",
     "@dnd-kit/abstract": "^0.4.0",
     "@dnd-kit/collision": "^0.4.0",
@@ -132,8 +132,8 @@
     "wait-on": "^9.0.4"
   },
   "optionalDependencies": {
-    "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.2.139",
-    "@anthropic-ai/claude-agent-sdk-win32-x64": "0.2.139"
+    "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.142",
+    "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.142"
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,mjs,cjs}": [

pnpm-lock.yaml

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  migratePaneSizeStorage,
+  readStoredSizes,
+  SPLIT_SIZE_STORAGE_PREFIX,
+  swapPaneIdsInStorage,
+  writeStoredSizes,
+} from "./paneSizeStorage";
+
+function key(axis: "vertical" | "horizontal", ids: string[]): string {
+  return `${SPLIT_SIZE_STORAGE_PREFIX}:${axis}:${ids.join("\0")}`;
+}
+
+describe("paneSizeStorage", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  describe("migratePaneSizeStorage", () => {
+    it("renames a single pane id in the storage key while preserving sizes", () => {
+      writeStoredSizes(key("vertical", ["draft-a", "thread-x"]), [70, 30]);
+      migratePaneSizeStorage("draft-a", "thread-a");
+      expect(readStoredSizes(key("vertical", ["draft-a", "thread-x"]), 2)).toEqual([50, 50]);
+      expect(readStoredSizes(key("vertical", ["thread-a", "thread-x"]), 2)).toEqual([70, 30]);
+    });
+
+    it("is a no-op when old and new ids are equal", () => {
+      writeStoredSizes(key("vertical", ["a", "b"]), [60, 40]);
+      migratePaneSizeStorage("a", "a");
+      expect(readStoredSizes(key("vertical", ["a", "b"]), 2)).toEqual([60, 40]);
+    });
+
+    it("leaves unrelated keys untouched", () => {
+      writeStoredSizes(key("vertical", ["a", "b"]), [70, 30]);
+      writeStoredSizes(key("vertical", ["c", "d"]), [25, 75]);
+      migratePaneSizeStorage("a", "z");
+      expect(readStoredSizes(key("vertical", ["z", "b"]), 2)).toEqual([70, 30]);
+      expect(readStoredSizes(key("vertical", ["c", "d"]), 2)).toEqual([25, 75]);
+    });
+  });
+
+  describe("swapPaneIdsInStorage", () => {
+    it("swaps two pane ids in a single split, preserving slot sizes", () => {
+      // Three panes [A, X, Y] sized 20/30/50. After swapping A and Y, the
+      // layout becomes [Y, X, A] but slot widths must stay 20/30/50 so the
+      // visual placements don't jump.
+      writeStoredSizes(key("vertical", ["A", "X", "Y"]), [20, 30, 50]);
+      swapPaneIdsInStorage("A", "Y");
+      expect(readStoredSizes(key("vertical", ["Y", "X", "A"]), 3)).toEqual([20, 30, 50]);
+      // Old key is gone.
+      expect(localStorage.getItem(key("vertical", ["A", "X", "Y"]))).toBeNull();
+    });
+
+    it("swaps pane ids across two different splits, preserving each slot's size", () => {
+      writeStoredSizes(key("vertical", ["A", "X", "Y"]), [20, 30, 50]);
+      writeStoredSizes(key("horizontal", ["P", "Q", "B"]), [40, 35, 25]);
+      swapPaneIdsInStorage("A", "B");
+      expect(readStoredSizes(key("vertical", ["B", "X", "Y"]), 3)).toEqual([20, 30, 50]);
+      expect(readStoredSizes(key("horizontal", ["P", "Q", "A"]), 3)).toEqual([40, 35, 25]);
+    });
+
+    it("is a no-op when the two ids are equal", () => {
+      writeStoredSizes(key("vertical", ["a", "b"]), [60, 40]);
+      swapPaneIdsInStorage("a", "a");
+      expect(readStoredSizes(key("vertical", ["a", "b"]), 2)).toEqual([60, 40]);
+    });
+
+    it("leaves keys that contain neither id untouched", () => {
+      writeStoredSizes(key("vertical", ["c", "d"]), [70, 30]);
+      swapPaneIdsInStorage("a", "b");
+      expect(readStoredSizes(key("vertical", ["c", "d"]), 2)).toEqual([70, 30]);
+    });
+  });
+});

src/renderer/components/layout/paneSizeStorage.test.ts

@@ -48,13 +48,16 @@ export function writeStoredSizes(key: string, sizes: number[]) {
 }
 
 /**
- * Rewrite split-size localStorage keys when a pane id changes (e.g., a draft
- * pane is replaced by the real thread id once the first message is sent).
- * Without this, the storage key — derived from the pane id list — no longer
- * matches and the user's custom proportions silently fall back to equal sizes.
+ * Rewrite split-size localStorage keys by remapping pane ids. The storage key
+ * encodes the full pane id list (in tree order), so any change to that list —
+ * a rename (draft → real thread id) or a swap (drag-to-replace pane reorder) —
+ * shifts the key. Without rewriting the stored entry, `readStoredSizes` falls
+ * back to equal sizes and the user's custom proportions are silently lost.
+ *
+ * Sizes are stored as a positional array; this only rewrites the *key*, so
+ * size-per-slot is preserved while the contents of those slots change.
  */
-export function migratePaneSizeStorage(oldPaneId: string, newPaneId: string): void {
-  if (oldPaneId === newPaneId) return;
+function remapPaneIdsInStorage(mapper: (paneId: string) => string): void {
   if (typeof localStorage === "undefined") return;
 
   const matchingKeys: string[] = [];
@@ -70,8 +73,8 @@ export function migratePaneSizeStorage(oldPaneId: string, newPaneId: string): vo
     if (axisSeparator === -1) continue;
     const idsPart = key.slice(axisSeparator + 1);
     const ids = idsPart.split(PANE_ID_SEPARATOR);
-    if (!ids.includes(oldPaneId)) continue;
-    const nextIds = ids.map((id) => (id === oldPaneId ? newPaneId : id));
+    const nextIds = ids.map(mapper);
+    if (nextIds.every((id, i) => id === ids[i])) continue;
     const nextKey = `${key.slice(0, axisSeparator + 1)}${nextIds.join(PANE_ID_SEPARATOR)}`;
     if (nextKey === key) continue;
     const value = localStorage.getItem(key);
@@ -84,3 +87,22 @@ export function migratePaneSizeStorage(oldPaneId: string, newPaneId: string): vo
     }
   }
 }
+
+export function migratePaneSizeStorage(oldPaneId: string, newPaneId: string): void {
+  if (oldPaneId === newPaneId) return;
+  remapPaneIdsInStorage((id) => (id === oldPaneId ? newPaneId : id));
+}
+
+/**
+ * Swap two pane ids in all split-size localStorage keys at once. Used when the
+ * user drags one pane onto another to swap positions: each slot keeps its size,
+ * only the pane id occupying that slot changes.
+ */
+export function swapPaneIdsInStorage(firstPaneId: string, secondPaneId: string): void {
+  if (firstPaneId === secondPaneId) return;
+  remapPaneIdsInStorage((id) => {
+    if (id === firstPaneId) return secondPaneId;
+    if (id === secondPaneId) return firstPaneId;
+    return id;
+  });
+}

src/renderer/components/layout/paneSizeStorage.ts

@@ -9,6 +9,7 @@ import {
   swapPaneIdsInLayout,
   type PaneLayoutInsertTarget,
 } from "@/shared/paneLayout";
+import { swapPaneIdsInStorage } from "@/renderer/components/layout/paneSizeStorage";
 import { reorderIds, type ReorderPlacement } from "../reorder";
 import {
   clearFinishedAndDone,
@@ -441,6 +442,10 @@ export const createViewSlice: SliceCreator<ViewSlice> = (set) => ({
       ) {
         return {};
       }
+      // Rewrite stored split sizes so each slot keeps its width after the swap.
+      // The storage key is derived from the pane id list, so the layout swap
+      // alone would shift the key and lose the user's custom proportions.
+      swapPaneIdsInStorage(firstPaneId, secondPaneId);
       const layout = swapPaneIdsInLayout(currentPaneLayout(state.view), firstPaneId, secondPaneId);
       return {
         view: {