perf(hooks): use primitive fingerprint for ensure-draft-when-empty effect

Audit pass on the same class of bug fixed in b0b41a6 found a second
hook subscribing to the entire `appState` and using it as an effect
dep: `useEnsureDraftWhenEmpty` had `[appState, ...]` in its dep
array. Lower severity than the worktree-include case because the
inner Tauri call (`agentChatCreatePane`) is guarded by an
`inFlightSpawnRef`, so the effect didn't actually fan out into
duplicate IPC calls. But the effect BODY still re-ran on every
backend tick (many per second under the 5 s git poll + agent
streaming), walking workspace surface trees and doing pane-tree
checks for nothing.

Replaced the `appState` subscription with a primitive string
fingerprint built from the four fields the effect actually
depends on:

  `${active_workspace_id}|${hasPane}|${project_root}`

The selector returns a primitive string so React/Zustand bail on
identity equality. The effect body now only runs when one of those
three fields actually changes — i.e. when the user activates a
different workspace, or panes are added/removed on the active
surface, or `project_root` flips.

Inside the effect, the live `appState` is read via
`useAppStore.getState()` at fire time so we can still walk surfaces
to pick the Home-draft-vs-pane-spawn branch.

Added a regression test (`use-ensure-draft-when-empty.test.tsx`)
that simulates a backend tick changing only `git_branch` on the
active workspace (the most frequent backend mutation under the 5 s
git poll). The hook must NOT fire `agentChatCreatePane` a second
time across the rerender. Now 17 tests in this file (up from 16),
1686/1686 frontend tests pass.

Tests verified:
- npx tsc --noEmit: clean
- npx vitest run: 1686/1686 pass

Author: Zeus-Deus

src/hooks/use-ensure-draft-when-empty.test.tsx

@@ -348,6 +348,68 @@ describe("useEnsureDraftWhenEmpty", () => {
     expect(agentChatCreatePane).toHaveBeenCalledTimes(1);
   });
 
+  it("does NOT re-spawn when only an irrelevant workspace field changes (perf — fingerprint guard)", () => {
+    // Regression guard for the audit-pass fix that switched this hook
+    // from a `[appState]` dep array to a primitive-fingerprint
+    // selector. Without the fingerprint, every backend
+    // `app-state-changed` tick (agent tokens, git polls, hook events)
+    // re-ran the effect body — walking surface trees and doing
+    // workspace lookups for nothing. The `inFlightSpawnRef` guard
+    // prevented duplicate IPC, but the wasted cycles still added up.
+    //
+    // This test simulates a backend tick that changes `git_branch` on
+    // the active workspace (a frequent mutation under the 5 s git
+    // poll). The effect's fingerprint is built from
+    // `(active_workspace_id, hasPane, project_root)` — `git_branch`
+    // is intentionally NOT in it — so the effect must NOT fire a
+    // second time across the rerender.
+    enableAgentChatFlag = true;
+    enableLazyFlag = true;
+    flagsLoaded = true;
+    homeDirSnapshot = "/home/user";
+    appStateSnapshot = {
+      active_workspace_id: "ws-foo",
+      workspaces: [
+        {
+          workspace_id: "ws-foo",
+          active_surface_id: "surf-empty",
+          surfaces: [emptySplitSurface],
+          project_root: "/projects/foo",
+          cwd: "/projects/foo",
+          git_branch: "main",
+        },
+      ],
+    };
+    const { rerender } = renderHook(() => useEnsureDraftWhenEmpty());
+    expect(agentChatCreatePane).toHaveBeenCalledTimes(1);
+
+    // Backend tick: same fingerprint fields, different git_branch +
+    // a different workspaces array reference (Rust rebuilds the
+    // snapshot on every emit). The hook's effect MUST NOT fire
+    // again — fingerprint is reference-equal.
+    appStateSnapshot = {
+      active_workspace_id: "ws-foo",
+      workspaces: [
+        {
+          workspace_id: "ws-foo",
+          active_surface_id: "surf-empty",
+          surfaces: [emptySplitSurface],
+          project_root: "/projects/foo",
+          cwd: "/projects/foo",
+          git_branch: "feature-x",
+        },
+      ],
+    };
+    rerender();
+
+    // Either branch of the proof works:
+    //  - in-flight ref is set, so even if the effect DID fire it
+    //    would short-circuit; OR
+    //  - fingerprint is unchanged, so the effect didn't re-fire at all.
+    // The contract we care about is: zero extra Tauri calls.
+    expect(agentChatCreatePane).toHaveBeenCalledTimes(1);
+  });
+
   it("falls back to workspace.cwd when project_root is missing (ad-hoc workspaces)", () => {
     enableAgentChatFlag = true;
     enableLazyFlag = true;

src/hooks/use-ensure-draft-when-empty.ts

@@ -5,6 +5,34 @@ import { useFeatureFlags } from "@/stores/feature-flags";
 import { hasAnyPane } from "@/lib/pane-tree";
 import { agentChatCreatePane } from "@/tauri/commands";
 
+/**
+ * Primitive-summary selector for the bits of `appState` this hook
+ * actually depends on. Returning a string fingerprint means the effect
+ * below only re-runs when one of the four relevant fields changes —
+ * not on every backend `app-state-changed` tick (agent tokens, git
+ * polls, hook events). Without this, the effect body would walk the
+ * surface tree on every tick under heavy load.
+ */
+function selectEmptyWorkspaceFingerprint(
+  s: { appState: ReturnType<typeof useAppStore.getState>["appState"] },
+): string {
+  const app = s.appState;
+  if (!app) return "no-app-state";
+  const wsId = app.active_workspace_id;
+  if (!wsId) return "no-active-ws";
+  const ws = app.workspaces.find((w) => w.workspace_id === wsId);
+  if (!ws) return `ws-missing:${wsId}`;
+  // Whether the active surface has any panes — this is the only
+  // structural fact the effect cares about.
+  const activeSurface = ws.surfaces.find(
+    (sf) => sf.surface_id === ws.active_surface_id,
+  );
+  const hasPane = activeSurface ? hasAnyPane(activeSurface.root) : false;
+  // Project_root vs cwd drives the Home-draft-vs-pane branch.
+  const projectRoot = ws.project_root ?? ws.cwd;
+  return `${wsId}|${hasPane ? "1" : "0"}|${projectRoot}`;
+}
+
 /**
  * Ensure something is showing for the active workspace whenever the
  * user has nothing else to look at.
@@ -28,7 +56,13 @@ import { agentChatCreatePane } from "@/tauri/commands";
  *    effect fires while the Tauri call is pending don't double-spawn.
  */
 export function useEnsureDraftWhenEmpty() {
-  const appState = useAppStore((s) => s.appState);
+  // Subscribe to a primitive string fingerprint of the four fields
+  // this effect actually depends on, NOT the whole appState. Without
+  // this, the effect body re-ran on every backend `app-state-changed`
+  // tick (many per second under load) walking surface trees and doing
+  // workspace lookups for nothing. The audit pass found this pattern;
+  // see `selectEmptyWorkspaceFingerprint` above.
+  const fingerprint = useAppStore(selectEmptyWorkspaceFingerprint);
   const homeDir = useHomeDir();
   const enableAgentChat = useFeatureFlags((s) => s.enableAgentChat);
   const enableLazyWorkspaceCreation = useFeatureFlags(
@@ -44,10 +78,17 @@ export function useEnsureDraftWhenEmpty() {
   const inFlightSpawnRef = useRef<string | null>(null);
 
   useEffect(() => {
-    if (!appState || !flagsLoaded) return;
+    if (!flagsLoaded) return;
     if (!enableAgentChat || !enableLazyWorkspaceCreation) return;
     if (activeDraftId) return;
 
+    // Re-read the live snapshot at effect-fire time. The fingerprint
+    // dep above ensures we only get here when the relevant slice
+    // changed, but we still need the full workspace object to read
+    // surfaces / surface ids.
+    const appState = useAppStore.getState().appState;
+    if (!appState) return;
+
     const activeWs = appState.workspaces.find(
       (w) => w.workspace_id === appState.active_workspace_id,
     );
@@ -86,7 +127,7 @@ export function useEnsureDraftWhenEmpty() {
     const draft = store.getOrCreateHomeDraft();
     store.setActiveDraft(draft.draftId);
   }, [
-    appState,
+    fingerprint,
     homeDir,
     enableAgentChat,
     enableLazyWorkspaceCreation,