postgres-aiops 0.10.3__tar.gz → 0.12.0__tar.gz

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "postgres-aiops",
   "displayName": "Postgres AIops",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "Governed PostgreSQL DBA ops: slow-query RCA, bloat/vacuum & blocking-lock analysis; 35 MCP tools.",
   "author": {
     "name": "Wei Zhou",

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/.mcp.json

@@ -5,7 +5,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "postgres-aiops==0.10.3",
+        "postgres-aiops==0.12.0",
         "postgres-aiops-mcp"
       ]
     }

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## v0.12.0 — 2026-10-15
+
+### Fixed
+- The MCP server moved from a top-level `mcp_server` package to
+  `postgres_aiops.mcp_server`. Every AIops tool used to ship its own top-level
+  `mcp_server`, so installing two of them into one environment merged the two
+  into one package: `postgres-aiops-mcp` could start another tool's server, and
+  `postgres-aiops undo` wrote audit and undo rows into the other tool's home
+  directory. Installs through `uvx`, the Claude Code plugin or the OpenClaw
+  bundle were isolated and unaffected. The `postgres-aiops-mcp` command is
+  unchanged; only code that imported `mcp_server` directly must now import
+  `postgres_aiops.mcp_server`.
+
+## v0.11.0 — 2026-10-15
+
+### Added
+- MCP tool annotations derived from each tool's governance `risk_level`, so
+  clients can gate approval from `tools/list` alone. `low` tools advertise
+  `readOnlyHint: true`; every other tool advertises `readOnlyHint: false` and
+  `destructiveHint: true`. The `medium` tier includes deletes and hard
+  power-offs, so a tool is never advertised as non-destructive on the strength
+  of its tier. `idempotentHint` only repeats an explicit declaration. The exact
+  level is published in `_meta` under `io.github.AIops-tools/riskLevel`. These
+  are hints for the client; audit and undo are unchanged.
+
+### Fixed
+- `blocking_lock_chain_rca`: the chain root's state was dropped and a missing
+  query became `""`. For a backend that is `idle in transaction`, `rootQuery` is
+  the last statement it ran, not a running one, so the recommended
+  `cancel_query` had nothing to cancel. Roots now carry `rootState` and
+  `rootIdle` (true for any `idle*` state, including plain `idle` with session-level locks), a missing query stays `null`, and the action for an
+  idle root points at `terminate_backend` (which rolls the transaction back).
+
 ## v0.10.3 — 2026-09-15
 
 ### Fixed

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: postgres-aiops
-Version: 0.10.3
+Version: 0.12.0
 Summary: Governed AI-ops for PostgreSQL DBA operations: slow-query RCA, bloat/vacuum & blocking-lock analysis with a built-in governance harness (audit, budget, undo, risk tiers)
 Author-email: Wei Zhou <zhouwei008@gmail.com>
 License-Expression: MIT

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/RELEASE_NOTES.md

@@ -1,5 +1,8 @@
 # Release notes — postgres-aiops 0.6.0
 
+> Historical — this file covers the 0.6.0 release only and is not updated.
+> For every release since, see [CHANGELOG.md](CHANGELOG.md) and the GitHub releases.
+
 Previous release: 0.5.0.
 
 ## BREAKING — the authorization layer is removed

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/SECURITY.md

@@ -82,7 +82,7 @@ connection. No post-install scripts or background services.
 ## Static Analysis
 
 ```bash
-uvx bandit -r postgres_aiops/ mcp_server/
+uvx bandit -r postgres_aiops/
 uv run ruff check .
 ```
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/openclaw.plugin.json

@@ -11,7 +11,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "postgres-aiops==0.10.3",
+        "postgres-aiops==0.12.0",
         "postgres-aiops-mcp"
       ]
     }

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zw008/postgres-aiops",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "Governed PostgreSQL DBA ops: slow-query RCA, bloat/vacuum & blocking-lock analysis; 35 MCP tools.",
   "private": true,
   "license": "MIT",

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/postgres_aiops/cli/_root.py

@@ -61,7 +61,7 @@ def mcp_cmd() -> None:
         )
         raise typer.Exit(2)
 
-    from mcp_server.server import main as _mcp_main
+    from postgres_aiops.mcp_server.server import main as _mcp_main
 
     _mcp_main()
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/postgres_aiops/cli/query.py

@@ -70,7 +70,7 @@ def query_reset(target: TargetOption = None, dry_run: DryRunOption = False) -> N
     ``@governed_tool``-wrapped MCP function, so each is audited on the same
     governance path as MCP calls.
     """
-    from mcp_server.tools import queries as gov
+    from postgres_aiops.mcp_server.tools import queries as gov
 
     if dry_run:
         dry_run_preview(

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/postgres_aiops/cli/remediate.py

@@ -32,7 +32,7 @@ def remediate_terminate(
     dry_run: DryRunOption = False,
 ) -> None:
     """Terminate a backend (no undo; dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         # Through the governed call: terminate_backend refuses this tool's own
@@ -54,7 +54,7 @@ def remediate_cancel(
     dry_run: DryRunOption = False,
 ) -> None:
     """Cancel a backend's running query (no undo; dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         dry_run_preview(
@@ -76,7 +76,7 @@ def remediate_vacuum(
     dry_run: DryRunOption = False,
 ) -> None:
     """VACUUM a table (dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         dry_run_preview(
@@ -97,7 +97,7 @@ def remediate_analyze(
     dry_run: DryRunOption = False,
 ) -> None:
     """ANALYZE a table (dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         dry_run_preview(
@@ -120,7 +120,7 @@ def remediate_create_index(
     dry_run: DryRunOption = False,
 ) -> None:
     """Create an index (reversible; dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         # Through the governed call: create_index validates the table/columns vs
@@ -146,7 +146,7 @@ def remediate_drop_index(
     dry_run: DryRunOption = False,
 ) -> None:
     """Drop an index (reversible; captures the definition first; dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         dry_run_preview(
@@ -168,7 +168,7 @@ def remediate_reindex(
     dry_run: DryRunOption = False,
 ) -> None:
     """REINDEX an index/table/schema (dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     if dry_run:
         dry_run_preview(
@@ -195,7 +195,7 @@ def remediate_set(
     dry_run: DryRunOption = False,
 ) -> None:
     """ALTER SYSTEM SET a parameter, or --reset it (reversible; dry-run + confirm)."""
-    from mcp_server.tools import remediation as gov
+    from postgres_aiops.mcp_server.tools import remediation as gov
 
     action = f"ALTER SYSTEM RESET {name}" if reset else f"ALTER SYSTEM SET {name} ="
     if dry_run:

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/postgres_aiops/cli/undo.py

@@ -1,7 +1,7 @@
 """``postgres-aiops undo`` — list recorded undo tokens and apply them.
 
 Real execution is delegated to the ``@governed_tool``-wrapped functions in
-``mcp_server.tools.undo`` so an applied undo is audited on the SAME governance
+``postgres_aiops.mcp_server.tools.undo`` so an applied undo is audited on the SAME governance
 path as any other write (the inverse tool it dispatches is itself re-gated).
 """
 
@@ -38,7 +38,7 @@ def undo_list_cmd(
     target: TargetOption = None,
 ) -> None:
     """List recorded, not-yet-applied undo tokens."""
-    from mcp_server.tools import undo as gov
+    from postgres_aiops.mcp_server.tools import undo as gov
 
     console.print_json(json.dumps(gov.undo_list(limit=limit, target=target)))
 
@@ -49,7 +49,7 @@ def undo_apply_cmd(
     undo_id: UndoIdArg, target: TargetOption = None, dry_run: DryRunOption = False
 ) -> None:
     """Apply a recorded undo (dispatches its inverse tool; dry-run + confirm)."""
-    from mcp_server.tools import undo as gov
+    from postgres_aiops.mcp_server.tools import undo as gov
 
     if dry_run:
         # undo_apply refuses an unknown or already-applied token, and refuses one

postgres_aiops-0.12.0/postgres_aiops/mcp_server/_annotations.py

@@ -0,0 +1,66 @@
+"""Derive MCP tool annotations from the governance risk level.
+
+Every tool already declares ``risk_level`` on ``@governed_tool``; this module
+publishes it to MCP clients as the standard ``ToolAnnotations`` hints plus the
+exact level under ``_meta``, so a client can gate approval without reading our
+docstrings.
+
+Only the safe direction is ever asserted:
+
+- ``low`` → ``readOnlyHint: true``. Backed by the smoke-test invariant that
+  ``risk_level == "low"`` exactly when the docstring says ``[READ]``.
+- anything else → ``readOnlyHint: false, destructiveHint: true``. The
+  ``medium`` tier is NOT non-destructive — it holds deletes, hard power-offs,
+  state kills and stat resets — so claiming ``destructiveHint: false`` from the
+  tier would tell a client it may skip approval for a delete. Over-warning
+  costs a confirmation prompt; under-warning costs data.
+- ``idempotentHint`` only echoes an explicit ``@governed_tool(idempotent=True)``
+  declaration; it is never inferred.
+- ``openWorldHint`` is left unset (spec default ``true``): every tool talks to
+  an external system.
+
+This file is identical across the AIops line; keep it that way.
+"""
+
+from typing import Any
+
+from mcp.types import ToolAnnotations
+
+RISK_META_KEY = "io.github.AIops-tools/riskLevel"
+RISK_LEVELS = frozenset({"low", "medium", "high", "critical"})
+
+
+def annotations_for(risk_level: str, idempotent: bool) -> ToolAnnotations:
+    """Return the MCP hints that a tool of ``risk_level`` may honestly claim."""
+    if risk_level not in RISK_LEVELS:
+        raise ValueError(
+            f"unknown risk_level {risk_level!r}; expected one of {sorted(RISK_LEVELS)}"
+        )
+    if risk_level == "low":
+        return ToolAnnotations(read_only_hint=True)
+    return ToolAnnotations(
+        read_only_hint=False,
+        destructive_hint=True,
+        idempotent_hint=idempotent,
+    )
+
+
+def apply_risk_annotations(server: Any) -> None:
+    """Replace every registered tool with a copy carrying its risk annotations.
+
+    Fails fast on a tool without ``@governed_tool`` metadata: an unannotated
+    tool would be advertised with the spec defaults, i.e. as a destructive
+    write with no stated risk level — wrong for a read, silent for a write.
+    """
+    tools = server._tool_manager._tools  # same private registry undo.py relies on
+    for name, tool in list(tools.items()):
+        risk_level = getattr(tool.fn, "_risk_level", None)
+        if risk_level is None:
+            raise RuntimeError(f"tool {name!r} has no @governed_tool risk_level")
+        idempotent = bool(getattr(tool.fn, "_idempotent", False))
+        tools[name] = tool.model_copy(
+            update={
+                "annotations": annotations_for(risk_level, idempotent),
+                "meta": {**(tool.meta or {}), RISK_META_KEY: risk_level},
+            }
+        )

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/_shared.py

@@ -1,8 +1,8 @@
 """Shared MCP server primitives: the MCPServer instance, connection helper,
 error sanitisation, and the ``@tool_errors`` decorator.
 
-Tool modules under ``mcp_server/tools/`` import ``mcp`` from here and register
-their ``@mcp.tool()`` functions onto it. ``mcp_server/server.py`` then imports
+Tool modules under ``postgres_aiops/mcp_server/tools/`` import ``mcp`` from here and register
+their ``@mcp.tool()`` functions onto it. ``postgres_aiops/mcp_server/server.py`` then imports
 those modules and runs the server.
 
 Keep ``Optional[X]`` (never PEP 604 ``X | None``) in any reflected tool

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/server.py

@@ -1,6 +1,6 @@
 """MCP server wrapping postgres-aiops operations (stdio transport).
 
-Thin adapter layer: each ``@mcp.tool()`` function (in ``mcp_server/tools/``)
+Thin adapter layer: each ``@mcp.tool()`` function (in ``postgres_aiops/mcp_server/tools/``)
 delegates to the ``postgres_aiops`` ops package and is wrapped with the
 postgres-aiops ``@governed_tool`` harness (audit / budget / undo / risk-tier).
 
@@ -14,11 +14,12 @@ License: MIT
 import logging
 import os
 
-from mcp_server._shared import _safe_error, mcp, tool_errors
+from postgres_aiops.mcp_server._annotations import apply_risk_annotations
+from postgres_aiops.mcp_server._shared import _safe_error, mcp, tool_errors
 
 # Importing the tool modules registers every @mcp.tool() onto the shared
 # `mcp` instance. Order does not matter; each module is self-contained.
-from mcp_server.tools import (  # noqa: F401 — side effects
+from postgres_aiops.mcp_server.tools import (  # noqa: F401 — side effects
     activity,
     analysis,
     indexes,
@@ -30,6 +31,10 @@ from mcp_server.tools import (  # noqa: F401 — side effects
     undo,
 )
 
+# Publish each tool's governance risk level as MCP annotations. Runs after
+# every tool module has registered, so no tool is advertised unannotated.
+apply_risk_annotations(mcp)
+
 __all__ = ["mcp", "main", "_safe_error", "tool_errors"]
 
 logger = logging.getLogger(__name__)

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/activity.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import activity as ops
 
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/analysis.py

@@ -2,8 +2,8 @@
 
 from typing import Any, Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import activity as activity_ops
 from postgres_aiops.ops import analysis as ops
 from postgres_aiops.ops import queries as query_ops

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/indexes.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import indexes as ops
 
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/queries.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import queries as ops
 
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/remediation.py

@@ -12,8 +12,8 @@ Risk tiers:
 
 from typing import Any, Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import remediation as ops
 
 # ── undo descriptors (built from the fetched before-state) ──────────────────

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/replication.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import replication as ops
 
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/server.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import overview as overview_ops
 from postgres_aiops.ops import server as ops
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/tables.py

@@ -2,8 +2,8 @@
 
 from typing import Optional
 
-from mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.governance import governed_tool
+from postgres_aiops.mcp_server._shared import _get_connection, mcp, tool_errors
 from postgres_aiops.ops import tables as ops
 
 

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0/postgres_aiops}/mcp_server/tools/undo.py

@@ -15,26 +15,26 @@ design, inverses in this line key off ids/names, not credentials.
 import json
 from typing import Any, Optional
 
-from mcp_server._shared import mcp, tool_errors
 from postgres_aiops.governance import governed_tool
 from postgres_aiops.governance.undo import get_undo_store
+from postgres_aiops.mcp_server._shared import mcp, tool_errors
 
 
 def _resolve_tool(name: str) -> Any:
     """Return the governed callable registered under ``name`` (or None).
 
     The CLI reaches this through ``undo apply``, whose process only imports
-    ``mcp_server.tools.undo`` — every other tool module is imported lazily inside
+    ``postgres_aiops.mcp_server.tools.undo`` — every other tool module is imported lazily inside
     its own CLI command and so is absent here. Without forcing a full load,
     ``undo_apply`` would fail with "inverse tool not registered" for every write
     tool when driven from the CLI (the MCP entry point loads all modules, so it
-    never hit this). If the first lookup misses, import ``mcp_server.server`` —
+    never hit this). If the first lookup misses, import ``postgres_aiops.mcp_server.server`` —
     which registers every ``@mcp.tool()`` as an import side effect — and retry.
     Imported lazily to avoid the undo↔server cycle.
     """
     tool = mcp._tool_manager._tools.get(name)
     if tool is None:
-        import mcp_server.server  # noqa: F401 — registers all tools as a side effect
+        import postgres_aiops.mcp_server.server  # noqa: F401 — registers all tools as a side effect
 
         tool = mcp._tool_manager._tools.get(name)
     return getattr(tool, "fn", None) if tool else None

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/postgres_aiops/ops/analysis.py

@@ -201,6 +201,22 @@ def _descendants(root: int, children: dict[int, list[int]]) -> set[int]:
     return seen
 
 
+def _lock_root_action(pid: int, idle: bool | None) -> str:
+    if idle:
+        return (
+            f"Backend {pid} heads the chain but is not running a statement (see "
+            "rootState: an open transaction, or session-level locks): rootQuery is "
+            "the last statement it ran, not a running one. cancel_query has nothing "
+            f"to cancel; terminate_backend({pid}) ends the session, rolling back any "
+            "transaction and releasing its locks — confirm with its owner first."
+        )
+    return (
+        f"Backend {pid} is the head of the chain — investigate its transaction; "
+        f"cancel_query({pid}) to stop its statement, or terminate_backend({pid}) to "
+        "end the session and release the locks."
+    )
+
+
 def blocking_lock_chain_rca(pairs: list[dict]) -> dict:
     """[READ] Build the wait-for tree from blocking pairs and name the root blocker.
 
@@ -217,7 +233,8 @@ def blocking_lock_chain_rca(pairs: list[dict]) -> dict:
         return {"blockedBackends": 0, "roots": [], "note": "No blocking detected."}
 
     children: dict[int, list[int]] = {}
-    blocking_query: dict[int, str] = {}
+    blocking_query: dict[int, str | None] = {}
+    blocking_state: dict[int, str | None] = {}
     blocked_pids: set[int] = set()
     blocking_pids: set[int] = set()
     for e in edges:
@@ -225,7 +242,8 @@ def blocking_lock_chain_rca(pairs: list[dict]) -> dict:
         children.setdefault(g, []).append(b)
         blocked_pids.add(b)
         blocking_pids.add(g)
-        blocking_query.setdefault(g, e.get("blockingQuery") or "")
+        blocking_query.setdefault(g, e.get("blockingQuery"))
+        blocking_state.setdefault(g, e.get("blockingState"))
 
     root_pids = [pid for pid in blocking_pids if pid not in blocked_pids]
     if not root_pids:
@@ -242,16 +260,18 @@ def blocking_lock_chain_rca(pairs: list[dict]) -> dict:
     roots = []
     for pid in root_pids:
         blocked = _descendants(pid, children)
+        state = blocking_state.get(pid)
+        # Any idle state means no statement is running: "idle in transaction"
+        # holds row locks, plain "idle" can still hold session-level advisory locks.
+        idle = None if state is None else str(state).startswith("idle")
         roots.append({
             "rootPid": pid,
             "blockedCount": len(blocked),
             "blockedPids": sorted(blocked),
-            "rootQuery": blocking_query.get(pid, ""),
-            "action": (
-                f"Backend {pid} is the head of the chain — investigate its "
-                "transaction; cancel_query(pid) to stop its statement, or "
-                "terminate_backend(pid) to end the session and release the locks."
-            ),
+            "rootQuery": blocking_query.get(pid),
+            "rootState": state,
+            "rootIdle": idle,
+            "action": _lock_root_action(pid, idle),
         })
     roots.sort(key=lambda r: r["blockedCount"], reverse=True)
     return {

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "postgres-aiops"
-version = "0.10.3"
+version = "0.12.0"
 description = "Governed AI-ops for PostgreSQL DBA operations: slow-query RCA, bloat/vacuum & blocking-lock analysis with a built-in governance harness (audit, budget, undo, risk tiers)"
 readme = "README.md"
 license = "MIT"
@@ -28,10 +28,10 @@ dev = [
 
 [project.scripts]
 postgres-aiops = "postgres_aiops.cli:app"
-postgres-aiops-mcp = "mcp_server.server:main"
+postgres-aiops-mcp = "postgres_aiops.mcp_server.server:main"
 
 [tool.hatch.build.targets.wheel]
-packages = ["postgres_aiops", "mcp_server"]
+packages = ["postgres_aiops"]
 
 [tool.ruff]
 line-length = 100
@@ -47,7 +47,7 @@ select = ["E", "F", "I", "N", "W", "UP"]
 "postgres_aiops/governance/*.py" = ["E501", "N818"]
 # MCP server files are reflected by FastMCP/Pydantic; PEP 604 unions (X | None)
 # crash on older mcp/pydantic, so they intentionally use Optional[X].
-"mcp_server/**/*.py" = ["UP007", "UP045"]
+"postgres_aiops/mcp_server/**/*.py" = ["UP007", "UP045"]
 # The MCP entry keeps an explicit Python-version guard even though the declared
 # minimum is already 3.11.
 "postgres_aiops/cli/_root.py" = ["UP036"]

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/AIops-tools/Postgres-AIops",
     "source": "github"
   },
-  "version": "0.10.3",
+  "version": "0.12.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "postgres-aiops",
-      "version": "0.10.3",
+      "version": "0.12.0",
       "transport": {
         "type": "stdio"
       }

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/skills/postgres-aiops/references/agent-guardrails.md

@@ -28,7 +28,7 @@ recorded on the audit row; they are never required and never block a call.
 ## What still needs a prompt
 
 These are model-behaviour problems the harness cannot fix from the outside.
-Copy this into your agent's system prompt:
+Recommended setup for a local model (adapt it to your agent client):
 
 ```text
 You operate a PostgreSQL server through the postgres-aiops MCP tools.

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/skills/postgres-aiops/references/capabilities.md

@@ -32,7 +32,7 @@
 | `wal_status` | WAL fns + `pg_stat_archiver` | currentLsn, walLevel, max/minWalSize, archiver |
 | `slow_query_rca` | pg_stat_statements + EXPLAIN | worst{}, findings[] (cited cause/action) |
 | `bloat_and_vacuum_analysis` | table-bloat rows | recommendations[] (cited reasons + action) |
-| `blocking_lock_chain_rca` | `pg_blocking_pids` pairs | roots[], worstRootPid, deadlockSuspected |
+| `blocking_lock_chain_rca` | `pg_blocking_pids` pairs | roots[] (rootQuery, rootState, rootIdle — true for any `idle*` state; rootQuery is then the last statement run, not a running one — and action), worstRootPid, deadlockSuspected |
 | `undo_list` | local undo store | recorded, not-yet-applied reversible writes: undoId, ts, originalTool, inverseTool, note |
 
 The flagship analyses accept injected records (`statements=` / `tables=` /

{postgres_aiops-0.10.3 → postgres_aiops-0.12.0}/tests/test_analysis.py

@@ -82,3 +82,48 @@ def test_blocking_chain_detects_cycle():
 def test_blocking_chain_no_blocking():
     out = analysis.blocking_lock_chain_rca([])
     assert out["blockedBackends"] == 0
+
+
+# ── lock-chain root that is idle inside an open transaction ──────────────────
+
+
+def _pg_pairs(state, query="UPDATE t SET v=1 WHERE id=1"):
+    return [{"blockedPid": 201, "blockingPid": 100, "blockedQuery": "DELETE FROM t",
+             "blockingQuery": query, "blockingState": state}]
+
+
+def test_idle_in_transaction_root_is_named_and_cancel_is_ruled_out():
+    from postgres_aiops.ops import analysis as a
+
+    (root,) = a.blocking_lock_chain_rca(_pg_pairs("idle in transaction"))["roots"]
+    assert root["rootState"] == "idle in transaction"
+    assert root["rootIdle"] is True
+    # The query is the LAST statement it ran, not a running one.
+    assert "last statement" in root["action"]
+    assert "terminate_backend(100)" in root["action"]
+    assert "nothing to cancel" in root["action"]
+
+
+def test_active_root_offers_cancel_first():
+    from postgres_aiops.ops import analysis as a
+
+    (root,) = a.blocking_lock_chain_rca(_pg_pairs("active"))["roots"]
+    assert root["rootIdle"] is False
+    assert "cancel_query(100)" in root["action"]
+
+
+def test_missing_root_query_stays_null():
+    from postgres_aiops.ops import analysis as a
+
+    (root,) = a.blocking_lock_chain_rca(_pg_pairs(None, query=None))["roots"]
+    assert root["rootQuery"] is None
+    assert root["rootState"] is None
+    assert root["rootIdle"] is None  # state unknown
+
+
+def test_plain_idle_root_with_session_locks_is_not_offered_cancel():
+    from postgres_aiops.ops import analysis as a
+
+    (root,) = a.blocking_lock_chain_rca(_pg_pairs("idle"))["roots"]
+    assert root["rootIdle"] is True
+    assert "terminate_backend(100)" in root["action"]