queue-aiops 0.5.0__tar.gz → 0.7.0__tar.gz

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.7.0 — 2026-08-10
+
+### Fixed
+- **`purge_queue` could never have worked against a real RabbitMQ.** The management-API client sent `Accept: application/json`, but the purge endpoint (`DELETE /api/queues/{vhost}/{name}/contents`) answers *204 No Content* and offers no JSON representation, so content negotiation failed and the broker returned **406 with an empty body** — on every purge, on every server. Accept is now `application/json, */*`; every other endpoint (GETs, PUT declare, DELETE queue, DELETE policy) was enumerated against a live broker and behaves identically either way. Verified on RabbitMQ 3.13.7 by purging a real 9-message backlog.
+- **A 406 now explains itself.** The broker sends no body with a 406, so the generic branch produced a message with nothing in it — and, because the platform label already ends in "API", it read "RabbitMQ management API **API error**". There is now a 406 branch naming content negotiation as the cause, and the generic branch no longer doubles the word.
+- **Two more integer quantities stayed integers** (bug class #2): a node's `memUsedBytes` / `memLimitBytes` came back as floats (`161222656.0`) while the `diskFreeBytes` beside them was an int — one payload disagreeing with itself — and the per-peer `channels` count rendered as `1.0` for one channel, from a `0.0` accumulator seed. Both found on a live broker; regression tests assert the type.
+- **Write-path integer quantities stay integers** (bug class #2/#4). `ops/writes.py` still rendered whole-second and count fields through the float helper `num()` — `kill_client`'s `priorState.ageSeconds` came back as `49.0`, and the RabbitMQ purge/policy captures rendered `messages` and `priority` as floats too. It was missed in the earlier read-path sweep (the module did not even import `as_int`) and was inconsistent with `list_clients`, which already rendered the identical CLIENT LIST `age` field as an `int`. Now uses `as_int`; a regression test asserts the *type* (equality cannot catch `49 == 49.0`). Found live while verifying `kill-client` against a real blocked `BLPOP` client on Redis 7.4.
+
+## v0.6.0 — 2026-08-03
+
+### Fixed
+- **A cluster node's key count no longer poses as the whole dataset.** `INFO keyspace` on a Redis Cluster node answers for that node's slots only, so `keyspace` / `overview` reported `totalKeys: 100` for a 3-master cluster actually holding 300 — a dataset-wide claim wrong by the shard count, with nothing in the payload to say otherwise. Both now carry `scope` (`node` vs `server`), `clusterMode`, and on a cluster a note explaining that the figure covers one node. Measured on a real 3-master Redis 7.4 cluster (100 / 92 / 108).
+- **`undo apply` replays against the target the original write ran on.** It dispatched the inverse against whatever target the *caller* named — in practice the config's first entry — while the write's own target sat unused in the undo record. On a multi-target config the inverse therefore ran against the wrong host; it only looks harmless because the resource usually is not there, but two hosts holding the same name and the inverse **succeeds on the wrong one, silently**. An explicitly named target still wins. Line-wide: all 24 copies had the identical defect. Caught live in container-host-aiops, where a stop recorded against a Podman target replayed against a Portainer one.
+
 ## v0.5.0 — 2026-08-02
 
 ### Changed (BREAKING)

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queue-aiops
-Version: 0.5.0
+Version: 0.7.0
 Summary: Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)
 Author-email: Wei Zhou <zhouwei008@gmail.com>
 License-Expression: MIT

queue_aiops-0.7.0/docs/VERIFICATION.md

@@ -0,0 +1,97 @@
+# Live verification status
+
+This document records what has and has not been validated against real Redis /
+RabbitMQ servers, so the maturity claim is auditable rather than a vibe.
+
+## Already live-verified ✅ — Redis 7.4.9, 2026-07-19
+
+Exercised end-to-end against a real **Redis 7.4.9** server (Docker) seeded with
+202 keys and a list-backed job queue:
+
+- `doctor` against a live server: PING OK, no-AUTH lab path reported clearly.
+- Every Redis read cross-checked against `redis-cli` ground truth:
+  `overview`, `redis info/memory/clients/slowlog/keyspace/bigkeys`
+  (key count matched `DBSIZE` exactly).
+- All four analyses ran clean: `analyze memory/latency/backlog/churn`.
+- Governance loop end-to-end: `redis_config_set` really changed
+  `maxmemory-policy`, captured `noeviction` as `priorState`, wrote an audit row,
+  and `undo_apply` restored the prior value on the live server.
+
+**A real defect was found and fixed by this run**: integer quantities were
+rendered as floats — `202.0` keys, `1.0` connected clients, float byte counts —
+because they were routed through `num()`. Values were arithmetically right but
+semantically wrong, and equality assertions could not catch it
+(`202 == 202.0`). Fixed with `as_int()` plus a regression test that asserts the
+*type*, keeping genuine ratios (`hitRatePct`, `usedPctOfMax`, `opsPerSec`) as
+floats. ⚠️ That round's claim of a fix "across the Redis and RabbitMQ reads"
+was **overstated**: the 2026-08-10 RabbitMQ run found `memUsedBytes` /
+`memLimitBytes` and the per-peer `channels` count still floats, and an earlier
+2026-08-03 round found the whole *write* path untouched. The sweep was never as
+wide as the sentence claimed — treat "fixed line-wide" claims as needing their
+own enumeration.
+
+## Not yet live-verified ⚠️
+
+- ~~**RabbitMQ** — the entire `rabbitmq` command group and its management-API
+  shapes are unit-tested only. This is now the largest gap in this repo.~~
+  **Closed 2026-08-10 against a real RabbitMQ 3.13.7** (management plugin), with
+  a seeded estate: 3 queues, a real backlog, a live pika consumer holding a
+  connection/channel, and a policy.
+  - All 7 reads cross-checked against `rabbitmqctl` / `rabbitmqadmin`:
+    `overview` (33 ready messages, cluster name, node count), `queues`
+    (per-queue counts and durability exact), `queue` detail, `connections`,
+    `channels` (unacked and consumer counts), `policies`, `nodes`.
+  - All 5 writes exercised end-to-end with their undo: `declare-queue` →
+    `undo_apply` deleted it; `set-policy` → `undo_apply` removed it leaving the
+    pre-existing policy untouched; `delete-queue` → `undo_apply` re-declared it
+    with the captured `durable=false`; `purge` destroyed a real 9-message
+    backlog and correctly recorded **no** undo.
+  - 🔴 **`purge_queue` had never worked against a real broker.** The HTTP client
+    sent `Accept: application/json`, and RabbitMQ's purge endpoint
+    (`DELETE /api/queues/{vhost}/{name}/contents`) answers *204 No Content* with
+    no JSON representation, so content negotiation failed and the broker
+    returned **406 with an empty body** — every purge, on every server. The
+    other endpoints were enumerated against the live broker and behave
+    identically under either Accept value, so the fix is `application/json, */*`.
+    The 406 message was also useless (no body to quote, and the label already
+    ended in "API" so it read "…management API API error"); both fixed.
+  - 🔴 Two integer quantities rendered as floats (bug class #2): a node's
+    `memUsedBytes` / `memLimitBytes` (`161222656.0` sitting next to an integer
+    `diskFreeBytes` — one payload disagreeing with itself), and the per-peer
+    `channels` count (`1.0` for one channel, from a `0.0` accumulator seed).
+  - Still untested: clustered RabbitMQ, quorum/stream queues, and TLS (AMQPS /
+    HTTPS management).
+- ~~Redis **cluster / sentinel** topologies (only standalone was exercised).~~
+  **Both exercised 2026-08-03**, and the cluster one found a defect: a node's
+  `totalKeys` was reported as the dataset total (100 on a 3-master cluster
+  holding 300). Reads, `overview` and the RCAs otherwise behaved correctly on a
+  cluster node, on a Sentinel-fronted primary, and on its replica (`role:
+  slave`). Still untested: an actual **failover** through Sentinel, and any
+  cluster-wide aggregate — this tool talks to one endpoint by design, which is
+  exactly why the scope marker matters.
+- ~~AUTH-enabled Redis and TLS connections.~~ **Both verified 2026-08-03**
+  against a real Redis 7.4 (Docker). AUTH: without the password every read
+  fails with a clear `Authentication required` envelope (nulls + `errors`, not
+  a silent empty); with the password via the encrypted-store/env fallback,
+  `overview`/`keyspace` matched `DBSIZE` exactly. TLS: `use_tls` with
+  `verify_ssl: false` connects over a `rediss://` socket to a self-signed
+  instance and returns the right key count; `verify_ssl: true` against the same
+  self-signed cert fails with `CERTIFICATE_VERIFY_FAILED` — TLS verification is
+  really enforced, not silently downgraded.
+- ~~`kill-client` against a real blocked client.~~ **Verified 2026-08-03**: a
+  client genuinely blocked on `BLPOP` was listed by `redis clients` (with the
+  tool's own connection correctly excluded), the `--dry-run` preview recorded a
+  `wouldKill` audit row *without* killing, the real kill removed it server-side
+  (confirmed via `CLIENT LIST`), and its CLIENT LIST row was captured as
+  `priorState`. Both the preview and the real call wrote audit rows through the
+  same governed twin.
+
+  **A real defect was found and fixed by this run** (bug class #2/#4): the write
+  path rendered integer quantities as floats — `ageSeconds: 49.0` in
+  `kill_client`'s `priorState`, and likewise `messages`/`priority` in the
+  RabbitMQ purge/policy captures — because `ops/writes.py` still routed them
+  through `num()`. It was missed in the earlier read-path sweep (it did not even
+  import `as_int`), and was inconsistent with `list_clients`, which already
+  rendered the identical CLIENT LIST `age` field as an `int`. Fixed with
+  `as_int()` and a type-asserting regression test (equality cannot catch it:
+  `49 == 49.0`); `ageSeconds` re-confirmed as `4` (int) on a live re-kill.

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/mcp_server/tools/undo.py

@@ -87,6 +87,32 @@ def undo_list(limit: int = 50, target: Optional[str] = None) -> dict:
     }
 
 
+def _origin_target(rec: dict) -> Optional[str]:
+    """The target the ORIGINAL write ran against, read from its recorded params.
+
+    Without this the replay goes to whatever target the caller names — in
+    practice the config's first entry — so on a multi-target config the inverse
+    runs against the wrong host. It only *looks* harmless because the resource
+    usually does not exist there; when two hosts both hold a resource with the
+    same name the inverse succeeds on the wrong one, silently.
+
+    Caught live on 2026-08-03 in container-host-aiops: a ``stop_container``
+    recorded against a Podman target replayed against a Portainer target.
+
+    A ``target`` in ``orig_params`` also means the original call accepted one,
+    so the fallback cannot hand a keyword to a tool that has no such parameter.
+    """
+    raw = rec.get("orig_params") or ""
+    try:
+        orig = json.loads(raw) if raw else {}
+    except (ValueError, TypeError):
+        return None  # unreadable: fall back to the caller/default, as before
+    if not isinstance(orig, dict):
+        return None
+    value = orig.get("target")
+    return value if isinstance(value, str) and value else None
+
+
 @mcp.tool()
 @governed_tool(risk_level="medium")
 @tool_errors("dict")
@@ -150,8 +176,10 @@ def undo_apply(undo_id: str, dry_run: bool = False, target: Optional[str] = None
         }
 
     call_params = dict(params)
-    if target is not None and "target" not in call_params:
-        call_params["target"] = target
+    if "target" not in call_params:
+        chosen = target if target is not None else _origin_target(rec)
+        if chosen is not None:
+            call_params["target"] = chosen
     result = fn(**call_params)
 
     # Only mark applied when the inverse did not itself return an error dict.

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "queue-aiops"
-version = "0.5.0"
+version = "0.7.0"
 description = "Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)"
 readme = "README.md"
 license = "MIT"

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/queue_aiops/connection.py

@@ -63,12 +63,25 @@ def _teaching_message(status: int, path: str, body: str, label: str) -> str:
             f"Bad request (400) on {label} {path}. The broker rejected the "
             f"request — check required fields and value formats. {snippet}"
         )
+    if status == 406:
+        # Content negotiation, and the broker sends NO body with it — so the
+        # generic branch produced a message that explained nothing at all
+        # (measured while purge_queue was failing on RabbitMQ 3.13.7).
+        return (
+            f"Content negotiation failed (406) on {label} {path}. The endpoint "
+            f"has no representation matching the request's Accept header — "
+            f"endpoints that answer '204 No Content' need '*/*' in Accept, not "
+            f"'application/json' alone. The broker sends no body with a 406, so "
+            f"there is nothing further to quote. {snippet}"
+        ).strip()
     if status in (500, 502, 503, 504):
         return (
             f"{label} server error ({status}) on {path}. The broker may be "
             f"busy; retry shortly. {snippet}"
         )
-    return f"{label} API error ({status}) on {path}. {snippet}"
+    # `label` already ends in "API" for rabbitmq ("RabbitMQ management API"),
+    # so the old "{label} API error" read "…management API API error".
+    return f"{label} error ({status}) on {path}. {snippet}".strip()
 
 
 class QueueConnection:
@@ -102,7 +115,19 @@ class QueueConnection:
             verify=target.verify_ssl,
             timeout=_TIMEOUT,
             auth=httpx.BasicAuth(target.username, target.secret),
-            headers={"Accept": "application/json", "Content-Type": "application/json"},
+            # `*/*` must stay in Accept. RabbitMQ's purge endpoint
+            # (DELETE /api/queues/{vhost}/{name}/contents) answers 204 with no
+            # body and offers no JSON representation, so a bare
+            # "Accept: application/json" fails content negotiation and the
+            # server returns **406 with an empty body** — measured on 3.13.7.
+            # purge_queue could therefore never succeed against a real broker.
+            # Every other endpoint (GETs, PUT declare, DELETE queue, DELETE
+            # policy) behaves identically under either value; enumerated, not
+            # assumed.
+            headers={
+                "Accept": "application/json, */*",
+                "Content-Type": "application/json",
+            },
         )
 
     @property

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/queue_aiops/ops/overview.py

@@ -54,6 +54,10 @@ def _redis_overview(conn: Any) -> dict:
         "maxmemoryPolicy": mem.get("maxmemoryPolicy"),
         "fragmentationRatio": mem.get("fragmentationRatio"),
         "totalKeys": keys.get("totalKeys"),
+        # On a cluster node totalKeys covers this node's slots only — the scope
+        # marker has to travel with the number, not be left in a sibling call.
+        "keyScope": keys.get("scope"),
+        "clusterMode": keys.get("clusterMode"),
         "errors": errors,
     }
 

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/queue_aiops/ops/rabbit_reads.py

@@ -132,7 +132,9 @@ def list_connections(conn: Any) -> dict:
         by_host: dict[str, dict] = {}
         for r in rows:
             bucket = by_host.setdefault(
-                r["peerHost"], {"peerHost": r["peerHost"], "connections": 0, "channels": 0.0}
+                # A channel count seeded as 0.0 makes the whole sum a float —
+                # "1.0 channels" for one channel. Both members are counts.
+                r["peerHost"], {"peerHost": r["peerHost"], "connections": 0, "channels": 0}
             )
             bucket["connections"] += 1
             bucket["channels"] += r["channels"]
@@ -211,8 +213,12 @@ def node_health(conn: Any) -> dict:
     try:
         rows = []
         for n in conn.platform.rows(conn.get(conn.platform.path("nodes"))):
-            mem_used = num(n.get("mem_used"))
-            mem_limit = num(n.get("mem_limit"))
+            # Byte counts, not ratios — every sibling byte field below already
+            # used as_int, so routing these two through the float helper made a
+            # single payload disagree with itself (memUsedBytes 161222656.0
+            # next to diskFreeBytes 36616110080).
+            mem_used = as_int(n.get("mem_used"))
+            mem_limit = as_int(n.get("mem_limit"))
             rows.append(
                 {
                     "name": opt(n.get("name"), 64),

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/queue_aiops/ops/redis_reads.py

@@ -190,8 +190,38 @@ def config_get(conn: Any, pattern: str = "*") -> dict:
         return {"error": s(exc, 200)}
 
 
+def _scope(conn: Any) -> dict:
+    """Whether the counts that follow describe the whole dataset or one shard.
+
+    A Redis Cluster node answers ``INFO keyspace`` for **its own slots only**, so
+    on a three-master cluster holding 300 keys this reports 100 — a number that
+    is wrong by the shard count and, called ``totalKeys`` with nothing else in
+    the payload, reads as the whole dataset. Measured on a real 3-master Redis
+    7.4 cluster. The marker travels with the counts so a consumer can tell a
+    complete answer from a partial one.
+    """
+    try:
+        mode = str(as_obj(conn.redis_info("server")).get("redis_mode") or "")
+    except Exception:  # noqa: BLE001 — scope is an annotation, never the answer
+        return {"scope": "server", "clusterMode": None}
+    if mode != "cluster":
+        return {"scope": "server", "clusterMode": False}
+    return {
+        "scope": "node",
+        "clusterMode": True,
+        "note": (
+            "Redis Cluster: these counts cover THIS node's slots only, not the "
+            "whole cluster. Query each master, or use a cluster-aware client, "
+            "for a dataset-wide figure."
+        ),
+    }
+
+
 def keyspace(conn: Any) -> dict:
-    """[READ] Per-db key counts + expiry coverage from INFO keyspace."""
+    """[READ] Per-db key counts + expiry coverage from INFO keyspace.
+
+    On a cluster node the counts are per-shard; the returned ``scope`` says so.
+    """
     try:
         info = as_obj(conn.redis_info("keyspace"))
         dbs = []
@@ -208,7 +238,11 @@ def keyspace(conn: Any) -> dict:
                     "avgTtlMs": as_int(cell.get("avg_ttl")),
                 }
             )
-        return {"databases": dbs, "totalKeys": sum(d["keys"] for d in dbs)}
+        return {
+            "databases": dbs,
+            "totalKeys": sum(d["keys"] for d in dbs),
+            **_scope(conn),
+        }
     except Exception as exc:  # noqa: BLE001 — report as partial
         return {"error": s(exc, 200)}
 

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/queue_aiops/ops/writes.py

@@ -42,7 +42,7 @@ import re
 from typing import Any
 
 from queue_aiops.connection import QueueApiError
-from queue_aiops.ops._util import as_obj, num, opt, s
+from queue_aiops.ops._util import as_int, as_obj, opt, s
 
 # CONFIG SET parameter names are plain words (e.g. maxmemory-policy); reject
 # anything else before it reaches the wire.
@@ -220,7 +220,7 @@ def kill_client(conn: Any, client_id: int = 0, addr: str = "") -> dict:
                 "addr": opt(c.get("addr"), 64),
                 "name": opt(c.get("name"), 64),
                 "lastCommand": opt(c.get("cmd"), 64),
-                "ageSeconds": num(c.get("age")),
+                "ageSeconds": as_int(c.get("age")),
             }
             break
     killed = (
@@ -246,7 +246,7 @@ def _queue_def(conn: Any, vhost: str, name: str) -> dict:
         conn.platform.normalise(conn.get(conn.platform.path("queue", vhost=vhost, name=name)))
     )
     return {
-        "messages": num(obj.get("messages")),
+        "messages": as_int(obj.get("messages")),
         "durable": bool(obj.get("durable")),
         "autoDelete": bool(obj.get("auto_delete")),
         "arguments": as_obj(obj.get("arguments")),
@@ -350,7 +350,7 @@ def _policy_or_none(conn: Any, vhost: str, name: str) -> dict | None:
     return {
         "pattern": opt(obj.get("pattern"), 128),
         "definition": as_obj(obj.get("definition")),
-        "priority": num(obj.get("priority")),
+        "priority": as_int(obj.get("priority")),
         "applyTo": opt(obj.get("apply-to") or obj.get("apply_to") or "all", 32),
     }
 

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/AIops-tools/Queue-AIops",
     "source": "github"
   },
-  "version": "0.5.0",
+  "version": "0.7.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "queue-aiops",
-      "version": "0.5.0",
+      "version": "0.7.0",
       "transport": {
         "type": "stdio"
       }

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/tests/test_connection.py

@@ -239,3 +239,56 @@ def test_manager_unknown_target_teaches_available(fake_build):
     mgr = ConnectionManager(_cfg())
     with pytest.raises(KeyError, match="Available: cache1, broker1"):
         mgr.connect("ghost")
+
+
+@pytest.mark.unit
+def test_rabbitmq_accept_header_keeps_a_wildcard_for_no_content_endpoints(monkeypatch):
+    """Accept must not be JSON-only, or the purge endpoint 406s.
+
+    Measured on a real RabbitMQ 3.13.7: ``DELETE /api/queues/{vhost}/{name}
+    /contents`` answers 204 with no body and offers no JSON representation, so
+    a bare ``Accept: application/json`` fails content negotiation and the broker
+    returns **406 with an empty body** — meaning ``purge_queue`` could never
+    succeed against a real server. Adding ``*/*`` returns 204, and every other
+    endpoint (GETs, PUT declare, DELETE queue, DELETE policy) answers the same
+    either way; that was enumerated against the live broker, not assumed.
+
+    Nothing else pins this header, which is why the defect survived: the fake
+    HTTP client in the unit suite never negotiates content.
+    """
+    monkeypatch.setenv("QUEUE_BROKER1_SECRET", "pw")
+    client = QueueConnection._build_client(rabbit_target())
+    try:
+        accept = client.headers["accept"]
+    finally:
+        client.close()
+    assert "application/json" in accept
+    assert "*/*" in accept, (
+        "purge (DELETE .../contents) 406s when Accept is JSON-only — keep */*"
+    )
+
+
+@pytest.mark.unit
+def test_rabbitmq_406_explains_content_negotiation():
+    """A 406 carries no body, so the generic branch explained nothing.
+
+    Encountered live while purge_queue was failing: the operator got
+    "RabbitMQ management API API error (406) on /api/queues/%2F/q/contents. "
+    — a doubled word and zero diagnosis. The 406 branch now names the cause,
+    and the generic branch no longer repeats "API" after a label ending in it.
+    """
+    conn = rabbit_conn({("GET", "/api/x"): FakeResponse(406, text="")})
+    with pytest.raises(QueueApiError) as err:
+        conn.get("/api/x")
+    msg = str(err.value)
+    assert "Content negotiation failed (406)" in msg
+    assert "Accept" in msg
+    assert "API API error" not in msg
+
+
+@pytest.mark.unit
+def test_rabbitmq_unmapped_status_does_not_double_the_word_api():
+    conn = rabbit_conn({("GET", "/api/x"): FakeResponse(418, text="teapot")})
+    with pytest.raises(QueueApiError) as err:
+        conn.get("/api/x")
+    assert "API API error" not in str(err.value)

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/tests/test_reads.py

@@ -239,6 +239,9 @@ def test_list_connections_groups_by_peer_host():
     assert out["total"] == 3
     assert out["byPeerHost"][0]["peerHost"] == "10.0.0.7"
     assert out["byPeerHost"][0]["channels"] == 4
+    # A channel count, not a rate: seeding the accumulator at 0.0 rendered one
+    # channel as "1.0" on a live broker. Equality cannot catch it (4 == 4.0).
+    assert isinstance(out["byPeerHost"][0]["channels"], int)
 
 
 @pytest.mark.unit
@@ -274,6 +277,12 @@ def test_node_health_flags_alarms():
     out = rabbit_reads.node_health(conn)
     assert out["alarms"] == 1
     assert out["nodes"][0]["memAlarm"] is True
+    # Byte counts stay integers. On a live broker these two came back as
+    # 161222656.0 / 13462616473.0 while diskFreeBytes beside them was an int —
+    # one payload disagreeing with itself (bug class #2).
+    node = out["nodes"][0]
+    for field in ("memUsedBytes", "memLimitBytes", "diskFreeBytes"):
+        assert isinstance(node[field], int), field
 
 
 @pytest.mark.unit
@@ -308,3 +317,36 @@ def test_queue_overview_rabbitmq_shape_degrades_partially():
     assert out["platform"] == "rabbitmq"
     assert out["queues"] == 12
     assert any("nodes:" in e for e in out["errors"])
+
+
+@pytest.mark.unit
+def test_keyspace_marks_a_cluster_node_count_as_partial():
+    """A cluster node's key count is per-shard and must say so.
+
+    ``INFO keyspace`` on a Redis Cluster node answers for its own slots only, so
+    a 3-master cluster holding 300 keys reports 100 here. Emitting that as
+    ``totalKeys`` with nothing else in the payload states a dataset-wide figure
+    that is wrong by the shard count. Measured on a real 3-master Redis 7.4
+    cluster: 100 / 92 / 108.
+    """
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=100,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "cluster"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["totalKeys"] == 100
+    assert out["scope"] == "node"
+    assert out["clusterMode"] is True
+    assert "THIS node" in out["note"]
+
+
+@pytest.mark.unit
+def test_keyspace_on_a_standalone_server_is_scoped_whole():
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=7,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "standalone"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["scope"] == "server"
+    assert out["clusterMode"] is False
+    assert "note" not in out

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/tests/test_undo_executor.py

@@ -21,18 +21,21 @@ from mcp_server.tools import undo as gov
 from queue_aiops.governance import governed_tool
 
 _CALLS: list[dict] = []
+_TARGETS: list = []
 
 
 @governed_tool(risk_level="low")
 def _undo_probe(value: str = "", target=None) -> dict:
     """Synthetic inverse target used only by the undo-executor tests."""
     _CALLS.append({"value": value})
+    _TARGETS.append(target)
     return {"ok": True, "value": value}
 
 
 @pytest.fixture
 def gov_home(tmp_path, monkeypatch):
     _CALLS.clear()
+    _TARGETS.clear()
     # Register the probe only for the duration of these tests so it never
     # pollutes the real tool registry (which exact-count smoke tests assert on).
     mcp.add_tool(_undo_probe, name="_undo_probe")
@@ -77,6 +80,52 @@ def test_undo_apply_dispatches_inverse_and_marks_applied(gov_home):
     assert uid not in {u["undoId"] for u in gov.undo_list()["undos"]}
 
 
+@pytest.mark.unit
+def test_undo_apply_replays_against_the_target_the_write_ran_on(gov_home):
+    """A replay must go to the host the original write went to.
+
+    Without this the inverse ran against whatever target the caller named — in
+    practice the config's first entry — so on a multi-target config it hit the
+    wrong host. It only looked harmless because the resource usually does not
+    exist there; two hosts holding the same name and the inverse succeeds on the
+    wrong one, silently. Caught live on 2026-08-03 in container-host-aiops: a
+    stop recorded against a Podman target replayed against a Portainer target.
+    """
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    result = gov.undo_apply(undo_id=uid)
+    assert result["applied"] is True
+    assert _TARGETS == ["second-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_prefers_an_explicit_caller_target(gov_home):
+    """An explicitly named target still wins — the fallback is only a default."""
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    gov.undo_apply(undo_id=uid, target="chosen-host")
+    assert _TARGETS == ["chosen-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_survives_unreadable_orig_params(gov_home):
+    """Corrupt orig_params must not break the replay — just lose the fallback."""
+    uid = _record(params={"value": "v1"})
+    with sqlite3.connect(gov_home / "undo.db") as db:
+        db.execute("UPDATE undo_log SET orig_params = ? WHERE undo_id = ?",
+                   ("{not json", uid))
+    assert gov.undo_apply(undo_id=uid)["applied"] is True
+    assert _TARGETS == [None]
+
+
 @pytest.mark.unit
 def test_undo_apply_dry_run_previews_without_running(gov_home):
     uid = _record()

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/tests/test_writes.py

@@ -71,6 +71,42 @@ def test_kill_client_requires_id_or_addr():
         ops.kill_client(conn)
 
 
+@pytest.mark.unit
+def test_write_prior_state_integer_quantities_stay_int():
+    """priorState counts/whole-seconds must be int, not float (bug class #2/#4).
+
+    CLIENT LIST ``age`` (whole seconds), a queue's ``messages`` count and a
+    policy ``priority`` are integer quantities. The write path rendered them
+    through ``num`` → ``120.0``/``1234.0``/``3.0`` — inconsistent with the read
+    path (``list_clients`` already uses ``as_int``) and semantically wrong. An
+    equality assertion cannot catch this (``120 == 120.0``); assert the *type*.
+    ``bool`` must not sneak through the int check (it subclasses int).
+    """
+    kc = ops.kill_client(
+        redis_conn(clients=[{"id": "77", "addr": "10.0.0.5:5000", "cmd": "blpop",
+                             "age": "120"}]),
+        client_id=77,
+    )
+    age = kc["priorState"]["client"]["ageSeconds"]
+    assert isinstance(age, int) and not isinstance(age, bool) and age == 120
+
+    purge = ops.purge_queue(
+        rabbit_conn({("GET", "/api/queues/%2F/orders"): _Q,
+                     ("DELETE", "/api/queues/%2F/orders/contents"): {}}),
+        "/", "orders",
+    )
+    msgs = purge["priorState"]["messages"]
+    assert isinstance(msgs, int) and not isinstance(msgs, bool) and msgs == 1234
+
+    policy = ops.set_policy(
+        rabbit_conn({("GET", "/api/policies/%2F/lim"): _POLICY,
+                     ("PUT", "/api/policies/%2F/lim"): {}}),
+        "/", "lim", "^work\\.", {"max-length": 9000}, priority=4,
+    )
+    prio = policy["priorState"]["policy"]["priority"]
+    assert isinstance(prio, int) and not isinstance(prio, bool) and prio == 3
+
+
 # ── rabbitmq purge/delete prior-state capture ────────────────────────────────
 
 _Q = {"name": "orders", "vhost": "/", "messages": 1234, "durable": True,

{queue_aiops-0.5.0 → queue_aiops-0.7.0}/uv.lock

@@ -812,7 +812,7 @@ wheels = [
 
 [[package]]
 name = "queue-aiops"
-version = "0.5.0"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },

queue_aiops-0.5.0/docs/VERIFICATION.md

@@ -1,34 +0,0 @@
-# Live verification status
-
-This document records what has and has not been validated against real Redis /
-RabbitMQ servers, so the maturity claim is auditable rather than a vibe.
-
-## Already live-verified ✅ — Redis 7.4.9, 2026-07-19
-
-Exercised end-to-end against a real **Redis 7.4.9** server (Docker) seeded with
-202 keys and a list-backed job queue:
-
-- `doctor` against a live server: PING OK, no-AUTH lab path reported clearly.
-- Every Redis read cross-checked against `redis-cli` ground truth:
-  `overview`, `redis info/memory/clients/slowlog/keyspace/bigkeys`
-  (key count matched `DBSIZE` exactly).
-- All four analyses ran clean: `analyze memory/latency/backlog/churn`.
-- Governance loop end-to-end: `redis_config_set` really changed
-  `maxmemory-policy`, captured `noeviction` as `priorState`, wrote an audit row,
-  and `undo_apply` restored the prior value on the live server.
-
-**A real defect was found and fixed by this run**: integer quantities were
-rendered as floats — `202.0` keys, `1.0` connected clients, float byte counts —
-because they were routed through `num()`. Values were arithmetically right but
-semantically wrong, and equality assertions could not catch it
-(`202 == 202.0`). Fixed with `as_int()` across the Redis and RabbitMQ reads,
-plus a regression test that asserts the *type*, keeping genuine ratios
-(`hitRatePct`, `usedPctOfMax`, `opsPerSec`) as floats.
-
-## Not yet live-verified ⚠️
-
-- **RabbitMQ** — the entire `rabbitmq` command group and its management-API
-  shapes are unit-tested only. This is now the largest gap in this repo.
-- Redis **cluster / sentinel** topologies (only standalone was exercised).
-- AUTH-enabled Redis and TLS connections.
-- `kill-client` against a real blocked client.