fix(routing): close root-fetch race + Starter editability + binding autosave

Five fixes pulled from a session-mapping debugging pass.

1. on_initialized retries list_roots(). The single-shot
   peer.list_roots() in the spawned init task had no retry. A transient
   transport blip left the session at PendingRoots forever, and
   roots-capable sessions saw only the meta tools. Loop with backoffs
   100ms / 300ms / 800ms / 2s / 5s = 6 attempts, ~8s budget, retrying
   only on transport errors (Ok([]) is a valid 'no folder open' answer
   the client will follow up with a roots/list_changed when it has one).

2. On-demand probe in list_tools / list_prompts / list_resources. If
   a roots-capable session hits a list request before its init
   list_roots() landed (the visible 'Claude shows only 4 meta tools
   after opening a new workspace' bug), fire a 300ms-budget probe
   here, populate session_roots, then resolve routing. SessionRootsRegistry
   gains claim_probe(sid, throttle) so a burst of three list calls
   doesn't fan out three upstream peer.list_roots() — only the first
   in any 1s window wins.

3. Migration 015 rewrites the *other* legacy seeded copy. Migration
   014 only caught the 'The fallback feature set for this space'
   variant set by space_repository.rs. The Default Space's row was
   seeded by migration 001 itself with 'Features automatically
   granted to all connected clients in this space' — directly the
   opposite of what's true under resolver v3. 015 rewrites that
   string with the same is_builtin + name + description guard so
   any operator-customized copy survives.

4. Starter FSes are editable. The two member-modification guards
   in commands/feature_set.rs (add_feature_set_member,
   set_feature_set_members) rejected feature_set_type='starter'
   because they only accepted 'default' and 'custom'. Result: the
   auto-seeded Starter FS was read-only — useless. Both guards now
   accept 'starter' (and keep 'default' as a legacy alias for any
   stale read pre-migration-013). Comment updated.

5. WorkspaceBinding autosave debounce + flush-on-close. Bumped
   debounce 600ms to 1500ms to coalesce multi-FS toggle bursts into
   one save. Stricter dedupe (compares against last-saved, not just
   initial — re-toggling A → B → A is a true no-op). Most importantly,
   pending edits now survive panel close: a separate unmount-only
   useEffect reads pendingPayloadRef and posts the IPC immediately
   if there's unsaved work, so closing the sheet right after typing
   no longer drops the change. Latest onSubmit / onSaveStatusChange
   are kept in refs so the unmount handler uses the freshest closures.

cargo check + clippy (-D warnings) + pnpm typecheck all clean.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

apps/desktop/src-tauri/src/commands/feature_set.rs

@@ -314,9 +314,14 @@ pub async fn add_feature_set_member(
         .map_err(|e| e.to_string())?
         .ok_or("Feature set not found")?;
 
-    // Only "default" and "custom" types can have their members modified
+    // Both Starter (auto-seeded) and Custom FeatureSets are member-driven
+    // and editable. Reject anything else — there are no other configurable
+    // types today, but the guard stays for forward compatibility.
+    // `'default'` is accepted as a legacy alias because `parse('default')`
+    // resolves to `Starter` and `as_str()` always emits `'starter'` post-
+    // migration 013, but older in-memory data could still surface it.
     let fs_type = feature_set.feature_set_type.as_str();
-    if fs_type != "default" && fs_type != "custom" {
+    if fs_type != "starter" && fs_type != "default" && fs_type != "custom" {
         return Err(format!(
             "Cannot modify members of '{}' type feature set",
             fs_type
@@ -453,12 +458,13 @@ pub async fn set_feature_set_members(
         .map_err(|e| e.to_string())?
         .ok_or("Feature set not found")?;
 
-    // Only "default" and "custom" types can have their members modified
-    // "all" grants everything automatically, "server-all" is also auto-computed
+    // Both Starter (auto-seeded) and Custom FeatureSets are member-driven
+    // and editable. `'default'` is accepted as a legacy alias for the same
+    // reason described in `add_feature_set_member` — see comment there.
     let fs_type = feature_set.feature_set_type.as_str();
-    if fs_type != "default" && fs_type != "custom" {
+    if fs_type != "starter" && fs_type != "default" && fs_type != "custom" {
         return Err(format!(
-            "Cannot modify members of '{}' type feature set. Only 'default' and 'custom' types are configurable.",
+            "Cannot modify members of '{}' type feature set. Only Starter and Custom FeatureSets are configurable.",
             fs_type
         ));
     }

apps/desktop/src/features/workspaces/WorkspacesPage.tsx

@@ -455,6 +455,23 @@ function formatFsList(names: string[]): string {
   return names.filter((n) => n && n.length > 0).join(' + ');
 }
 
+/**
+ * Structural equality between two binding inputs. The autosave effect
+ * uses this to skip writes when the user re-toggled their way back to
+ * the last-saved state — avoids spamming `WorkspaceBindingChanged` for
+ * a no-op edit. `feature_set_ids` order matters (it's the operator-
+ * chosen render order, not just a set), so we compare positionally.
+ */
+function sameBindingInput(
+  a: WorkspaceBindingInput,
+  b: { workspace_root: string; space_id: string; feature_set_ids: string[] }
+): boolean {
+  if (a.workspace_root.trim() !== b.workspace_root.trim()) return false;
+  if (a.space_id !== b.space_id) return false;
+  if (a.feature_set_ids.length !== b.feature_set_ids.length) return false;
+  return a.feature_set_ids.every((id, i) => id === b.feature_set_ids[i]);
+}
+
 function SegmentedFilter<T extends string>({
   value,
   onChange,
@@ -1638,35 +1655,75 @@ function BindingForm({
     }
   };
 
-  // Auto-save in edit mode — debounced, sequence-numbered to discard stale
-  // saves, and a no-op while the form's contents still match the initial
-  // values so just opening the panel doesn't fire a write.
+  // ---------- Autosave (edit mode) -----------------------------------------
+  //
+  // Debounced (1500 ms) so a burst of FS-toggle clicks coalesces into one
+  // save instead of firing N WorkspaceBindingChanged events back-to-back.
+  // Dedupe is against the **last successfully-saved** payload, not just
+  // `initial` — so re-toggling A → B → A is a no-op (back to last saved),
+  // and once a save lands the next idle window doesn't re-save the same
+  // values.
+  //
+  // Critical: the debounce timer is cleared on dependency change but the
+  // **pending payload survives panel close**. If the user edits then
+  // closes before the debounce fires, the unmount handler flushes the
+  // save synchronously to Tauri — the IPC goes out before React tears
+  // the component down, and the save completes in the background.
   const saveSeqRef = useRef(0);
   const savedTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Snapshot of the last payload we successfully wrote. `null` means
+  // "never saved during this panel session" — fall back to `initial` for
+  // dedupe in that case.
+  const lastSavedRef = useRef<WorkspaceBindingInput | null>(null);
+  // The most recent payload the user produced that has NOT yet been
+  // committed. Cleared on successful save. The unmount handler reads
+  // this to decide whether to flush.
+  const pendingPayloadRef = useRef<WorkspaceBindingInput | null>(null);
+  // Latest closures via ref so the unmount-only effect's empty-deps
+  // cleanup can still call the freshest handlers — closing the panel
+  // mid-edit must use the parent's *current* `onSubmit`, not whatever it
+  // captured on first mount.
+  const onSubmitRef = useRef(onSubmit);
+  const onSaveStatusChangeRef = useRef(onSaveStatusChange);
+  useEffect(() => {
+    onSubmitRef.current = onSubmit;
+    onSaveStatusChangeRef.current = onSaveStatusChange;
+  }, [onSubmit, onSaveStatusChange]);
+
   useEffect(() => {
     if (!isEdit || !initial) return;
-    const sameFs =
-      fsIds.length === initial.feature_set_ids.length &&
-      fsIds.every((id, i) => id === initial.feature_set_ids[i]);
-    const same =
-      root.trim() === initial.workspace_root &&
-      spaceId === initial.space_id &&
-      sameFs;
-    if (same) return;
     if (!canSubmit) return;
+
+    const candidate: WorkspaceBindingInput = {
+      workspace_root: root.trim(),
+      space_id: spaceId,
+      feature_set_ids: fsIds,
+    };
+
+    // Dedupe baseline: last-saved if we've saved during this session,
+    // otherwise the initial payload from when the panel opened.
+    const baseline = lastSavedRef.current ?? {
+      workspace_root: initial.workspace_root,
+      space_id: initial.space_id,
+      feature_set_ids: initial.feature_set_ids,
+    };
+    if (sameBindingInput(candidate, baseline)) {
+      pendingPayloadRef.current = null;
+      return;
+    }
+
+    pendingPayloadRef.current = candidate;
     const seq = ++saveSeqRef.current;
     onSaveStatusChange?.({ kind: 'idle' });
     const handle = setTimeout(async () => {
       if (saveSeqRef.current !== seq) return;
       onSaveStatusChange?.({ kind: 'saving' });
       setSubmitting(true);
       try {
-        await onSubmit({
-          workspace_root: root.trim(),
-          space_id: spaceId,
-          feature_set_ids: fsIds,
-        });
+        await onSubmit(candidate);
         if (saveSeqRef.current !== seq) return;
+        lastSavedRef.current = candidate;
+        pendingPayloadRef.current = null;
         onSaveStatusChange?.({ kind: 'saved' });
         if (savedTimerRef.current) clearTimeout(savedTimerRef.current);
         savedTimerRef.current = setTimeout(() => {
@@ -1680,7 +1737,7 @@ function BindingForm({
       } finally {
         setSubmitting(false);
       }
-    }, 600);
+    }, 1500);
     return () => clearTimeout(handle);
   }, [
     isEdit,
@@ -1694,6 +1751,36 @@ function BindingForm({
     onSaveStatusChange,
   ]);
 
+  // Unmount-only flush. If a save was scheduled but the timer hasn't
+  // fired by the time the user closes the panel, fire it now so their
+  // edits aren't silently dropped. Empty-deps so this only runs on
+  // unmount, not on every dep change of the autosave effect above.
+  useEffect(() => {
+    return () => {
+      const pending = pendingPayloadRef.current;
+      if (!pending) return;
+      // Fire-and-forget. Tauri's `invoke` posts the IPC message to the
+      // Rust side immediately; the React tree can unmount in parallel
+      // and the save still completes. Bump the seq so any in-flight
+      // debounced save from before the close is discarded if it lands.
+      saveSeqRef.current += 1;
+      onSaveStatusChangeRef.current?.({ kind: 'saving' });
+      onSubmitRef
+        .current(pending)
+        .then(() => {
+          onSaveStatusChangeRef.current?.({ kind: 'saved' });
+        })
+        .catch((e) => {
+          // Parent's toast bridge is gone with the panel — fall back to
+          // the console so the failure isn't silent in dev.
+          console.warn(
+            '[workspace-binding] flush-on-close save failed:',
+            e instanceof Error ? e.message : String(e)
+          );
+        });
+    };
+  }, []);
+
   const submitLabel =
     mode === 'create-from-live' ? 'Save binding' : 'Create binding';