Cache notes in one place, and serialise a project's writes

Implements the design spec's §2 — "notes cached in zustand keyed by
project id" — which the plan substituted with a hook-local `useState`.

Sharing the `NotesPanel` *component* between the Project Home sub-tab and
the dock did not share the *cache*. Both resolve to the same project, so
two panels mount two `useNotes(P)`, each with its own list. Edit a note
in the dock and blur; the tab's copy is still pre-edit, and the tab's
next blur commits `{...staleRecord, title, body}` — the dock's edit gone
from disk with no error and no indicator. That is the feature's own
primary workflow: take notes in the dock while the agent runs, which is
the reason the dock exists, then go back to the tab.

`notesByProject` plus a per-project in-flight flag now hold the list.
Both surfaces render from one array; two panels mounting for one project
make one read; and because the write is keyed by project, a response
that lands after the user has moved on updates the project it belongs to
rather than whichever is on screen. This is also the boundary §8 says a
detached notes window needs.

Three more bugs in the same code, fixed with it:

- Delete-after-edit could resurrect the note. Clicking Delete with the
  textarea focused fires blur first, so `save_note` and `delete_note` go
  out back to back; Rust's `write_lock` stops them interleaving but does
  not order them, and a delete that wins the lock is undone by the
  upsert behind it. A project's mutations now go through one promise
  chain, module-scoped for the reason `useTerminal`'s input queue is.
- An unsaved draft vanished when any other note was saved, because the
  re-read replaced the list with the backend's. "New note" now persists,
  so the backend owns the row from the start — chosen over merging local
  drafts because a local-only row in a *shared* cache would exist in the
  panel that made it and nowhere else.
- The save outcome was reported for the wrong project after a switch:
  the guard covered only the list replacement, so the new project's
  SaveIndicator flashed "Saved ✓" for the old project's write. The
  indicator now resets on a project change and reports only its own.

`NotesPanel` also re-seeds its draft when the *stored* text of the note
it has selected changes, so an edit made in the other surface reaches
the editor and not only the list. It never overwrites something
half-typed; that still blurs into a last-writer-wins save, as any
blur-commit editor does.

NotesPanel.shared.test.tsx is the configuration none of the existing
tests had: two panels, one project, the real hook. Four of its six
assertions fail against the previous implementation.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HjL1E2JFNctUqCYotUwqqb

app/src/components/notes/NotesPanel.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { useNotes } from "../../hooks/useNotes";
 import NoteEditor from "./NoteEditor";
 import Button from "../ui/Button";
@@ -30,22 +30,44 @@ export default function NotesPanel({ projectId }: Props) {
     [notes, selectedId],
   );
 
-  // Load the selected note's stored text into the draft. Keyed on the id, not
-  // the note object, so a save round trip does not stomp what is being typed.
+  // What was last copied out of the store into the draft fields. The draft is
+  // "untouched" exactly while it still matches this, which is how an edit made
+  // somewhere else can be shown without ever discarding something half-typed.
+  const seeded = useRef<{ id: string | null; title: string; body: string }>({
+    id: null,
+    title: "",
+    body: "",
+  });
+
+  // Load the selected note's stored text into the draft — on a change of note,
+  // and on a change to the *stored* text of the note already selected. The
+  // second case is the dock and the tab showing one project at once: an edit
+  // committed in one surface has to reach the other's editor, not just its
+  // list. It never overwrites text the user is part-way through typing; that
+  // blurs into a last-writer-wins save, as any blur-commit editor does.
   useEffect(() => {
     if (!selected) {
+      seeded.current = { id: null, title: "", body: "" };
       setTitle("");
       setBody("");
       return;
     }
-    setTitle(selected.title);
-    setBody(selected.body);
-  }, [selected?.id]); // eslint-disable-line react-hooks/exhaustive-deps
+    const untouched =
+      title === seeded.current.title && body === seeded.current.body;
+    if (seeded.current.id !== selected.id || untouched) {
+      seeded.current = { id: selected.id, title: selected.title, body: selected.body };
+      setTitle(selected.title);
+      setBody(selected.body);
+    }
+  }, [selected?.id, selected?.title, selected?.body]); // eslint-disable-line react-hooks/exhaustive-deps
 
   const commit = () => {
     if (!selected) return;
     // Reading is not editing: clicking through notes must not rewrite the file.
     if (title === selected.title && body === selected.body) return;
+    // Mark the draft as matching what was just committed, so the store update
+    // this save produces reads as "no change" rather than as a stale re-seed.
+    seeded.current = { id: selected.id, title, body };
     void saveNote({ ...selected, title, body });
   };