@jaguilar87/gaia 5.0.6 → 5.0.8

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.6",
+      "version": "5.0.8",
       "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.6",
+      "version": "5.0.8",
       "category": "security",
       "author": {
         "name": "jaguilar87",

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.0.8] - 2026-06-24
+
+## [5.0.7] - 2026-06-12
+
+### Fixed
+
+- `gaia doctor` now passes (rc=0) on a clean install: the `commands` symlink (a removed surface) was dropped from the symlink checks, and `memory_fts5_count` now reads the canonical gaia.db store instead of the legacy search.db — eliminating the two warnings that made a fresh install report "degraded" in 5.0.5/5.0.6.
+
+### Changed
+
+- Release pipeline: the sandbox validation harness is now a PRE-publish gate (runs against the packed tarball before `npm publish`), and the harness fails if `gaia doctor` returns rc>=1 — so a degraded build can no longer be published.
+
 ## [5.0.6] - 2026-06-12
 
 ### Fixed

package/bin/cli/_install_helpers.py

@@ -345,7 +345,7 @@ def merge_local_hooks(
 # ---------------------------------------------------------------------------
 
 # Directories the package exposes via .claude/<name> symlinks
-_SYMLINK_NAMES = ["agents", "tools", "hooks", "commands", "config", "skills"]
+_SYMLINK_NAMES = ["agents", "tools", "hooks", "config", "skills"]
 # Files (not dirs) we link or copy into .claude/
 _SYMLINK_FILES = ["CHANGELOG.md"]
 

package/bin/cli/approvals.py

@@ -889,12 +889,6 @@ def _import_approval_display():
     return display
 
 
-def _import_approval_revert():
-    """Import gaia.approvals.revert lazily."""
-    from gaia.approvals import revert as revert_mod
-    return revert_mod
-
-
 # ---------------------------------------------------------------------------
 # T3.1: gaia approvals pending -- shortcut for list --status=pending
 # ---------------------------------------------------------------------------
@@ -1209,199 +1203,6 @@ def cmd_history(args) -> int:
     return 0
 
 
-# ---------------------------------------------------------------------------
-# T3.5: gaia approvals revert <id> -- interactive inverse-command UX (D14)
-# ---------------------------------------------------------------------------
-
-def cmd_revert(args) -> int:
-    """Revert an approval by executing inverse commands for its EXECUTED events.
-
-    Per D14:
-    - Interactive by default: shows numbered list of candidate inverse commands,
-      user selects by number, comma-separated, 'all', or 'none'.
-    - ``--yes`` suppresses per-event confirmation.
-    - ``--file ids.txt`` reads event_ids from a file (one per line) for batch mode.
-    - ``--dry-run`` shows the inverse commands without executing them.
-
-    Exits 0 on success or when no reversible events exist.
-    Exits 1 on error.
-    """
-    raw_id = _resolve_approval_id(args.approval_id)
-    skip_confirm = getattr(args, "yes", False)
-    dry_run = getattr(args, "dry_run", False)
-    batch_file = getattr(args, "file", None)
-    output_json = getattr(args, "json", False)
-
-    # Resolve the approval and its EXECUTED events.
-    try:
-        store = _import_approval_store()
-        approval = store.get_by_id(raw_id)
-        if approval is None:
-            _print_error(f"No approval found for id: {raw_id}", args)
-            return 1
-    except Exception as exc:
-        _print_error(f"Failed to look up approval: {exc}", args)
-        return 1
-
-    # Derive inverse commands.
-    try:
-        revert_mod = _import_approval_revert()
-        store = _import_approval_store()
-        con = store._open_db()
-        try:
-            inverses = revert_mod.derive_inverses_for_approval(raw_id, con)
-        finally:
-            con.close()
-    except Exception as exc:
-        _print_error(f"Failed to derive inverse commands: {exc}", args)
-        return 1
-
-    if not inverses:
-        print(f"No EXECUTED events found for approval {raw_id}. Nothing to revert.")
-        return 0
-
-    # Display the candidate inverse commands.
-    print(f"\nCandidate inverse commands for approval {raw_id}:")
-    print("-" * 60)
-    for i, ic in enumerate(inverses):
-        reversible_marker = "" if ic.reversible else " [NOT REVERSIBLE]"
-        inverse_display = ic.inverse_command if ic.inverse_command else "N/A"
-        print(f"  [{i}] Original : {ic.original_command}")
-        print(f"      Inverse  : {inverse_display}{reversible_marker}")
-        print(f"      Notes    : {ic.notes}")
-        print()
-
-    # Filter to only reversible ones.
-    reversible = [ic for ic in inverses if ic.reversible and ic.inverse_command]
-    if not reversible:
-        print("None of the events have derivable inverse commands.")
-        return 0
-
-    if dry_run:
-        print("[dry-run] Would execute the following inverse commands:")
-        for ic in reversible:
-            print(f"  {ic.inverse_command}")
-        return 0
-
-    # Batch file mode: read event_ids to revert.
-    selected = reversible
-    if batch_file:
-        try:
-            with open(batch_file) as fh:
-                event_ids_str = {line.strip() for line in fh if line.strip()}
-        except OSError as exc:
-            _print_error(f"Cannot read batch file {batch_file!r}: {exc}", args)
-            return 1
-        event_ids = set()
-        for eid in event_ids_str:
-            try:
-                event_ids.add(int(eid))
-            except ValueError:
-                pass
-        selected = [ic for ic in reversible if ic.event_id in event_ids]
-        if not selected:
-            print(f"No matching reversible events found in batch file.")
-            return 0
-    elif not skip_confirm:
-        # Interactive selection.
-        print("Select events to revert (comma-separated numbers, 'all', or 'none'):")
-        try:
-            choice = input("> ").strip().lower()
-        except EOFError:
-            choice = "none"
-
-        if choice == "none" or choice == "":
-            print("Revert cancelled.")
-            return 0
-        elif choice == "all":
-            selected = reversible
-        else:
-            try:
-                indices = [int(x.strip()) for x in choice.split(",") if x.strip()]
-                selected = [reversible[i] for i in indices if 0 <= i < len(reversible)]
-            except (ValueError, IndexError):
-                _print_error("Invalid selection. Use numbers, 'all', or 'none'.", args)
-                return 1
-
-    if not selected:
-        print("No events selected. Revert cancelled.")
-        return 0
-
-    # Final confirmation.
-    if not skip_confirm:
-        print("\nWill execute:")
-        for ic in selected:
-            print(f"  {ic.inverse_command}")
-        try:
-            confirm = input("\nProceed? [y/N] ").strip().lower()
-        except EOFError:
-            confirm = "n"
-        if confirm not in ("y", "yes"):
-            print("Revert cancelled.")
-            return 0
-
-    # Execute inverse commands.
-    import subprocess
-    results = []
-    session_id = os.environ.get("CLAUDE_SESSION_ID") or "cli-session"
-    all_ok = True
-
-    for ic in selected:
-        print(f"Executing: {ic.inverse_command}")
-        try:
-            proc = subprocess.run(
-                ic.inverse_command,
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-            ok = proc.returncode == 0
-            results.append({
-                "event_id": ic.event_id,
-                "command": ic.inverse_command,
-                "exit_code": proc.returncode,
-                "stdout": proc.stdout.strip(),
-                "stderr": proc.stderr.strip(),
-            })
-            if ok:
-                print(f"  OK (exit 0)")
-                # Record REVERTED event in the chain.
-                try:
-                    store = _import_approval_store()
-                    import json as _json
-                    metadata = _json.dumps({
-                        "original_event_id": ic.event_id,
-                        "inverse_command": ic.inverse_command,
-                    })
-                    store.record_event(
-                        raw_id,
-                        "REVERTED",
-                        session_id=session_id,
-                        metadata_json=metadata,
-                    )
-                except Exception:
-                    pass  # Chain write failure is non-fatal for the revert operation.
-            else:
-                print(f"  FAILED (exit {proc.returncode})")
-                if proc.stderr:
-                    print(f"  stderr: {proc.stderr.strip()}")
-                all_ok = False
-        except Exception as exc:
-            print(f"  ERROR: {exc}")
-            results.append({
-                "event_id": ic.event_id,
-                "command": ic.inverse_command,
-                "exit_code": -1,
-                "error": str(exc),
-            })
-            all_ok = False
-
-    if output_json:
-        print(json.dumps({"results": results, "all_ok": all_ok}))
-
-    return 0 if all_ok else 1
-
-
 # ---------------------------------------------------------------------------
 # T3.5: gaia approvals replay <id> [--dry-run]
 # ---------------------------------------------------------------------------
@@ -1522,6 +1323,114 @@ def cmd_replay(args) -> int:
     return 0 if all_ok else 1
 
 
+# ---------------------------------------------------------------------------
+# derive-id -- reproduce a plan-first COMMAND_SET approval_id from its commands
+# ---------------------------------------------------------------------------
+
+def _read_command_set_input(args) -> list:
+    """Resolve the command list for derive-id from args/stdin.
+
+    Accepts, in order of precedence:
+      1. ``--commands-json '[{"command": "..."}, ...]'`` or a bare list of
+         strings ``["cmd a", "cmd b"]`` -- the command_set as the orchestrator
+         reads it from the contract.
+      2. stdin (when ``--commands-json`` is omitted), same JSON shapes.
+
+    Returns the ordered list of command STRINGS (rationale is irrelevant to the
+    derivation). Raises ValueError on malformed input.
+    """
+    raw = getattr(args, "commands_json", None)
+    if raw is None:
+        raw = sys.stdin.read()
+    raw = (raw or "").strip()
+    if not raw:
+        raise ValueError("no command_set provided (use --commands-json or stdin)")
+
+    parsed = json.loads(raw)
+
+    # Accept either a top-level list, or {"command_set": [...]} / {"commands": [...]}.
+    if isinstance(parsed, dict):
+        parsed = parsed.get("command_set") or parsed.get("commands") or []
+
+    if not isinstance(parsed, list):
+        raise ValueError("command_set must be a JSON array")
+
+    commands: list = []
+    for item in parsed:
+        if isinstance(item, str):
+            if item:
+                commands.append(item)
+        elif isinstance(item, dict) and item.get("command"):
+            commands.append(item["command"])
+    return commands
+
+
+def cmd_derive_id(args) -> int:
+    """Derive the deterministic COMMAND_SET approval_id from its commands.
+
+    This is the orchestrator-side mirror of the intake's mint: given the
+    ``command_set`` the subagent emitted in its contract (no DB search), it
+    reproduces the EXACT ``P-...`` id the SubagentStop intake wrote as the
+    pending row, by applying the SAME mutative filter and the SAME
+    ``derive_command_set_id`` canonicalization the intake uses.
+
+    The mutative filter is shared with the intake
+    (``handoff_persister._filter_mutative_command_set``) so the CLI and the hook
+    operate on the identical post-filter command list. When fewer than 2
+    mutative commands remain, NO COMMAND_SET was minted (the singular path owns
+    it) -- the helper reports that rather than emitting a bogus id.
+
+    Exits 0 on success, 1 on error.
+    """
+    output_json = getattr(args, "json", False)
+    apply_filter = not getattr(args, "no_filter", False)
+
+    try:
+        commands = _read_command_set_input(args)
+    except Exception as exc:
+        _print_error(f"Failed to parse command_set: {exc}", args)
+        return 1
+
+    # Apply the SAME mutative filter the intake uses, so the orchestrator's
+    # derivation operates on the identical post-filter list. Skippable via
+    # --no-filter for callers that already hold the filtered list.
+    if apply_filter:
+        try:
+            from modules.agents.handoff_persister import _filter_mutative_command_set
+            filtered = _filter_mutative_command_set(
+                [{"command": c, "rationale": ""} for c in commands]
+            )
+            commands = [it["command"] for it in filtered]
+        except Exception as exc:
+            _print_error(f"Failed to apply mutative filter: {exc}", args)
+            return 1
+
+    if len(commands) < 2:
+        msg = (
+            f"Not a COMMAND_SET: {len(commands)} mutative command(s) after filter "
+            "(need >= 2). No COMMAND_SET approval was minted -- the singular path "
+            "owns this."
+        )
+        if output_json:
+            print(json.dumps({"approval_id": None, "command_count": len(commands), "reason": msg}))
+        else:
+            _print_error(msg, args)
+        return 1
+
+    try:
+        store = _import_approval_store()
+        approval_id = store.derive_command_set_id(commands)
+    except Exception as exc:
+        _print_error(f"Failed to derive id: {exc}", args)
+        return 1
+
+    if output_json:
+        print(json.dumps({"approval_id": approval_id, "command_count": len(commands)}))
+    else:
+        print(approval_id)
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # Plugin registration (called by bin/gaia dispatcher)
 # ---------------------------------------------------------------------------
@@ -1531,7 +1440,7 @@ def register(subparsers) -> None:
     p = subparsers.add_parser(
         "approvals",
         help="Manage T3 pending approvals",
-        description="View, approve, reject, revert, and replay Gaia approval requests.",
+        description="View, approve, reject, and replay Gaia approval requests.",
     )
     sub = p.add_subparsers(dest="approvals_cmd", metavar="SUBCOMMAND")
     sub.required = True
@@ -1652,33 +1561,6 @@ def register(subparsers) -> None:
     p_history.add_argument("--json", action="store_true", help="JSON output")
     p_history.set_defaults(func=cmd_history)
 
-    # revert (T3.5) -- interactive inverse-command UX
-    p_revert = sub.add_parser(
-        "revert",
-        help="Revert an approval by executing inverse commands (interactive)",
-        description=(
-            "Per D14: interactive inverse-command UX for reverting executed approvals.\n\n"
-            "Shows candidate inverse commands, prompts for selection, then executes\n"
-            "the selected inverses sequentially. Uses --yes to skip per-event prompts.\n"
-            "Use --dry-run to preview without executing."
-        ),
-    )
-    p_revert.add_argument(
-        "approval_id",
-        metavar="APPROVAL_ID",
-        help="P-{uuid4hex} of the approval to revert",
-    )
-    p_revert.add_argument("--yes", action="store_true", help="Skip confirmation prompts")
-    p_revert.add_argument("--dry-run", action="store_true", dest="dry_run", help="Preview only")
-    p_revert.add_argument(
-        "--file",
-        metavar="PATH",
-        default=None,
-        help="File of event_ids to revert (one per line) for batch mode",
-    )
-    p_revert.add_argument("--json", action="store_true", help="JSON output for results")
-    p_revert.set_defaults(func=cmd_revert)
-
     # replay (T3.5) -- re-run commands from an executed approval
     p_replay = sub.add_parser(
         "replay",
@@ -1763,6 +1645,35 @@ def register(subparsers) -> None:
     p_stats.add_argument("--json", action="store_true", help="JSON output")
     p_stats.set_defaults(func=cmd_stats)
 
+    # derive-id -- reproduce a plan-first COMMAND_SET id from its commands
+    p_derive = sub.add_parser(
+        "derive-id",
+        help="Derive the deterministic COMMAND_SET approval_id from its commands",
+        description=(
+            "Reproduce the content-derived approval_id the SubagentStop intake\n"
+            "minted for a plan-first COMMAND_SET, from the command_set in the\n"
+            "contract -- no DB search. Pass the command_set as JSON via\n"
+            "--commands-json or stdin (a list of strings, a list of\n"
+            "{command, rationale} objects, or an object with a command_set/\n"
+            "commands key). Applies the same mutative filter the intake uses."
+        ),
+    )
+    p_derive.add_argument(
+        "--commands-json",
+        dest="commands_json",
+        metavar="JSON",
+        default=None,
+        help="command_set as JSON (omit to read from stdin)",
+    )
+    p_derive.add_argument(
+        "--no-filter",
+        action="store_true",
+        dest="no_filter",
+        help="Skip the mutative filter (input is already the filtered list)",
+    )
+    p_derive.add_argument("--json", action="store_true", help="JSON output")
+    p_derive.set_defaults(func=cmd_derive_id)
+
     p.set_defaults(func=_approvals_default)
 
 
@@ -1788,13 +1699,13 @@ def _approvals_default(args) -> int:
     print("  approve APPROVAL_ID               -- cross-session approve")
     print("  revoke APPROVAL_ID                -- revoke a pending approval")
     print("  history [APPROVAL_ID] [--limit N] -- temporal history or per-approval chain")
-    print("  revert APPROVAL_ID [--dry-run]    -- interactive inverse-command revert")
     print("  replay APPROVAL_ID [--dry-run]    -- replay an executed approval")
     print("  list [--session S] [--orphans-only]  -- list (legacy + DB grants)")
     print("  reject NONCE [--all]              -- reject pending (legacy)")
     print("  reject-all [--dry-run]            -- bulk reject (legacy)")
     print("  clean [--dry-run]                 -- remove expired approvals")
     print("  stats                             -- approval system statistics")
+    print("  derive-id --commands-json JSON    -- reproduce a COMMAND_SET id (no DB)")
     print("")
     print("Run 'gaia approvals --help' for more information.")
     return 0
@@ -1850,14 +1761,6 @@ def _build_standalone_parser() -> argparse.ArgumentParser:
     p_history.add_argument("--json", action="store_true")
     p_history.set_defaults(func=cmd_history)
 
-    p_revert = subparsers.add_parser("revert", help="Revert an approval (interactive)")
-    p_revert.add_argument("approval_id", metavar="APPROVAL_ID")
-    p_revert.add_argument("--yes", action="store_true")
-    p_revert.add_argument("--dry-run", action="store_true", dest="dry_run")
-    p_revert.add_argument("--file", metavar="PATH", default=None)
-    p_revert.add_argument("--json", action="store_true")
-    p_revert.set_defaults(func=cmd_revert)
-
     p_replay = subparsers.add_parser("replay", help="Replay an executed approval")
     p_replay.add_argument("approval_id", metavar="APPROVAL_ID")
     p_replay.add_argument("--dry-run", action="store_true", dest="dry_run")
@@ -1886,6 +1789,12 @@ def _build_standalone_parser() -> argparse.ArgumentParser:
     p_stats.add_argument("--json", action="store_true")
     p_stats.set_defaults(func=cmd_stats)
 
+    p_derive = subparsers.add_parser("derive-id", help="Derive a COMMAND_SET approval_id from its commands")
+    p_derive.add_argument("--commands-json", dest="commands_json", metavar="JSON", default=None)
+    p_derive.add_argument("--no-filter", action="store_true", dest="no_filter")
+    p_derive.add_argument("--json", action="store_true")
+    p_derive.set_defaults(func=cmd_derive_id)
+
     return parser
 
 

package/bin/cli/doctor.py

@@ -762,7 +762,7 @@ def _extract_check_values(
 @register_check("Symlinks", order=50)
 def check_symlinks(project_root: Path) -> dict:
     """Check .claude/ symlinks resolve to package content."""
-    names = ["agents", "tools", "hooks", "commands", "config", "skills", "CHANGELOG.md"]
+    names = ["agents", "tools", "hooks", "config", "skills", "CHANGELOG.md"]
     critical = {"agents", "hooks", "skills"}
     valid = 0
     has_critical_missing = False
@@ -1053,34 +1053,36 @@ def check_memory_fts5_db(project_root: Path) -> dict:
 
 @register_check("memory_fts5_count", order=130)
 def check_memory_fts5_count(project_root: Path) -> dict:
-    """Check FTS5 indexed count against total episode count in index.json."""
-    index_path = project_root / ".claude" / "project-context" / "episodic-memory" / "index.json"
-
-    if not index_path.is_file():
-        return _result("memory_fts5_count", "info", "index.json not found — no episodes yet")
-
-    index_data = _read_json(index_path)
-    if not index_data:
-        return _result("memory_fts5_count", "info", "index.json unreadable")
-
-    total = len(index_data.get("episodes") or [])
+    """Check FTS5 indexed count against total episode count in gaia.db.
 
+    T6 migration: replaced legacy search_store.count()/index.json check
+    (which read search.db and ignored GAIA_DATA_DIR) with queries against
+    the canonical gaia.db -- episodes_fts for indexed, episodes for total.
+    """
     try:
         import sys as _sys
-        # Ensure package root is on path for lazy import
         pkg_root = str(_package_root())
         if pkg_root not in _sys.path:
             _sys.path.insert(0, pkg_root)
-        from tools.memory import search_store  # noqa: PLC0415
-        indexed = search_store.count()
+        from gaia.store.writer import _connect as _store_connect
     except ImportError:
         return _result(
             "memory_fts5_count",
             "info",
-            "tools.memory.search_store not importable — FTS5 count skipped",
+            "gaia.store.writer not importable — FTS5 count skipped",
         )
+
+    try:
+        con = _store_connect()
+        try:
+            indexed_row = con.execute("SELECT COUNT(*) FROM episodes_fts").fetchone()
+            indexed = indexed_row[0] if indexed_row else 0
+            total_row = con.execute("SELECT COUNT(*) FROM episodes").fetchone()
+            total = total_row[0] if total_row else 0
+        finally:
+            con.close()
     except Exception as exc:
-        return _result("memory_fts5_count", "info", f"Could not query FTS5 count: {exc}")
+        return _result("memory_fts5_count", "info", f"Could not query FTS5 count from gaia.db: {exc}")
 
     if total == 0:
         return _result("memory_fts5_count", "pass", "No episodes to index")

package/bin/validate-sandbox.sh

@@ -590,11 +590,16 @@ else
   rc=$?
 fi
 ms=$(( $(now_ms) - t0 ))
-# doctor may exit 1 on warnings; allow rc=0 or rc=1 if json is parseable
-if python3 -c "import json,sys; d=json.loads(sys.argv[1]); c=d['checks']; p=sum(1 for r in c if r['severity']=='pass'); t=len(c); sys.exit(0 if t>=5 and p>=max(1,t-3) else 1)" "${out}" 2>/dev/null; then
+# The harness gate must not pass a degraded doctor: a non-zero rc means at
+# least one check is warning/error, so treat rc>=1 as a hard FAILURE. Only a
+# clean rc=0 (all checks pass/info) with parseable JSON counts as PASS.
+if [[ "${rc}" -ne 0 ]]; then
+  nonpass="$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(', '.join(f\"{r['name']}={r['severity']}\" for r in d['checks'] if r['severity'] not in ('pass','info')))" "${out}" 2>/dev/null || echo "unparseable output")"
+  record "gaia doctor --json" "FAIL" "doctor returned rc=${rc}; non-pass: ${nonpass:-none}" "${ms}"
+elif python3 -c "import json,sys; d=json.loads(sys.argv[1]); c=d['checks']; t=len(c); sys.exit(0 if t>=5 else 1)" "${out}" 2>/dev/null; then
   total=$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(len(d['checks']))" "${out}")
   passed=$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(sum(1 for r in d['checks'] if r['severity']=='pass'))" "${out}")
-  record "gaia doctor --json" "PASS" "${passed}/${total} checks passed" "${ms}"
+  record "gaia doctor --json" "PASS" "rc=0, ${passed}/${total} checks passed" "${ms}"
 else
   record "gaia doctor --json" "FAIL" "parse/threshold failure (rc=${rc})" "${ms}"
 fi

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

@@ -1,6 +1,6 @@
 {
   "name": "gaia-ops",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "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",