@jaguilar87/gaia 5.0.9 → 5.0.11

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.11",
       "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.11",
       "category": "security",
       "author": {
         "name": "jaguilar87",

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.0.11] - 2026-06-30
+
+### Changed
+
+- Host decoupling (#88): la lógica del core (clasificación T0–T3, grants, validación, audit) queda desacoplada de Claude Code tras la capa adapter. Lo específico del host vive en seams: `host_session`, `host_transcript`, `registry`/`get_adapter`, `request_consent`/`ConsentRequest`, `HostCapability`/degradación, `HostDistribution`. Soportar un host nuevo de la familia hook-interception = escribir un adapter + declarar capacidades, sin tocar el core.
+
+### Added
+
+- Estado terminal `descoped` para acceptance criteria (descope deliberado, hard-terminal) más invariantes de `verify_brief` (`closed_brief_nonterminal_ac`, `closed_brief_open_plan`) para coherencia brief/plan/AC al cerrar.
+
+### Fixed
+
+- Endurecimiento del security-core a 100% killable (mutation testing) en `blocked_commands`, `mutative_verbs`, `tiers` y `approval_grants`. Arreglado el mecanismo de skip-file de equivalentes para casar por identidad estable (`operator|posición|occurrence`) en vez de `job_ids` regenerados — elimina la exclusión-cero silenciosa ("falso 100%") tras cada `cosmic-ray init`.
+- Corregido el help de `brief close` (verify advisory, sin cascade de estado).
+
+## [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/ac.py

@@ -229,8 +229,8 @@ def register(subparsers) -> None:
     setstatus_p.add_argument("ac_id", metavar="AC_ID", help="AC identifier.")
     setstatus_p.add_argument(
         "status",
-        choices=("pending", "done", "blocked"),
-        help="Target status.",
+        choices=("pending", "done", "blocked", "descoped"),
+        help="Target status ('descoped' is a hard-terminal drop; no reopen).",
     )
     setstatus_p.add_argument("--workspace", default=None, metavar="W")
     setstatus_p.add_argument("--json", action="store_true", default=False,

package/bin/cli/brief.py

@@ -14,7 +14,9 @@ Subcommands:
     gaia brief show <name> [--json]       Print brief as markdown
     gaia brief list [--status=...]        List briefs in the workspace
                   [--format=table|count|json]
-    gaia brief close <name>               Set status -> closed
+    gaia brief close <name>               Set status -> closed (advisory: runs
+                                          verify_brief and prints inconsistencies;
+                                          does NOT change AC/milestone/plan status)
     gaia brief set-status <name> <status> Validated state-machine transition
                                           (DB-only)
     gaia brief deps <name> [--json]       Print dependency graph
@@ -380,16 +382,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))
@@ -725,8 +755,13 @@ def register(subparsers) -> None:
     # -- close --------------------------------------------------------------
     close_p = actions.add_parser(
         "close",
-        help="Set brief status to closed",
-        description="Shortcut for set-status closed.",
+        help="Set brief status to closed (advisory verify, no cascade)",
+        description=(
+            "Set the brief's status to 'closed', then run verify_brief and "
+            "print any inconsistencies as warnings. ADVISORY ONLY: it does NOT "
+            "change AC, milestone, or plan status, and performs no cascade. To "
+            "resolve a flagged AC, use 'gaia ac set-status' (done / descoped)."
+        ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="Examples:\n  gaia brief close <name>\n  gaia brief close my-feature --workspace=me\n",
     )

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

@@ -185,7 +185,7 @@ def _package_root() -> Path:
 # in lock-step with the INSERT it adds to bootstrap_database.sh. If a user
 # upgrades the CLI past a schema bump but does not re-run `gaia install`,
 # `check_schema_version` raises a warning telling them how to repair.
-EXPECTED_SCHEMA_VERSION = 20
+EXPECTED_SCHEMA_VERSION = 21
 
 # Locations the doctor reads outside the workspace.
 _INSTALL_ERROR_MARKER = Path("~/.gaia/last-install-error.json").expanduser()
@@ -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.11",
   "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/adapters/__init__.py

@@ -13,10 +13,13 @@ Modules:
 from .types import (
     HookEventType,
     PermissionDecision,
-    DistributionChannel,
+    HostDistribution,
+    HostCapability,
     HookEvent,
     ValidationRequest,
     ValidationResult,
+    ConsentRequest,
+    CapabilityDegradation,
     ToolResult,
     AgentCompletion,
     CompletionResult,
@@ -28,15 +31,19 @@ from .types import (
 )
 from .base import HookAdapter
 from .claude_code import ClaudeCodeAdapter
+from .registry import get_adapter, register_adapter, DEFAULT_HOST
 from .utils import has_stdin_data, warn_if_dual_channel
 
 __all__ = [
     "HookEventType",
     "PermissionDecision",
-    "DistributionChannel",
+    "HostDistribution",
+    "HostCapability",
     "HookEvent",
     "ValidationRequest",
     "ValidationResult",
+    "ConsentRequest",
+    "CapabilityDegradation",
     "ToolResult",
     "AgentCompletion",
     "CompletionResult",
@@ -47,6 +54,9 @@ __all__ = [
     "HookResponse",
     "HookAdapter",
     "ClaudeCodeAdapter",
+    "get_adapter",
+    "register_adapter",
+    "DEFAULT_HOST",
     "has_stdin_data",
     "warn_if_dual_channel",
 ]