fix(tree): refresh loaded branches on reconnect so they don't go stale (#159)

Third tree-sync finding (#8). On a socket reconnect after a missed-events gap
(laptop sleep / wifi blip), the resync only invalidated the ROOT sidebar query;
a move/rename/delete that happened INSIDE an already-loaded, expanded branch was
never reflected — the branch stayed stale until the user manually interacted.
(The #2 fix reconciles the root level; this covers the deeper loaded branches.)

- `treeModel.reconcileChildren(tree, parentId, fresh)`: replace a loaded
  branch's DIRECT children with the authoritative fresh set (drop removed, add
  new, reorder to server) while PRESERVING each surviving child's already-loaded
  grandchildren, so deeper expansion is not collapsed. An unloaded branch
  (children === undefined) is left untouched (lazy-load fetches it fresh).
- `loadedOpenBranchIds(tree, openIds)`: the branches a reconnect should refresh
  (open AND loaded). `fetchAllAncestorChildren(..., { fresh: true })` bypasses
  the 30-min sidebar cache so the reconcile sees current data (handler-order
  independent).
- space-tree: on socket `connect`, re-fetch + reconcile each open loaded branch
  of the active space (space-switch-guarded; an unloaded branch is skipped).

Tests: reconcileChildren (drop/add/reorder + preserve grandchildren + unloaded
no-op) and loadedOpenBranchIds (open+loaded only, skip unloaded, nested). The
pure logic is unit-tested; the live socket-reconnect round-trip is not
browser-automated (simulating a reconnect gap is impractical) — sidebar render +
expand were smoke-tested with no regression.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/client/src/features/page/tree/utils/utils.test.ts

@@ -7,6 +7,7 @@ import {
   openBranches,
   closeIds,
   mergeRootTrees,
+  loadedOpenBranchIds,
 } from "./utils";
 import type { IPage } from "@/features/page/types/page.types.ts";
 import type { SpaceTreeNode } from "@/features/page/tree/types.ts";
@@ -321,3 +322,41 @@ describe("mergeRootTrees (#159 #2 reconnect reconcile)", () => {
     expect(merged[0].name).toBe("NEW");
   });
 });
+
+describe("loadedOpenBranchIds (#159 #8 reconnect refresh targets)", () => {
+  function n(id: string, children?: SpaceTreeNode[]): SpaceTreeNode {
+    return {
+      id,
+      slugId: `slug-${id}`,
+      name: id.toUpperCase(),
+      icon: undefined,
+      position: "a0",
+      spaceId: "space-1",
+      parentPageId: null as unknown as string,
+      hasChildren: !!children,
+      children: children as SpaceTreeNode[],
+    };
+  }
+
+  it("returns OPEN branches whose children are loaded (array)", () => {
+    const tree = [n("a", [n("a1")]), n("b", [n("b1")])];
+    const ids = loadedOpenBranchIds(tree, new Set(["a"]));
+    expect(ids).toEqual(["a"]); // b is closed; a is open+loaded
+  });
+
+  it("skips an open branch whose children are NOT loaded (undefined)", () => {
+    const tree = [n("a")]; // children undefined
+    expect(loadedOpenBranchIds(tree, new Set(["a"]))).toEqual([]);
+  });
+
+  it("includes a loaded-but-empty open branch (a child may have been added during the gap)", () => {
+    const tree = [n("a", [])];
+    expect(loadedOpenBranchIds(tree, new Set(["a"]))).toEqual(["a"]);
+  });
+
+  it("walks nested open+loaded branches (deep chain refreshes every level)", () => {
+    const tree = [n("a", [n("a1", [n("a1a")])])];
+    const ids = loadedOpenBranchIds(tree, new Set(["a", "a1"]));
+    expect(ids.sort()).toEqual(["a", "a1"]);
+  });
+});