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.ts

@@ -246,6 +246,29 @@ export function mergeRootTrees(
   return sortPositionKeys(reconciled);
 }
 
+/**
+ * Ids of branches a socket-reconnect refresh should re-fetch and reconcile
+ * (#159 #8): a node that is currently OPEN and whose children are LOADED
+ * (`children` is an array — possibly empty). An unloaded branch (`children ===
+ * undefined`) is skipped because lazy-load fetches it fresh on the next expand,
+ * so there is nothing stale to reconcile. Walks the whole tree (a deep open
+ * chain refreshes every loaded level).
+ */
+export function loadedOpenBranchIds(
+  tree: SpaceTreeNode[],
+  openIds: ReadonlySet<string>,
+): string[] {
+  const ids: string[] = [];
+  const walk = (nodes: SpaceTreeNode[]) => {
+    for (const n of nodes) {
+      if (openIds.has(n.id) && Array.isArray(n.children)) ids.push(n.id);
+      if (n.children) walk(n.children);
+    }
+  };
+  walk(tree);
+  return ids;
+}
+
 // Collect every node id in the tree (roots, branches, leaves). Used by
 // collapseAll to clear the open-state map for all current-space nodes.
 export function collectAllIds(nodes: SpaceTreeNode[]): string[] {