@jaguilar87/gaia 5.0.9 → 5.0.10

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "gaia-ops",
       "description": "Full DevOps orchestration for Claude Code. Eight specialized agents handle the complete development lifecycle — analysis, planning, execution, and deployment. Gaia-Ops scans your codebase to understand it and injects the right context into each sub-agent. Every command is classified by risk: read-only runs freely, state changes pause for your approval, and irreversible operations are permanently blocked.",
-      "version": "5.0.9",
+      "version": "5.0.10",
       "category": "devops",
       "author": {
         "name": "jaguilar87",
@@ -20,7 +20,7 @@
     {
       "name": "gaia-security",
       "description": "Keeps you in the loop only when it matters. Gaia Security analyzes every command and classifies it into risk tiers: read-only queries run freely, simulations and validations pass through, and state-changing operations (create, delete, apply, push) pause for your explicit approval before executing. Irreversible commands like dropping databases or deleting cloud infrastructure are permanently blocked.",
-      "version": "5.0.9",
+      "version": "5.0.10",
       "category": "security",
       "author": {
         "name": "jaguilar87",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gaia-ops",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "description": "Security-first orchestrator with specialized agents, hooks, and governance for AI coding",
   "author": {
     "name": "jaguilar87",

package/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.0.10] - 2026-06-29
+
 ## [5.0.9] - 2026-06-25
 
 ### Changed

package/bin/README.md

@@ -33,7 +33,9 @@ npm uninstall @jaguilar87/gaia
         |
 preuninstall script -> python3 bin/gaia uninstall --preuninstall
         |
-Cleans temporary caches, old logs, __pycache__, preserves .claude/ symlinks
+Removes Gaia-owned symlinks (agents, hooks, skills, …), cleans caches /
+logs / __pycache__, and surgically removes only Gaia's contributions from
+settings.local.json and plugin-registry.json
 ```
 
 No Claude Code session is involved in either case. The subcommands run in a normal Python process and interact with the filesystem directly.
@@ -97,7 +99,7 @@ Modules whose name starts with `_` (e.g. `_install_helpers.py`) are private help
 
 **Exit codes:** `0` on success, `1` on warnings, `2` on errors. The release pipeline's sandbox harness relies on these -- do not print a success line and exit non-zero, or vice versa.
 
-**Preserved on cleanup:** `.claude/` symlinks are never touched by `gaia cleanup`. Project context is canonical in `~/.gaia/gaia.db` and persists across reinstalls independently of the filesystem. The preservation list for legacy filesystem artifacts lives in `cli/cleanup.py`.
+**Cleanup footprint:** Full cleanup (the default, used by `gaia uninstall`) removes everything `gaia install` wrote: `CLAUDE.md`, `.claude/settings.json`, all Gaia-owned symlinks (`.claude/agents`, `.claude/hooks`, `.claude/skills`, and siblings), and the `.claude/.plugin-initialized` marker. Two files are handled surgically because they are shared with Claude Code: `settings.local.json` has only Gaia-injected keys removed (agent identity, two env vars, Gaia's permission entries; user content is preserved); `plugin-registry.json` has only Gaia's `installed[]` entry removed and is deleted only if it contained nothing else. The user DB at `~/.gaia/gaia.db` is never touched; pass `--purge` to `gaia uninstall` to remove it. The canonical source for what gets removed is `cli/cleanup.py` (`SYMLINKS_TO_REMOVE`, `_clean_settings_local_json`, `_remove_plugin_registry_entry`).
 
 **`package.json` `bin` field:**
 

package/bin/cli/_install_helpers.py

@@ -175,9 +175,6 @@ def merge_local_permissions(
 
     # env vars (smart merge -- preserve user values)
     env = existing.setdefault("env", {})
-    if "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS" not in env:
-        env["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"] = "1"
-        changed_fields.append("env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS")
     if "CLAUDE_CODE_DISABLE_AUTO_MEMORY" not in env:
         env["CLAUDE_CODE_DISABLE_AUTO_MEMORY"] = "1"
         changed_fields.append("env.CLAUDE_CODE_DISABLE_AUTO_MEMORY")

package/bin/cli/brief.py

@@ -380,16 +380,44 @@ def _cmd_edit(args) -> int:
 
 
 def _cmd_show(args) -> int:
-    from gaia.briefs import get_brief, serialize_brief_to_markdown
+    from gaia.briefs import (
+        get_brief,
+        get_brief_by_id,
+        find_brief_workspaces,
+        serialize_brief_to_markdown,
+    )
     workspace = _resolve_workspace(getattr(args, "workspace", None))
     name = args.name
+    as_json = getattr(args, "json", False)
+
+    # FIX 1: when the argument is all-digits, resolve by numeric id first.
+    if name.isdigit():
+        brief = get_brief_by_id(int(name))
+        if brief is not None:
+            if as_json:
+                out = {k: v for k, v in brief.items() if k != "id"}
+                print(json.dumps(out, indent=2, default=str))
+                return 0
+            print(serialize_brief_to_markdown(brief))
+            return 0
+        # Numeric id not found -- fall through to the slug path so that a
+        # name that happens to look like a number still gets a useful error.
 
     brief = get_brief(workspace, name)
     if brief is None:
-        return _err(f"brief '{name}' not found in workspace '{workspace}'",
-                    as_json=getattr(args, "json", False))
+        # FIX 2: cross-workspace hint instead of bare "not found".
+        other_workspaces = find_brief_workspaces(name)
+        if other_workspaces:
+            hint = ", ".join(repr(w) for w in other_workspaces)
+            msg = (
+                f"brief '{name}' not found in workspace '{workspace}', "
+                f"but exists in: {hint} -- use --workspace=<workspace> to show it"
+            )
+        else:
+            msg = f"brief '{name}' not found in workspace '{workspace}'"
+        return _err(msg, as_json=as_json)
 
-    if getattr(args, "json", False):
+    if as_json:
         # Drop internal SQL columns for cleanliness
         out = {k: v for k, v in brief.items() if k != "id"}
         print(json.dumps(out, indent=2, default=str))

package/bin/cli/cleanup.py

@@ -1,10 +1,19 @@
 """
-gaia cleanup -- Remove temporary caches, old logs, and `__pycache__`;
-preserves project-context.json and .claude/ symlinks.
+gaia cleanup -- Remove Gaia's workspace footprint and apply data retention.
+
+The full-cleanup footprint mirrors what `gaia install` writes, in reverse:
+  - CLAUDE.md and .claude/settings.json (removed outright -- Gaia-owned)
+  - .claude/ symlinks incl. skills (removed -- Gaia-owned)
+  - .claude/.plugin-initialized marker (removed -- Gaia-owned)
+  - .claude/plugin-registry.json (surgical: only Gaia's installed[] entry is
+    removed; the file is shared with Claude Code's plugin system)
+  - .claude/settings.local.json (surgical: only Gaia-injected keys are removed
+    -- agent, two env vars, Gaia's permission entries; user config preserved)
+The user DB at ~/.gaia/gaia.db is never touched here.
 
 Modes:
-  --prune / --retain  Apply data retention policy only (no symlink/settings removal)
-  (default)           Remove CLAUDE.md, settings.json, symlinks + run retention
+  --prune / --retain  Apply data retention policy only (no footprint removal)
+  (default)           Remove the footprint above + run retention
 
 Flags:
   --dry-run           Print what would be pruned/removed without modifying files
@@ -16,6 +25,11 @@ import os
 import sys
 from pathlib import Path
 
+# bin/cli/cleanup.py -> bin/cli -> bin -> gaia/
+_PACKAGE_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(_PACKAGE_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PACKAGE_ROOT))
+
 
 # ---------------------------------------------------------------------------
 # Project root detection (mirrors JS findProjectRoot)
@@ -334,6 +348,7 @@ SYMLINKS_TO_REMOVE = [
     ".claude/hooks",
     ".claude/commands",
     ".claude/config",
+    ".claude/skills",
     ".claude/CHANGELOG.md",
     ".claude/README.en.md",
     ".claude/README.md",
@@ -358,6 +373,271 @@ def _remove_settings_json(root: Path, dry_run: bool) -> dict:
     return {"found": True, "removed": not dry_run, "dry_run": dry_run}
 
 
+# ---------------------------------------------------------------------------
+# Gaia-owned data-dir markers (.plugin-initialized, plugin-registry.json)
+#
+# Both live in get_plugin_data_dir(), which falls back to .claude/ when
+# CLAUDE_PLUGIN_DATA is unset (the common npm-install case). The marker is a
+# pure Gaia artifact -- removed outright. The registry is shared with Claude
+# Code's plugin system, so only Gaia's own entry is removed surgically.
+# ---------------------------------------------------------------------------
+
+# Plugin names Gaia registers in plugin-registry.json (see _read_plugin_name
+# in _install_helpers.py: package "gaia" maps to the canonical "gaia-ops").
+_GAIA_PLUGIN_NAMES = {"gaia-ops", "gaia-security", "gaia"}
+
+
+def _remove_plugin_initialized(root: Path, dry_run: bool) -> dict:
+    """Remove the .plugin-initialized first-run marker.
+
+    Written by plugin_setup.mark_initialized() into get_plugin_data_dir().
+    A pure Gaia artifact (timestamp + mode), safe to delete outright.
+    """
+    path = root / ".claude" / ".plugin-initialized"
+    if not path.exists():
+        return {"found": False}
+    if not dry_run:
+        try:
+            path.unlink()
+        except OSError as exc:
+            return {"found": True, "removed": False, "error": str(exc)}
+    return {"found": True, "removed": not dry_run, "dry_run": dry_run}
+
+
+def _remove_plugin_registry_entry(root: Path, dry_run: bool) -> dict:
+    """Remove Gaia's entry from plugin-registry.json, preserving other plugins.
+
+    plugin-registry.json is shared with Claude Code's plugin system. Install
+    (register_plugin / ensure_plugin_registry) writes Gaia's entry into the
+    ``installed`` list. Uninstall is symmetric: drop only Gaia-owned entries
+    from ``installed``. If that empties the registry of all plugins, the file
+    is equivalent to its pre-Gaia state and is removed; otherwise it is
+    rewritten with the surviving entries.
+
+    Idempotent: a registry with no Gaia entry returns found=False.
+    """
+    path = root / ".claude" / "plugin-registry.json"
+    if not path.exists():
+        return {"found": False}
+
+    data = _read_json_file(path)
+    if not isinstance(data, dict):
+        # Malformed/unexpected shape -- leave it untouched rather than risk
+        # destroying a file Gaia did not write.
+        return {"found": False, "skipped": "registry not a JSON object"}
+
+    installed = data.get("installed")
+    if not isinstance(installed, list):
+        return {"found": False, "skipped": "no installed[] array"}
+
+    kept = [
+        e for e in installed
+        if not (isinstance(e, dict) and e.get("name") in _GAIA_PLUGIN_NAMES)
+    ]
+    removed_entries = [
+        e for e in installed
+        if isinstance(e, dict) and e.get("name") in _GAIA_PLUGIN_NAMES
+    ]
+
+    if not removed_entries:
+        return {"found": False}
+
+    # Only Gaia keys present (installed + source) and nothing survives ->
+    # the file existed solely for Gaia; remove it entirely.
+    only_gaia_keys = set(data.keys()) <= {"installed", "source"}
+    delete_file = not kept and only_gaia_keys
+
+    result = {
+        "found": True,
+        "removed_entries": [e.get("name") for e in removed_entries],
+        "file_removed": delete_file and not dry_run,
+        "dry_run": dry_run,
+    }
+
+    if dry_run:
+        return result
+
+    try:
+        if delete_file:
+            path.unlink()
+        else:
+            data["installed"] = kept
+            _write_json_file(path, data)
+    except OSError as exc:
+        result["error"] = str(exc)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# settings.local.json -- surgical removal of Gaia-injected config
+#
+# Install (merge_local_permissions) MERGES into a user-owned file: it sets
+# agent=gaia-orchestrator, adds two env vars, and authoritative-merges its
+# permission entries. Uninstall must mirror that injection key-for-key and
+# leave everything the user added intact -- never delete the whole file.
+#
+# Note on permissions: install's authoritative merge already overwrote any
+# user-scoped variants of tool names Gaia manages (e.g. a prior Edit(/tmp/*)
+# became Edit). That loss is not recoverable at uninstall time; the symmetric
+# action is to drop the tool names Gaia manages and its deny rules, leaving
+# only entries for tools Gaia never touched.
+# ---------------------------------------------------------------------------
+
+_GAIA_ENV_KEYS = {
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
+}
+
+
+def _gaia_managed_permission_sets():
+    """Return (managed_tool_names, deny_entries) Gaia injects into settings.
+
+    Pulled from the canonical OPS/SECURITY permission constants in
+    plugin_setup.py (the same source install merges from). Falls back to a
+    minimal set if the hooks package cannot be imported (partial install).
+    """
+    try:
+        from hooks.modules.core.plugin_setup import (  # type: ignore
+            OPS_PERMISSIONS,
+            SECURITY_PERMISSIONS,
+            _tool_name,
+        )
+        allow = (
+            set(OPS_PERMISSIONS["permissions"]["allow"])
+            | set(SECURITY_PERMISSIONS["permissions"]["allow"])
+        )
+        deny = (
+            set(OPS_PERMISSIONS["permissions"]["deny"])
+            | set(SECURITY_PERMISSIONS["permissions"]["deny"])
+        )
+        managed_names = {_tool_name(e) for e in allow}
+        return managed_names, deny
+    except Exception:  # noqa: BLE001
+        return {"Bash"}, set()
+
+
+def _clean_settings_local_json(root: Path, dry_run: bool) -> dict:
+    """Remove only Gaia-injected keys from settings.local.json; preserve user config.
+
+    Mirrors merge_local_permissions:
+      - agent: removed only if it equals "gaia-orchestrator".
+      - env: removes the two Gaia keys only when their value matches what
+        install set (a user override of the value is preserved).
+      - permissions.allow: drops entries whose tool name Gaia manages.
+      - permissions.deny: drops Gaia's deny rules.
+      - Empty containers (env / permissions / allow / deny) are pruned so the
+        file does not retain hollow Gaia scaffolding.
+
+    If nothing Gaia-owned remains and the file becomes ``{}``, it is removed.
+    Idempotent: a file with no Gaia keys returns found=False.
+    """
+    path = root / ".claude" / "settings.local.json"
+    if not path.exists():
+        return {"found": False}
+
+    data = _read_json_file(path)
+    if not isinstance(data, dict):
+        return {"found": False, "skipped": "settings.local.json not a JSON object"}
+
+    removed_fields: list[str] = []
+
+    # agent identity
+    if data.get("agent") == "gaia-orchestrator":
+        removed_fields.append("agent")
+        if not dry_run:
+            del data["agent"]
+
+    # env vars (only when value still matches what install set)
+    env = data.get("env")
+    if isinstance(env, dict):
+        for key, expected in _GAIA_ENV_KEYS.items():
+            if env.get(key) == expected:
+                removed_fields.append(f"env.{key}")
+                if not dry_run:
+                    del env[key]
+        if not dry_run and not env:
+            del data["env"]
+
+    # permissions
+    perms = data.get("permissions")
+    if isinstance(perms, dict):
+        managed_names, gaia_deny = _gaia_managed_permission_sets()
+
+        allow = perms.get("allow")
+        if isinstance(allow, list):
+            kept_allow = [e for e in allow if _perm_tool_name(e) not in managed_names]
+            if len(kept_allow) != len(allow):
+                removed_fields.append("permissions.allow")
+                if not dry_run:
+                    if kept_allow:
+                        perms["allow"] = kept_allow
+                    else:
+                        del perms["allow"]
+
+        deny = perms.get("deny")
+        if isinstance(deny, list):
+            kept_deny = [e for e in deny if e not in gaia_deny]
+            if len(kept_deny) != len(deny):
+                removed_fields.append("permissions.deny")
+                if not dry_run:
+                    if kept_deny:
+                        perms["deny"] = kept_deny
+                    else:
+                        del perms["deny"]
+
+        # Drop hollow empty lists (ask/allow/deny) and an empty permissions
+        # block -- these are Gaia scaffolding, not user data.
+        if not dry_run:
+            for empty_key in ("ask", "allow", "deny"):
+                if perms.get(empty_key) == []:
+                    del perms[empty_key]
+            if not perms:
+                del data["permissions"]
+
+    if not removed_fields:
+        return {"found": False}
+
+    result = {
+        "found": True,
+        "removed_fields": removed_fields,
+        "file_removed": False,
+        "dry_run": dry_run,
+    }
+
+    if dry_run:
+        return result
+
+    try:
+        if not data:
+            path.unlink()
+            result["file_removed"] = True
+        else:
+            _write_json_file(path, data)
+    except OSError as exc:
+        result["error"] = str(exc)
+    return result
+
+
+def _perm_tool_name(entry: str) -> str:
+    """Base tool name from a permission entry (mirror of plugin_setup._tool_name)."""
+    if not isinstance(entry, str):
+        return ""
+    paren = entry.find("(")
+    return entry[:paren] if paren != -1 else entry
+
+
+def _read_json_file(path: Path):
+    """Read JSON, returning None on any error."""
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _write_json_file(path: Path, data) -> None:
+    """Write JSON with indent=2 + trailing newline (gaia convention)."""
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
 def _remove_symlinks(root: Path, dry_run: bool) -> dict:
     removed = []
     skipped = []
@@ -513,11 +793,17 @@ def cmd_cleanup(args) -> int:
 
     claude_md = _remove_claude_md(root, dry_run)
     settings = _remove_settings_json(root, dry_run)
+    settings_local = _clean_settings_local_json(root, dry_run)
+    plugin_initialized = _remove_plugin_initialized(root, dry_run)
+    plugin_registry = _remove_plugin_registry_entry(root, dry_run)
     symlinks = _remove_symlinks(root, dry_run)
     retention_actions = _apply_retention_policy(root, dry_run)
 
     result["claude_md"] = claude_md
     result["settings_json"] = settings
+    result["settings_local_json"] = settings_local
+    result["plugin_initialized"] = plugin_initialized
+    result["plugin_registry"] = plugin_registry
     result["symlinks"] = symlinks
     result["retention_actions"] = retention_actions
     result["retention_policy"] = retention_policy_info
@@ -529,6 +815,9 @@ def cmd_cleanup(args) -> int:
         anything_done = (
             claude_md.get("found")
             or settings.get("found")
+            or settings_local.get("found")
+            or plugin_initialized.get("found")
+            or plugin_registry.get("found")
             or symlinks.get("removed")
             or retention_actions
         )
@@ -539,6 +828,17 @@ def cmd_cleanup(args) -> int:
         if settings.get("found"):
             verb = "Would remove" if dry_run else "Removed"
             print(f"  {verb}: .claude/settings.json")
+        if settings_local.get("found"):
+            verb = "Would clean" if dry_run else "Cleaned"
+            fields = ", ".join(settings_local.get("removed_fields", []))
+            print(f"  {verb}: .claude/settings.local.json ({fields})")
+        if plugin_initialized.get("found"):
+            verb = "Would remove" if dry_run else "Removed"
+            print(f"  {verb}: .claude/.plugin-initialized")
+        if plugin_registry.get("found"):
+            verb = "Would remove" if dry_run else "Removed"
+            entries = ", ".join(plugin_registry.get("removed_entries", []))
+            print(f"  {verb}: plugin-registry.json entry ({entries})")
         for rel in symlinks.get("removed", []):
             verb = "Would remove symlink" if dry_run else "Removed symlink"
             print(f"  {verb}: {rel}")

package/bin/cli/doctor.py

@@ -854,10 +854,6 @@ def check_settings(project_root: Path) -> dict:
     if deny_count == 0:
         issues.append("No deny rules (destructive commands not blocked)")
 
-    env = data.get("env", {})
-    if not env.get("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"):
-        infos.append("AGENT_TEAMS env not set")
-
     if issues:
         return _result("Settings", "error", "; ".join(issues), "Run `gaia scan` or `gaia update`")
 

package/bin/cli/uninstall.py

@@ -38,8 +38,11 @@ from pathlib import Path
 # duplicating retention policy, symlink lists, or root detection.
 from cli.cleanup import (  # type: ignore  # noqa: E402
     _apply_retention_policy,
+    _clean_settings_local_json,
     _find_project_root,
     _remove_claude_md,
+    _remove_plugin_initialized,
+    _remove_plugin_registry_entry,
     _remove_settings_json,
     _remove_symlinks,
 )
@@ -250,6 +253,9 @@ def cmd_uninstall(args: argparse.Namespace) -> int:
     try:
         result["claude_md"] = _remove_claude_md(workspace, dry_run)
         result["settings_json"] = _remove_settings_json(workspace, dry_run)
+        result["settings_local_json"] = _clean_settings_local_json(workspace, dry_run)
+        result["plugin_initialized"] = _remove_plugin_initialized(workspace, dry_run)
+        result["plugin_registry"] = _remove_plugin_registry_entry(workspace, dry_run)
         result["symlinks"] = _remove_symlinks(workspace, dry_run)
         result["retention_actions"] = _apply_retention_policy(workspace, dry_run)
     except Exception as exc:  # noqa: BLE001
@@ -345,6 +351,9 @@ def _print_human(result: dict, *, preuninstall: bool, purge: bool, dry_run: bool
 
     claude_md = result.get("claude_md") or {}
     settings = result.get("settings_json") or {}
+    settings_local = result.get("settings_local_json") or {}
+    plugin_initialized = result.get("plugin_initialized") or {}
+    plugin_registry = result.get("plugin_registry") or {}
     symlinks = result.get("symlinks") or {}
     retention = result.get("retention_actions") or []
     db = result.get("db") or {}
@@ -355,6 +364,17 @@ def _print_human(result: dict, *, preuninstall: bool, purge: bool, dry_run: bool
     if settings.get("found"):
         verb = "Would remove" if dry_run else "Removed"
         print(f"  {verb}: .claude/settings.json")
+    if settings_local.get("found"):
+        verb = "Would clean" if dry_run else "Cleaned"
+        fields = ", ".join(settings_local.get("removed_fields", []))
+        print(f"  {verb}: .claude/settings.local.json ({fields})")
+    if plugin_initialized.get("found"):
+        verb = "Would remove" if dry_run else "Removed"
+        print(f"  {verb}: .claude/.plugin-initialized")
+    if plugin_registry.get("found"):
+        verb = "Would remove" if dry_run else "Removed"
+        entries = ", ".join(plugin_registry.get("removed_entries", []))
+        print(f"  {verb}: plugin-registry.json entry ({entries})")
     for rel in symlinks.get("removed", []):
         verb = "Would remove symlink" if dry_run else "Removed symlink"
         print(f"  {verb}: {rel}")

package/dist/gaia-ops/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gaia-ops",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "description": "Full DevOps orchestration for Claude Code. Eight specialized agents handle the complete development lifecycle \u2014 analysis, planning, execution, and deployment. Gaia-Ops scans your codebase to understand it and injects the right context into each sub-agent. Every command is classified by risk: read-only runs freely, state changes pause for your approval, and irreversible operations are permanently blocked.",
   "author": {
     "name": "jaguilar87",

package/dist/gaia-ops/hooks/modules/core/plugin_setup.py

@@ -347,11 +347,6 @@ def setup_project_permissions() -> bool:
     existing["permissions"]["deny"] = merged_deny
     existing["permissions"].setdefault("ask", [])
 
-    # Add env vars (smart merge: add if not present, don't overwrite)
-    env = existing.setdefault("env", {})
-    if "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS" not in env:
-        env["CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"] = "1"
-
     claude_dir.mkdir(parents=True, exist_ok=True)
     settings_path.write_text(json.dumps(existing, indent=2) + "\n")
     logger.info("Merged gaia %s permissions and env into %s", mode, settings_path)