groove-dev 0.27.14 → 0.27.17

package/packages/gui/src/stores/groove.js

@@ -19,7 +19,7 @@ function persistJSON(key, value) {
 }
 
 // Clear stale persisted data on version change
-const STORE_VERSION = '0.22.27';
+const STORE_VERSION = '0.22.28';
 if (loadJSON('groove:storeVersion') !== STORE_VERSION) {
   localStorage.removeItem('groove:chatHistory');
   localStorage.removeItem('groove:activityLog');
@@ -42,12 +42,23 @@ export const useGrooveStore = create((set, get) => ({
   // ── Gateways ──────────────────────────────────────────────
   gateways: [],
 
+  // ── Federation ────────────────────────────────────────────
+  federation: {
+    peers: [],
+    whitelist: [],
+    connections: [],
+    pouchLog: [],
+    ambassadors: [],
+    selectedPeerId: null,
+  },
+
   // ── Navigation ────────────────────────────────────────────
   activeView: 'agents',           // 'agents' | 'editor' | 'dashboard' | 'marketplace' | 'teams' | 'settings'
   detailPanel: null,              // null | { type: 'agent', agentId } | { type: 'spawn' } | { type: 'journalist' }
   teamDetailPanels: {},            // { [teamId]: detailPanel } — persists panel state per team
   commandPaletteOpen: false,
   quickConnectOpen: false,
+  upgradeModalOpen: false,
 
   // ── Node expansion (click-to-open persistent panels) ───────
   expandedNodes: loadJSON('groove:expandedNodes'),
@@ -70,6 +81,7 @@ export const useGrooveStore = create((set, get) => ({
 
   // ── Recommended Team ──────────────────────────────────────
   recommendedTeam: null,  // { name, agents: [...] } from planner
+  _delegatingTeamIds: new Set(),
 
   // ── Journalist ────────────────────────────────────────────
   journalistStatus: null, // { cycleCount, lastCycleTime, history, lastSynthesis }
@@ -77,6 +89,16 @@ export const useGrooveStore = create((set, get) => ({
   // ── Marketplace Auth ───────────────────────────────────────
   marketplaceUser: null,        // { id, displayName, avatar, ... } or null
   marketplaceAuthenticated: false,
+  edition: 'community',         // 'community' | 'pro' — runtime edition from /edition
+  subscription: {
+    plan: 'community',
+    status: 'none',
+    active: false,
+    features: [],
+    seats: 1,
+    periodEnd: null,
+    cancelAtPeriodEnd: false,
+  },
 
   // ── Toasts ────────────────────────────────────────────────
   toasts: [],
@@ -96,6 +118,10 @@ export const useGrooveStore = create((set, get) => ({
   editorTreeCache: {},
   editorChangedFiles: {},
   editorRecentSaves: {},
+  editorSidebarWidth: Number(localStorage.getItem('groove:editorSidebarWidth')) || 240,
+
+  // ── Onboarding ────────────────────────────────────────────
+  onboardingComplete: localStorage.getItem('groove:onboardingComplete') === 'true',
 
   // ── Connection ────────────────────────────────────────────
 
@@ -116,14 +142,23 @@ export const useGrooveStore = create((set, get) => ({
       get().fetchTeams();
       get().fetchApprovals();
       get().checkMarketplaceAuth();
+      get().fetchTunnels();
+      if (!get().onboardingComplete) get().fetchOnboardingStatus();
+      if (window.groove?.auth?.onSubscriptionStatus) {
+        window.groove.auth.onSubscriptionStatus((data) => {
+          if (data) set({ subscription: { ...get().subscription, ...data } });
+        });
+      }
     };
 
     ws.onmessage = (event) => {
       const msg = JSON.parse(event.data);
+      if (!msg || typeof msg !== 'object' || Object.hasOwn(msg, '__proto__') || Object.hasOwn(msg, 'constructor')) return;
       switch (msg.type) {
         case 'state': {
           const timeline = { ...get().tokenTimeline };
           const now = Date.now();
+          const liveIds = new Set(msg.data.map((a) => a.id));
           for (const agent of msg.data) {
             if (!timeline[agent.id]) timeline[agent.id] = [];
             const arr = timeline[agent.id];
@@ -133,15 +168,30 @@ export const useGrooveStore = create((set, get) => ({
               if (arr.length > 200) timeline[agent.id] = arr.slice(-200);
             }
           }
+          // Prune stale agent data from timeline, chatHistory, activityLog.
+          // Without this, localStorage fills with dead agents' data until quota is
+          // exceeded and nothing else (e.g. node positions) can save.
+          let prunedChat = null, prunedLog = null;
+          const st = get();
+          for (const id of Object.keys(timeline)) if (!liveIds.has(id)) delete timeline[id];
+          for (const id of Object.keys(st.chatHistory)) {
+            if (!liveIds.has(id)) { if (!prunedChat) prunedChat = { ...st.chatHistory }; delete prunedChat[id]; }
+          }
+          for (const id of Object.keys(st.activityLog)) {
+            if (!liveIds.has(id)) { if (!prunedLog) prunedLog = { ...st.activityLog }; delete prunedLog[id]; }
+          }
           // Only replace agents array if something meaningful changed
           // (prevents React Flow tree flicker on every lastActivity update)
-          const prev = get().agents;
+          const prev = st.agents;
           const changed = msg.data.length !== prev.length || msg.data.some((a, i) => {
             const p = prev[i];
             return !p || p.id !== a.id || p.status !== a.status || p.tokensUsed !== a.tokensUsed
               || p.contextUsage !== a.contextUsage || p.name !== a.name || p.model !== a.model;
           });
-          set({ agents: changed ? msg.data : prev, tokenTimeline: timeline, hydrated: true });
+          const nextState = { agents: changed ? msg.data : prev, tokenTimeline: timeline, hydrated: true };
+          if (prunedChat) { nextState.chatHistory = prunedChat; persistJSON('groove:chatHistory', prunedChat); }
+          if (prunedLog) { nextState.activityLog = prunedLog; persistJSON('groove:activityLog', prunedLog); }
+          set(nextState);
 
           // Poll for recommended-team.json while a planner is running
           const hasRunningPlanner = msg.data.some((a) => a.role === 'planner' && a.status === 'running');
@@ -258,6 +308,15 @@ export const useGrooveStore = create((set, get) => ({
           const type = msg.status === 'completed' ? 'success' : isKill ? 'info' : 'warning';
           get().addToast(type, text, msg.error ? msg.error.slice(0, 200) : undefined);
 
+          // Clear thinking indicator — agent is no longer active
+          if (get().thinkingAgents.has(msg.agentId)) {
+            set((s) => {
+              const next = new Set(s.thinkingAgents);
+              next.delete(msg.agentId);
+              return { thinkingAgents: next };
+            });
+          }
+
           // Log crash error to agent chat so user can see what happened
           if (msg.error && msg.agentId) {
             get().addChatMessage(msg.agentId, 'system', `Crashed: ${msg.error}`);
@@ -377,6 +436,30 @@ export const useGrooveStore = create((set, get) => ({
           set({ gateways: msg.data || [] });
           break;
 
+        case 'federation:whitelist':
+          set((s) => ({ federation: { ...s.federation, whitelist: msg.data || [] } }));
+          break;
+
+        case 'federation:connection':
+          set((s) => {
+            const conns = [...s.federation.connections];
+            const idx = conns.findIndex((c) => c.ip === msg.data?.ip);
+            if (idx >= 0) conns[idx] = { ...conns[idx], ...msg.data };
+            else conns.push(msg.data);
+            return { federation: { ...s.federation, connections: conns } };
+          });
+          break;
+
+        case 'federation:pouch':
+        case 'federation:pouch-log':
+          set((s) => ({
+            federation: {
+              ...s.federation,
+              pouchLog: [...s.federation.pouchLog, msg.data].slice(-200),
+            },
+          }));
+          break;
+
         case 'tunnel.connected':
           set({ activeTunnelId: msg.data?.id || null });
           get().fetchTunnels();
@@ -394,6 +477,34 @@ export const useGrooveStore = create((set, get) => ({
           set({ savedTunnels: tunnels });
           break;
         }
+
+        case 'subscription:updated': {
+          const subUpdate = { subscription: msg.data };
+          if (msg.data?.active === true && !get().marketplaceAuthenticated) {
+            subUpdate.marketplaceAuthenticated = true;
+          }
+          set(subUpdate);
+          api.get('/edition').then((ed) => {
+            set({
+              edition: ed.edition || 'community',
+              subscription: {
+                plan: ed.plan || 'community',
+                status: ed.status || (ed.subscriptionActive ? 'active' : 'none'),
+                active: ed.subscriptionActive === true,
+                features: ed.features || [],
+                seats: ed.seats || 1,
+                periodEnd: ed.periodEnd || null,
+                cancelAtPeriodEnd: ed.cancelAtPeriodEnd || false,
+              },
+            });
+          }).catch(() => {});
+          break;
+        }
+
+        case 'auth:expired':
+          set({ marketplaceAuthenticated: false, marketplaceUser: null });
+          get().addToast('warning', 'Session expired', 'Please sign in again');
+          break;
       }
     };
 
@@ -465,7 +576,7 @@ export const useGrooveStore = create((set, get) => ({
     const team = get().teams.find((t) => t.id === id);
     if (team?.isDefault) { get().addToast('warning', 'Cannot delete the default team'); return; }
     try {
-      await api.delete(`/teams/${id}`);
+      await api.delete(`/teams/${encodeURIComponent(id)}`);
       // WS team:deleted handler removes from array and switches activeTeamId
       get().addToast('info', `Team "${team?.name}" deleted`);
     } catch (err) {
@@ -483,7 +594,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async renameTeam(id, name) {
     try {
-      const team = await api.patch(`/teams/${id}`, { name });
+      const team = await api.patch(`/teams/${encodeURIComponent(id)}`, { name });
       set((s) => ({ teams: s.teams.map((t) => (t.id === id ? team : t)) }));
       return team;
     } catch (err) {
@@ -510,6 +621,7 @@ export const useGrooveStore = create((set, get) => ({
   },
   toggleCommandPalette() { set((s) => ({ commandPaletteOpen: !s.commandPaletteOpen })); },
   toggleQuickConnect() { set((s) => ({ quickConnectOpen: !s.quickConnectOpen })); },
+  setUpgradeModalOpen: (open) => set({ upgradeModalOpen: open }),
 
   setDetailPanelWidth(w) {
     set({ detailPanelWidth: w });
@@ -552,6 +664,21 @@ export const useGrooveStore = create((set, get) => ({
         marketplaceAuthenticated: data.authenticated || false,
         marketplaceUser: data.user || null,
       });
+      try {
+        const edition = await api.get('/edition');
+        set({
+          edition: edition.edition || 'community',
+          subscription: {
+            plan: edition.plan || 'community',
+            status: edition.status || (edition.subscriptionActive ? 'active' : 'none'),
+            active: edition.subscriptionActive === true,
+            features: edition.features || [],
+            seats: edition.seats || 1,
+            periodEnd: edition.periodEnd || null,
+            cancelAtPeriodEnd: edition.cancelAtPeriodEnd || false,
+          },
+        });
+      } catch { /* edition endpoint may not exist */ }
     } catch {
       set({ marketplaceAuthenticated: false, marketplaceUser: null });
     }
@@ -569,6 +696,38 @@ export const useGrooveStore = create((set, get) => ({
             clearInterval(poll);
             set({ marketplaceAuthenticated: true, marketplaceUser: status.user });
             get().addToast('success', `Signed in as ${status.user?.displayName || status.user?.id || 'user'}`);
+            try {
+              const edition = await api.get('/edition');
+              set({
+                edition: edition.edition || 'community',
+                subscription: {
+                  plan: edition.plan || 'community',
+                  status: edition.status || (edition.subscriptionActive ? 'active' : 'none'),
+                  active: edition.subscriptionActive === true,
+                  features: edition.features || [],
+                  seats: edition.seats || 1,
+                  periodEnd: edition.periodEnd || null,
+                  cancelAtPeriodEnd: edition.cancelAtPeriodEnd || false,
+                },
+              });
+            } catch { /* edition endpoint may not exist */ }
+            setTimeout(async () => {
+              try {
+                const e = await api.get('/edition');
+                set({
+                  edition: e.edition || 'community',
+                  subscription: {
+                    plan: e.plan || 'community',
+                    status: e.status || (e.subscriptionActive ? 'active' : 'none'),
+                    active: e.subscriptionActive === true,
+                    features: e.features || [],
+                    seats: e.seats || 1,
+                    periodEnd: e.periodEnd || null,
+                    cancelAtPeriodEnd: e.cancelAtPeriodEnd || false,
+                  },
+                });
+              } catch { /* delayed re-fetch may fail */ }
+            }, 2000);
           }
         } catch { /* keep polling */ }
       }, 2000);
@@ -600,6 +759,65 @@ export const useGrooveStore = create((set, get) => ({
     }
   },
 
+  // ── Subscription ────────────────────────────────────────────
+
+  async fetchSubscriptionPlans() {
+    return api.get('/subscription/plans');
+  },
+
+  async startCheckout(priceId) {
+    try {
+      const data = await api.post('/subscription/checkout', { priceId });
+      if (data.url) {
+        if (window.groove?.openExternal) {
+          window.groove.openExternal(data.url);
+        } else {
+          window.open(data.url, '_blank');
+        }
+      }
+      return data;
+    } catch (err) {
+      if (err.status === 401 || err.message?.includes('Not authenticated')) {
+        get().addToast('info', 'Please sign in to subscribe');
+        get().marketplaceLogin();
+      } else if (err.status === 409) {
+        get().addToast('info', 'Already subscribed', 'Use Manage Subscription to switch plans');
+      } else {
+        get().addToast('error', 'Checkout failed', err.message);
+      }
+      throw err;
+    }
+  },
+
+  async openPortal() {
+    try {
+      const data = await api.post('/subscription/portal');
+      if (data.url) {
+        if (window.groove?.openExternal) {
+          window.groove.openExternal(data.url);
+        } else {
+          window.open(data.url, '_blank');
+        }
+      }
+      return data;
+    } catch (err) {
+      get().addToast('error', 'Portal failed', err.message);
+      throw err;
+    }
+  },
+
+  async updateSeats(seats) {
+    try {
+      const data = await api.patch('/subscription', { seats });
+      set({ subscription: { ...get().subscription, ...data } });
+      get().addToast('success', `Updated to ${seats} seat${seats !== 1 ? 's' : ''}`);
+      return data;
+    } catch (err) {
+      get().addToast('error', 'Seat update failed', err.message);
+      throw err;
+    }
+  },
+
   // ── Approvals ──────────────────────────────────────────────
 
   async fetchApprovals() {
@@ -614,7 +832,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async approveRequest(id) {
     try {
-      await api.post(`/approvals/${id}/approve`);
+      await api.post(`/approvals/${encodeURIComponent(id)}/approve`);
       set((s) => ({ pendingApprovals: s.pendingApprovals.filter((a) => a.id !== id) }));
       get().addToast('success', 'Approved');
     } catch (err) {
@@ -624,7 +842,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async rejectRequest(id, reason = '') {
     try {
-      await api.post(`/approvals/${id}/reject`, { reason });
+      await api.post(`/approvals/${encodeURIComponent(id)}/reject`, { reason });
       set((s) => ({ pendingApprovals: s.pendingApprovals.filter((a) => a.id !== id) }));
       get().addToast('info', 'Rejected');
     } catch (err) {
@@ -652,19 +870,26 @@ export const useGrooveStore = create((set, get) => ({
         const allExist = phase1Roles.every((role) => teamAgents.some((a) => a.role === role));
 
         if (allExist && phase1Roles.length > 0) {
-          // Auto-delegate — all agents already exist in the team
-          set({ recommendedTeam: null });
-          const result = await api.post('/recommended-team/launch');
-          const agents = result.agents || [];
-          const names = agents.map((a) => a.name).join(', ') || '';
-          get().addToast('success', 'Planner delegated work', names ? `→ ${names}` : undefined);
-          // Set thinking indicator for all delegated agents so the UI shows activity
-          if (agents.length > 0) {
-            set((s) => ({
-              thinkingAgents: new Set([...s.thinkingAgents, ...agents.map((a) => a.id)]),
-            }));
+          // Guard: skip if already delegating for this team (poll race)
+          if (get()._delegatingTeamIds.has(teamId)) return;
+          set((s) => ({ recommendedTeam: null, _delegatingTeamIds: new Set([...s._delegatingTeamIds, teamId]) }));
+          try {
+            const result = await api.post('/recommended-team/launch', { teamId });
+            const agents = result.agents || [];
+            const names = agents.map((a) => a.name).join(', ') || '';
+            get().addToast('success', 'Planner delegated work', names ? `→ ${names}` : undefined);
+            if (agents.length > 0) {
+              set((s) => ({
+                thinkingAgents: new Set([...s.thinkingAgents, ...agents.map((a) => a.id)]),
+              }));
+            }
+          } finally {
+            set((s) => {
+              const next = new Set(s._delegatingTeamIds);
+              next.delete(teamId);
+              return { _delegatingTeamIds: next };
+            });
           }
-          api.post('/cleanup').catch(() => {});
           return;
         }
       }
@@ -729,12 +954,12 @@ export const useGrooveStore = create((set, get) => ({
   },
 
   async softRemoveRepo(importId) {
-    await api.delete('/repos/' + importId + '/remove');
+    await api.delete(`/repos/${encodeURIComponent(importId)}/remove`);
     get().fetchImportedRepos();
   },
 
   async hardNukeRepo(importId, deleteFiles = true) {
-    await api.delete('/repos/' + importId + '/nuke?deleteFiles=' + deleteFiles);
+    await api.delete(`/repos/${encodeURIComponent(importId)}/nuke?deleteFiles=${deleteFiles}`);
     get().fetchImportedRepos();
   },
 
@@ -754,22 +979,22 @@ export const useGrooveStore = create((set, get) => ({
   },
 
   async updateTunnel(id, config) {
-    const result = await api.patch('/tunnels/' + id, config);
+    const result = await api.patch(`/tunnels/${encodeURIComponent(id)}`, config);
     get().fetchTunnels();
     return result;
   },
 
   async deleteTunnel(id) {
-    await api.delete('/tunnels/' + id);
+    await api.delete(`/tunnels/${encodeURIComponent(id)}`);
     get().fetchTunnels();
   },
 
   async testTunnel(id) {
-    return api.post('/tunnels/' + id + '/test');
+    return api.post(`/tunnels/${encodeURIComponent(id)}/test`);
   },
 
   async connectTunnel(id) {
-    const result = await api.post('/tunnels/' + id + '/connect');
+    const result = await api.post(`/tunnels/${encodeURIComponent(id)}/connect`);
     set({ activeTunnelId: id });
     get().fetchTunnels();
     if (result.url) window.open(result.url, '_blank');
@@ -777,17 +1002,17 @@ export const useGrooveStore = create((set, get) => ({
   },
 
   async disconnectTunnel(id) {
-    await api.post('/tunnels/' + id + '/disconnect');
+    await api.post(`/tunnels/${encodeURIComponent(id)}/disconnect`);
     set({ activeTunnelId: null });
     get().fetchTunnels();
   },
 
   async installTunnel(id) {
-    return api.post('/tunnels/' + id + '/install');
+    return api.post(`/tunnels/${encodeURIComponent(id)}/install`);
   },
 
   async startTunnel(id) {
-    return api.post('/tunnels/' + id + '/start');
+    return api.post(`/tunnels/${encodeURIComponent(id)}/start`);
   },
 
   // ── Journalist ────────────────────────────────────────────
@@ -828,7 +1053,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async killAgent(id, purge = false) {
     try {
-      await api.delete(`/agents/${id}?purge=${purge}`);
+      await api.delete(`/agents/${encodeURIComponent(id)}?purge=${purge}`);
     } catch (err) {
       get().addToast('error', 'Kill failed', err.message);
     }
@@ -836,7 +1061,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async rotateAgent(id) {
     try {
-      return await api.post(`/agents/${id}/rotate`);
+      return await api.post(`/agents/${encodeURIComponent(id)}/rotate`);
     } catch (err) {
       get().addToast('error', 'Rotation failed', err.message);
       throw err;
@@ -847,6 +1072,48 @@ export const useGrooveStore = create((set, get) => ({
     return api.get('/providers');
   },
 
+  // ── Onboarding ────────────────────────────────────────────
+
+  async fetchOnboardingStatus() {
+    try {
+      const data = await api.get('/onboarding/status');
+      if (data?.complete) {
+        set({ onboardingComplete: true });
+        localStorage.setItem('groove:onboardingComplete', 'true');
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  },
+
+  dismissOnboarding() {
+    set({ onboardingComplete: true });
+    localStorage.setItem('groove:onboardingComplete', 'true');
+    api.post('/onboarding/dismiss').catch(() => {});
+  },
+
+  async installProvider(providerId) {
+    try {
+      const data = await api.post('/onboarding/install-provider', { provider: providerId });
+      get().addToast('success', `${providerId} installed`);
+      return data;
+    } catch (err) {
+      get().addToast('error', `Install failed: ${providerId}`, err.message);
+      throw err;
+    }
+  },
+
+  async setDefaultProvider(provider, model) {
+    try {
+      await api.post('/onboarding/set-default', { provider, model });
+      get().addToast('success', `Default set to ${provider} (${model})`);
+    } catch (err) {
+      get().addToast('error', 'Failed to set default', err.message);
+      throw err;
+    }
+  },
+
   // ── Chat ──────────────────────────────────────────────────
 
   addChatMessage(agentId, from, text, isQuery = false) {
@@ -864,7 +1131,7 @@ export const useGrooveStore = create((set, get) => ({
 
   async stopAgent(id) {
     try {
-      await api.post(`/agents/${id}/stop`);
+      await api.post(`/agents/${encodeURIComponent(id)}/stop`);
       // Clear thinking indicator
       set((s) => {
         const next = new Set(s.thinkingAgents);
@@ -878,41 +1145,24 @@ export const useGrooveStore = create((set, get) => ({
   },
 
   async instructAgent(id, message) {
-    const agent = get().agents.find((a) => a.id === id);
-    const isAlive = agent && (agent.status === 'running' || agent.status === 'starting');
+    get().addChatMessage(id, 'user', message, false);
+    set((s) => ({ thinkingAgents: new Set([...s.thinkingAgents, id]) }));
+    try {
+      const data = await api.post(`/agents/${encodeURIComponent(id)}/instruct`, { message });
 
-    // Running agent: use query (non-destructive) instead of killing it
-    if (isAlive) {
-      get().addChatMessage(id, 'user', message, false);
-      try {
-        const data = await api.post(`/agents/${id}/query`, { message });
-        // Agent loop agents: response comes via WebSocket, show thinking indicator
-        if (data.status === 'pending' || data.response === 'Message sent to agent') {
-          set((s) => ({ thinkingAgents: new Set([...s.thinkingAgents, id]) }));
-          return data;
-        }
-        get().addChatMessage(id, 'agent', data.response);
+      // Agent loop: message sent directly to running agent — response comes via WebSocket
+      if (data.status === 'message_sent') {
         return data;
-      } catch (err) {
-        get().addChatMessage(id, 'system', `failed: ${err.message}`);
-        throw err;
       }
-    }
 
-    // Completed/stopped agent: resume with full context
-    get().addChatMessage(id, 'user', message, false);
-    // Show thinking indicator immediately — stays until first WebSocket output
-    set((s) => ({ thinkingAgents: new Set([...s.thinkingAgents, id]) }));
-    try {
-      const newAgent = await api.post(`/agents/${id}/instruct`, { message });
-      // Carry history + thinking state to new agent ID
+      // CLI agent: was stopped + resumed/rotated — transfer state to new agent ID
+      const newAgent = data;
       for (const key of ['chatHistory', 'activityLog', 'tokenTimeline']) {
         const old = get()[key][id];
         if (old?.length) {
           set((s) => ({ [key]: { ...s[key], [newAgent.id]: [...old] } }));
         }
       }
-      // Transfer thinking indicator to the new agent
       set((s) => {
         const next = new Set(s.thinkingAgents);
         next.delete(id);
@@ -924,7 +1174,6 @@ export const useGrooveStore = create((set, get) => ({
       get().selectAgent(newAgent.id);
       return newAgent;
     } catch (err) {
-      // Clear thinking indicator on failure
       set((s) => {
         const next = new Set(s.thinkingAgents);
         next.delete(id);
@@ -938,7 +1187,7 @@ export const useGrooveStore = create((set, get) => ({
   async queryAgent(id, message) {
     get().addChatMessage(id, 'user', message, true);
     try {
-      const data = await api.post(`/agents/${id}/query`, { message });
+      const data = await api.post(`/agents/${encodeURIComponent(id)}/query`, { message });
       get().addChatMessage(id, 'agent', data.response);
       return data;
     } catch (err) {
@@ -998,6 +1247,11 @@ export const useGrooveStore = create((set, get) => ({
 
   setActiveFile(path) { set({ editorActiveFile: path }); },
 
+  setEditorSidebarWidth(width) {
+    set({ editorSidebarWidth: width });
+    localStorage.setItem('groove:editorSidebarWidth', String(width));
+  },
+
   updateFileContent(path, content) {
     set((s) => ({ editorFiles: { ...s.editorFiles, [path]: { ...s.editorFiles[path], content } } }));
   },
@@ -1081,6 +1335,67 @@ export const useGrooveStore = create((set, get) => ({
     }
   },
 
+  // ── Federation ────────────────────────────────────────────
+
+  async fetchFederationStatus() {
+    try {
+      const data = await api.get('/federation');
+      set((s) => ({
+        federation: {
+          ...s.federation,
+          peers: data.peers || [],
+          whitelist: data.whitelist || [],
+          connections: data.connections || [],
+          ambassadors: data.ambassadors?.ambassadors || data.ambassadors || [],
+        },
+      }));
+      return data;
+    } catch { return null; }
+  },
+
+  async addToWhitelist(ip, port = 31415, name) {
+    try {
+      await api.post('/federation/whitelist', { ip, port, ...(name && { name }) });
+      get().addToast('success', `Added ${ip} to whitelist`);
+      get().fetchFederationStatus();
+    } catch (err) {
+      get().addToast('error', 'Whitelist failed', err.message);
+      throw err;
+    }
+  },
+
+  async removeFromWhitelist(ip) {
+    try {
+      await api.delete(`/federation/whitelist/${encodeURIComponent(ip)}`);
+      get().addToast('info', `Removed ${ip}`);
+      get().fetchFederationStatus();
+    } catch (err) {
+      get().addToast('error', 'Remove failed', err.message);
+    }
+  },
+
+  setSelectedPeer(peerId) {
+    set((s) => ({ federation: { ...s.federation, selectedPeerId: peerId } }));
+  },
+
+  async fetchPouchLog(peerId) {
+    try {
+      const data = await api.get(`/federation/pouch/log${peerId ? `?peerId=${encodeURIComponent(peerId)}` : ''}`);
+      set((s) => ({ federation: { ...s.federation, pouchLog: data || [] } }));
+    } catch { /* ignore */ }
+  },
+
+  async sendPouch(peerId, contract) {
+    try {
+      const result = await api.post('/federation/pouch/send', { peerId, contract });
+      get().addToast('success', 'Pouch sent');
+      return result;
+    } catch (err) {
+      get().addToast('error', 'Pouch send failed', err.message);
+      throw err;
+    }
+  },
+
   async renameFile(oldPath, newPath) {
     try {
       await api.post('/files/rename', { oldPath, newPath });