groove-dev 0.27.143 → 0.27.145

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

@@ -1,262 +1,57 @@
-// GROOVE GUI v2 — Zustand Store
+// GROOVE GUI v2 — Zustand Store (composed from slices)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { create } from 'zustand';
 import { api } from '../lib/api';
+import { persistJSON } from './helpers.js';
+import { createUiSlice } from './slices/ui-slice.js';
+import { createAgentsSlice } from './slices/agents-slice.js';
+import { createTeamsSlice } from './slices/teams-slice.js';
+import { createChatSlice } from './slices/chat-slice.js';
+import { createEditorSlice } from './slices/editor-slice.js';
+import { createProvidersSlice } from './slices/providers-slice.js';
+import { createNetworkSlice } from './slices/network-slice.js';
+import { createPreviewSlice } from './slices/preview-slice.js';
+import { createMarketplaceSlice } from './slices/marketplace-slice.js';
+import { createAutomationsSlice } from './slices/automations-slice.js';
 
 const WS_URL = `ws://${window.location.hostname}:${window.location.port || 31415}`;
 
-let toastCounter = 0;
 let plannerPollInterval = null;
-const _modeChangePending = new Set();
-
-function loadJSON(key, fallback = {}) {
-  try { return JSON.parse(localStorage.getItem(key) || JSON.stringify(fallback)); }
-  catch { return fallback; }
-}
-
-function persistJSON(key, value) {
-  try { localStorage.setItem(key, JSON.stringify(value)); } catch { /* quota */ }
-}
 
 // Clear stale persisted data on version change
 const STORE_VERSION = '0.22.28';
-if (loadJSON('groove:storeVersion') !== STORE_VERSION) {
+if (localStorage.getItem('groove:storeVersion') !== JSON.stringify(STORE_VERSION)) {
   localStorage.removeItem('groove:chatHistory');
   localStorage.removeItem('groove:activityLog');
   persistJSON('groove:storeVersion', STORE_VERSION);
 }
 
 export const useGrooveStore = create((set, get) => ({
+  // ── Spread all slices ───────────────────────────────────────
+  ...createUiSlice(set, get),
+  ...createAgentsSlice(set, get),
+  ...createTeamsSlice(set, get),
+  ...createChatSlice(set, get),
+  ...createEditorSlice(set, get),
+  ...createProvidersSlice(set, get),
+  ...createNetworkSlice(set, get),
+  ...createPreviewSlice(set, get),
+  ...createMarketplaceSlice(set, get),
+  ...createAutomationsSlice(set, get),
+
   // ── Connection ────────────────────────────────────────────
-  agents: [],
   connected: false,
-  hydrated: false,  // true after first WS state message — gates the UI to prevent flicker
+  hydrated: false,
   ws: null,
   daemonHost: null,
   tunneled: false,
   remoteHomedir: null,
 
-  // ── Teams ─────────────────────────────────────────────────
-  teams: [],
-  archivedTeams: [],
-  activeTeamId: localStorage.getItem('groove:activeTeamId') || null,
-
-  // ── Gateways ──────────────────────────────────────────────
-  gateways: [],
-
-  // ── Providers ────────────────────────────────────────────
-  _providerRefreshTick: 0,
-
-  // ── Local Models (Ollama) ─────────────────────────────────
-  ollamaStatus: { installed: false, serverRunning: false, hardware: null },
-  ollamaInstalledModels: [],
-  ollamaRunningModels: [],
-  ollamaCatalog: [],
-  ollamaPullProgress: {},
-
-  // ── Federation ────────────────────────────────────────────
-  federation: {
-    peers: [],
-    whitelist: [],
-    connections: [],
-    pouchLog: [],
-    ambassadors: [],
-    selectedPeerId: null,
-  },
-
-  // ── Preview ───────────────────────────────────────────────
-  previewState: { url: null, teamId: null, kind: null, deviceSize: 'desktop', screenshotMode: false },
-  showPreviewInAgents: false,
-  previewChat: [],
-  previewIterating: false,
-  teamPreviews: {},  // teamId -> { url, kind, active } — survives team switches
-
-  // ── Team Launch Config (set during planner spawn, cascades to team) ──
-  teamLaunchConfig: null, // { provider, model, reasoningEffort, temperature, verbosity, mode }
-
-  // ── Team Builder ──────────────────────────────────────────
-  teamBuilderOpen: false,
-  teamBuilderRoles: [],
-  teamBuilderSettings: { provider: null, model: null, reasoningEffort: 50, temperature: 0.5 },
-  teamBuilderTask: '',
-  teamTemplates: { builtIn: [], custom: [] },
-
-  // ── Navigation ────────────────────────────────────────────
-  activeView: 'agents',           // 'agents' | 'editor' | 'dashboard' | 'marketplace' | 'teams' | 'settings' | 'preview'
-  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'),
-
-  // ── Layout persistence ────────────────────────────────────
-  detailPanelWidth: Number(localStorage.getItem('groove:detailWidth')) || 480,
-  terminalVisible: localStorage.getItem('groove:terminalVisible') === 'true',
-  terminalHeight: Number(localStorage.getItem('groove:terminalHeight')) || 260,
-  terminalFullHeight: false,
-
-  // ── Agent data ────────────────────────────────────────────
-  activityLog: loadJSON('groove:activityLog'),
-  chatHistory: loadJSON('groove:chatHistory'),
-  chatInputs: {},   // Per-agent draft input text — persists across tab switches
-  tokenTimeline: {},
-
-  // ── Conversations (Chat view) ────────────────────────────
-  conversations: [],
-  activeConversationId: localStorage.getItem('groove:activeConversationId') || null,
-  conversationMessages: loadJSON('groove:conversationMessages'),
-  sendingMessage: false,
-  streamingConversationId: null,
-  conversationRoles: loadJSON('groove:conversationRoles'),
-  conversationReasoningEffort: loadJSON('groove:conversationReasoningEffort'),
-  conversationVerbosity: loadJSON('groove:conversationVerbosity'),
-
-  // ── Keeper (tagged memory) ─────────────────────────────────
-  keeperItems: [],
-  keeperTree: [],
-  keeperEditing: null,  // { tag, content, isNew, readOnly } — drives the editor modal
-  keeperInstructOpen: false,
-
-  // ── Approvals ─────────────────────────────────────────────
-  pendingApprovals: [],
-  resolvedApprovals: [],
-
-  // ── Recommended Team ──────────────────────────────────────
-  recommendedTeam: null,  // { name, agents: [...] } from planner
-  _delegatingTeamIds: new Set(),
-
-  // ── Journalist ────────────────────────────────────────────
-  journalistStatus: null, // { cycleCount, lastCycleTime, history, lastSynthesis }
-
-  // ── Network (Early Access) ────────────────────────────────
-  networkUnlocked: false,
-  networkInstalled: false,
-  networkInstallProgress: { installing: false, step: null, message: null, percent: 0, error: null },
-  networkNode: { active: false, status: 'disconnected', nodeId: null, layers: null, model: null, sessions: 0, hardware: null },
-  networkStatus: { nodes: [], coverage: 0, totalLayers: 0, models: [], activeSessions: 0 },
-  networkStatusReachable: false,
-  networkEvents: [],
-  networkVersion: { installed: null, latest: null, updateAvailable: false },
-  networkUpdateProgress: { updating: false, step: null, message: null, percent: 0, error: null },
-  networkCompute: { totalRamMb: 0, totalVramMb: 0, totalCpuCores: 0, totalBandwidthMbps: 0, activeNodes: 0, totalNodes: 0, avgLoad: 0 },
-  networkSnapshots: [],
-  networkTokenTiming: null,
-  networkBenchmarks: [],
-  networkTraces: [],
-  networkPerfSnapshots: [],
-  networkNodeTelemetry: {},
-  networkWallet: { connected: false, address: null, balance: '0.00', token: 'GROOVE', chain: 'base-l2' },
-  networkEarnings: { today: 0, thisWeek: 0, allTime: 0, history: [] },
-
-  // ── Training Data ──────────────────────────────────────────
-  trainingOptIn: false,
-  trainingStats: null,
-  dataSharingDismissed: false,
-  dataSharingModalOpen: false,
-
-  // ── 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,
-  },
-
-  // ── Version / Auto-Update ──────────────────────────────────
-  version: null,
-  updateReady: null,
-  updateProgress: null,
-  updateModalOpen: false,
-
-  // ── Toasts ────────────────────────────────────────────────
-  toasts: [],
-
-  // ── Project Directory ───────────────────────────────────────
-  projectDir: null,
-  recentProjects: [],
-  showProjectPicker: false,
-
-  // ── Tunnels ────────────────────────────────────────────────
-  savedTunnels: [],
-  tunnelConnectStep: null,
-
-  // ── GitHub Repo Import ────────────────────────────────────
-  importedRepos: [],
-  importInProgress: false,
-
-  // ── Editor state ──────────────────────────────────────────
-  editorFiles: {},
-  editorActiveFile: null,
-  editorOpenTabs: [],
-  editorTreeCache: {},
-  editorChangedFiles: {},
-  editorRecentSaves: {},
-  editorSidebarWidth: Number(localStorage.getItem('groove:editorSidebarWidth')) || 240,
-  editorTheme: localStorage.getItem('groove:editorTheme') || 'vscodeDark',
-
-  // ── Workspace Mode ────────────────────────────────────────
-  workspaceMode: localStorage.getItem('groove:workspaceMode') === 'true',
-  workspaceAgentId: null,
-  workspaceSnapshots: {},
-  workspaceReviewMode: false,
-  workspaceReviewFiles: [],
-
-  // ── Editor (Cursor-style) ────────────────────────────────
-  editorSelectedAgent: null,
-  editorPendingSnippet: null,
-  editorViewMode: 'code',
-  editorAiPanelOpen: false,
-  editorAiPanelWidth: Number(localStorage.getItem('groove:editorAiPanelWidth')) || 360,
-  editorGitStatus: null,
-  editorGitBranch: null,
-  editorGitDiff: null,
-  editorQuickSearchOpen: false,
-
-  // ── Model Lab ──────────────────────────────────────────────
-  labRuntimes: loadJSON('groove:labRuntimes', []),
-  labActiveRuntime: null,
-  labModels: [],
-  labActiveModel: null,
-  labPresets: loadJSON('groove:labPresets', []),
-  labActivePreset: null,
-  labSessions: [],
-  labActiveSession: null,
-  labMetrics: { ttft: null, tokensPerSec: null, tokensPerSecHistory: [], memory: null, totalTokens: 0, generationTime: null },
-  labParameters: loadJSON('groove:labParameters', {
-    temperature: 0.7, topP: 0.9, topK: 40, repeatPenalty: 1.1,
-    maxTokens: 2048, frequencyPenalty: 0, presencePenalty: 0,
-  }),
-  labSystemPrompt: localStorage.getItem('groove:labSystemPrompt') || '',
-  labStreaming: false,
-  labAbortController: null,
-  labLocalModels: [],
-  labLaunching: null,
-  labLlamaInstalled: null,
-  labLaunchPhase: null,
-  labLaunchError: null,
-  labAssistantAgentId: localStorage.getItem('groove:labAssistantAgentId') || null,
-  labAssistantMode: false,
-  labAssistantBackend: localStorage.getItem('groove:labAssistantBackend') || null,
-
-  // ── Onboarding ────────────────────────────────────────────
-  onboardingComplete: localStorage.getItem('groove:onboardingComplete') === 'true',
-
-  // ── Connection ────────────────────────────────────────────
-
   connect() {
     if (get().ws) return;
     const ws = new WebSocket(WS_URL);
-    set({ ws }); // Claim slot immediately to prevent StrictMode double-connect
+    set({ ws });
 
     ws.onopen = () => {
       set({ connected: true });
@@ -296,6 +91,11 @@ export const useGrooveStore = create((set, get) => ({
           if (data) set({ subscription: { ...get().subscription, ...data } });
         });
       }
+      if (window.groove?.update?.onUpdateAvailable) {
+        window.groove.update.onUpdateAvailable((data) => {
+          set({ updateProgress: { percent: 0, version: data.version } });
+        });
+      }
       if (window.groove?.update?.onUpdateProgress) {
         window.groove.update.onUpdateProgress((data) => {
           set({ updateProgress: data });
@@ -306,6 +106,18 @@ export const useGrooveStore = create((set, get) => ({
           set({ updateReady: data.version, updateModalOpen: true, updateProgress: null });
         });
       }
+      if (window.groove?.update?.getUpdateStatus) {
+        window.groove.update.getUpdateStatus().then((state) => {
+          if (!state) return;
+          if (state.downloaded) {
+            set({ updateReady: state.downloaded.version, updateProgress: null });
+          } else if (state.progress) {
+            set({ updateProgress: state.progress });
+          } else if (state.available) {
+            set({ updateProgress: { percent: 0, version: state.available.version } });
+          }
+        }).catch(() => {});
+      }
     };
 
     ws.onmessage = (event) => {
@@ -325,15 +137,8 @@ export const useGrooveStore = create((set, get) => ({
               if (arr.length > 200) timeline[agent.id] = arr.slice(-200);
             }
           }
-          // Prune stale tokenTimeline (high-volume metrics, safe to drop).
-          // chatHistory and activityLog are NOT pruned here — they must survive
-          // the gap between registry.remove() and rotation:complete so the
-          // rotation handler can migrate them to the new agent ID.  Explicit
-          // cleanup happens in killAgent(purge=true) and rotation:complete.
           const st = get();
           for (const id of Object.keys(timeline)) if (!liveIds.has(id)) delete timeline[id];
-          // Only replace agents array if something meaningful changed
-          // (prevents React Flow tree flicker on every lastActivity update)
           const prev = st.agents;
           const changed = msg.data.length !== prev.length || msg.data.some((a, i) => {
             const p = prev[i];
@@ -342,7 +147,6 @@ export const useGrooveStore = create((set, get) => ({
           });
           set({ agents: changed ? msg.data : prev, tokenTimeline: timeline, hydrated: true });
 
-          // Poll for recommended-team.json while a planner is running
           const hasRunningPlanner = msg.data.some((a) => a.role === 'planner' && a.status === 'running');
           if (hasRunningPlanner && !plannerPollInterval && !get().recommendedTeam) {
             plannerPollInterval = setInterval(() => {
@@ -376,7 +180,6 @@ export const useGrooveStore = create((set, get) => ({
               if (upd) { found++; return upd; }
               return a;
             });
-            // New agents not yet in the list
             if (found < changed.length) {
               for (const a of changed) {
                 if (!agents.some((ex) => ex.id === a.id)) agents.push(a);
@@ -402,7 +205,6 @@ export const useGrooveStore = create((set, get) => ({
         case 'agent:output': {
           const { agentId, data } = msg;
 
-          // Separate text content from tool calls
           let chatText = '';
           let activityText = '';
           if (typeof data.data === 'string') {
@@ -415,7 +217,6 @@ export const useGrooveStore = create((set, get) => ({
             }).join('\n');
           }
 
-          // Update agent metrics in real-time (contextUsage, tokensUsed)
           if (data.contextUsage !== undefined || data.tokensUsed !== undefined) {
             const agents = get().agents.map((a) => {
               if (a.id !== agentId) return a;
@@ -427,17 +228,12 @@ export const useGrooveStore = create((set, get) => ({
             set({ agents });
           }
 
-          // Text responses → chat bubbles
-          // Skip pure token-level stream chunks (subtype='stream') — too granular
-          // Show: subtype='assistant' (Claude Code), subtype='text' (agent loop), type='result',
-          //        and plain activity events with string data (Gemini/Codex/Ollama CLI)
           const isTokenStream = data.subtype === 'stream';
           const showAsChat = chatText && chatText.trim() && !isTokenStream && (
             data.subtype === 'assistant' || data.subtype === 'text' || data.type === 'result' ||
             (data.type === 'activity' && typeof data.data === 'string')
           );
           if (showAsChat) {
-            // Clear thinking indicator only when actual text renders as a chat bubble
             if (get().thinkingAgents.has(agentId)) {
               set((s) => {
                 const next = new Set(s.thinkingAgents);
@@ -453,17 +249,13 @@ export const useGrooveStore = create((set, get) => ({
             const last = arr[arr.length - 1];
             const isRecent = last && last.from === 'agent' && (Date.now() - last.timestamp) < 8000;
 
-            // Skip duplicate text — Claude Code sends 'assistant' then 'result' with same content
             const isDupe = isRecent && (last.text === trimmed || last.text.endsWith(trimmed));
 
             if (!isDupe) {
               if (isRecent) {
-                // Append to the last agent message (streaming from any provider)
-                // Claude Code blocks use \n\n separator; plain text uses space
                 const sep = data.subtype === 'assistant' ? '\n\n' : ' ';
                 arr[arr.length - 1] = { ...last, text: last.text + sep + trimmed, timestamp: Date.now() };
               } else {
-                // New message bubble
                 arr.push({ from: 'agent', text: trimmed, timestamp: Date.now() });
               }
 
@@ -472,7 +264,6 @@ export const useGrooveStore = create((set, get) => ({
               persistJSON('groove:chatHistory', history);
             }
 
-            // Mirror to conversation messages if this agent belongs to a conversation
             const conv = get().conversations.find((c) => c.agentId === agentId);
             if (conv) {
               const convMsgs = { ...get().conversationMessages };
@@ -495,7 +286,6 @@ export const useGrooveStore = create((set, get) => ({
             }
           }
 
-          // Tool calls → activity log (shown in streaming bar, not as chat bubbles)
           if (activityText && activityText.trim()) {
             const log = { ...get().activityLog };
             if (!log[agentId]) log[agentId] = [];
@@ -509,7 +299,6 @@ export const useGrooveStore = create((set, get) => ({
             persistJSON('groove:activityLog', log);
           }
 
-          // Open-on-write: auto-open files the agent writes in workspace mode
           if (get().workspaceMode && Array.isArray(data.data)) {
             const WRITE_TOOLS = new Set(['Write', 'Edit', 'write_file', 'edit_file', 'create_file']);
             for (const block of data.data) {
@@ -534,7 +323,6 @@ 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);
@@ -543,17 +331,14 @@ export const useGrooveStore = create((set, get) => ({
             });
           }
 
-          // Clear conversation streaming state
           const exitConv = get().conversations.find((c) => c.agentId === msg.agentId);
           if (exitConv && get().streamingConversationId === exitConv.id) {
             set({ sendingMessage: false, streamingConversationId: null });
           }
 
-          // 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}`);
           }
-          // Clear workspace if the exiting agent was the workspace target
           if (get().workspaceAgentId === msg.agentId) {
             const teamAgents = get().agents.filter(
               (a) => a.id !== msg.agentId && a.teamId === get().activeTeamId,
@@ -562,7 +347,6 @@ export const useGrooveStore = create((set, get) => ({
             set({ workspaceAgentId: next?.id || null });
           }
 
-          // Check for recommended team when planner completes
           if (agent?.role === 'planner' && msg.status === 'completed') {
             setTimeout(() => get().checkRecommendedTeam(), 1000);
           }
@@ -679,9 +463,6 @@ export const useGrooveStore = create((set, get) => ({
           break;
 
         case 'rotation:complete': {
-          // Migrate all agent-keyed state to the new ID so chat history,
-          // activity log, and token timeline carry forward seamlessly.
-          // The broadcast sends `agentId` (new) and `oldAgentId` (old).
           const newId = msg.agentId;
           const oldId = msg.oldAgentId;
           if (!newId || !oldId) break;
@@ -728,7 +509,6 @@ export const useGrooveStore = create((set, get) => ({
         case 'file:changed': {
           const savedAt = get().editorRecentSaves[msg.path];
           if (savedAt && Date.now() - savedAt < 2000) break;
-          // Auto-capture workspace snapshot for diff viewer
           if (get().workspaceMode && msg.path && !get().workspaceSnapshots[msg.path]) {
             const existing = get().editorFiles[msg.path];
             if (existing?.content) {
@@ -779,6 +559,13 @@ export const useGrooveStore = create((set, get) => ({
 
         case 'schedule:execute':
           get().addToast('info', `Scheduled agent spawned: ${msg.name || msg.role || 'agent'}`);
+          get().fetchAutomations();
+          break;
+
+        case 'schedule:created':
+        case 'schedule:updated':
+        case 'schedule:deleted':
+          get().fetchAutomations();
           break;
 
         case 'gateway:status':
@@ -957,7 +744,6 @@ export const useGrooveStore = create((set, get) => ({
           }
           set(nsUpdate);
 
-          // Push snapshot for activity chart
           const wsNodes = nsData.nodes || [];
           const wsOwnId = get().networkNode.nodeId;
           const wsOwn = wsOwnId ? wsNodes.find((n) => (n.node_id || n.nodeId) === wsOwnId) : null;
@@ -1239,2883 +1025,4 @@ export const useGrooveStore = create((set, get) => ({
     };
     ws.onerror = () => ws.close();
   },
-
-  // ── Navigation ────────────────────────────────────────────
-
-  setActiveView(view) { set({ activeView: view }); },
-
-  // ── Keeper (tagged memory) ────────────────────────────────
-
-  async fetchKeeperItems() {
-    try {
-      const data = await api.get('/keeper');
-      const treeData = await api.get('/keeper/tree');
-      set({ keeperItems: data.items || [], keeperTree: treeData.tree || [] });
-    } catch { /* ignore */ }
-  },
-
-  async saveKeeperItem(tag, content) {
-    try {
-      const item = await api.post('/keeper', { tag, content });
-      get().fetchKeeperItems();
-      get().addToast('success', `Saved #${item.tag}`);
-      return item;
-    } catch (err) {
-      get().addToast('error', 'Failed to save memory', err.message);
-      throw err;
-    }
-  },
-
-  async appendKeeperItem(tag, content) {
-    try {
-      const item = await api.post('/keeper/append', { tag, content });
-      get().fetchKeeperItems();
-      get().addToast('success', `Appended to #${item.tag}`);
-      return item;
-    } catch (err) {
-      get().addToast('error', 'Failed to append', err.message);
-      throw err;
-    }
-  },
-
-  async updateKeeperItem(tag, content) {
-    try {
-      const item = await api.patch(`/keeper/${tag}`, { content });
-      get().fetchKeeperItems();
-      get().addToast('success', `Updated #${item.tag}`);
-      return item;
-    } catch (err) {
-      get().addToast('error', 'Failed to update memory', err.message);
-      throw err;
-    }
-  },
-
-  async deleteKeeperItem(tag) {
-    try {
-      await api.delete(`/keeper/${tag}`);
-      get().fetchKeeperItems();
-      get().addToast('success', `Deleted #${tag}`);
-    } catch (err) {
-      get().addToast('error', 'Failed to delete memory', err.message);
-    }
-  },
-
-  async getKeeperItem(tag) {
-    try {
-      return await api.get(`/keeper/${tag}`);
-    } catch {
-      return null;
-    }
-  },
-
-  async searchKeeper(query) {
-    try {
-      const data = await api.get(`/keeper/search?q=${encodeURIComponent(query)}`);
-      return data.results || [];
-    } catch {
-      return [];
-    }
-  },
-
-  setKeeperEditing(editing) {
-    set({ keeperEditing: editing });
-  },
-
-  async _handleKeeperCommand(agentId, message, command) {
-    const rest = message.replace(/\[\w+[-\w]*\]/i, '').trim();
-    const tags = (rest.match(/#[\w/.-]+/g) || []).map(t => t.replace(/^#/, ''));
-
-    const addSystemMsg = (text) => {
-      get().addChatMessage(agentId, 'system', text);
-    };
-
-    try {
-      switch (command) {
-        case 'instruct': {
-          set({ keeperInstructOpen: true });
-          return true;
-        }
-
-        case 'save': {
-          if (tags.length === 0) { addSystemMsg('Usage: save #tag your message here'); return true; }
-          const content = rest.replace(/#[\w/.-]+/g, '').trim();
-          if (!content) { addSystemMsg('Usage: save #tag your message here'); return true; }
-          await get().saveKeeperItem(tags[0], content);
-          addSystemMsg(`Saved to #${tags[0]}`);
-          return { passthrough: content };
-        }
-
-        case 'append': {
-          if (tags.length === 0) { addSystemMsg('Usage: append #tag content to add'); return true; }
-          const content = rest.replace(/#[\w/.-]+/g, '').trim();
-          if (!content) { addSystemMsg('Usage: append #tag content to add'); return true; }
-          await get().appendKeeperItem(tags[0], content);
-          addSystemMsg(`Appended to #${tags[0]}`);
-          return { passthrough: content };
-        }
-
-        case 'update': {
-          if (tags.length === 0) { addSystemMsg('Usage: [update] #tag'); return true; }
-          get().addChatMessage(agentId, 'user', message, false);
-          const existing = await get().getKeeperItem(tags[0]);
-          set({ keeperEditing: { tag: tags[0], content: existing?.content || '', isNew: !existing } });
-          return true;
-        }
-
-        case 'delete': {
-          if (tags.length === 0) { addSystemMsg('Usage: [delete] #tag'); return true; }
-          get().addChatMessage(agentId, 'user', message, false);
-          await get().deleteKeeperItem(tags[0]);
-          addSystemMsg(`Deleted #${tags[0]}`);
-          return true;
-        }
-
-        case 'view': {
-          if (tags.length === 0) { addSystemMsg('Usage: [view] #tag'); return true; }
-          get().addChatMessage(agentId, 'user', message, false);
-          const item = await get().getKeeperItem(tags[0]);
-          if (item) {
-            set({ keeperEditing: { tag: tags[0], content: item.content, isNew: false, readOnly: true } });
-          } else {
-            addSystemMsg(`#${tags[0]} not found`);
-          }
-          return true;
-        }
-
-        case 'read': {
-          if (tags.length === 0) { addSystemMsg('Usage: [read] #tag1 #tag2 ...'); return true; }
-          get().addChatMessage(agentId, 'user', message, false);
-          const readBrief = await api.post('/keeper/pull', { tags });
-          if (readBrief?.brief) {
-            await api.post(`/agents/${encodeURIComponent(agentId)}/instruct`, {
-              message: `Here is context from my tagged memories:\n\n${readBrief.brief}`,
-            });
-            addSystemMsg(`Sent ${tags.map(t => '#' + t).join(', ')} to agent`);
-          } else {
-            addSystemMsg(`No memories found for ${tags.map(t => '#' + t).join(', ')}`);
-          }
-          return true;
-        }
-
-        case 'doc': {
-          if (tags.length === 0) { addSystemMsg('Usage: [doc] #tag'); return true; }
-          get().addChatMessage(agentId, 'user', message, false);
-          addSystemMsg(`Generating doc for #${tags[0]}...`);
-          const history = get().chatHistory[agentId] || [];
-          const result = await api.post('/keeper/doc', { tag: tags[0], chatHistory: history, agentId });
-          if (result?.content) {
-            addSystemMsg(`Doc #${tags[0]} generated (${result.size}B)`);
-            set({ keeperEditing: { tag: tags[0], content: result.content, isNew: false } });
-          }
-          return true;
-        }
-
-        case 'link': {
-          const linkMatch = rest.match(/^((?:#[\w/.-]+\s*)+)\s+(.+)$/);
-          if (!linkMatch || tags.length === 0) { addSystemMsg('Usage: [link] #tag path/to/doc'); return true; }
-          const docPath = linkMatch[2].trim();
-          get().addChatMessage(agentId, 'user', message, false);
-          await api.post('/keeper/link', { tag: tags[0], docPath });
-          addSystemMsg(`Linked #${tags[0]} → ${docPath}`);
-          return true;
-        }
-      }
-    } catch (err) {
-      addSystemMsg(`Keeper error: ${err.message}`);
-      return true;
-    }
-    return false;
-  },
-
-  // ── Teams ─────────────────────────────────────────────────
-
-  async fetchTeams() {
-    try {
-      const data = await api.get('/teams');
-      let teams = data.teams || [];
-      const defaultTeamId = data.defaultTeamId;
-      try {
-        const saved = JSON.parse(localStorage.getItem('groove:teamOrder') || '[]');
-        if (saved.length) {
-          const byId = Object.fromEntries(teams.map((t) => [t.id, t]));
-          const ordered = saved.filter((id) => byId[id]).map((id) => byId[id]);
-          const remaining = teams.filter((t) => !saved.includes(t.id));
-          teams = [...ordered, ...remaining];
-        }
-      } catch {}
-      const { activeTeamId } = get();
-      const ids = teams.map((t) => t.id);
-      const resolved = ids.includes(activeTeamId) ? activeTeamId : defaultTeamId;
-      set({ teams, activeTeamId: resolved });
-      if (resolved) localStorage.setItem('groove:activeTeamId', resolved);
-    } catch { /* ignore */ }
-  },
-
-  switchTeam(id) {
-    const { activeTeamId, detailPanel, teamDetailPanels, teamPreviews } = get();
-    const updated = { ...teamDetailPanels };
-    if (activeTeamId) updated[activeTeamId] = detailPanel;
-    const restored = updated[id] || null;
-    const tp = teamPreviews[id];
-    const previewUpdate = tp
-      ? { previewState: { url: tp.url, teamId: id, kind: tp.kind, deviceSize: 'desktop', screenshotMode: false } }
-      : {};
-    set({ activeTeamId: id, detailPanel: restored, teamDetailPanels: updated, ...previewUpdate });
-    localStorage.setItem('groove:activeTeamId', id);
-  },
-
-  async createTeam(name, workingDir, mode) {
-    try {
-      const body = { name };
-      if (workingDir) body.workingDir = workingDir;
-      if (mode) body.mode = mode;
-      const team = await api.post('/teams', body);
-      // Only set activeTeamId — the WS team:created handler adds to the teams array
-      set({ activeTeamId: team.id });
-      localStorage.setItem('groove:activeTeamId', team.id);
-      get().addToast('success', `Team "${name}" created`);
-      return team;
-    } catch (err) {
-      get().addToast('error', 'Failed to create team', err.message);
-      throw err;
-    }
-  },
-
-  async archiveTeam(id) {
-    const team = get().teams.find((t) => t.id === id);
-    try {
-      await api.delete(`/teams/${encodeURIComponent(id)}`);
-      const wiped = team?.isDefault ? 'wiped' : 'archived';
-      get().addToast('success', `Team "${team?.name}" ${wiped}`, wiped === 'archived' ? 'Files preserved — restore anytime from Archived Teams' : undefined);
-      get().fetchArchivedTeams();
-    } catch (err) {
-      get().addToast('error', 'Failed to archive team', err.message);
-    }
-  },
-
-  async deleteTeamPermanently(id) {
-    const team = get().teams.find((t) => t.id === id);
-    try {
-      await api.delete(`/teams/${encodeURIComponent(id)}?permanent=true`);
-      get().addToast('success', `Team "${team?.name}" permanently deleted`);
-    } catch (err) {
-      get().addToast('error', 'Failed to delete team', err.message);
-    }
-  },
-
-  async deleteTeam(id) {
-    return get().archiveTeam(id);
-  },
-
-  reorderTeams(fromIndex, toIndex) {
-    const teams = [...get().teams];
-    const [moved] = teams.splice(fromIndex, 1);
-    teams.splice(toIndex, 0, moved);
-    set({ teams });
-    try { localStorage.setItem('groove:teamOrder', JSON.stringify(teams.map((t) => t.id))); } catch {}
-  },
-
-  async fetchArchivedTeams() {
-    try {
-      const data = await api.get('/teams/archived');
-      set({ archivedTeams: data.archived || data.teams || [] });
-    } catch { /* endpoint may not exist yet */ }
-  },
-
-  async restoreTeam(archivedId) {
-    try {
-      await api.post(`/teams/archived/${encodeURIComponent(archivedId)}/restore`);
-      get().addToast('success', 'Team restored');
-      get().fetchArchivedTeams();
-    } catch (err) {
-      get().addToast('error', 'Failed to restore team', err.message);
-    }
-  },
-
-  async purgeTeam(archivedId) {
-    try {
-      await api.delete(`/teams/archived/${encodeURIComponent(archivedId)}`);
-      get().addToast('info', 'Archived team permanently deleted');
-      get().fetchArchivedTeams();
-    } catch (err) {
-      get().addToast('error', 'Failed to purge team', err.message);
-    }
-  },
-
-  async cloneTeam(id) {
-    const team = get().teams.find((t) => t.id === id);
-    if (!team) return;
-    const sourceAgents = get().agents.filter((a) => a.teamId === id);
-    try {
-      const newTeam = await api.post('/teams', { name: `${team.name} (copy)` });
-      set({ activeTeamId: newTeam.id });
-      localStorage.setItem('groove:activeTeamId', newTeam.id);
-      for (const agent of sourceAgents) {
-        await api.post('/agents', {
-          role: agent.role,
-          name: agent.name,
-          provider: agent.provider,
-          model: agent.model,
-          scope: agent.scope,
-          teamId: newTeam.id,
-        });
-      }
-      get().addToast('success', `Cloned "${team.name}" with ${sourceAgents.length} agent${sourceAgents.length !== 1 ? 's' : ''}`);
-      return newTeam;
-    } catch (err) {
-      get().addToast('error', 'Failed to clone team', err.message);
-    }
-  },
-
-  async renameTeam(id, name) {
-    try {
-      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) {
-      get().addToast('error', 'Failed to rename team', err.message);
-      throw err;
-    }
-  },
-
-  async promoteTeam(id) {
-    try {
-      const team = await api.post(`/teams/${encodeURIComponent(id)}/promote`);
-      set((s) => ({ teams: s.teams.filter((t) => t.id !== id) }));
-      get().addToast('success', 'Team promoted — files moved to project directory');
-      return team;
-    } catch (err) {
-      get().addToast('error', 'Failed to promote team', err.message);
-      throw err;
-    }
-  },
-
-  openDetail(descriptor) {
-    const tid = get().activeTeamId;
-    set((s) => ({ detailPanel: descriptor, teamDetailPanels: { ...s.teamDetailPanels, [tid]: descriptor } }));
-  },
-  closeDetail() {
-    const tid = get().activeTeamId;
-    set((s) => ({ detailPanel: null, teamDetailPanels: { ...s.teamDetailPanels, [tid]: null } }));
-  },
-  selectAgent(id) {
-    const tid = get().activeTeamId;
-    const match = get().agents.find((a) => a.id === id);
-    if (tid && match && match.teamId && match.teamId !== tid) return;
-    const panel = { type: 'agent', agentId: id };
-    set((s) => ({ detailPanel: panel, teamDetailPanels: { ...s.teamDetailPanels, [tid]: panel } }));
-  },
-  clearSelection() {
-    const tid = get().activeTeamId;
-    set((s) => ({ detailPanel: null, teamDetailPanels: { ...s.teamDetailPanels, [tid]: null } }));
-  },
-  toggleCommandPalette() { set((s) => ({ commandPaletteOpen: !s.commandPaletteOpen })); },
-  toggleQuickConnect() { set((s) => ({ quickConnectOpen: !s.quickConnectOpen })); },
-  setUpgradeModalOpen: (open) => set({ upgradeModalOpen: open }),
-
-  setDetailPanelWidth(w) {
-    set({ detailPanelWidth: w });
-    localStorage.setItem('groove:detailWidth', String(w));
-  },
-  setTerminalVisible(v) {
-    set({ terminalVisible: v });
-    localStorage.setItem('groove:terminalVisible', String(v));
-  },
-  setTerminalHeight(h) {
-    set({ terminalHeight: h });
-    localStorage.setItem('groove:terminalHeight', String(h));
-  },
-  setTerminalFullHeight(v) { set({ terminalFullHeight: v }); },
-
-  toggleNodeExpanded(id) {
-    const expanded = { ...get().expandedNodes };
-    expanded[id] = !expanded[id];
-    if (!expanded[id]) delete expanded[id];
-    set({ expandedNodes: expanded });
-    persistJSON('groove:expandedNodes', expanded);
-  },
-
-  // ── Preview ──────────────────────────────────────────────
-
-  async fetchActivePreviews() {
-    try {
-      const data = await api.get('/preview');
-      const previews = data.previews || [];
-      if (previews.length > 0) {
-        const updates = {};
-        for (const p of previews) {
-          updates[p.teamId] = { url: `/api/preview/${p.teamId}/proxy/`, kind: p.kind, active: true };
-        }
-        const most = previews.sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0))[0];
-        set((s) => ({
-          teamPreviews: { ...s.teamPreviews, ...updates },
-          previewState: { url: `/api/preview/${most.teamId}/proxy/`, teamId: most.teamId, kind: most.kind, deviceSize: 'desktop', screenshotMode: false },
-          showPreviewInAgents: true,
-        }));
-      }
-    } catch {}
-  },
-
-  openPreview(url, teamId, kind) {
-    set((s) => ({
-      previewState: { url, teamId, kind, deviceSize: 'desktop', screenshotMode: false },
-      teamPreviews: { ...s.teamPreviews, [teamId]: { url, kind, active: true } },
-      previewChat: [],
-      showPreviewInAgents: true,
-    }));
-  },
-  closePreview() {
-    set({ showPreviewInAgents: false });
-  },
-  stopPreview() {
-    const { previewState } = get();
-    if (previewState.teamId) {
-      api.delete(`/preview/${previewState.teamId}`).catch(() => {});
-      set((s) => ({
-        teamPreviews: {
-          ...s.teamPreviews,
-          [previewState.teamId]: { ...s.teamPreviews[previewState.teamId], active: false },
-        },
-        showPreviewInAgents: false,
-      }));
-    }
-  },
-  async relaunchPreview(teamId) {
-    try {
-      const result = await api.post(`/preview/${teamId}/launch`);
-      if (result.launched) {
-        const proxyUrl = `/api/preview/${teamId}/proxy/`;
-        set((s) => ({
-          previewState: { url: proxyUrl, teamId, kind: result.kind, deviceSize: 'desktop', screenshotMode: false },
-          teamPreviews: { ...s.teamPreviews, [teamId]: { url: proxyUrl, kind: result.kind, active: true } },
-          showPreviewInAgents: true,
-        }));
-      } else {
-        get().addToast('warning', 'Preview could not launch', result.reason ? String(result.reason).slice(0, 200) : 'Build or server failed');
-      }
-    } catch (err) {
-      get().addToast('error', 'Failed to launch preview', err.message);
-    }
-  },
-  togglePreviewInAgents() {
-    set((s) => ({ showPreviewInAgents: !s.showPreviewInAgents }));
-  },
-  setPreviewDevice(size) {
-    set((s) => ({ previewState: { ...s.previewState, deviceSize: size } }));
-  },
-  toggleScreenshotMode() {
-    set((s) => ({ previewState: { ...s.previewState, screenshotMode: !s.previewState.screenshotMode } }));
-  },
-  async iteratePreview(message, screenshotBase64) {
-    const { previewState } = get();
-    if (!previewState.teamId) return;
-
-    const userMsg = { role: 'user', content: message, screenshot: screenshotBase64 || null, timestamp: Date.now() };
-    set((s) => ({ previewChat: [...s.previewChat, userMsg], previewIterating: true }));
-
-    try {
-      const body = { message };
-      if (screenshotBase64) body.screenshot = screenshotBase64;
-      const res = await api.post(`/preview/${previewState.teamId}/iterate`, body);
-      const assistantMsg = { role: 'assistant', content: res.response || res.message || 'Changes routed to planner.', timestamp: Date.now() };
-      set((s) => ({ previewChat: [...s.previewChat, assistantMsg], previewIterating: false }));
-    } catch (err) {
-      const errMsg = { role: 'assistant', content: `Failed to iterate: ${err.message}`, timestamp: Date.now() };
-      set((s) => ({ previewChat: [...s.previewChat, errMsg], previewIterating: false }));
-    }
-  },
-  addPreviewChatMessage(role, content, screenshot) {
-    const msg = { role, content, screenshot: screenshot || null, timestamp: Date.now() };
-    set((s) => ({ previewChat: [...s.previewChat, msg] }));
-  },
-  clearPreviewChat() {
-    set({ previewChat: [] });
-  },
-
-  // ── Toasts ────────────────────────────────────────────────
-
-  addToast(type, message, detail, action, options = {}) {
-    const id = ++toastCounter;
-    const persistent = !!options.persistent;
-    const duration = options.duration;
-    const actions = options.actions;
-    set((s) => ({ toasts: [...s.toasts, { id, type, message, detail, action, actions, persistent, duration }] }));
-  },
-  removeToast(id) {
-    set((s) => ({ toasts: s.toasts.filter((t) => t.id !== id) }));
-  },
-
-  installUpdate() {
-    window.groove?.update?.installUpdate();
-  },
-  setUpdateModalOpen(open) {
-    set({ updateModalOpen: open });
-  },
-  checkForUpdate() {
-    window.groove?.update?.checkForUpdate();
-  },
-
-  // ── Marketplace Auth ────────────────────────────────────────
-
-  async checkMarketplaceAuth() {
-    try {
-      const data = await api.get('/auth/status');
-      set({
-        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 });
-    }
-  },
-
-  async marketplaceLogin() {
-    try {
-      const data = await api.get('/auth/login-url');
-      if (data.url) window.open(data.url, '_blank');
-      // Poll for auth completion (user logs in via browser)
-      const poll = setInterval(async () => {
-        try {
-          const status = await api.get('/auth/status');
-          if (status.authenticated) {
-            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);
-      // Stop polling after 5 minutes
-      setTimeout(() => clearInterval(poll), 300000);
-    } catch (err) {
-      get().addToast('error', 'Login failed', err.message);
-    }
-  },
-
-  async marketplaceLogout() {
-    try {
-      await api.post('/auth/logout');
-      set({ marketplaceAuthenticated: false, marketplaceUser: null });
-      get().addToast('info', 'Signed out of marketplace');
-    } catch (err) {
-      get().addToast('error', 'Logout failed', err.message);
-    }
-  },
-
-  async marketplaceCheckout(skillId) {
-    try {
-      const data = await api.post('/auth/checkout', { skillId });
-      if (data.url) window.open(data.url, '_blank');
-      return data;
-    } catch (err) {
-      get().addToast('error', 'Checkout failed', err.message);
-      throw err;
-    }
-  },
-
-  // ── 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() {
-    try {
-      const data = await api.get('/approvals');
-      set({
-        pendingApprovals: data.pending || [],
-        resolvedApprovals: data.resolved || [],
-      });
-    } catch { /* ignore */ }
-  },
-
-  async approveRequest(id) {
-    try {
-      await api.post(`/approvals/${encodeURIComponent(id)}/approve`);
-      set((s) => ({ pendingApprovals: s.pendingApprovals.filter((a) => a.id !== id) }));
-      get().addToast('success', 'Approved');
-    } catch (err) {
-      get().addToast('error', 'Approve failed', err.message);
-    }
-  },
-
-  async rejectRequest(id, reason = '') {
-    try {
-      await api.post(`/approvals/${encodeURIComponent(id)}/reject`, { reason });
-      set((s) => ({ pendingApprovals: s.pendingApprovals.filter((a) => a.id !== id) }));
-      get().addToast('info', 'Rejected');
-    } catch (err) {
-      get().addToast('error', 'Reject failed', err.message);
-    }
-  },
-
-  // ── Recommended Team ──────────────────────────────────────
-
-  async checkRecommendedTeam() {
-    try {
-      const data = await api.get('/recommended-team');
-      if (!data || !data.agents?.length) {
-        set({ recommendedTeam: null });
-        return;
-      }
-
-      // Check if all recommended roles already exist in the planner's team.
-      // If so, auto-delegate instead of showing the "Launch Team" modal.
-      const teamId = data.teamId || null;
-
-      if (teamId) {
-        const teamAgents = get().agents.filter((a) => a.teamId === teamId && a.role !== 'planner');
-        const phase1Roles = data.agents.filter((a) => !a.phase || a.phase === 1).map((a) => a.role);
-        const allExist = phase1Roles.every((role) => teamAgents.some((a) => a.role === role));
-
-        if (allExist && phase1Roles.length > 0) {
-          // 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 tlc = get().teamLaunchConfig;
-            const result = await api.post('/recommended-team/launch', {
-              teamId,
-              ...(tlc?.provider && { teamProvider: tlc.provider }),
-              ...(tlc?.model && { teamModel: tlc.model }),
-              ...(tlc?.reasoningEffort != null && { teamReasoningEffort: tlc.reasoningEffort }),
-              ...(tlc?.temperature != null && { teamTemperature: tlc.temperature }),
-            });
-            const agents = result.agents || [];
-            const failures = result.failed || [];
-            const names = agents.map((a) => a.name).join(', ') || '';
-
-            if (agents.length === 0 && failures.length > 0) {
-              get().addToast('error', 'Delegation failed', failures.map(f => f.role + ': ' + f.error).join(', '));
-            } else {
-              get().addToast('success', 'Planner delegated work', names ? `→ ${names}` : undefined);
-              if (failures.length > 0) {
-                get().addToast('warning', `${failures.length} agent(s) failed to spawn`, failures.map(f => f.role + ': ' + f.error).join(', '));
-              }
-            }
-            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 };
-            });
-          }
-          return;
-        }
-      }
-
-      // New agents needed — show the modal for approval
-      set({ recommendedTeam: { ...data, teamId: data.teamId || null } });
-    } catch {
-      set({ recommendedTeam: null });
-    }
-  },
-
-  async launchRecommendedTeam(modifiedAgents) {
-    try {
-      const teamId = get().recommendedTeam?.teamId || null;
-      const tlc = get().teamLaunchConfig;
-      set({ recommendedTeam: null }); // Dismiss modal immediately
-      get().addToast('info', 'Launching team...');
-      const body = {
-        ...(modifiedAgents && { agents: modifiedAgents }),
-        ...(teamId && { teamId }),
-        ...(tlc?.provider && { teamProvider: tlc.provider }),
-        ...(tlc?.model && { teamModel: tlc.model }),
-        ...(tlc?.reasoningEffort != null && { teamReasoningEffort: tlc.reasoningEffort }),
-        ...(tlc?.temperature != null && { teamTemperature: tlc.temperature }),
-        ...(tlc?.verbosity != null && { teamVerbosity: tlc.verbosity }),
-      };
-      const result = await api.post('/recommended-team/launch', body);
-      const totalOk = (result.launched || 0) + (result.reused || 0);
-      const failures = result.failed || [];
-
-      if (totalOk === 0 && failures.length > 0) {
-        get().addToast('error', 'Team launch failed', failures.map(f => f.role + ': ' + f.error).join(', '));
-      } else {
-        const sub = [
-          result.phase2Pending ? `${result.phase2Pending} QC queued` : '',
-          result.projectDir ? `→ ${result.projectDir}/` : '',
-        ].filter(Boolean).join(' · ');
-        get().addToast('success', `Launched ${totalOk} agents`, sub || undefined);
-        if (failures.length > 0) {
-          get().addToast('warning', `${failures.length} agent(s) failed to spawn`, failures.map(f => f.role + ': ' + f.error).join(', '));
-        }
-      }
-      // Set thinking indicator for all launched/reused agents
-      const launchedAgents = result.agents || [];
-      if (launchedAgents.length > 0) {
-        set((s) => ({
-          thinkingAgents: new Set([...s.thinkingAgents, ...launchedAgents.map((a) => a.id)]),
-        }));
-      }
-      // Clean up stale files — scoped to the launched team so plans in other
-      // teams' workspaces survive. The launch endpoint already unlinks the
-      // exact plan it read; this is a belt-and-suspenders sweep.
-      const launchedTeamId = body?.teamId || result?.teamId || null;
-      if (launchedTeamId) {
-        api.post('/cleanup', { teamId: launchedTeamId }).catch(() => {});
-      }
-      return result;
-    } catch (err) {
-      get().addToast('error', 'Launch failed', err.message);
-      throw err;
-    }
-  },
-
-  // ── Team Builder ──────────────────────────────────────────
-
-  openTeamBuilder() { set({ teamBuilderOpen: true }); },
-  closeTeamBuilder() {
-    set({
-      teamBuilderOpen: false,
-      teamBuilderRoles: [],
-      teamBuilderSettings: { provider: null, model: null, reasoningEffort: 50, temperature: 0.5 },
-      teamBuilderTask: '',
-    });
-  },
-  addTeamBuilderRole(role) {
-    set((s) => ({
-      teamBuilderRoles: [...s.teamBuilderRoles, {
-        role, name: '', provider: null, model: null,
-        reasoningEffort: null, temperature: null, prompt: '',
-      }],
-    }));
-  },
-  removeTeamBuilderRole(index) {
-    set((s) => ({ teamBuilderRoles: s.teamBuilderRoles.filter((_, i) => i !== index) }));
-  },
-  updateTeamBuilderRole(index, updates) {
-    set((s) => ({
-      teamBuilderRoles: s.teamBuilderRoles.map((r, i) => i === index ? { ...r, ...updates } : r),
-    }));
-  },
-  applyTemplate(template) {
-    set({
-      teamBuilderRoles: (template.roles || []).map((r) => ({
-        role: typeof r === 'string' ? r : r.role,
-        name: '', provider: null, model: null,
-        reasoningEffort: null, temperature: null, prompt: '',
-      })),
-    });
-  },
-  setTeamBuilderSettings(settings) {
-    set((s) => ({ teamBuilderSettings: { ...s.teamBuilderSettings, ...settings } }));
-  },
-  setTeamBuilderTask(task) { set({ teamBuilderTask: task }); },
-
-  async fetchTeamTemplates() {
-    try {
-      const data = await api.get('/team-templates');
-      const builtIn = [];
-      const custom = [];
-      for (const [key, tmpl] of Object.entries(data || {})) {
-        const entry = { ...tmpl, name: key };
-        if (tmpl.builtIn) builtIn.push(entry);
-        else custom.push(entry);
-      }
-      set({ teamTemplates: { builtIn, custom } });
-    } catch { /* endpoint may not exist yet */ }
-  },
-
-  async saveTeamTemplate(name) {
-    try {
-      const { teamBuilderRoles, teamBuilderSettings } = get();
-      await api.post('/team-templates', {
-        name,
-        roles: teamBuilderRoles.map((r) => r.role),
-        settings: teamBuilderSettings,
-      });
-      get().addToast('success', `Template "${name}" saved`);
-      get().fetchTeamTemplates();
-    } catch (err) {
-      get().addToast('error', 'Failed to save template', err.message);
-    }
-  },
-
-  async deleteTeamTemplate(name) {
-    try {
-      await api.delete(`/team-templates/${encodeURIComponent(name)}`);
-      get().addToast('info', `Template "${name}" deleted`);
-      get().fetchTeamTemplates();
-    } catch (err) {
-      get().addToast('error', 'Failed to delete template', err.message);
-    }
-  },
-
-  async launchTeamBuilder() {
-    const { teamBuilderRoles, teamBuilderSettings, teamBuilderTask, activeTeamId } = get();
-    if (teamBuilderRoles.length === 0) return;
-    set({ teamLaunchConfig: {
-      provider: teamBuilderSettings.provider || null,
-      model: teamBuilderSettings.model || null,
-      reasoningEffort: teamBuilderSettings.reasoningEffort,
-      temperature: teamBuilderSettings.temperature,
-    }});
-    get().closeTeamBuilder();
-    try {
-      const body = {
-        task: teamBuilderTask,
-        roles: teamBuilderRoles,
-        settings: teamBuilderSettings,
-        launchMode: 'plan-first',
-        teamId: activeTeamId,
-      };
-      const result = await api.post('/team-builder/launch', body);
-      get().addToast('success', 'Planner spawned — team will build automatically');
-      return result;
-    } catch (err) {
-      get().addToast('error', 'Team launch failed', err.message);
-      throw err;
-    }
-  },
-
-  // ── GitHub Repo Import ────────────────────────────────────
-
-  async fetchImportedRepos() {
-    try {
-      const repos = await api.get('/repos/imported');
-      set({ importedRepos: repos });
-    } catch { /* ignore */ }
-  },
-
-  async previewRepo(repoUrl) {
-    return api.post('/repos/preview', { repoUrl });
-  },
-
-  async importRepo(repoUrl, targetPath, createTeam, teamName) {
-    set({ importInProgress: true });
-    try {
-      const result = await api.post('/repos/import', { repoUrl, targetPath, createTeam, teamName });
-      get().fetchImportedRepos();
-      return result;
-    } finally {
-      set({ importInProgress: false });
-    }
-  },
-
-  async softRemoveRepo(importId) {
-    await api.delete(`/repos/${encodeURIComponent(importId)}/remove`);
-    get().fetchImportedRepos();
-  },
-
-  async hardNukeRepo(importId, deleteFiles = true) {
-    await api.delete(`/repos/${encodeURIComponent(importId)}/nuke?deleteFiles=${deleteFiles}`);
-    get().fetchImportedRepos();
-  },
-
-  // ── Project Directory ────────────────────────────────────
-
-  async fetchProjectDir() {
-    try {
-      const data = await api.get('/project-dir');
-      const isHome = /^\/home\/[^/]+$/.test(data.projectDir) || data.projectDir === '/root';
-      set({
-        projectDir: data.projectDir,
-        recentProjects: data.recentProjects || [],
-        showProjectPicker: isHome || (data.recentProjects || []).length === 0,
-        editorTreeCache: {},
-      });
-    } catch {}
-  },
-
-  async setProjectDir(path) {
-    const data = await api.post('/project-dir', { path });
-    try { await api.post('/files/root', { root: data.projectDir }); } catch {}
-    set({
-      projectDir: data.projectDir,
-      recentProjects: data.recentProjects || [],
-      showProjectPicker: false,
-      editorTreeCache: {},
-    });
-    get().fetchTreeDir('');
-  },
-
-  async removeRecentProject(path) {
-    try {
-      await api.delete('/projects/recent', { path });
-    } catch {}
-    get().fetchProjectDir();
-  },
-
-  toggleProjectPicker() {
-    set((s) => ({ showProjectPicker: !s.showProjectPicker }));
-  },
-
-  // ── Tunnels ──────────────────────────────────────────────
-
-  async fetchTunnels() {
-    try {
-      const tunnels = await api.get('/tunnels');
-      set({ savedTunnels: Array.isArray(tunnels) ? tunnels : [] });
-    } catch {}
-  },
-
-  async saveTunnel(config) {
-    const result = await api.post('/tunnels', config);
-    get().fetchTunnels();
-    return result;
-  },
-
-  async updateTunnel(id, config) {
-    const result = await api.patch(`/tunnels/${encodeURIComponent(id)}`, config);
-    get().fetchTunnels();
-    return result;
-  },
-
-  async deleteTunnel(id) {
-    await api.delete(`/tunnels/${encodeURIComponent(id)}`);
-    get().fetchTunnels();
-  },
-
-  async testTunnel(id) {
-    return api.post(`/tunnels/${encodeURIComponent(id)}/test`);
-  },
-
-  async connectTunnel(id) {
-    try {
-      const result = await api.post(`/tunnels/${encodeURIComponent(id)}/connect`);
-      get().fetchTunnels();
-      if (result.localPort && result.name) {
-        if (window.groove?.remote?.openWindow) {
-          window.groove.remote.openWindow(result.localPort, result.name);
-        } else {
-          window.open(`http://localhost:${result.localPort}?instance=${encodeURIComponent(result.name)}`, '_blank');
-        }
-      }
-      return result;
-    } finally {
-      set({ tunnelConnectStep: null });
-    }
-  },
-
-  async upgradeTunnel(id) {
-    return api.post(`/tunnels/${encodeURIComponent(id)}/upgrade`);
-  },
-
-  async disconnectTunnel(id) {
-    const tunnel = get().savedTunnels.find(t => t.id === id);
-    await api.post(`/tunnels/${encodeURIComponent(id)}/disconnect`);
-    get().fetchTunnels();
-    if (tunnel?.localPort && window.groove?.remote?.closeByPort) {
-      window.groove.remote.closeByPort(tunnel.localPort);
-    }
-  },
-
-  async installTunnel(id) {
-    return api.post(`/tunnels/${encodeURIComponent(id)}/install`);
-  },
-
-  async startTunnel(id) {
-    return api.post(`/tunnels/${encodeURIComponent(id)}/start`);
-  },
-
-  // ── Journalist ────────────────────────────────────────────
-
-  async fetchJournalist() {
-    try {
-      const data = await api.get('/journalist');
-      set({ journalistStatus: data });
-      return data;
-    } catch { return null; }
-  },
-
-  async triggerJournalistCycle() {
-    try {
-      const data = await api.post('/journalist/cycle');
-      get().addToast('success', 'Synthesis cycle triggered');
-      set({ journalistStatus: data });
-      return data;
-    } catch (err) {
-      get().addToast('error', 'Synthesis failed', err.message);
-      throw err;
-    }
-  },
-
-  // ── Agent Actions ─────────────────────────────────────────
-
-  async spawnAgent(config) {
-    try {
-      const teamId = get().activeTeamId;
-      const agent = await api.post('/agents', { ...config, teamId });
-      get().addToast('success', `Spawned ${agent.name}`);
-      return agent;
-    } catch (err) {
-      let detail = err.message;
-      if (detail?.includes('workingDir must be within project directory')) {
-        const projDir = get().projectDir || 'unknown';
-        const workDir = config.workingDir || 'default';
-        detail = `workingDir "${workDir}" is outside project directory "${projDir}". Change the project directory or pick a subfolder within it.`;
-      }
-      get().addToast('error', 'Spawn failed', detail);
-      throw err;
-    }
-  },
-
-  async killAgent(id, purge = false) {
-    try {
-      await api.delete(`/agents/${encodeURIComponent(id)}?purge=${purge}`);
-      if (purge) {
-        set((s) => {
-          const chatHistory = { ...s.chatHistory };
-          const activityLog = { ...s.activityLog };
-          const tokenTimeline = { ...s.tokenTimeline };
-          delete chatHistory[id];
-          delete activityLog[id];
-          delete tokenTimeline[id];
-          persistJSON('groove:chatHistory', chatHistory);
-          persistJSON('groove:activityLog', activityLog);
-          return { chatHistory, activityLog, tokenTimeline };
-        });
-      }
-    } catch (err) {
-      get().addToast('error', 'Kill failed', err.message);
-    }
-  },
-
-  async rotateAgent(id) {
-    try {
-      return await api.post(`/agents/${encodeURIComponent(id)}/rotate`);
-    } catch (err) {
-      get().addToast('error', 'Rotation failed', err.message);
-      throw err;
-    }
-  },
-
-  async fetchProviders() {
-    return api.get('/providers');
-  },
-
-  // ── Local Models (Ollama) ─────────────────────────────────
-
-  async fetchOllamaStatus() {
-    try {
-      const check = await api.post('/providers/ollama/check');
-      const updates = {
-        ollamaStatus: { installed: check.installed, serverRunning: check.serverRunning, hardware: check.hardware },
-      };
-      if (check.installed) {
-        try {
-          const models = await api.get('/providers/ollama/models');
-          updates.ollamaInstalledModels = models.installed || [];
-          updates.ollamaCatalog = models.catalog || [];
-        } catch {}
-      }
-      if (check.serverRunning) {
-        try {
-          const running = await api.get('/providers/ollama/running');
-          updates.ollamaRunningModels = running.models || [];
-        } catch {
-          updates.ollamaRunningModels = [];
-        }
-      } else {
-        updates.ollamaRunningModels = [];
-      }
-      set(updates);
-      return updates.ollamaStatus;
-    } catch {
-      return get().ollamaStatus;
-    }
-  },
-
-  async startOllamaServer() {
-    try {
-      const result = await api.post('/providers/ollama/serve');
-      if (result.ok) {
-        get().addToast('success', 'Ollama server started');
-        await new Promise((r) => setTimeout(r, 2000));
-        await get().fetchOllamaStatus();
-      }
-      return result;
-    } catch (err) {
-      get().addToast('error', 'Could not start server', err.message);
-      throw err;
-    }
-  },
-
-  async stopOllamaServer() {
-    try {
-      const result = await api.post('/providers/ollama/stop');
-      if (result.ok) {
-        get().addToast('info', 'Ollama server stopped');
-        set((s) => ({
-          ollamaStatus: { ...s.ollamaStatus, serverRunning: false },
-          ollamaRunningModels: [],
-        }));
-      }
-      return result;
-    } catch (err) {
-      get().addToast('error', 'Stop failed', err.message);
-      throw err;
-    }
-  },
-
-  async restartOllamaServer() {
-    try {
-      const result = await api.post('/providers/ollama/restart');
-      if (result.ok) {
-        get().addToast('success', 'Ollama server restarted');
-        await new Promise((r) => setTimeout(r, 2000));
-        await get().fetchOllamaStatus();
-      }
-      return result;
-    } catch (err) {
-      get().addToast('error', 'Restart failed', err.message);
-      throw err;
-    }
-  },
-
-  async pullOllamaModel(modelId) {
-    try {
-      set((s) => ({ ollamaPullProgress: { ...s.ollamaPullProgress, [modelId]: { status: 'pulling', progress: '' } } }));
-      await api.post('/providers/ollama/pull', { model: modelId });
-      set((s) => {
-        const progress = { ...s.ollamaPullProgress };
-        delete progress[modelId];
-        return { ollamaPullProgress: progress };
-      });
-      get().addToast('success', `${modelId} ready to use`);
-      get().fetchOllamaStatus();
-    } catch (err) {
-      set((s) => {
-        const progress = { ...s.ollamaPullProgress };
-        delete progress[modelId];
-        return { ollamaPullProgress: progress };
-      });
-      get().addToast('error', `Pull failed: ${err.message}`);
-    }
-  },
-
-  async deleteOllamaModel(modelId) {
-    try {
-      await api.delete(`/providers/ollama/models/${encodeURIComponent(modelId)}`);
-      set((s) => ({ ollamaInstalledModels: s.ollamaInstalledModels.filter((m) => m.id !== modelId) }));
-      get().addToast('success', `Removed ${modelId}`);
-    } catch (err) {
-      get().addToast('error', `Delete failed: ${err.message}`);
-    }
-  },
-
-  async loadOllamaModel(modelId) {
-    try {
-      await api.post('/providers/ollama/load', { model: modelId });
-      get().addToast('success', `${modelId} loaded into memory`);
-      get().fetchOllamaStatus();
-    } catch (err) {
-      get().addToast('error', `Could not load model: ${err.message}`);
-    }
-  },
-
-  async unloadOllamaModel(modelId) {
-    try {
-      await api.post('/providers/ollama/unload', { model: modelId });
-      set((s) => ({ ollamaRunningModels: s.ollamaRunningModels.filter((m) => m.name !== modelId) }));
-      get().addToast('info', `${modelId} unloaded`);
-    } catch (err) {
-      get().addToast('error', `Unload failed: ${err.message}`);
-    }
-  },
-
-  spawnFromModel(modelId) {
-    get().openDetail({ type: 'spawn', presetProvider: 'ollama', presetModel: modelId });
-  },
-
-  // ── 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(() => {});
-  },
-
-  // ── Provider Setup (Settings) ──────────────────────────────
-
-  providerInstallProgress: {},
-
-  async installProvider(providerId) {
-    const update = (patch) => set((s) => ({
-      providerInstallProgress: {
-        ...s.providerInstallProgress,
-        [providerId]: { ...s.providerInstallProgress[providerId], ...patch },
-      },
-    }));
-
-    update({ installing: true, percent: 0, message: 'Starting install...', error: null, done: false });
-
-    try {
-      const res = await fetch(`/api/providers/${encodeURIComponent(providerId)}/install`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-      });
-      if (!res.ok) {
-        const err = await res.text();
-        throw new Error(err || `Install failed (${res.status})`);
-      }
-
-      let body;
-      try {
-        body = await res.text();
-      } catch (e) {
-        throw new Error(`Failed to read response: ${e.message}`);
-      }
-
-      let lastError = null;
-      let completed = false;
-      for (const line of body.split('\n')) {
-        if (!line.trim()) continue;
-        try {
-          const ev = JSON.parse(line);
-          const isError = ev.status === 'error';
-          const isDone = ev.status === 'complete';
-          if (isError) lastError = ev.output || 'Install failed';
-          if (isDone) completed = true;
-          update({
-            percent: ev.progress ?? get().providerInstallProgress[providerId]?.percent ?? 0,
-            message: ev.output || get().providerInstallProgress[providerId]?.message,
-            error: isError ? (ev.output || 'Install failed') : null,
-            done: isDone,
-            installing: !isDone && !isError,
-          });
-        } catch { /* skip malformed line */ }
-      }
-
-      if (lastError) throw new Error(lastError);
-      if (!completed) throw new Error(body.slice(0, 500) || 'Install ended without confirmation');
-
-      update({ installing: false, percent: 100, message: 'Installed', error: null, done: true });
-      set({ _providerRefreshTick: Date.now() });
-      get().addToast('success', `${providerId} installed`);
-    } catch (err) {
-      update({ installing: false, percent: 0, message: null, error: err.message, done: false });
-      get().addToast('error', `Install failed: ${providerId}`, err.message);
-      throw err;
-    }
-  },
-
-  async loginProvider(providerId, body) {
-    try {
-      const data = await api.post(`/providers/${encodeURIComponent(providerId)}/login`, body);
-      if (data?.url && !data?.browserOpened) window.open(data.url, '_blank');
-      return data;
-    } catch (err) {
-      get().addToast('error', `Login failed`, err.message);
-      throw err;
-    }
-  },
-
-  async setProviderPath(providerId, path) {
-    try {
-      await api.post(`/providers/${encodeURIComponent(providerId)}/set-path`, { path });
-      get().addToast('success', `Custom path set for ${providerId}`);
-    } catch (err) {
-      get().addToast('error', 'Failed to set path', err.message);
-      throw err;
-    }
-  },
-
-  async verifyProvider(providerId) {
-    try {
-      const data = await api.post(`/providers/${encodeURIComponent(providerId)}/verify`);
-      return data;
-    } catch (err) {
-      get().addToast('error', `Verification failed`, 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) {
-    set((s) => {
-      const history = { ...s.chatHistory };
-      if (!history[agentId]) history[agentId] = [];
-      history[agentId] = [...history[agentId].slice(-100), { from, text, timestamp: Date.now(), isQuery }];
-      persistJSON('groove:chatHistory', history);
-      return { chatHistory: history };
-    });
-  },
-
-  // Track which agents are thinking (sent a message, waiting for response)
-  thinkingAgents: new Set(),
-
-  async stopAgent(id) {
-    try {
-      await api.post(`/agents/${encodeURIComponent(id)}/stop`);
-      // Clear thinking indicator
-      set((s) => {
-        const next = new Set(s.thinkingAgents);
-        next.delete(id);
-        return { thinkingAgents: next };
-      });
-      get().addToast('info', 'Stopped agent');
-    } catch (err) {
-      get().addToast('error', 'Stop failed', err.message);
-    }
-  },
-
-  async instructAgent(id, message) {
-    // ── Keeper command interception ─────────────────────────
-    const keeperCmd = message.match(/\[(save|append|update|delete|view|doc|link|read|instruct)\]/i);
-    if (keeperCmd) {
-      const handled = await get()._handleKeeperCommand(id, message, keeperCmd[1].toLowerCase());
-      if (handled === true) return { status: 'keeper_handled' };
-      if (handled?.passthrough) {
-        message = handled.passthrough;
-      }
-    }
-
-    get().addChatMessage(id, 'user', message, false);
-    set((s) => ({ thinkingAgents: new Set([...s.thinkingAgents, id]) }));
-
-    // Auto-attach active file context when in workspace mode
-    let enriched = message;
-    if (get().workspaceMode && get().workspaceAgentId === id && get().editorActiveFile) {
-      const filePath = get().editorActiveFile;
-      enriched = `[Active file: ${filePath}]\n\n${message}`;
-    }
-
-    const snapshot = {
-      chatHistory: [...(get().chatHistory[id] || [])],
-      activityLog: [...(get().activityLog[id] || [])],
-      tokenTimeline: [...(get().tokenTimeline[id] || [])],
-    };
-
-    try {
-      const data = await api.post(`/agents/${encodeURIComponent(id)}/instruct`, { message: enriched });
-
-      if (data.status === 'message_sent') {
-        return data;
-      }
-      if (data.status === 'message_queued') {
-        set((s) => {
-          const next = new Set(s.thinkingAgents);
-          next.delete(id);
-          return { thinkingAgents: next };
-        });
-        return data;
-      }
-
-      // CLI agent: was stopped + resumed/rotated — transfer state to new agent ID
-      const newAgent = data;
-      for (const key of ['chatHistory', 'activityLog', 'tokenTimeline']) {
-        if (snapshot[key]?.length) {
-          set((s) => ({ [key]: { ...s[key], [newAgent.id]: [...snapshot[key]] } }));
-        }
-      }
-      set((s) => {
-        const next = new Set(s.thinkingAgents);
-        next.delete(id);
-        next.add(newAgent.id);
-        return { thinkingAgents: next };
-      });
-      if (get().chatHistory[newAgent.id]?.length) persistJSON('groove:chatHistory', get().chatHistory);
-      if (get().activityLog[newAgent.id]?.length) persistJSON('groove:activityLog', get().activityLog);
-      get().selectAgent(newAgent.id);
-      return newAgent;
-    } catch (err) {
-      set((s) => {
-        const next = new Set(s.thinkingAgents);
-        next.delete(id);
-        return { thinkingAgents: next };
-      });
-      get().addChatMessage(id, 'system', `failed: ${err.message}`);
-      throw err;
-    }
-  },
-
-  async queryAgent(id, message) {
-    get().addChatMessage(id, 'user', message, true);
-    try {
-      const data = await api.post(`/agents/${encodeURIComponent(id)}/query`, { message });
-      get().addChatMessage(id, 'agent', data.response);
-      return data;
-    } catch (err) {
-      get().addChatMessage(id, 'system', `query failed: ${err.message}`);
-      throw err;
-    }
-  },
-
-  // ── Conversations (Chat view) ────────────────────────────
-
-  async fetchConversations() {
-    try {
-      const data = await api.get('/conversations');
-      set({ conversations: data.conversations || data || [] });
-    } catch { /* endpoint may not exist yet */ }
-  },
-
-  async createConversation(provider, model, mode = 'api') {
-    try {
-      const conv = await api.post('/conversations', { provider, model, mode });
-      set((s) => ({
-        conversations: [conv, ...s.conversations.filter((c) => c.id !== conv.id)],
-        activeConversationId: conv.id,
-      }));
-      localStorage.setItem('groove:activeConversationId', conv.id);
-      return conv;
-    } catch (err) {
-      get().addToast('error', 'Failed to create conversation', err.message);
-      throw err;
-    }
-  },
-
-  async setConversationMode(id, mode) {
-    if (_modeChangePending.has(id)) return;
-    _modeChangePending.add(id);
-    try {
-      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { mode });
-      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
-    } catch (err) {
-      get().addToast('error', 'Mode change failed', err.message);
-    } finally {
-      _modeChangePending.delete(id);
-    }
-  },
-
-  async setConversationModel(id, provider, model) {
-    try {
-      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { provider, model });
-      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
-    } catch (err) {
-      get().addToast('error', 'Model change failed', err.message);
-    }
-  },
-
-  async stopChatStreaming(conversationId) {
-    try {
-      await api.post(`/conversations/${encodeURIComponent(conversationId)}/stop`);
-      set({ sendingMessage: false, streamingConversationId: null });
-    } catch { /* ignore */ }
-  },
-
-  async deleteConversation(id) {
-    try {
-      await api.delete(`/conversations/${encodeURIComponent(id)}`);
-      set((s) => {
-        const conversations = s.conversations.filter((c) => c.id !== id);
-        const conversationMessages = { ...s.conversationMessages };
-        delete conversationMessages[id];
-        persistJSON('groove:conversationMessages', conversationMessages);
-        const activeConversationId = s.activeConversationId === id
-          ? (conversations[0]?.id || null)
-          : s.activeConversationId;
-        localStorage.setItem('groove:activeConversationId', activeConversationId || '');
-        const conversationRoles = { ...s.conversationRoles };
-        delete conversationRoles[id];
-        persistJSON('groove:conversationRoles', conversationRoles);
-        const conversationReasoningEffort = { ...s.conversationReasoningEffort };
-        delete conversationReasoningEffort[id];
-        persistJSON('groove:conversationReasoningEffort', conversationReasoningEffort);
-        const conversationVerbosity = { ...s.conversationVerbosity };
-        delete conversationVerbosity[id];
-        persistJSON('groove:conversationVerbosity', conversationVerbosity);
-        return { conversations, conversationMessages, conversationRoles, conversationReasoningEffort, conversationVerbosity, activeConversationId };
-      });
-    } catch (err) {
-      get().addToast('error', 'Delete failed', err.message);
-    }
-  },
-
-  async renameConversation(id, title) {
-    try {
-      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { title });
-      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
-    } catch (err) {
-      get().addToast('error', 'Rename failed', err.message);
-    }
-  },
-
-  async pinConversation(id, pinned) {
-    try {
-      const conv = await api.patch(`/conversations/${encodeURIComponent(id)}`, { pinned });
-      set((s) => ({ conversations: s.conversations.map((c) => c.id === id ? { ...c, ...conv } : c) }));
-    } catch (err) {
-      get().addToast('error', 'Pin failed', err.message);
-    }
-  },
-
-  setActiveConversation(id) {
-    set({ activeConversationId: id });
-    localStorage.setItem('groove:activeConversationId', id || '');
-  },
-
-  setConversationRole(id, role) {
-    set((s) => {
-      const roles = { ...s.conversationRoles };
-      if (role) {
-        roles[id] = role;
-      } else {
-        delete roles[id];
-      }
-      persistJSON('groove:conversationRoles', roles);
-      return { conversationRoles: roles };
-    });
-  },
-
-  setConversationReasoningEffort(id, effort) {
-    set((s) => {
-      const map = { ...s.conversationReasoningEffort };
-      map[id] = effort || 'medium';
-      persistJSON('groove:conversationReasoningEffort', map);
-      return { conversationReasoningEffort: map };
-    });
-  },
-
-  setConversationVerbosity(id, verbosity) {
-    set((s) => {
-      const map = { ...s.conversationVerbosity };
-      map[id] = verbosity || 'medium';
-      persistJSON('groove:conversationVerbosity', map);
-      return { conversationVerbosity: map };
-    });
-  },
-
-  async sendChatMessage(conversationId, message) {
-    const conv = get().conversations.find((c) => c.id === conversationId);
-    if (!conv) return;
-
-    // Add user message to local state immediately
-    set((s) => {
-      const msgs = { ...s.conversationMessages };
-      if (!msgs[conversationId]) msgs[conversationId] = [];
-      msgs[conversationId] = [...msgs[conversationId], { from: 'user', text: message, timestamp: Date.now() }];
-      persistJSON('groove:conversationMessages', msgs);
-      return { conversationMessages: msgs, sendingMessage: true, streamingConversationId: conversationId };
-    });
-
-    try {
-      const body = { message };
-      if (conv.mode === 'api' || !conv.mode) {
-        const history = get().conversationMessages[conversationId] || [];
-        body.history = history.slice(0, -1);
-
-        const role = get().conversationRoles?.[conversationId];
-        const rules = ['Never use emojis in your responses.', 'Be professional, concise, and direct.'];
-        if (role) rules.unshift(`You are a professional ${role}. Respond with deep expertise in that domain.`);
-        const systemCtx = rules.join(' ');
-        body.history = [
-          { from: 'user', text: `Instructions: ${systemCtx}` },
-          { from: 'assistant', text: 'Understood.' },
-          ...body.history,
-        ];
-      }
-      const effort = get().conversationReasoningEffort?.[conversationId] || 'medium';
-      const verbosity = get().conversationVerbosity?.[conversationId] || 'medium';
-      if (conv.provider === 'codex') {
-        body.reasoning_effort = effort;
-        body.verbosity = verbosity;
-      }
-      await api.post(`/conversations/${encodeURIComponent(conversationId)}/message`, body);
-    } catch (err) {
-      set((s) => {
-        const msgs = { ...s.conversationMessages };
-        if (!msgs[conversationId]) msgs[conversationId] = [];
-        msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Failed: ${err.message}`, timestamp: Date.now() }];
-        persistJSON('groove:conversationMessages', msgs);
-        return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
-      });
-      get().addToast('error', 'Message failed', err.message);
-    }
-  },
-
-  async sendImageMessage(conversationId, prompt, { model, size, quality } = {}) {
-    const conv = get().conversations.find((c) => c.id === conversationId);
-    if (!conv) return;
-
-    set((s) => {
-      const msgs = { ...s.conversationMessages };
-      if (!msgs[conversationId]) msgs[conversationId] = [];
-      msgs[conversationId] = [...msgs[conversationId], { from: 'user', text: prompt, timestamp: Date.now() }];
-      persistJSON('groove:conversationMessages', msgs);
-      return { conversationMessages: msgs, sendingMessage: true, streamingConversationId: conversationId };
-    });
-
-    try {
-      await api.post(`/conversations/${encodeURIComponent(conversationId)}/generate-image`, { prompt, model, size, quality });
-    } catch (err) {
-      set((s) => {
-        const msgs = { ...s.conversationMessages };
-        if (!msgs[conversationId]) msgs[conversationId] = [];
-        msgs[conversationId] = [...msgs[conversationId], { from: 'system', text: `Image failed: ${err.message}`, timestamp: Date.now() }];
-        persistJSON('groove:conversationMessages', msgs);
-        return { conversationMessages: msgs, sendingMessage: false, streamingConversationId: null };
-      });
-      get().addToast('error', 'Image generation failed', err.message);
-    }
-  },
-
-  // ── Editor ────────────────────────────────────────────────
-
-  async openFile(path) {
-    if (get().editorFiles[path] || get().editorOpenTabs.includes(path)) {
-      set((s) => ({
-        editorActiveFile: path,
-        editorOpenTabs: s.editorOpenTabs.includes(path) ? s.editorOpenTabs : [...s.editorOpenTabs, path],
-      }));
-      return;
-    }
-    const ext = path.split('.').pop()?.toLowerCase();
-    const MEDIA = ['png','jpg','jpeg','gif','svg','webp','ico','bmp','avif','mp4','webm','mov','avi','mkv','ogv'];
-    if (MEDIA.includes(ext)) {
-      set((s) => ({ editorActiveFile: path, editorOpenTabs: [...s.editorOpenTabs, path] }));
-      return;
-    }
-    try {
-      const data = await api.get(`/files/read?path=${encodeURIComponent(path)}`);
-      if (data.binary) { get().addToast('warning', 'Binary file — cannot open'); return; }
-      set((s) => ({
-        editorFiles: { ...s.editorFiles, [path]: { content: data.content, originalContent: data.content, language: data.language, loadedAt: Date.now() } },
-        editorActiveFile: path,
-        editorOpenTabs: s.editorOpenTabs.includes(path) ? s.editorOpenTabs : [...s.editorOpenTabs, path],
-      }));
-      const ws = get().ws;
-      if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:watch', path }));
-    } catch (err) {
-      get().addToast('error', 'Failed to open file', err.message);
-    }
-  },
-
-  closeFile(path) {
-    set((s) => {
-      const tabs = s.editorOpenTabs.filter((t) => t !== path);
-      const files = { ...s.editorFiles };
-      delete files[path];
-      const changed = { ...s.editorChangedFiles };
-      delete changed[path];
-      let active = s.editorActiveFile;
-      if (active === path) {
-        const idx = s.editorOpenTabs.indexOf(path);
-        active = tabs[Math.min(idx, tabs.length - 1)] || null;
-      }
-      return { editorOpenTabs: tabs, editorFiles: files, editorChangedFiles: changed, editorActiveFile: active };
-    });
-    const ws = get().ws;
-    if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:unwatch', path }));
-  },
-
-  setActiveFile(path) { set({ editorActiveFile: path }); },
-
-  setEditorSidebarWidth(width) {
-    set({ editorSidebarWidth: width });
-    localStorage.setItem('groove:editorSidebarWidth', String(width));
-  },
-  setEditorTheme(theme) {
-    set({ editorTheme: theme });
-    localStorage.setItem('groove:editorTheme', theme);
-  },
-
-  updateFileContent(path, content) {
-    set((s) => ({ editorFiles: { ...s.editorFiles, [path]: { ...s.editorFiles[path], content } } }));
-  },
-
-  async saveFile(path) {
-    const file = get().editorFiles[path];
-    if (!file) return;
-    try {
-      await api.post('/files/write', { path, content: file.content });
-      set((s) => ({
-        editorFiles: { ...s.editorFiles, [path]: { ...s.editorFiles[path], originalContent: file.content } },
-        editorChangedFiles: (() => { const c = { ...s.editorChangedFiles }; delete c[path]; return c; })(),
-        editorRecentSaves: { ...s.editorRecentSaves, [path]: Date.now() },
-      }));
-      get().addToast('success', 'File saved');
-    } catch (err) {
-      get().addToast('error', 'Save failed', err.message);
-    }
-  },
-
-  async reloadFile(path) {
-    try {
-      const data = await api.get(`/files/read?path=${encodeURIComponent(path)}`);
-      if (data.binary) return;
-      set((s) => ({
-        editorFiles: { ...s.editorFiles, [path]: { content: data.content, originalContent: data.content, language: data.language, loadedAt: Date.now() } },
-        editorChangedFiles: (() => { const c = { ...s.editorChangedFiles }; delete c[path]; return c; })(),
-      }));
-    } catch { /* ignore */ }
-  },
-
-  dismissFileChange(path) {
-    set((s) => { const c = { ...s.editorChangedFiles }; delete c[path]; return { editorChangedFiles: c }; });
-  },
-
-  async fetchTreeDir(dirPath) {
-    try {
-      const data = await api.get(`/files/tree?path=${encodeURIComponent(dirPath)}`);
-      set((s) => ({ editorTreeCache: { ...s.editorTreeCache, [dirPath]: data.entries || [] } }));
-      const ws = get().ws;
-      if (ws?.readyState === 1) ws.send(JSON.stringify({ type: 'editor:watchdir', path: dirPath }));
-    } catch (err) {
-      console.error('[file-tree] fetchTreeDir failed for', dirPath, err.message);
-      set((s) => ({ editorTreeCache: { ...s.editorTreeCache, [dirPath]: [] } }));
-    }
-  },
-
-  async createFile(relPath) {
-    try {
-      await api.post('/files/create', { path: relPath });
-      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
-      await get().fetchTreeDir(parent);
-      get().addToast('success', 'File created');
-      return true;
-    } catch (err) {
-      get().addToast('error', 'Create failed', err.message);
-      return false;
-    }
-  },
-
-  async createDir(relPath) {
-    try {
-      await api.post('/files/mkdir', { path: relPath });
-      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
-      await get().fetchTreeDir(parent);
-      get().addToast('success', 'Folder created');
-      return true;
-    } catch (err) {
-      get().addToast('error', 'Create failed', err.message);
-      return false;
-    }
-  },
-
-  async deleteFile(relPath) {
-    try {
-      await api.delete(`/files/delete?path=${encodeURIComponent(relPath)}`);
-      if (get().editorOpenTabs.includes(relPath)) get().closeFile(relPath);
-      const parent = relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '';
-      await get().fetchTreeDir(parent);
-      set((s) => { const cache = { ...s.editorTreeCache }; delete cache[relPath]; return { editorTreeCache: cache }; });
-      get().addToast('success', 'Deleted');
-      return true;
-    } catch (err) {
-      get().addToast('error', 'Delete failed', err.message);
-      return false;
-    }
-  },
-
-  // ── Workspace Mode ────────────────────────────────────────
-
-  setWorkspaceMode(on) {
-    set({ workspaceMode: on });
-    localStorage.setItem('groove:workspaceMode', String(on));
-    if (on) {
-      const teamAgents = get().agents.filter((a) => a.teamId === get().activeTeamId);
-      const current = get().workspaceAgentId;
-      const belongsToTeam = current && teamAgents.some((a) => a.id === current);
-      if (!belongsToTeam) {
-        const selected = get().detailPanel?.type === 'agent' ? get().detailPanel.agentId : null;
-        const selectedInTeam = selected && teamAgents.some((a) => a.id === selected);
-        const running = teamAgents.find((a) => a.status === 'running');
-        set({ workspaceAgentId: (selectedInTeam ? selected : null) || running?.id || teamAgents[0]?.id || null });
-      }
-      const agentId = get().workspaceAgentId;
-      if (agentId) get().selectAgent(agentId);
-    }
-  },
-
-  setWorkspaceAgent(id) {
-    set({ workspaceAgentId: id });
-    if (id) get().selectAgent(id);
-  },
-
-  captureSnapshot(path, content) {
-    set((s) => {
-      if (s.workspaceSnapshots[path]) return s;
-      const next = { ...s.workspaceSnapshots, [path]: content };
-      const keys = Object.keys(next);
-      if (keys.length > 200) {
-        delete next[keys[0]];
-      }
-      return { workspaceSnapshots: next };
-    });
-  },
-
-  async toggleReviewMode() {
-    const st = get();
-    if (st.workspaceReviewMode) {
-      set({ workspaceReviewMode: false, workspaceReviewFiles: [] });
-      return;
-    }
-    const agentId = st.workspaceAgentId;
-    if (!agentId) return;
-    try {
-      const res = await api.get(`/agents/${agentId}/files-touched`);
-      const touched = res.data || [];
-      const files = touched
-        .filter((f) => f.writes > 0)
-        .map((f) => ({ path: f.path, status: 'pending', comment: '' }));
-      set({ workspaceReviewMode: true, workspaceReviewFiles: files });
-    } catch (err) {
-      console.error('Failed to fetch touched files for review:', err);
-    }
-  },
-
-  approveFile(path) {
-    set((s) => ({
-      workspaceReviewFiles: s.workspaceReviewFiles.map((f) =>
-        f.path === path ? { ...f, status: 'approved' } : f,
-      ),
-    }));
-  },
-
-  rejectFile(path) {
-    set((s) => ({
-      workspaceReviewFiles: s.workspaceReviewFiles.map((f) =>
-        f.path === path ? { ...f, status: 'rejected' } : f,
-      ),
-    }));
-  },
-
-  commentFile(path, comment) {
-    set((s) => ({
-      workspaceReviewFiles: s.workspaceReviewFiles.map((f) =>
-        f.path === path ? { ...f, comment } : f,
-      ),
-    }));
-  },
-
-  // ── Editor (Cursor-style) ──────────────────────────────────
-
-  setEditorAgent(id) {
-    set({ editorSelectedAgent: id });
-  },
-
-  setEditorViewMode(mode) {
-    set({ editorViewMode: mode });
-  },
-
-  toggleAiPanel() {
-    set((s) => {
-      const open = !s.editorAiPanelOpen;
-      return { editorAiPanelOpen: open };
-    });
-  },
-
-  setEditorAiPanelWidth(width) {
-    set({ editorAiPanelWidth: width });
-    localStorage.setItem('groove:editorAiPanelWidth', String(width));
-  },
-
-  setEditorQuickSearchOpen(open) {
-    set({ editorQuickSearchOpen: open });
-  },
-
-  attachSnippet(snippet) {
-    set({ editorPendingSnippet: snippet });
-    if (!get().editorAiPanelOpen) {
-      set({ editorAiPanelOpen: true });
-    }
-  },
-
-  clearSnippet() {
-    set({ editorPendingSnippet: null });
-  },
-
-  async sendCodeToAgent(agentId, instruction, filePath, lineStart, lineEnd, selectedCode) {
-    if (!agentId) return;
-    get().attachSnippet({
-      type: 'code',
-      instruction,
-      filePath,
-      lineStart,
-      lineEnd,
-      code: selectedCode,
-    });
-  },
-
-  async fetchGitStatus() {
-    try {
-      const data = await api.get('/files/git-status');
-      set({ editorGitStatus: data });
-      return data;
-    } catch { return null; }
-  },
-
-  async fetchGitBranch() {
-    try {
-      const data = await api.get('/files/git-branch');
-      set({ editorGitBranch: data });
-      return data;
-    } catch { return null; }
-  },
-
-  async fetchGitDiff(path) {
-    try {
-      const url = path ? `/files/git-diff?path=${encodeURIComponent(path)}` : '/files/git-diff';
-      const data = await api.get(url);
-      set({ editorGitDiff: data });
-      return data;
-    } catch { return null; }
-  },
-
-  // ── 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 disconnectPeer(peerId) {
-    try {
-      await api.delete(`/federation/peers/${encodeURIComponent(peerId)}`);
-      get().addToast('info', 'Peer disconnected');
-      get().fetchFederationStatus();
-    } catch (err) {
-      get().addToast('error', 'Disconnect failed', err.message);
-    }
-  },
-
-  // ── Training Data ─────────────────────────────────────────
-
-  async setTrainingOptIn(enabled) {
-    try {
-      await api.post('/training/opt-in', { enabled });
-      set({ trainingOptIn: enabled, dataSharingModalOpen: false });
-      if (!enabled) set({ trainingStats: null });
-    } catch (e) {
-      get().addToast('error', 'Failed to update training preference', e.body?.detail || e.message);
-    }
-  },
-
-  async fetchTrainingStatus() {
-    try {
-      const data = await api.get('/training/status');
-      set({ trainingOptIn: data.optedIn, trainingStats: data });
-    } catch { /* endpoint may not exist on older daemons */ }
-  },
-
-  async dismissDataSharingModal(permanent) {
-    if (permanent) {
-      try { await api.patch('/config', { dataSharingDismissed: true }); } catch {}
-      set({ dataSharingDismissed: true, dataSharingModalOpen: false });
-    } else {
-      set({ dataSharingModalOpen: false });
-    }
-  },
-
-  // ── Network (Early Access) ────────────────────────────────
-
-  async fetchBetaStatus() {
-    try {
-      const data = await api.get('/beta/status');
-      set({ networkUnlocked: !!data?.unlocked });
-    } catch { /* endpoint may not exist yet */ }
-  },
-
-  async activateBeta(code) {
-    const data = await api.post('/beta/activate', { code });
-    if (!data?.unlocked) {
-      throw new Error(data?.message || 'Invalid invite code');
-    }
-    set({ networkUnlocked: true });
-    return data;
-  },
-
-  async deactivateBeta() {
-    try {
-      await api.post('/beta/deactivate');
-      set({
-        networkUnlocked: false,
-        activeView: get().activeView === 'network' ? 'agents' : get().activeView,
-      });
-    } catch (err) {
-      get().addToast('error', 'Deactivate failed', err.message);
-      throw err;
-    }
-  },
-
-  async fetchNetworkNodeStatus() {
-    try {
-      const data = await api.get('/network/node/status');
-      const update = { networkNode: { ...get().networkNode, ...(data || {}) } };
-      if (data && typeof data.installed === 'boolean') {
-        update.networkInstalled = data.installed;
-      }
-      set(update);
-      return data;
-    } catch { return null; }
-  },
-
-  async fetchNetworkInstallStatus() {
-    try {
-      const data = await api.get('/network/install/status');
-      if (data && typeof data.installed === 'boolean') {
-        set({ networkInstalled: data.installed });
-      }
-      return data;
-    } catch { return null; }
-  },
-
-  async installNetworkPackage() {
-    set({
-      networkInstallProgress: {
-        installing: true,
-        step: 'starting',
-        message: 'Starting install…',
-        percent: 0,
-        error: null,
-      },
-    });
-    try {
-      await api.post('/network/install');
-    } catch (err) {
-      set({
-        networkInstallProgress: {
-          installing: false,
-          step: 'error',
-          message: err.message,
-          percent: 0,
-          error: err.message,
-        },
-      });
-      get().addToast('error', 'Install failed', err.message);
-    }
-  },
-
-  async uninstallNetworkPackage() {
-    try {
-      await api.post('/network/uninstall');
-      set({
-        networkInstalled: false,
-        networkNode: { active: false, status: 'disconnected', nodeId: null, layers: null, model: null, sessions: 0, hardware: null },
-        networkInstallProgress: { installing: false, step: null, message: null, percent: 0, error: null },
-      });
-      get().addToast('success', 'Network package uninstalled');
-    } catch (err) {
-      get().addToast('error', 'Uninstall failed', err.message);
-      throw err;
-    }
-  },
-
-  async fetchNetworkStatus() {
-    try {
-      const data = await api.get('/network/status');
-      const update = {
-        networkStatus: { ...get().networkStatus, ...(data || {}) },
-        networkStatusReachable: true,
-      };
-      if (data?.compute) {
-        const c = data.compute;
-        update.networkCompute = {
-          totalRamMb: c.totalRamMb ?? c.total_ram_mb ?? 0,
-          totalVramMb: c.totalVramMb ?? c.total_vram_mb ?? 0,
-          totalCpuCores: c.totalCpuCores ?? c.total_cpu_cores ?? 0,
-          totalBandwidthMbps: c.totalBandwidthMbps ?? c.total_bandwidth_mbps ?? 0,
-          activeNodes: c.activeNodes ?? c.active_nodes ?? 0,
-          totalNodes: c.totalNodes ?? c.total_nodes ?? 0,
-          avgLoad: c.avgLoad ?? c.avg_load ?? 0,
-        };
-      } else if (Array.isArray(data?.nodes) && data.nodes.length > 0) {
-        const nodes = data.nodes;
-        const active = nodes.filter((n) => n.status === 'active');
-        update.networkCompute = {
-          totalRamMb: nodes.reduce((s, n) => s + (n.ram_mb || 0), 0),
-          totalVramMb: nodes.reduce((s, n) => s + (n.vram_mb || 0), 0),
-          totalCpuCores: nodes.reduce((s, n) => s + (n.cpu_cores || 0), 0),
-          totalBandwidthMbps: nodes.reduce((s, n) => s + (n.bandwidth_mbps || 0), 0),
-          activeNodes: active.length,
-          totalNodes: nodes.length,
-          avgLoad: active.length > 0 ? active.reduce((s, n) => s + (n.load || 0), 0) / active.length : 0,
-        };
-      }
-      set(update);
-
-      // Push snapshot for activity chart
-      if (data) {
-        const ownId = get().networkNode.nodeId;
-        const nodes = data.nodes || [];
-        const ownNode = ownId ? nodes.find((n) => (n.node_id || n.nodeId) === ownId) : null;
-        const activeNodes = nodes.filter((n) => n.status === 'active');
-        const snap = {
-          t: Date.now(),
-          globalSessions: data.activeSessions || 0,
-          mySessions: ownNode?.active_sessions ?? ownNode?.sessions ?? 0,
-          nodeCount: activeNodes.length,
-          avgLoad: activeNodes.length > 0 ? activeNodes.reduce((s, n) => s + (n.load || 0), 0) / activeNodes.length : 0,
-          myLoad: ownNode?.load ?? 0,
-          totalVramMb: nodes.reduce((s, n) => s + (n.vram_mb || 0), 0),
-          totalRamMb: nodes.reduce((s, n) => s + (n.ram_mb || 0), 0),
-        };
-        let snapshots = [...get().networkSnapshots, snap];
-        if (snapshots.length > 100) snapshots = snapshots.slice(-100);
-        set({ networkSnapshots: snapshots });
-      }
-
-      return data;
-    } catch {
-      set({ networkStatusReachable: false });
-      return null;
-    }
-  },
-
-  async checkNetworkUpdate() {
-    try {
-      const data = await api.get('/network/update/check');
-      if (!data) return null;
-      set({
-        networkVersion: {
-          installed: data.installed ?? null,
-          latest: data.latest ?? null,
-          updateAvailable: !!data.updateAvailable,
-        },
-      });
-      return data;
-    } catch { return null; }
-  },
-
-  async updateNetworkPackage() {
-    set({
-      networkUpdateProgress: {
-        updating: true,
-        step: 'starting',
-        message: 'Starting update…',
-        percent: 0,
-        error: null,
-      },
-    });
-    try {
-      await api.post('/network/update');
-    } catch (err) {
-      set({
-        networkUpdateProgress: {
-          updating: false,
-          step: 'error',
-          message: err.message,
-          percent: 0,
-          error: err.message,
-        },
-      });
-      get().addToast('error', 'Update failed', err.message);
-    }
-  },
-
-  async startNetworkNode() {
-    set({ networkNode: { ...get().networkNode, status: 'connecting' } });
-    try {
-      const data = await api.post('/network/node/start');
-      set({ networkNode: { ...get().networkNode, active: true, ...(data || {}) } });
-      get().addToast('success', 'Node started', 'Connecting to the Groove network');
-      return data;
-    } catch (err) {
-      set({ networkNode: { ...get().networkNode, status: 'disconnected', active: false } });
-      get().addToast('error', 'Node start failed', err.message);
-      throw err;
-    }
-  },
-
-  async stopNetworkNode() {
-    try {
-      await api.post('/network/node/stop');
-      set({ networkNode: { ...get().networkNode, active: false, status: 'disconnected' } });
-      get().addToast('info', 'Node stopped');
-    } catch (err) {
-      get().addToast('error', 'Node stop failed', err.message);
-      throw err;
-    }
-  },
-
-  async fetchNetworkWallet() {
-    return get().networkWallet;
-  },
-  async fetchNetworkEarnings() {
-    return get().networkEarnings;
-  },
-
-  async fetchNetworkBenchmarks() {
-    try {
-      const data = await api.get('/network/benchmarks');
-      if (Array.isArray(data)) set({ networkBenchmarks: data.slice(-100) });
-      return data;
-    } catch { return null; }
-  },
-
-  async fetchNetworkTraces() {
-    try {
-      const data = await api.get('/network/traces');
-      if (Array.isArray(data)) set({ networkTraces: data });
-      return data;
-    } catch { return null; }
-  },
-
-  async fetchNetworkTrace(filename) {
-    try {
-      return await api.get(`/network/traces/${encodeURIComponent(filename)}`);
-    } catch { return null; }
-  },
-
-  async fetchLiveTrace(offset = 0) {
-    try {
-      return await api.get(`/network/traces/live?offset=${offset}`);
-    } catch { return null; }
-  },
-
-  // ── Model Lab Actions ──────────────────────────────────────
-
-  setLabParameter(key, value) {
-    const params = { ...get().labParameters, [key]: value };
-    set({ labParameters: params });
-    persistJSON('groove:labParameters', params);
-  },
-
-  setLabSystemPrompt(text) {
-    set({ labSystemPrompt: text });
-    localStorage.setItem('groove:labSystemPrompt', text);
-  },
-
-  async fetchLabRuntimes() {
-    try {
-      const raw = await api.get('/lab/runtimes');
-      const data = raw.map((rt) => ({
-        ...rt,
-        status: rt.online === true ? 'connected' : rt.online === false ? 'error' : rt.status,
-      }));
-      set({ labRuntimes: data });
-      persistJSON('groove:labRuntimes', data);
-      if (data.length > 0 && !get().labActiveRuntime) {
-        get().setLabActiveRuntime(data[0].id);
-      } else if (get().labActiveRuntime) {
-        get().fetchLabModels(get().labActiveRuntime);
-      }
-    } catch { /* backend may not have lab endpoints yet */ }
-  },
-
-  async fetchLabLocalModels() {
-    try {
-      const data = await api.get('/lab/local-models');
-      set({ labLocalModels: data });
-    } catch { set({ labLocalModels: [] }); }
-  },
-
-  async checkLlamaStatus() {
-    try {
-      const data = await api.get('/llama/status');
-      set({ labLlamaInstalled: !!data.installed });
-    } catch { set({ labLlamaInstalled: false }); }
-  },
-
-  async launchLocalModel(modelId) {
-    set({ labLaunching: modelId, labLaunchPhase: 'starting', labLaunchError: null });
-    try {
-      const result = await api.post('/lab/launch-local', { modelId });
-      const runtimes = await api.get('/lab/runtimes');
-      set({ labRuntimes: runtimes });
-      persistJSON('groove:labRuntimes', runtimes);
-      get().setLabActiveRuntime(result.runtime.id);
-      set({ labActiveModel: result.model, labLaunching: null, labLaunchPhase: 'ready' });
-      get().addToast('success', `Launched ${result.model}`);
-      setTimeout(() => { if (get().labLaunchPhase === 'ready') set({ labLaunchPhase: null }); }, 3000);
-      return result;
-    } catch (err) {
-      set({ labLaunching: null, labLaunchPhase: 'error', labLaunchError: err.message });
-      get().addToast('error', 'Failed to launch model', err.message);
-      throw err;
-    }
-  },
-
-  async addLabRuntime(runtime) {
-    try {
-      const created = await api.post('/lab/runtimes', runtime);
-      const runtimes = [...get().labRuntimes, created];
-      set({ labRuntimes: runtimes });
-      persistJSON('groove:labRuntimes', runtimes);
-      get().setLabActiveRuntime(created.id);
-      get().addToast('success', `Runtime "${runtime.name}" added`);
-      return created;
-    } catch (err) {
-      get().addToast('error', 'Failed to add runtime', err.message);
-      throw err;
-    }
-  },
-
-  async removeLabRuntime(id) {
-    try {
-      await api.delete(`/lab/runtimes/${id}`);
-      const runtimes = get().labRuntimes.filter((r) => r.id !== id);
-      const active = get().labActiveRuntime === id ? null : get().labActiveRuntime;
-      set({ labRuntimes: runtimes, labActiveRuntime: active, labModels: active ? get().labModels : [] });
-      persistJSON('groove:labRuntimes', runtimes);
-      get().addToast('success', 'Runtime removed');
-    } catch (err) {
-      get().addToast('error', 'Failed to remove runtime', err.message);
-    }
-  },
-
-  async testLabRuntime(id) {
-    try {
-      const result = await api.post(`/lab/runtimes/${id}/test`);
-      const runtimes = get().labRuntimes.map((r) =>
-        r.id === id ? { ...r, status: result.ok ? 'connected' : 'error', latency: result.latency } : r,
-      );
-      const updates = { labRuntimes: runtimes };
-      if (result.ok && result.models && get().labActiveRuntime === id) {
-        updates.labModels = result.models;
-      }
-      set(updates);
-      persistJSON('groove:labRuntimes', runtimes);
-      return result;
-    } catch (err) {
-      const runtimes = get().labRuntimes.map((r) =>
-        r.id === id ? { ...r, status: 'error' } : r,
-      );
-      set({ labRuntimes: runtimes });
-      persistJSON('groove:labRuntimes', runtimes);
-      return { ok: false, error: err.message };
-    }
-  },
-
-  setLabActiveRuntime(id) {
-    set({ labActiveRuntime: id, labModels: [], labActiveModel: null });
-    if (id) get().fetchLabModels(id);
-  },
-
-  setLabActiveModel(model) {
-    set({ labActiveModel: model });
-  },
-
-  async fetchLabModels(runtimeId) {
-    try {
-      const data = await api.get(`/lab/runtimes/${runtimeId}/models`);
-      set({ labModels: data });
-    } catch { set({ labModels: [] }); }
-  },
-
-  newLabSession() {
-    const id = `lab-${Date.now()}`;
-    const session = { id, messages: [], createdAt: Date.now() };
-    set((s) => ({
-      labSessions: [session, ...s.labSessions],
-      labActiveSession: id,
-      labMetrics: { ttft: null, tokensPerSec: null, tokensPerSecHistory: [], memory: null, totalTokens: 0, generationTime: null },
-    }));
-    return id;
-  },
-
-  loadLabSession(id) {
-    set({ labActiveSession: id });
-  },
-
-  async sendLabMessage(text) {
-    const st = get();
-    if (st.labStreaming) return;
-    let sessionId = st.labActiveSession;
-    if (!sessionId) sessionId = get().newLabSession();
-
-    const userMsg = { role: 'user', content: text, timestamp: Date.now() };
-    set((s) => {
-      const sessions = s.labSessions.map((sess) =>
-        sess.id === sessionId ? { ...sess, messages: [...sess.messages, userMsg] } : sess,
-      );
-      return { labSessions: sessions, labStreaming: true };
-    });
-
-    const assistantMsg = { role: 'assistant', content: '', timestamp: Date.now(), metrics: null };
-    set((s) => {
-      const sessions = s.labSessions.map((sess) =>
-        sess.id === sessionId ? { ...sess, messages: [...sess.messages, assistantMsg] } : sess,
-      );
-      return { labSessions: sessions };
-    });
-
-    const abortController = new AbortController();
-    set({ labAbortController: abortController });
-
-    const startTime = performance.now();
-    let firstTokenTime = null;
-    let tokenCount = 0;
-
-    try {
-      const p = st.labParameters;
-      const parameters = {};
-      if (p.temperature !== undefined) parameters.temperature = p.temperature;
-      if (p.topP !== undefined) parameters.top_p = p.topP;
-      if (p.topK !== undefined) parameters.top_k = p.topK;
-      if (p.repeatPenalty !== undefined) parameters.repeat_penalty = p.repeatPenalty;
-      if (p.maxTokens !== undefined) parameters.max_tokens = p.maxTokens;
-      if (p.frequencyPenalty !== undefined) parameters.frequency_penalty = p.frequencyPenalty;
-      if (p.presencePenalty !== undefined) parameters.presence_penalty = p.presencePenalty;
-
-      const messages = [];
-      if (st.labSystemPrompt) messages.push({ role: 'system', content: st.labSystemPrompt });
-      const sessionMsgs = get().labSessions.find((s) => s.id === sessionId)?.messages || [];
-      for (const m of sessionMsgs) {
-        if (m.role === 'assistant' && !m.content) continue;
-        messages.push({ role: m.role, content: m.content });
-      }
-
-      const body = {
-        runtimeId: st.labActiveRuntime,
-        model: st.labActiveModel,
-        messages,
-        parameters,
-        sessionId,
-      };
-
-      const res = await fetch('/api/lab/inference', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: abortController.signal,
-      });
-
-      if (!res.ok) {
-        let errMsg;
-        try { errMsg = (await res.json()).error || `HTTP ${res.status}`; } catch { errMsg = `HTTP ${res.status}`; }
-        throw new Error(errMsg);
-      }
-
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = '';
-      let fullContent = '';
-      let fullReasoning = '';
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) continue;
-          const payload = line.slice(6);
-          if (payload === '[DONE]') continue;
-          try {
-            const parsed = JSON.parse(payload);
-
-            // Support both raw OpenAI format (piped) and legacy wrapper format
-            const delta = parsed.choices?.[0]?.delta;
-            const reasoningText = delta?.reasoning_content || (parsed.type === 'reasoning' ? parsed.content : null);
-            const contentText = delta?.content || (parsed.type === 'token' ? parsed.content : null);
-
-            if (reasoningText) {
-              if (!firstTokenTime) firstTokenTime = performance.now();
-              tokenCount++;
-              fullReasoning += reasoningText;
-              set((s) => {
-                const sessions = s.labSessions.map((sess) => {
-                  if (sess.id !== sessionId) return sess;
-                  const msgs = [...sess.messages];
-                  msgs[msgs.length - 1] = { ...msgs[msgs.length - 1], reasoning: fullReasoning };
-                  return { ...sess, messages: msgs };
-                });
-                return { labSessions: sessions };
-              });
-            }
-            if (contentText) {
-              if (!firstTokenTime) firstTokenTime = performance.now();
-              tokenCount++;
-              fullContent += contentText;
-              set((s) => {
-                const sessions = s.labSessions.map((sess) => {
-                  if (sess.id !== sessionId) return sess;
-                  const msgs = [...sess.messages];
-                  msgs[msgs.length - 1] = { ...msgs[msgs.length - 1], content: fullContent };
-                  return { ...sess, messages: msgs };
-                });
-                return { labSessions: sessions };
-              });
-            }
-
-            // Handle done event (legacy wrapper) or finish_reason (raw OpenAI)
-            if (parsed.type === 'done' && parsed.metrics) {
-              const elapsed = performance.now() - startTime;
-              const ttft = firstTokenTime ? firstTokenTime - startTime : null;
-              const tps = tokenCount > 0 && elapsed > 0 ? (tokenCount / (elapsed / 1000)) : null;
-              const msgMetrics = { ttft, tokensPerSec: tps, tokens: tokenCount, generationTime: elapsed, ...parsed.metrics };
-
-              set((s) => {
-                const tpsHist = [...s.labMetrics.tokensPerSecHistory, tps].slice(-10);
-                const sessions = s.labSessions.map((sess) => {
-                  if (sess.id !== sessionId) return sess;
-                  const msgs = [...sess.messages];
-                  msgs[msgs.length - 1] = { ...msgs[msgs.length - 1], metrics: msgMetrics };
-                  return { ...sess, messages: msgs };
-                });
-                return {
-                  labSessions: sessions,
-                  labMetrics: {
-                    ttft, tokensPerSec: tps, tokensPerSecHistory: tpsHist,
-                    memory: parsed.metrics.memoryUsage || s.labMetrics.memory,
-                    totalTokens: s.labMetrics.totalTokens + (parsed.metrics.totalTokens || tokenCount),
-                    generationTime: parsed.metrics.generationTime || elapsed,
-                  },
-                };
-              });
-            }
-            if (parsed.type === 'error') {
-              throw new Error(parsed.error || 'Inference error');
-            }
-          } catch (e) {
-            if (e.message && e.message !== 'Inference error' && !e.message.startsWith('HTTP ')) continue;
-            throw e;
-          }
-        }
-      }
-
-      // Compute final metrics from client-side timing
-      const elapsed = performance.now() - startTime;
-      const ttft = firstTokenTime ? firstTokenTime - startTime : null;
-      const tps = tokenCount > 0 && elapsed > 0 ? (tokenCount / (elapsed / 1000)) : null;
-      if (tokenCount > 0) {
-        set((s) => {
-          const tpsHist = [...s.labMetrics.tokensPerSecHistory, tps].slice(-10);
-          const sessions = s.labSessions.map((sess) => {
-            if (sess.id !== sessionId) return sess;
-            const msgs = [...sess.messages];
-            const last = msgs[msgs.length - 1];
-            if (!last?.metrics) {
-              msgs[msgs.length - 1] = { ...last, metrics: { ttft, tokensPerSec: tps, tokens: tokenCount, generationTime: elapsed } };
-            }
-            return { ...sess, messages: msgs };
-          });
-          return {
-            labSessions: sessions,
-            labMetrics: { ...s.labMetrics, ttft, tokensPerSec: tps, tokensPerSecHistory: tpsHist, totalTokens: s.labMetrics.totalTokens + tokenCount, generationTime: elapsed },
-          };
-        });
-      }
-    } catch (err) {
-      if (err.name === 'AbortError') {
-        // User cancelled — keep whatever content was already streamed
-      } else {
-        set((s) => {
-          const sessions = s.labSessions.map((sess) => {
-            if (sess.id !== sessionId) return sess;
-            const msgs = [...sess.messages];
-            msgs[msgs.length - 1] = { ...msgs[msgs.length - 1], content: `Error: ${err.message}`, error: true };
-            return { ...sess, messages: msgs };
-          });
-          return { labSessions: sessions };
-        });
-      }
-    } finally {
-      set({ labStreaming: false, labAbortController: null });
-    }
-  },
-
-  stopLabInference() {
-    const ctrl = get().labAbortController;
-    if (ctrl) ctrl.abort();
-  },
-
-  saveLabPreset(name) {
-    const st = get();
-    const preset = {
-      id: `preset-${Date.now()}`,
-      name,
-      parameters: { ...st.labParameters },
-      systemPrompt: st.labSystemPrompt,
-      runtimeId: st.labActiveRuntime,
-      model: st.labActiveModel,
-      createdAt: Date.now(),
-    };
-    const presets = [...st.labPresets.filter((p) => p.name !== name), preset];
-    set({ labPresets: presets, labActivePreset: preset.id });
-    persistJSON('groove:labPresets', presets);
-    get().addToast('success', `Preset "${name}" saved`);
-    return preset;
-  },
-
-  loadLabPreset(id) {
-    const preset = get().labPresets.find((p) => p.id === id);
-    if (!preset) return;
-    const updates = {
-      labParameters: { ...preset.parameters },
-      labSystemPrompt: preset.systemPrompt || '',
-      labActivePreset: id,
-    };
-    if (preset.model) updates.labActiveModel = preset.model;
-    set(updates);
-    persistJSON('groove:labParameters', preset.parameters);
-    if (preset.systemPrompt !== undefined) localStorage.setItem('groove:labSystemPrompt', preset.systemPrompt);
-  },
-
-  deleteLabPreset(id) {
-    const presets = get().labPresets.filter((p) => p.id !== id);
-    set({ labPresets: presets, labActivePreset: get().labActivePreset === id ? null : get().labActivePreset });
-    persistJSON('groove:labPresets', presets);
-    get().addToast('success', 'Preset deleted');
-  },
-
-  async launchLabAssistant(backend) {
-    const existing = get().labAssistantAgentId;
-    if (existing) {
-      const agent = get().agents.find((a) => a.id === existing);
-      if (agent && agent.status === 'running') {
-        set({ labAssistantMode: true });
-        return;
-      }
-    }
-    try {
-      const data = await api.post('/lab/assistant', { backend });
-      localStorage.setItem('groove:labAssistantAgentId', data.agentId);
-      localStorage.setItem('groove:labAssistantBackend', backend);
-      set({ labAssistantAgentId: data.agentId, labAssistantMode: true, labAssistantBackend: backend });
-      get().addToast('info', `Lab Assistant started for ${backend}`);
-    } catch (err) {
-      get().addToast('error', 'Failed to start assistant', err.message);
-    }
-  },
-
-  dismissLabAssistant() {
-    set({ labAssistantMode: false });
-  },
-
-  clearLabAssistant() {
-    const id = get().labAssistantAgentId;
-    if (id) api.delete(`/agents/${encodeURIComponent(id)}`).catch(() => {});
-    localStorage.removeItem('groove:labAssistantAgentId');
-    localStorage.removeItem('groove:labAssistantBackend');
-    set({ labAssistantAgentId: null, labAssistantMode: false, labAssistantBackend: null });
-  },
-
-  setLabAssistantMode(mode) {
-    set({ labAssistantMode: mode });
-  },
-
-  async renameFile(oldPath, newPath) {
-    try {
-      await api.post('/files/rename', { oldPath, newPath });
-      set((s) => {
-        const tabs = s.editorOpenTabs.map((t) => t === oldPath ? newPath : t);
-        const files = { ...s.editorFiles };
-        if (files[oldPath]) { files[newPath] = files[oldPath]; delete files[oldPath]; }
-        const active = s.editorActiveFile === oldPath ? newPath : s.editorActiveFile;
-        return { editorOpenTabs: tabs, editorFiles: files, editorActiveFile: active };
-      });
-      const oldParent = oldPath.includes('/') ? oldPath.split('/').slice(0, -1).join('/') : '';
-      const newParent = newPath.includes('/') ? newPath.split('/').slice(0, -1).join('/') : '';
-      await get().fetchTreeDir(oldParent);
-      if (newParent !== oldParent) await get().fetchTreeDir(newParent);
-      get().addToast('success', 'Renamed');
-      return true;
-    } catch (err) {
-      get().addToast('error', 'Rename failed', err.message);
-      return false;
-    }
-  },
-
-  // ── Integration Agent Install ────────────────────────────
-
-  async installViaExistingAgent(integration, agentId) {
-    const message = buildIntegrationPrompt(integration);
-    await get().instructAgent(agentId, message);
-    get().setActiveView('agents');
-    get().selectAgent(agentId);
-  },
-
-  async spawnIntegrationTeam(integration) {
-    const team = await get().createTeam(integration.name);
-    const prompt = buildIntegrationPrompt(integration);
-    const agent = await get().spawnAgent({ role: 'planner', prompt, teamId: team.id });
-    get().setActiveView('agents');
-    get().selectAgent(agent.id);
-    return agent;
-  },
 }));
-
-function buildIntegrationPrompt(integration) {
-  const lines = [
-    `Set up the "${integration.name}" integration for this project.`,
-    '',
-  ];
-  if (integration.description) lines.push(`**Description:** ${integration.description}`);
-  if (integration.npmPackage) lines.push(`**npm package:** ${integration.npmPackage}`);
-  if (integration.authType) lines.push(`**Auth type:** ${integration.authType}`);
-  if (integration.envKeys?.length) {
-    lines.push('', '**Environment keys required:**');
-    for (const k of integration.envKeys) {
-      lines.push(`- \`${k.key}\` — ${k.label}${k.required ? ' (required)' : ''}`);
-    }
-  }
-  if (integration.setupSteps?.length) {
-    lines.push('', '**Setup steps:**');
-    integration.setupSteps.forEach((step, i) => lines.push(`${i + 1}. ${step}`));
-  }
-  if (integration.setupUrl) lines.push(``, `**Setup URL:** ${integration.setupUrl}`);
-  if (integration.agentInstructions) lines.push('', `**Agent instructions:** ${integration.agentInstructions}`);
-  return lines.join('\n');
-}