ltcai 3.1.0 → 3.2.0

package/latticeai/core/agent_registry.py

@@ -0,0 +1,234 @@
+"""Agent Registry — registration, discovery, metadata, versioning, capabilities.
+
+Part 2 of the v3.2.0 platform. Before this module the agent roster was derived
+ad-hoc from the hardcoded ``AGENT_ROLES`` tuple wherever it was needed. The
+registry makes every agent — built-in role and user-registered custom agent — a
+first-class entry with stable metadata: ``id``, ``type``, ``version``,
+``capabilities``, ``description`` and a mutable ``config``. The HTTP surface and
+the /app views read this registry instead of any hardcoded list.
+
+Built-in role agents are projected from the single source of truth in
+:mod:`latticeai.core.multi_agent` (so adding a role there flows through here).
+Custom agents and config overrides are persisted to
+``data_dir/agent_registry.json``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from latticeai.core.multi_agent import (
+    AGENT_ROLES,
+    CORE_PIPELINE,
+    MULTI_AGENT_VERSION,
+    ROLE_AGENT_IDS,
+)
+
+AGENT_TYPES = ("planner", "researcher", "executor", "reviewer", "release", "custom")
+
+
+def _now() -> str:
+    return datetime.now().isoformat(timespec="seconds")
+
+
+# Capabilities + descriptions for the built-in role agents. Kept here as the
+# registry's metadata projection of the roles defined in multi_agent.py.
+ROLE_META: Dict[str, Dict[str, Any]] = {
+    "researcher": {
+        "description": "Gathers workspace context, memory, and graph signal for the goal.",
+        "capabilities": ["context-retrieval", "memory-recall", "graph-read", "hybrid-search"],
+    },
+    "planner": {
+        "description": "Decomposes the goal into an ordered, bounded, reviewable plan.",
+        "capabilities": ["task-decomposition", "plan-review", "delegation"],
+    },
+    "executor": {
+        "description": "Executes each planned step, invoking tools, workflows, and plugins.",
+        "capabilities": ["tool-use", "workflow-run", "plugin-run", "file-write"],
+    },
+    "reviewer": {
+        "description": "Reviews executed work and approves, rejects, or requests a retry.",
+        "capabilities": ["verification", "retry-control", "approval"],
+    },
+    "release": {
+        "description": "Finalizes and summarizes the approved outcome.",
+        "capabilities": ["summarize", "finalize"],
+    },
+}
+
+
+class AgentRegistry:
+    """Persisted registry of built-in role agents + user-registered agents."""
+
+    def __init__(self, path: Path):
+        self.path = Path(path)
+        self._state: Dict[str, Any] = self._load()
+
+    # ── persistence ───────────────────────────────────────────────────────
+    def _load(self) -> Dict[str, Any]:
+        if self.path.exists():
+            try:
+                with open(self.path, "r", encoding="utf-8") as fh:
+                    data = json.load(fh)
+                if isinstance(data, dict):
+                    data.setdefault("custom", [])
+                    data.setdefault("config_overrides", {})
+                    return data
+            except Exception:
+                pass
+        return {"custom": [], "config_overrides": {}}
+
+    def _save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=str(self.path.parent), suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                json.dump(self._state, fh, ensure_ascii=False, indent=2)
+            os.replace(tmp, self.path)
+        finally:
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+
+    # ── projection ────────────────────────────────────────────────────────
+    def _builtin_agents(self) -> List[Dict[str, Any]]:
+        overrides = self._state.get("config_overrides", {})
+        agents: List[Dict[str, Any]] = []
+        for role in AGENT_ROLES:
+            meta = ROLE_META.get(role, {"description": "", "capabilities": []})
+            agent_id = ROLE_AGENT_IDS.get(role, f"agent:{role}")
+            handoffs: List[str] = []
+            if role == "planner":
+                handoffs = [ROLE_AGENT_IDS["executor"]]
+            elif role == "executor":
+                handoffs = [ROLE_AGENT_IDS["reviewer"]]
+            ov = overrides.get(agent_id, {})
+            agents.append({
+                "id": agent_id,
+                "name": role.capitalize(),
+                "type": role,
+                "version": MULTI_AGENT_VERSION,
+                "description": meta["description"],
+                "capabilities": list(meta["capabilities"]),
+                "handoffs": handoffs,
+                "in_default_pipeline": role in CORE_PIPELINE,
+                "source": "builtin",
+                "removable": False,
+                "enabled": bool(ov.get("enabled", True)),
+                "config": ov.get("config", {}),
+            })
+        return agents
+
+    def _custom_agents(self) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+        for entry in self._state.get("custom", []):
+            agent = dict(entry)
+            agent["source"] = "user"
+            agent["removable"] = True
+            agent.setdefault("enabled", True)
+            agent.setdefault("handoffs", [])
+            out.append(agent)
+        return out
+
+    def all(self) -> List[Dict[str, Any]]:
+        return self._builtin_agents() + self._custom_agents()
+
+    # ── reads ─────────────────────────────────────────────────────────────
+    def list(self, agent_type: Optional[str] = None) -> Dict[str, Any]:
+        agents = self.all()
+        if agent_type:
+            agents = [a for a in agents if a["type"] == agent_type]
+        counts: Dict[str, int] = {}
+        for a in self.all():
+            counts[a["type"]] = counts.get(a["type"], 0) + 1
+        return {
+            "agents": agents,
+            "types": list(AGENT_TYPES),
+            "counts": counts,
+            "total": len(agents),
+            "version": MULTI_AGENT_VERSION,
+            "default_pipeline": list(CORE_PIPELINE),
+            "generated_at": _now(),
+        }
+
+    def get(self, agent_id: str) -> Optional[Dict[str, Any]]:
+        return next((a for a in self.all() if a["id"] == agent_id), None)
+
+    def capabilities(self) -> Dict[str, List[str]]:
+        """Inverted index: capability -> [agent_id, …]."""
+        index: Dict[str, List[str]] = {}
+        for a in self.all():
+            for cap in a.get("capabilities", []):
+                index.setdefault(cap, []).append(a["id"])
+        return index
+
+    def discover(self, capability: str) -> List[Dict[str, Any]]:
+        cap = str(capability or "").lower().strip()
+        return [a for a in self.all() if any(cap == c.lower() for c in a.get("capabilities", []))]
+
+    # ── mutations ─────────────────────────────────────────────────────────
+    def register(
+        self,
+        *,
+        name: str,
+        agent_type: str = "custom",
+        description: str = "",
+        capabilities: Optional[List[str]] = None,
+        config: Optional[Dict[str, Any]] = None,
+        version: str = "1.0.0",
+    ) -> Dict[str, Any]:
+        if not str(name).strip():
+            raise ValueError("name is required")
+        if agent_type not in AGENT_TYPES:
+            raise ValueError(f"type must be one of {', '.join(AGENT_TYPES)}")
+        slug = str(name).strip().lower().replace(" ", "-")
+        agent_id = f"agent:custom:{slug}"
+        existing = {c["id"] for c in self._state.get("custom", [])}
+        if agent_id in existing:
+            agent_id = f"agent:custom:{slug}-{len(existing) + 1}"
+        entry = {
+            "id": agent_id,
+            "name": str(name).strip(),
+            "type": agent_type,
+            "version": str(version or "1.0.0"),
+            "description": str(description or "").strip(),
+            "capabilities": list(capabilities or []),
+            "config": dict(config or {}),
+            "enabled": True,
+            "created_at": _now(),
+        }
+        self._state.setdefault("custom", []).append(entry)
+        self._save()
+        return entry
+
+    def update_config(self, agent_id: str, config: Dict[str, Any], *, enabled: Optional[bool] = None) -> Dict[str, Any]:
+        if self.get(agent_id) is None:
+            raise KeyError(agent_id)
+        if agent_id.startswith("agent:custom:"):
+            for entry in self._state.get("custom", []):
+                if entry["id"] == agent_id:
+                    entry["config"] = dict(config or {})
+                    if enabled is not None:
+                        entry["enabled"] = bool(enabled)
+                    entry["updated_at"] = _now()
+        else:
+            ov = self._state.setdefault("config_overrides", {}).setdefault(agent_id, {})
+            ov["config"] = dict(config or {})
+            if enabled is not None:
+                ov["enabled"] = bool(enabled)
+        self._save()
+        return self.get(agent_id)  # type: ignore[return-value]
+
+    def remove(self, agent_id: str) -> Dict[str, Any]:
+        if not agent_id.startswith("agent:custom:"):
+            raise ValueError("Built-in role agents cannot be removed; disable them via config instead.")
+        before = len(self._state.get("custom", []))
+        self._state["custom"] = [c for c in self._state.get("custom", []) if c["id"] != agent_id]
+        if len(self._state["custom"]) == before:
+            raise KeyError(agent_id)
+        self._save()
+        return {"removed": agent_id}

package/latticeai/core/hooks.py

@@ -0,0 +1,284 @@
+"""Hooks platform — a persisted registry of lifecycle extension points.
+
+Lattice AI runs several behaviours at well-defined points in the agent / tool /
+workflow lifecycle (audit logging, secret redaction, sensitive-data
+classification, tool-permission gating, memory snapshots, workflow replay
+logging). v3.2.0 makes those points *first-class and inspectable*: every hook is
+listed, ordered, and individually enable/disable-able, and users can register
+their own custom hooks alongside the built-ins.
+
+The registry owns metadata, ordering and the enabled flag (persisted to
+``data_dir/hooks.json``). Built-in hooks carry ``source="builtin"`` and map onto
+behaviour the platform already performs; ``managed`` records whether the
+behaviour is enforced by the platform (``platform``) or is an advisory hook the
+user has registered (``user``). The registry never silently drops a hook: the
+full set is always returned so the UI can show exactly what runs and in which
+order.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+HOOK_KINDS = (
+    "pre_run",
+    "post_run",
+    "pre_tool",
+    "post_tool",
+    "agent",
+    "pipeline",
+    "workflow",
+)
+
+
+def _now() -> str:
+    return datetime.now().isoformat(timespec="seconds")
+
+
+# Built-in hooks describe lifecycle points the platform already exercises. They
+# are honest reflections of existing behaviour (see the `binding` field), made
+# visible and orderable here. Disabling a `managed="platform"` hook is recorded
+# and surfaced, but core safety behaviours remain enforced by their owning
+# subsystem — the UI states this explicitly so nothing is misrepresented.
+BUILTIN_HOOKS: List[Dict[str, Any]] = [
+    {
+        "id": "builtin:redact-secrets",
+        "name": "Redact secrets",
+        "kind": "pre_run",
+        "order": 10,
+        "description": "Strip secret-like fields (token, password, api_key…) from agent context packets before a run.",
+        "binding": "latticeai.core.multi_agent._redact",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:research-memory-snapshot",
+        "name": "Research memory snapshot",
+        "kind": "agent",
+        "order": 20,
+        "description": "Capture a short-term memory snapshot after the researcher stage gathers context.",
+        "binding": "latticeai.core.multi_agent.default_role_runner",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:tool-permission-gate",
+        "name": "Tool permission gate",
+        "kind": "pre_tool",
+        "order": 10,
+        "description": "Require explicit approval for tools whose governance policy is not auto-approve.",
+        "binding": "latticeai.core.tool_registry.ToolRegistry.permission",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:sensitive-data-guard",
+        "name": "Sensitive-data guard",
+        "kind": "pre_tool",
+        "order": 20,
+        "description": "Classify outgoing content for sensitive data before tool execution.",
+        "binding": "server_app.classify_sensitive_message",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:audit-agent-run",
+        "name": "Audit agent run",
+        "kind": "post_run",
+        "order": 10,
+        "description": "Append every completed agent run to the workspace audit log.",
+        "binding": "latticeai.services.agent_runtime.AgentRuntime.start",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:workflow-replay-log",
+        "name": "Workflow replay log",
+        "kind": "workflow",
+        "order": 10,
+        "description": "Record each workflow run's timeline so it can be replayed step by step.",
+        "binding": "latticeai.api.workflow_designer",
+        "managed": "platform",
+    },
+    {
+        "id": "builtin:pipeline-index-status",
+        "name": "Pipeline index status",
+        "kind": "pipeline",
+        "order": 10,
+        "description": "Publish ingest / embed / graph-build pipeline state to the retrieval index status.",
+        "binding": "latticeai.api.search",
+        "managed": "platform",
+    },
+]
+
+
+class HooksRegistry:
+    """Persisted registry of lifecycle hooks (built-in + user-registered)."""
+
+    def __init__(self, path: Path):
+        self.path = Path(path)
+        self._state: Dict[str, Any] = self._load()
+
+    # ── persistence ───────────────────────────────────────────────────────
+    def _load(self) -> Dict[str, Any]:
+        if self.path.exists():
+            try:
+                with open(self.path, "r", encoding="utf-8") as fh:
+                    data = json.load(fh)
+                if isinstance(data, dict):
+                    data.setdefault("custom", [])
+                    data.setdefault("overrides", {})
+                    return data
+            except Exception:
+                pass
+        return {"custom": [], "overrides": {}}
+
+    def _save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=str(self.path.parent), suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                json.dump(self._state, fh, ensure_ascii=False, indent=2)
+            os.replace(tmp, self.path)
+        finally:
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+
+    # ── views ─────────────────────────────────────────────────────────────
+    def _materialize(self) -> List[Dict[str, Any]]:
+        overrides: Dict[str, Any] = self._state.get("overrides", {})
+        hooks: List[Dict[str, Any]] = []
+        for base in BUILTIN_HOOKS:
+            ov = overrides.get(base["id"], {})
+            hook = dict(base)
+            hook["source"] = "builtin"
+            hook["enabled"] = bool(ov.get("enabled", True))
+            if "order" in ov:
+                hook["order"] = ov["order"]
+            hook["removable"] = False
+            hooks.append(hook)
+        for custom in self._state.get("custom", []):
+            hook = dict(custom)
+            hook["source"] = "user"
+            hook.setdefault("managed", "user")
+            hook.setdefault("binding", "advisory")
+            hook["enabled"] = bool(custom.get("enabled", True))
+            hook["removable"] = True
+            hooks.append(hook)
+        hooks.sort(key=lambda h: (HOOK_KINDS.index(h["kind"]) if h["kind"] in HOOK_KINDS else 99, h.get("order", 100), h["id"]))
+        return hooks
+
+    def list(self, kind: Optional[str] = None) -> Dict[str, Any]:
+        hooks = self._materialize()
+        if kind:
+            hooks = [h for h in hooks if h["kind"] == kind]
+        counts: Dict[str, Dict[str, int]] = {}
+        for h in self._materialize():
+            bucket = counts.setdefault(h["kind"], {"total": 0, "enabled": 0})
+            bucket["total"] += 1
+            if h["enabled"]:
+                bucket["enabled"] += 1
+        return {
+            "hooks": hooks,
+            "kinds": list(HOOK_KINDS),
+            "counts": counts,
+            "total": len(hooks),
+            "enabled": sum(1 for h in hooks if h["enabled"]),
+            "generated_at": _now(),
+        }
+
+    def get(self, hook_id: str) -> Optional[Dict[str, Any]]:
+        return next((h for h in self._materialize() if h["id"] == hook_id), None)
+
+    def inspect(self, hook_id: str) -> Dict[str, Any]:
+        hook = self.get(hook_id)
+        if hook is None:
+            raise KeyError(hook_id)
+        detail = dict(hook)
+        detail["advisory"] = hook.get("managed") != "platform"
+        detail["note"] = (
+            "Enforced by its owning subsystem; the registry controls visibility and ordering."
+            if hook.get("managed") == "platform"
+            else "User-registered hook: listed, ordered and inspectable; runs advisory in this build."
+        )
+        return detail
+
+    # ── mutations ─────────────────────────────────────────────────────────
+    def set_enabled(self, hook_id: str, enabled: bool) -> Dict[str, Any]:
+        if self.get(hook_id) is None:
+            raise KeyError(hook_id)
+        if hook_id.startswith("builtin:"):
+            self._state.setdefault("overrides", {}).setdefault(hook_id, {})["enabled"] = bool(enabled)
+        else:
+            for custom in self._state.get("custom", []):
+                if custom["id"] == hook_id:
+                    custom["enabled"] = bool(enabled)
+        self._save()
+        return self.get(hook_id)  # type: ignore[return-value]
+
+    def set_order(self, hook_id: str, order: int) -> Dict[str, Any]:
+        if self.get(hook_id) is None:
+            raise KeyError(hook_id)
+        order = int(order)
+        if hook_id.startswith("builtin:"):
+            self._state.setdefault("overrides", {}).setdefault(hook_id, {})["order"] = order
+        else:
+            for custom in self._state.get("custom", []):
+                if custom["id"] == hook_id:
+                    custom["order"] = order
+        self._save()
+        return self.get(hook_id)  # type: ignore[return-value]
+
+    def reorder(self, kind: str, ordered_ids: List[str]) -> Dict[str, Any]:
+        for idx, hook_id in enumerate(ordered_ids):
+            try:
+                self.set_order(hook_id, (idx + 1) * 10)
+            except KeyError:
+                continue
+        return self.list(kind=kind)
+
+    def register(
+        self,
+        *,
+        name: str,
+        kind: str,
+        description: str = "",
+        command: str = "",
+        order: Optional[int] = None,
+        enabled: bool = True,
+    ) -> Dict[str, Any]:
+        if not str(name).strip():
+            raise ValueError("name is required")
+        if kind not in HOOK_KINDS:
+            raise ValueError(f"kind must be one of {', '.join(HOOK_KINDS)}")
+        slug = str(name).strip().lower().replace(" ", "-")
+        hook_id = f"user:{slug}"
+        existing = {c["id"] for c in self._state.get("custom", [])}
+        if hook_id in existing:
+            hook_id = f"user:{slug}-{len(existing) + 1}"
+        entry = {
+            "id": hook_id,
+            "name": str(name).strip(),
+            "kind": kind,
+            "description": str(description or "").strip(),
+            "command": str(command or "").strip(),
+            "order": int(order) if order is not None else 100,
+            "enabled": bool(enabled),
+            "managed": "user",
+            "binding": "advisory",
+            "created_at": _now(),
+        }
+        self._state.setdefault("custom", []).append(entry)
+        self._save()
+        return entry
+
+    def remove(self, hook_id: str) -> Dict[str, Any]:
+        if hook_id.startswith("builtin:"):
+            raise ValueError("Built-in hooks cannot be removed; disable them instead.")
+        before = len(self._state.get("custom", []))
+        self._state["custom"] = [c for c in self._state.get("custom", []) if c["id"] != hook_id]
+        if len(self._state["custom"]) == before:
+            raise KeyError(hook_id)
+        self._save()
+        return {"removed": hook_id}

package/latticeai/core/marketplace.py

@@ -11,10 +11,39 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "2.2.0"
+MARKETPLACE_VERSION = "3.2.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 
+def _agent_template(
+    template_id: str,
+    name: str,
+    description: str,
+    *,
+    roles: List[str],
+    capabilities: List[str],
+    suggested_tools: List[str],
+    category: str,
+    max_retries: int = 2,
+) -> Dict[str, Any]:
+    """Build a portable agent template entry (Part 4 reusable templates)."""
+    return {
+        "id": template_id,
+        "kind": "agent",
+        "name": name,
+        "version": "1.0.0",
+        "description": description,
+        "metadata": {"category": category, "installable": True, "agent_template": True},
+        "definition": {
+            "roles": roles,
+            "max_retries": max_retries,
+            "capabilities": capabilities,
+            "suggested_tools": suggested_tools,
+            "constraints": ["workspace scoped", "no secret leakage", "replayable timeline"],
+        },
+    }
+
+
 class MarketplaceError(Exception):
     """Raised for invalid template operations."""
 
@@ -73,7 +102,47 @@ BUILTIN_TEMPLATES: Dict[str, List[Dict[str, Any]]] = {
                 "max_retries": 2,
                 "constraints": ["workspace scoped", "no secret leakage", "replayable timeline"],
             },
-        }
+        },
+        _agent_template(
+            "agent-research-assistant", "Research Assistant",
+            "Retrieves workspace context, plans an inquiry, and synthesizes a reviewed answer.",
+            roles=["researcher", "planner", "reviewer"],
+            capabilities=["context-retrieval", "hybrid-search", "memory-recall", "synthesis"],
+            suggested_tools=["knowledge_search", "knowledge_graph_search", "read_file"],
+            category="research",
+        ),
+        _agent_template(
+            "agent-coding-assistant", "Coding Assistant",
+            "Plans a change, edits files, runs the build, and reviews the result before finishing.",
+            roles=["planner", "executor", "reviewer"],
+            capabilities=["task-decomposition", "tool-use", "file-write", "verification"],
+            suggested_tools=["edit_file", "write_file", "run_command", "build_project", "git_diff"],
+            category="coding",
+        ),
+        _agent_template(
+            "agent-knowledge-curator", "Knowledge Curator",
+            "Captures, structures, and saves knowledge into the graph and memory.",
+            roles=["researcher", "executor"],
+            capabilities=["context-retrieval", "graph-read", "knowledge-save"],
+            suggested_tools=["knowledge_save", "knowledge_graph_ingest", "knowledge_tree"],
+            category="knowledge",
+        ),
+        _agent_template(
+            "agent-documentation-writer", "Documentation Writer",
+            "Plans a document, drafts and writes it, and reviews for completeness.",
+            roles=["planner", "executor", "reviewer"],
+            capabilities=["task-decomposition", "file-write", "summarize", "verification"],
+            suggested_tools=["create_docx", "create_pdf", "write_file", "read_document"],
+            category="documentation",
+        ),
+        _agent_template(
+            "agent-workflow-builder", "Workflow Builder",
+            "Plans and assembles a multi-step workflow definition for repeatable automation.",
+            roles=["planner", "executor"],
+            capabilities=["task-decomposition", "workflow-run", "delegation"],
+            suggested_tools=["todo_write", "workspace_tree"],
+            category="automation",
+        ),
     ],
 }
 
@@ -110,6 +179,22 @@ class TemplateCatalog:
                 return deepcopy(template)
         raise MarketplaceError(f"template not found: {item_kind}/{template_id}")
 
+    def clone_template(self, kind: str, template_id: str, new_name: Optional[str] = None) -> Dict[str, Any]:
+        """Return an editable copy of a template with a fresh id (Part 4 clone)."""
+        template = self.get_template(kind, template_id)
+        name = (new_name or f"{template['name']} (Copy)").strip()
+        slug = name.lower().replace(" ", "-").replace("(", "").replace(")", "")
+        clone = deepcopy(template)
+        clone["id"] = f"{template['id']}-copy-{slug}"[:80]
+        clone["name"] = name
+        clone["version"] = "1.0.0"
+        clone["metadata"] = {
+            **(template.get("metadata") or {}),
+            "cloned_from": template_id,
+            "editable": True,
+        }
+        return clone
+
     def export_template(self, kind: str, template_id: str) -> Dict[str, Any]:
         template = self.get_template(kind, template_id)
         return {

package/latticeai/core/multi_agent.py

@@ -14,7 +14,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "2.2.0"
+MULTI_AGENT_VERSION = "3.2.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/core/workspace_os.py

@@ -18,7 +18,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "3.1.0"
+WORKSPACE_OS_VERSION = "3.2.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type