@xenosystem/agent-interface-ui 0.1.3

package/dist/stores/workspaceStore.js

@@ -0,0 +1,694 @@
+import { getAgentPlatformBridge } from '../platformBridge';
+/**
+ * Workspace Store — Zustand store with file-backed persistence
+ *
+ * Manages the workspace → team → agent hierarchy.
+ * Persists to ~/.xeno/workspaces.json via Electron IPC.
+ * Conversations are NOT stored here — they live in agentChatStore.
+ */
+import { create } from 'zustand';
+import { useAgentChatStore } from './agentChatStore';
+import { DEFAULT_HUB_AGENT_RUNTIME_SELECTION, normalizeHubAgentRuntimeSelection, } from '../utils/agentRuntimeProvider';
+// =============================================================================
+// HELPERS
+// =============================================================================
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+const DEFAULT_CAPABILITIES = {
+    terminal: true,
+    fileRead: true,
+    fileWrite: false,
+    appLaunch: true,
+};
+const DEFAULT_PERMISSION_PROFILE = 'standard';
+const VALID_PERMISSION_PROFILES = new Set([
+    'standard',
+    'read-only',
+    'edit-with-approval',
+    'trusted-workspace',
+    'plan',
+]);
+function normalizePermissionProfile(value) {
+    if (typeof value !== 'string')
+        return DEFAULT_PERMISSION_PROFILE;
+    const normalized = value.trim().toLowerCase();
+    return VALID_PERMISSION_PROFILES.has(normalized) ? normalized : DEFAULT_PERMISSION_PROFILE;
+}
+function normalizeTeamAgentCallPolicy(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const stringArray = (entry) => Array.isArray(entry)
+        ? Array.from(new Set(entry.filter((item) => typeof item === 'string' && !!item.trim()).map(item => item.trim())))
+        : undefined;
+    const positiveNumber = (entry) => (typeof entry === 'number' && Number.isFinite(entry) && entry > 0 ? Math.floor(entry) : undefined);
+    const allowedExpectedArtifacts = Array.isArray(record.allowedExpectedArtifacts)
+        ? record.allowedExpectedArtifacts.filter((entry) => (entry === 'answer' || entry === 'file' || entry === 'diff' || entry === 'diagnostic' || entry === 'report'))
+        : undefined;
+    const policy = {
+        callableAgentIds: stringArray(record.callableAgentIds),
+        deniedAgentIds: stringArray(record.deniedAgentIds),
+        maxConcurrentChildRuns: positiveNumber(record.maxConcurrentChildRuns),
+        maxChildDepth: positiveNumber(record.maxChildDepth),
+        maxTokens: positiveNumber(record.maxTokens),
+        maxCredits: positiveNumber(record.maxCredits),
+        maxRuntimeMs: positiveNumber(record.maxRuntimeMs),
+        contextAttachmentLimit: positiveNumber(record.contextAttachmentLimit),
+        allowedExpectedArtifacts,
+        allowFurtherDelegation: typeof record.allowFurtherDelegation === 'boolean' ? record.allowFurtherDelegation : undefined,
+        cancellationPropagation: typeof record.cancellationPropagation === 'boolean' ? record.cancellationPropagation : undefined,
+    };
+    return Object.values(policy).some((entry) => entry !== undefined) ? policy : undefined;
+}
+function normalizeLoadedAgent(agent) {
+    return {
+        ...agent,
+        capabilities: agent.capabilities || DEFAULT_CAPABILITIES,
+        permissionProfile: normalizePermissionProfile(agent.permissionProfile),
+        runtimeSelection: normalizeHubAgentRuntimeSelection(agent.runtimeSelection),
+        allowedDirectories: Array.isArray(agent.allowedDirectories) ? agent.allowedDirectories : [],
+        allowedApps: Array.isArray(agent.allowedApps) ? agent.allowedApps : [],
+        approvalRules: Array.isArray(agent.approvalRules) ? agent.approvalRules : [],
+        conversations: Array.isArray(agent.conversations) ? agent.conversations : [],
+    };
+}
+function normalizeLoadedWorkspaces(workspaces) {
+    return workspaces.map((workspace) => ({
+        ...workspace,
+        directories: Array.isArray(workspace.directories) ? workspace.directories : [],
+        apps: Array.isArray(workspace.apps) ? workspace.apps : [],
+        teams: (Array.isArray(workspace.teams) ? workspace.teams : []).map((team) => ({
+            ...team,
+            allowedDirectories: Array.isArray(team.allowedDirectories) ? team.allowedDirectories : [],
+            allowedApps: Array.isArray(team.allowedApps) ? team.allowedApps : [],
+            teamAgentPolicy: normalizeTeamAgentCallPolicy(team.teamAgentPolicy),
+            agents: (Array.isArray(team.agents) ? team.agents : []).map(normalizeLoadedAgent),
+        })),
+    }));
+}
+// Debounced persist
+let persistTimer = null;
+function schedulePersist(workspaces) {
+    if (persistTimer)
+        clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+        persistTimer = null;
+        const teamCount = workspaces.reduce((sum, w) => sum + w.teams.length, 0);
+        const agentCount = workspaces.reduce((sum, w) => sum + w.teams.reduce((s, t) => s + t.agents.length, 0), 0);
+        console.warn(`[WorkspaceStore] Saving ${workspaces.length} workspaces, ${teamCount} teams, ${agentCount} agents`);
+        getAgentPlatformBridge()?.workspaceStorage?.save(workspaces).catch((err) => {
+            console.warn('[WorkspaceStore] Save failed:', err);
+        });
+    }, 300);
+}
+function flushPersist(workspaces) {
+    if (persistTimer)
+        clearTimeout(persistTimer);
+    persistTimer = null;
+    console.warn(`[WorkspaceStore] Flush-saving (delete operation)`);
+    getAgentPlatformBridge()?.workspaceStorage?.save(workspaces).catch((err) => {
+        console.warn('[WorkspaceStore] Save failed:', err);
+    });
+}
+let workspaceStorageChangedListenerRegistered = false;
+let workspaceStorageChangedUnsupportedReported = false;
+/**
+ * Registers the cross-surface workspace-change listener when the active platform
+ * bridge actually provides one.
+ *
+ * The presence of `onChanged` is NOT proof the capability works, so the
+ * "registered" latch is only set once registration has actually completed. When the
+ * surface does not deliver change notifications the absence is reported once and the
+ * latch stays open, so a later bridge that does support it can still register.
+ */
+function ensureWorkspaceStorageChangedListener() {
+    if (workspaceStorageChangedListenerRegistered)
+        return;
+    const storage = getAgentPlatformBridge()?.workspaceStorage;
+    if (typeof storage?.onChanged !== 'function') {
+        if (!workspaceStorageChangedUnsupportedReported) {
+            workspaceStorageChangedUnsupportedReported = true;
+            console.warn('[WorkspaceStore] This surface does not deliver workspace-storage change notifications — '
+                + 'workspaces edited in another window or surface will not reload automatically.');
+        }
+        return;
+    }
+    try {
+        storage.onChanged(() => {
+            void useWorkspaceStore.getState().loadWorkspaces();
+        });
+        workspaceStorageChangedListenerRegistered = true;
+    }
+    catch (err) {
+        console.warn('[WorkspaceStore] Failed to register the workspace-storage change listener:', err);
+    }
+}
+// Cascade: collect all agent IDs from a workspace
+function collectAgentIds(workspace) {
+    return workspace.teams.flatMap(t => t.agents.map(a => a.id));
+}
+// Cascade: delete conversations for a list of agent IDs
+function cascadeDeleteConversations(agentIds) {
+    const store = useAgentChatStore.getState();
+    const conversations = store.conversations;
+    for (const conv of Object.values(conversations)) {
+        if (agentIds.includes(conv.agentId)) {
+            store.deleteConversation(conv.id);
+        }
+    }
+}
+export const useWorkspaceStore = create((set, get) => ({
+    workspaces: [],
+    isLoaded: false,
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+    loadWorkspaces: async () => {
+        try {
+            ensureWorkspaceStorageChangedListener();
+            const result = await getAgentPlatformBridge()?.workspaceStorage?.load();
+            if (result?.success && Array.isArray(result.workspaces)) {
+                const ws = normalizeLoadedWorkspaces(result.workspaces);
+                const teamCount = ws.reduce((sum, w) => sum + w.teams.length, 0);
+                const agentCount = ws.reduce((sum, w) => sum + w.teams.reduce((s, t) => s + t.agents.length, 0), 0);
+                console.warn(`[WorkspaceStore] Loaded ${ws.length} workspaces, ${teamCount} teams, ${agentCount} agents`);
+                set({ workspaces: ws, isLoaded: true });
+            }
+            else {
+                console.warn('[WorkspaceStore] No saved workspaces found — starting fresh');
+                set({ isLoaded: true });
+            }
+        }
+        catch (err) {
+            console.warn('[WorkspaceStore] Failed to load workspaces:', err);
+            set({ isLoaded: true });
+        }
+    },
+    // ── Workspace CRUD ───────────────────────────────────────────────────────
+    addWorkspace: (name) => {
+        const id = generateId();
+        const workspace = {
+            id,
+            name: name.trim(),
+            directories: [],
+            apps: [],
+            teams: [],
+            isExpanded: true,
+            createdAt: Date.now(),
+        };
+        set(state => {
+            const next = [...state.workspaces, workspace];
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+        return id;
+    },
+    renameWorkspace: (id, name) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === id ? { ...w, name: name.trim() } : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    deleteWorkspace: (id) => {
+        const ws = get().workspaces.find(w => w.id === id);
+        if (ws)
+            cascadeDeleteConversations(collectAgentIds(ws));
+        set(state => {
+            const next = state.workspaces.filter(w => w.id !== id);
+            flushPersist(next);
+            return { workspaces: next };
+        });
+    },
+    duplicateWorkspace: (id) => {
+        set(state => {
+            const source = state.workspaces.find(w => w.id === id);
+            if (!source)
+                return state;
+            const clone = {
+                ...source,
+                id: generateId(),
+                name: `${source.name} (copy)`,
+                teams: source.teams.map(t => ({
+                    ...t,
+                    id: generateId(),
+                    agents: t.agents.map(a => ({
+                        ...a,
+                        id: generateId(),
+                        conversations: [],
+                    })),
+                })),
+            };
+            const next = [...state.workspaces, clone];
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    toggleWorkspaceExpanded: (id) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === id ? { ...w, isExpanded: !w.isExpanded } : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    addDirectoryToWorkspace: (workspaceId, path) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId && !w.directories.includes(path)
+                ? { ...w, directories: [...w.directories, path] }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    removeDirectoryFromWorkspace: (workspaceId, directory) => {
+        set(state => {
+            const next = state.workspaces.map(w => {
+                if (w.id !== workspaceId)
+                    return w;
+                return {
+                    ...w,
+                    directories: w.directories.filter(d => d !== directory),
+                    teams: w.teams.map(t => ({
+                        ...t,
+                        allowedDirectories: t.allowedDirectories.filter(d => d !== directory),
+                        agents: t.agents.map(a => ({
+                            ...a,
+                            allowedDirectories: a.allowedDirectories.filter(d => d !== directory),
+                        })),
+                    })),
+                };
+            });
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    addAppToWorkspace: (workspaceId, app) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId ? { ...w, apps: [...w.apps, app] } : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    removeAppFromWorkspace: (workspaceId, appId) => {
+        set(state => {
+            const next = state.workspaces.map(w => {
+                if (w.id !== workspaceId)
+                    return w;
+                return {
+                    ...w,
+                    apps: w.apps.filter(a => a.id !== appId),
+                    teams: w.teams.map(t => ({
+                        ...t,
+                        allowedApps: t.allowedApps.filter(id => id !== appId),
+                        agents: t.agents.map(a => ({
+                            ...a,
+                            allowedApps: a.allowedApps.filter(id => id !== appId),
+                        })),
+                    })),
+                };
+            });
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    // ── Team CRUD ────────────────────────────────────────────────────────────
+    addTeam: (workspaceId, name) => {
+        const id = generateId();
+        const team = {
+            id,
+            name: name.trim(),
+            allowedDirectories: [],
+            allowedApps: [],
+            agents: [],
+            isExpanded: true,
+        };
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? { ...w, isExpanded: true, teams: [...w.teams, team] }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+        return id;
+    },
+    renameTeam: (workspaceId, teamId, name) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? { ...w, teams: w.teams.map(t => t.id === teamId ? { ...t, name: name.trim() } : t) }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    deleteTeam: (workspaceId, teamId) => {
+        const ws = get().workspaces.find(w => w.id === workspaceId);
+        const team = ws?.teams.find(t => t.id === teamId);
+        if (team)
+            cascadeDeleteConversations(team.agents.map(a => a.id));
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? { ...w, teams: w.teams.filter(t => t.id !== teamId) }
+                : w);
+            flushPersist(next);
+            return { workspaces: next };
+        });
+    },
+    duplicateTeam: (workspaceId, teamId) => {
+        set(state => {
+            const next = state.workspaces.map(w => {
+                if (w.id !== workspaceId)
+                    return w;
+                const source = w.teams.find(t => t.id === teamId);
+                if (!source)
+                    return w;
+                const clone = {
+                    ...source,
+                    id: generateId(),
+                    name: `${source.name} (copy)`,
+                    agents: source.agents.map(a => ({ ...a, id: generateId(), conversations: [] })),
+                };
+                return { ...w, teams: [...w.teams, clone] };
+            });
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    moveTeam: (sourceWsId, teamId, targetWsId) => {
+        if (sourceWsId === targetWsId)
+            return;
+        set(state => {
+            const sourceWs = state.workspaces.find(w => w.id === sourceWsId);
+            const targetWs = state.workspaces.find(w => w.id === targetWsId);
+            const team = sourceWs?.teams.find(t => t.id === teamId);
+            if (!sourceWs || !targetWs || !team)
+                return state;
+            // Sanitize: remove directories/apps not in target workspace
+            const movedTeam = {
+                ...team,
+                allowedDirectories: team.allowedDirectories.filter(d => targetWs.directories.includes(d)),
+                allowedApps: team.allowedApps.filter(id => targetWs.apps.some(a => a.id === id)),
+                agents: team.agents.map(a => ({
+                    ...a,
+                    allowedDirectories: a.allowedDirectories.filter(d => targetWs.directories.includes(d)),
+                    allowedApps: a.allowedApps.filter(id => targetWs.apps.some(app => app.id === id)),
+                    workspaceName: targetWs.name,
+                })),
+            };
+            const next = state.workspaces.map(w => {
+                if (w.id === sourceWsId)
+                    return { ...w, teams: w.teams.filter(t => t.id !== teamId) };
+                if (w.id === targetWsId)
+                    return { ...w, teams: [...w.teams, movedTeam] };
+                return w;
+            });
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    toggleTeamExpanded: (workspaceId, teamId) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? { ...w, teams: w.teams.map(t => t.id === teamId ? { ...t, isExpanded: !t.isExpanded } : t) }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    // ── Agent CRUD ───────────────────────────────────────────────────────────
+    addAgent: (workspaceId, teamId, name, model, systemPrompt, capabilities) => {
+        const id = generateId();
+        const ws = get().workspaces.find(w => w.id === workspaceId);
+        const team = ws?.teams.find(t => t.id === teamId);
+        const isFirst = !team?.agents.length || !team.agents.some(a => a.isMainAssistant);
+        const agent = {
+            id,
+            name: name.trim(),
+            isMainAssistant: isFirst,
+            model: model || 'claude-sonnet-4-6',
+            systemPrompt: systemPrompt || `You are ${name.trim()}, an assistant in ${ws?.name || 'Workspace'}/${team?.name || 'Team'}.`,
+            templateName: 'Custom',
+            capabilities: capabilities || DEFAULT_CAPABILITIES,
+            permissionProfile: DEFAULT_PERMISSION_PROFILE,
+            runtimeSelection: {
+                ...DEFAULT_HUB_AGENT_RUNTIME_SELECTION,
+                selectedAt: Date.now(),
+            },
+            allowedDirectories: [...(team?.allowedDirectories || [])],
+            allowedApps: [...(team?.allowedApps || [])],
+            approvalRules: [],
+            conversations: [],
+            isExpanded: false,
+            workspaceName: ws?.name,
+            teamName: team?.name,
+        };
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? { ...t, isExpanded: true, agents: [...t.agents, agent] }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+        return id;
+    },
+    renameAgent: (workspaceId, teamId, agentId, name) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? { ...t, agents: t.agents.map(a => a.id === agentId ? { ...a, name: name.trim() } : a) }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    deleteAgent: (workspaceId, teamId, agentId) => {
+        cascadeDeleteConversations([agentId]);
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? { ...t, agents: t.agents.filter(a => a.id !== agentId) }
+                        : t),
+                }
+                : w);
+            flushPersist(next);
+            return { workspaces: next };
+        });
+    },
+    duplicateAgent: (workspaceId, teamId, agentId) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => {
+                        if (t.id !== teamId)
+                            return t;
+                        const source = t.agents.find(a => a.id === agentId);
+                        if (!source)
+                            return t;
+                        const clone = {
+                            ...source,
+                            id: generateId(),
+                            name: `${source.name} (copy)`,
+                            conversations: [],
+                        };
+                        return { ...t, agents: [...t.agents, clone] };
+                    }),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    moveAgent: (srcWsId, srcTeamId, agentId, dstWsId, dstTeamId) => {
+        if (srcWsId === dstWsId && srcTeamId === dstTeamId)
+            return;
+        set(state => {
+            const srcWs = state.workspaces.find(w => w.id === srcWsId);
+            const srcTeam = srcWs?.teams.find(t => t.id === srcTeamId);
+            const agent = srcTeam?.agents.find(a => a.id === agentId);
+            if (!agent)
+                return state;
+            const dstWs = state.workspaces.find(w => w.id === dstWsId);
+            const dstTeam = dstWs?.teams.find(t => t.id === dstTeamId);
+            if (!dstWs || !dstTeam)
+                return state;
+            // Sanitize permissions for new workspace
+            const movedAgent = {
+                ...agent,
+                allowedDirectories: agent.allowedDirectories.filter(d => dstWs.directories.includes(d)),
+                allowedApps: agent.allowedApps.filter(id => dstWs.apps.some(a => a.id === id)),
+                workspaceName: dstWs.name,
+                teamName: dstTeam.name,
+            };
+            const next = state.workspaces.map(w => {
+                if (w.id === srcWsId) {
+                    return {
+                        ...w,
+                        teams: w.teams.map(t => t.id === srcTeamId
+                            ? { ...t, agents: t.agents.filter(a => a.id !== agentId) }
+                            : t),
+                    };
+                }
+                if (w.id === dstWsId) {
+                    return {
+                        ...w,
+                        teams: w.teams.map(t => t.id === dstTeamId
+                            ? { ...t, agents: [...t.agents, movedAgent] }
+                            : t),
+                    };
+                }
+                return w;
+            });
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    toggleAgentExpanded: (workspaceId, teamId, agentId) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? { ...t, agents: t.agents.map(a => a.id === agentId ? { ...a, isExpanded: !a.isExpanded } : a) }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    updateAgent: (workspaceId, teamId, agentId, updates) => {
+        const safeUpdates = updates.runtimeSelection === undefined
+            ? updates
+            : { ...updates, runtimeSelection: normalizeHubAgentRuntimeSelection(updates.runtimeSelection) };
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? { ...t, agents: t.agents.map(a => a.id === agentId ? { ...a, ...safeUpdates } : a) }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    addAgentApprovalRule: (workspaceId, teamId, agentId, rule) => {
+        set(state => {
+            const nextRule = {
+                ...rule,
+                id: rule.id || generateId(),
+                createdAt: rule.createdAt || Date.now(),
+            };
+            const sameRule = (existing) => (existing.surface === nextRule.surface
+                && existing.action === nextRule.action
+                && existing.matcher === nextRule.matcher
+                && (existing.browserOrigin || '') === (nextRule.browserOrigin || ''));
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? {
+                            ...t,
+                            agents: t.agents.map(a => {
+                                if (a.id !== agentId)
+                                    return a;
+                                const current = a.approvalRules || [];
+                                const deduped = current.filter(existing => !sameRule(existing));
+                                return { ...a, approvalRules: [...deduped, nextRule].slice(-200) };
+                            })
+                        }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    removeAgentApprovalRule: (workspaceId, teamId, agentId, ruleId) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId
+                        ? {
+                            ...t,
+                            agents: t.agents.map(a => a.id === agentId
+                                ? { ...a, approvalRules: (a.approvalRules || []).filter(rule => rule.id !== ruleId) }
+                                : a)
+                        }
+                        : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    // ── General settings ──────────────────────────────────────────────────────
+    updateWorkspace: (id, updates) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === id ? { ...w, ...updates, name: updates.name?.trim() || w.name, updatedAt: Date.now() } : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    updateTeam: (workspaceId, teamId, updates) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === workspaceId
+                ? {
+                    ...w,
+                    teams: w.teams.map(t => t.id === teamId ? { ...t, ...updates, name: updates.name?.trim() || t.name } : t),
+                }
+                : w);
+            schedulePersist(next);
+            return { workspaces: next };
+        });
+    },
+    archiveWorkspace: (id) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === id ? { ...w, isArchived: true } : w);
+            flushPersist(next);
+            return { workspaces: next };
+        });
+    },
+    unarchiveWorkspace: (id) => {
+        set(state => {
+            const next = state.workspaces.map(w => w.id === id ? { ...w, isArchived: false } : w);
+            flushPersist(next);
+            return { workspaces: next };
+        });
+    },
+    // ── Bulk setter (backward compat) ────────────────────────────────────────
+    setWorkspaces: (workspacesOrFn) => {
+        set(state => {
+            const next = typeof workspacesOrFn === 'function'
+                ? workspacesOrFn(state.workspaces)
+                : workspacesOrFn;
+            const normalized = normalizeLoadedWorkspaces(next);
+            schedulePersist(normalized);
+            return { workspaces: normalized };
+        });
+    },
+    // ── Lookups ──────────────────────────────────────────────────────────────
+    findAgentById: (agentId) => {
+        for (const workspace of get().workspaces) {
+            for (const team of workspace.teams) {
+                const agent = team.agents.find(a => a.id === agentId);
+                if (agent)
+                    return { workspace, team, agent };
+            }
+        }
+        return null;
+    },
+}));
+//# sourceMappingURL=workspaceStore.js.map