queue-aiops 0.9.2__tar.gz → 0.9.4__tar.gz

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "queue-aiops",
   "displayName": "Queue AIops",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Governed redis + rabbitmq ops: memory/latency/backlog/churn RCA, policies. 28 tools.",
   "author": {
     "name": "Wei Zhou",

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/.mcp.json

@@ -5,7 +5,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "queue-aiops==0.9.2",
+        "queue-aiops==0.9.4",
         "queue-aiops-mcp"
       ]
     }

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## v0.9.4 — 2026-09-16
+
+### Fixed
+- `redis_memory_pressure_rca`'s top-level `pressure` flag no longer decides by
+  comparing another finding's `cause` against the literal sentence "Healthy —
+  within thresholds". The flag is behaviourally unchanged, but rewording that
+  sentence — or normalising its em dash in a style sweep — would have reported
+  pressure on a healthy broker. It now reads the measured condition captured
+  before the healthy placeholder is appended, and an AST-based structural test
+  pins the whole package against a decision being taken on a finding's prose —
+  either operand order, the literal hoisted into a constant, `.get()`, `in`,
+  `startswith`, slicing and `.lower()` are all rejected.
+- `agent-guardrails.md` and `SKILL.md` claimed the four RCAs "rank findings
+  worst-first" and that "priority is in the payload, not implied by list
+  position". Neither was ever true here: there is no `rank` key, and findings are
+  appended in the order the checks run. The claim sat in the table headed "what
+  the tool enforces — do not waste prompt budget on these", so it actively told
+  operators to drop the prompt that would have compensated. A broker at 12 % of
+  `maxmemory` with 35 GiB of oversized keys reports the fragmentation finding
+  first, purely because fragmentation is checked earlier. The docs now say order
+  is not severity, and point at the `evidence` number each finding does carry.
+
+## v0.9.3 — 2026-09-15
+
+### Fixed
+- CLI commands that read the engine without calling an MCP tool now write an
+  audit row, as every MCP call does: they run through the same `@governed_tool`
+  harness, budget and runaway guard included. Before, an operator's CLI reads
+  left no trace in `audit.db`, contrary to the documented guarantee that MCP
+  and CLI are audited alike. A test fails if any engine command escapes it.
+
 ## v0.9.2 — 2026-09-12
 
 ### Changed

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: queue-aiops
-Version: 0.9.2
+Version: 0.9.4
 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.9.2 → queue_aiops-0.9.4}/openclaw.plugin.json

@@ -11,7 +11,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "queue-aiops==0.9.2",
+        "queue-aiops==0.9.4",
         "queue-aiops-mcp"
       ]
     }

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zw008/queue-aiops",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Governed redis + rabbitmq ops: memory/latency/backlog/churn RCA, policies. 28 tools.",
   "private": true,
   "license": "MIT",

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "queue-aiops"
-version = "0.9.2"
+version = "0.9.4"
 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.9.2 → queue_aiops-0.9.4}/queue_aiops/cli/_common.py

@@ -153,3 +153,43 @@ def double_confirm(action: str, resource: str) -> None:
         f"Confirm 2/2: really {action} '{resource}'? This may be irreversible.",
         abort=True,
     )
+
+
+def audited(fn: Callable) -> Callable:
+    """Audit a CLI command that reaches the engine without calling an MCP tool.
+
+    MCP tools write their audit row through ``@governed_tool``; a CLI command that
+    called the ops layer directly used to write none, so an operator's CLI reads
+    left no trail. This runs the command through the same harness: one audit row per
+    invocation (tool = the command function, params = its options), plus the budget
+    and runaway guard. ``typer.Exit`` is how a command ends: exit code 0 is audited
+    ``ok``, a non-zero code ``error``, and the exit is re-raised unchanged. Any other
+    exception is audited ``error`` and propagates to ``cli_errors`` as before.
+    """
+    import functools as _functools
+
+    from queue_aiops.governance import governed_tool
+
+    @_functools.wraps(fn)
+    def body(*args: Any, **kwargs: Any) -> Any:
+        try:
+            fn(*args, **kwargs)
+        except typer.Exit as exc:
+            code = exc.exit_code
+            outcome: dict[str, Any] = {"_exitCode": code}
+            if code:
+                outcome["error"] = f"command exited with code {code}"
+            return outcome
+        return None
+
+    governed = governed_tool(risk_level="low")(body)
+
+    @_functools.wraps(fn)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        result = governed(*args, **kwargs)
+        if isinstance(result, dict) and "_exitCode" in result:
+            raise typer.Exit(result["_exitCode"])
+        return None
+
+    wrapper._is_audited_cli = True  # type: ignore[attr-defined]
+    return wrapper

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/queue_aiops/cli/analyze.py

@@ -7,7 +7,7 @@ from typing import Annotated
 
 import typer
 
-from queue_aiops.cli._common import TargetOption, cli_errors, console, get_connection
+from queue_aiops.cli._common import TargetOption, audited, cli_errors, console, get_connection
 
 analyze_app = typer.Typer(
     name="analyze",
@@ -19,6 +19,7 @@ analyze_app = typer.Typer(
 
 @analyze_app.command("memory")
 @cli_errors
+@audited
 def analyze_memory(
     used_pct: Annotated[
         float, typer.Option("--used-pct", help="used/maxmemory %% pressure threshold")
@@ -41,6 +42,7 @@ def analyze_memory(
 
 @analyze_app.command("latency")
 @cli_errors
+@audited
 def analyze_latency(
     slow_us: Annotated[
         float, typer.Option("--slow-us", help="Slowlog threshold in microseconds")
@@ -57,6 +59,7 @@ def analyze_latency(
 
 @analyze_app.command("backlog")
 @cli_errors
+@audited
 def analyze_backlog(
     vhost: Annotated[
         str | None, typer.Option("--vhost", help="Restrict to one vhost")
@@ -76,6 +79,7 @@ def analyze_backlog(
 
 @analyze_app.command("churn")
 @cli_errors
+@audited
 def analyze_churn(target: TargetOption = None) -> None:
     """Connection-churn analysis (both platforms): counts, rates, by source."""
     from queue_aiops.ops import analysis as ops

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/queue_aiops/cli/overview.py

@@ -4,10 +4,11 @@ from __future__ import annotations
 
 import json
 
-from queue_aiops.cli._common import TargetOption, cli_errors, console, get_connection
+from queue_aiops.cli._common import TargetOption, audited, cli_errors, console, get_connection
 
 
 @cli_errors
+@audited
 def overview_cmd(target: TargetOption = None) -> None:
     """One-shot summary: platform + version + backlog/memory/client health."""
     from queue_aiops.ops import overview as ops

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/queue_aiops/cli/rabbit_cmds.py

@@ -10,6 +10,7 @@ import typer
 from queue_aiops.cli._common import (
     DryRunOption,
     TargetOption,
+    audited,
     checked,
     cli_errors,
     console,
@@ -32,6 +33,7 @@ VhostOption = Annotated[
 
 @rabbitmq_app.command("overview")
 @cli_errors
+@audited
 def rabbit_overview(target: TargetOption = None) -> None:
     """Broker identity + totals (queues, messages, connections, rates)."""
     from queue_aiops.ops import rabbit_reads as ops
@@ -42,6 +44,7 @@ def rabbit_overview(target: TargetOption = None) -> None:
 
 @rabbitmq_app.command("queues")
 @cli_errors
+@audited
 def rabbit_queues(
     vhost: Annotated[
         str | None, typer.Option("--vhost", help="Restrict to one vhost")
@@ -63,6 +66,7 @@ def rabbit_queues(
 
 @rabbitmq_app.command("queue")
 @cli_errors
+@audited
 def rabbit_queue(
     name: Annotated[str, typer.Argument(help="Queue name (from 'queues')")],
     vhost: VhostOption = "/",
@@ -77,6 +81,7 @@ def rabbit_queue(
 
 @rabbitmq_app.command("connections")
 @cli_errors
+@audited
 def rabbit_connections(target: TargetOption = None) -> None:
     """Client connections grouped by peer host."""
     from queue_aiops.ops import rabbit_reads as ops
@@ -93,6 +98,7 @@ def rabbit_connections(target: TargetOption = None) -> None:
 
 @rabbitmq_app.command("channels")
 @cli_errors
+@audited
 def rabbit_channels(target: TargetOption = None) -> None:
     """Channels with unacked/prefetch pressure."""
     from queue_aiops.ops import rabbit_reads as ops
@@ -109,6 +115,7 @@ def rabbit_channels(target: TargetOption = None) -> None:
 
 @rabbitmq_app.command("policies")
 @cli_errors
+@audited
 def rabbit_policies(
     vhost: Annotated[
         str | None, typer.Option("--vhost", help="Restrict to one vhost")
@@ -130,6 +137,7 @@ def rabbit_policies(
 
 @rabbitmq_app.command("nodes")
 @cli_errors
+@audited
 def rabbit_nodes(target: TargetOption = None) -> None:
     """Node memory/disk/fd posture + watermark alarms."""
     from queue_aiops.ops import rabbit_reads as ops

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/queue_aiops/cli/redis_cmds.py

@@ -10,6 +10,7 @@ import typer
 from queue_aiops.cli._common import (
     DryRunOption,
     TargetOption,
+    audited,
     checked,
     cli_errors,
     console,
@@ -28,6 +29,7 @@ redis_app = typer.Typer(
 
 @redis_app.command("info")
 @cli_errors
+@audited
 def redis_info(target: TargetOption = None) -> None:
     """Server identity + health basics (version, role, clients, ops/sec)."""
     from queue_aiops.ops import redis_reads as ops
@@ -38,6 +40,7 @@ def redis_info(target: TargetOption = None) -> None:
 
 @redis_app.command("memory")
 @cli_errors
+@audited
 def redis_memory(target: TargetOption = None) -> None:
     """Memory posture: used vs maxmemory, policy, fragmentation."""
     from queue_aiops.ops import redis_reads as ops
@@ -48,6 +51,7 @@ def redis_memory(target: TargetOption = None) -> None:
 
 @redis_app.command("clients")
 @cli_errors
+@audited
 def redis_clients(target: TargetOption = None) -> None:
     """Connected clients grouped by source address."""
     from queue_aiops.ops import redis_reads as ops
@@ -64,6 +68,7 @@ def redis_clients(target: TargetOption = None) -> None:
 
 @redis_app.command("slowlog")
 @cli_errors
+@audited
 def redis_slowlog(
     count: Annotated[int, typer.Option("--count", "-n", help="Max entries")] = 128,
     target: TargetOption = None,
@@ -83,6 +88,7 @@ def redis_slowlog(
 
 @redis_app.command("config-get")
 @cli_errors
+@audited
 def redis_config_get(
     pattern: Annotated[str, typer.Argument(help="Config-name glob, e.g. 'maxmemory*'")] = "*",
     target: TargetOption = None,
@@ -96,6 +102,7 @@ def redis_config_get(
 
 @redis_app.command("keyspace")
 @cli_errors
+@audited
 def redis_keyspace(target: TargetOption = None) -> None:
     """Per-db key counts and expiry coverage."""
     from queue_aiops.ops import redis_reads as ops
@@ -106,6 +113,7 @@ def redis_keyspace(target: TargetOption = None) -> None:
 
 @redis_app.command("bigkeys")
 @cli_errors
+@audited
 def redis_bigkeys(
     top: Annotated[int, typer.Option("--top", help="Rows to return, largest first")] = 20,
     target: TargetOption = None,

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/queue_aiops/ops/analysis.py

@@ -126,6 +126,10 @@ def redis_memory_pressure_rca(
             "evidence": {"bigKeys": big[:10]},
         })
 
+    # Captured before the healthy placeholder is appended. The flag reports the measured
+    # condition — did any check fire — and is never derived from another finding's prose:
+    # a reworded sentence would otherwise report pressure on a healthy broker.
+    pressure = bool(findings)
     if not findings:
         findings.append({
             "cause": "Healthy — within thresholds",
@@ -133,7 +137,7 @@ def redis_memory_pressure_rca(
             "evidence": {"usedPctOfMax": used_of_max, "fragmentationRatio": frag},
         })
     return {
-        "pressure": any(f["cause"] != "Healthy — within thresholds" for f in findings),
+        "pressure": pressure,
         "usedPctOfMax": used_of_max,
         "maxmemoryPolicy": policy,
         "fragmentationRatio": frag,

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/server.json

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

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/skills/queue-aiops/SKILL.md

@@ -121,8 +121,8 @@ skill.
    works before you read numbers off it.
 2. `queue-aiops redis memory` → used vs `maxmemory`, the eviction policy in force, and
    the fragmentation ratio, straight from `INFO memory`.
-3. `queue-aiops analyze memory --used-pct 85` → ranked findings, each citing its measured
-   number: **noeviction near the limit** (the dangerous one — writes will start failing
+3. `queue-aiops analyze memory --used-pct 85` → findings in check order, each citing its measured
+   number (order is not severity — weigh them all): **noeviction near the limit** (the dangerous one — writes will start failing
    with OOM rather than evicting), active eviction in progress, fragmentation versus real
    swapping, and oversized keys.
 4. `queue-aiops redis bigkeys --count 500` → a SCAN-budgeted sample of the largest keys,

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/skills/queue-aiops/references/agent-guardrails.md

@@ -31,7 +31,7 @@ What the tool *does* guarantee is that you can always see what happened:
 |---|---|
 | "Don't invent a value when a field is missing" | RabbitMQ omits `idle_since` for an active queue; a Redis primary reports no `master_link_status`; an unnamed client has no name. Those come back as `null`, never as `""`. |
 | "Tell me if the output was cut off" | `redis_slowlog`, `redis_clients`, `redis_big_keys`, `list_queues`, `list_connections`, `list_channels` and `list_policies` all return `{"<items>": [...], "returned": N, "limit": L, "truncated": true/false}`. Truncation is measured — one extra entry is requested from Redis — not guessed from a length coincidence. |
-| "Preserve the ordering / tell me what's most urgent" | `rabbitmq_queue_backlog_rca`, `redis_memory_pressure_rca`, `redis_latency_rca` and `connection_churn_analysis` rank findings worst-first, each carrying the measured number it was based on. Priority is in the payload, not implied by list position. |
+| "Make it show the number it judged on" | Every finding from `rabbitmq_queue_backlog_rca`, `redis_memory_pressure_rca`, `redis_latency_rca` and `connection_churn_analysis` carries the measured value it was based on under `evidence`, so a claim can always be checked against a number rather than taken on the model's word. |
 | "Don't run KEYS * on production" | `redis_big_keys` uses SCAN under a hard key budget and sizes only an evenly-spaced subset with MEMORY USAGE. There is no code path that can issue `KEYS *`. `coveragePct` reports how partial the walk was. |
 | "Confirm before anything destructive" | `delete_queue` and `purge_queue` require a `--dry-run`-able preview plus double confirmation at the CLI. |
 | "Log what you did" | Every governed call is audited to `~/.queue-aiops/audit.db` regardless of what the model says it did — and the CLI writes the same row the MCP path does, so there is no unaudited entry point. |
@@ -40,6 +40,14 @@ What the tool *does* guarantee is that you can always see what happened:
 ## What still needs a prompt
 
 These are model-behaviour problems the harness cannot fix from the outside.
+
+⚠️ **Finding order is not priority.** These RCAs append findings in the order the checks
+run, not worst-first, and there is no `rank` key in the payload. A broker at 12 % of
+`maxmemory` with 35 GiB of oversized keys reports the fragmentation finding first purely
+because fragmentation is checked before big keys. Do not let the model treat `findings[0]`
+as the headline — make it weigh every finding's `evidence` and say which one it acted on.
+(Earlier versions of this file claimed these lists were ranked worst-first. They never were.)
+
 Copy this into your agent's system prompt:
 
 ```text

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/tests/test_analysis.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import ast
+from pathlib import Path
+
 import pytest
 
 from queue_aiops.ops import analysis as ops
@@ -200,3 +203,68 @@ def test_churn_healthy_reports_metrics():
     })
     assert out["findings"][0]["action"] == "No action needed."
     assert out["metrics"]["channels"] == 8
+
+
+@pytest.mark.unit
+def test_no_decision_is_derived_from_a_findings_display_text():
+    """A rule's input is never another rule's display text.
+
+    `pressure` used to be `any(f["cause"] != "Healthy — within thresholds" ...)`, so
+    rewording that sentence — or normalising its em dash in a style sweep — would have
+    reported pressure on a healthy broker. The check is AST-based on purpose: a regex on
+    the source missed the shape that produced the original incident in another repo
+    (`"critical blocker" in f["signal"]`, literal on the left), and also fired on prose
+    inside comments and docstrings. Walking the tree catches either operand order, the
+    literal hoisted into a constant, `.get()`, `.lower()`, slicing and `startswith`, and
+    ignores comments entirely.
+    """
+    offenders = []
+    for path in _scanned_sources():
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Compare):
+                operands = [node.left, *node.comparators]
+                if any(_reads_display_text(o) for o in operands) and not _is_none_check(node):
+                    offenders.append(f"{path.name}:{node.lineno}: {ast.unparse(node)}")
+            elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) \
+                    and node.func.attr in _TEXT_PREDICATES and _reads_display_text(node.func.value):
+                offenders.append(f"{path.name}:{node.lineno}: {ast.unparse(node)}")
+    assert offenders == [], ("a decision is being derived from a finding's prose:\n"
+                             + "\n".join(offenders))
+
+
+_DISPLAY_KEYS = {"cause", "action", "signal", "note", "summary"}
+_TEXT_PREDICATES = {"startswith", "endswith", "count", "find", "index"}
+
+
+def _scanned_sources():
+    """Every module that could post-process a finding — not just the one that builds them.
+
+    `governance/` is excluded: it is vendored verbatim across the line and held byte-identical
+    by the drift gate, so it is not this repo's to edit.
+    """
+    root = Path(ops.__file__).parents[2]
+    found = sorted(root.glob("queue_aiops/**/*.py")) + sorted(root.glob("mcp_server/**/*.py"))
+    files = [p for p in found if "governance" not in p.parts]
+    assert len(files) > 10, f"source sweep found only {len(files)} modules — the glob is wrong"
+    return files
+
+
+def _reads_display_text(node):
+    """True if evaluating this expression reads a finding's display field, however wrapped."""
+    for sub in ast.walk(node):
+        if isinstance(sub, ast.Subscript) and isinstance(sub.slice, ast.Constant) \
+                and sub.slice.value in _DISPLAY_KEYS:
+            return True
+        if isinstance(sub, ast.Call) and isinstance(sub.func, ast.Attribute) \
+                and sub.func.attr == "get" and sub.args \
+                and isinstance(sub.args[0], ast.Constant) \
+                and sub.args[0].value in _DISPLAY_KEYS:
+            return True
+    return False
+
+
+def _is_none_check(node):
+    """`f["cause"] is None` is a presence test, not a decision taken on the prose."""
+    return all(isinstance(op, (ast.Is, ast.IsNot)) for op in node.ops) and all(
+        isinstance(c, ast.Constant) and c.value is None for c in node.comparators)

queue_aiops-0.9.4/tests/test_cli_audited.py

@@ -0,0 +1,131 @@
+"""Every CLI command that reaches the engine is audited.
+
+MCP tools write their audit row through ``@governed_tool``. CLI commands that called
+the ops layer directly wrote none: on 2026-09-15 a read command of every tool in the
+line, run in a scratch home, left no audit.db while the harness itself worked. Each
+such command is now wrapped in ``audited`` (``cli/_common.py``); commands that call an
+MCP tool are audited by that tool. This pins the helper's behaviour and that no
+engine command escapes it.
+"""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import sqlite3
+import textwrap
+
+import pytest
+import typer
+from typer.main import get_command
+
+from queue_aiops.cli import app
+from queue_aiops.cli._common import audited
+
+pytestmark = pytest.mark.unit
+
+#: Local-only commands: they never reach the engine (``undo`` goes through MCP tools).
+EXEMPT = {"init", "doctor", "secret", "mcp", "undo"}
+
+
+def _leaves() -> list[tuple[list[str], object]]:
+    found: list[tuple[list[str], object]] = []
+
+    def walk(cmd, path):
+        if hasattr(cmd, "list_commands"):
+            for name, sub in cmd.commands.items():
+                walk(sub, path + [name])
+        else:
+            found.append((path, cmd))
+
+    walk(get_command(app), [])
+    return found
+
+
+def _chain(fn):
+    seen = []
+    while fn is not None and fn not in seen:
+        seen.append(fn)
+        fn = getattr(fn, "__wrapped__", None)
+    return seen
+
+
+def _calls_an_mcp_tool(fn) -> bool:
+    source = inspect.getsource(fn)
+    if "mcp_server" in source:
+        return True
+    names = set()
+    for node in ast.parse(open(inspect.getsourcefile(fn)).read()).body:
+        if isinstance(node, ast.ImportFrom) and (node.module or "").startswith("mcp_server"):
+            names |= {a.asname or a.name for a in node.names}
+    used = {n.id for n in ast.walk(ast.parse(textwrap.dedent(source))) if isinstance(n, ast.Name)}
+    return bool(names & used)
+
+
+def test_every_engine_command_is_audited():
+    commands = [(path, cmd) for path, cmd in _leaves() if path and path[0] not in EXEMPT]
+    assert commands, "no commands found: the walker is broken, not the CLI clean"
+    missing = [
+        " ".join(path) for path, cmd in commands
+        if not any(getattr(f, "_is_audited_cli", False) for f in _chain(cmd.callback))
+        and not _calls_an_mcp_tool(inspect.unwrap(cmd.callback))
+    ]
+    assert not missing, f"CLI commands that leave no audit row: {missing}"
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    import queue_aiops.governance.audit as audit_mod
+    import queue_aiops.governance.budget as budget_mod
+
+    monkeypatch.setenv("QUEUE_AIOPS_HOME", str(tmp_path))
+    audit_mod.reset_engine()
+    budget_mod.reset_budget()
+    yield tmp_path
+    audit_mod.reset_engine()
+    budget_mod.reset_budget()
+
+
+def _rows(home) -> list[tuple[str, str]]:
+    con = sqlite3.connect(home / "audit.db")
+    try:
+        return con.execute("SELECT tool, status FROM audit_log ORDER BY id").fetchall()
+    finally:
+        con.close()
+
+
+def test_audited_records_success_exit_codes_and_exceptions(home):
+    @audited
+    def cmd_ok(target=None):
+        return None
+
+    @audited
+    def cmd_exit_zero(target=None):
+        raise typer.Exit()
+
+    @audited
+    def cmd_exit_one(target=None):
+        raise typer.Exit(1)
+
+    @audited
+    def cmd_raises(target=None):
+        raise RuntimeError("engine unreachable")
+
+    cmd_ok()
+    with pytest.raises(typer.Exit) as zero:
+        cmd_exit_zero()
+    assert zero.value.exit_code == 0
+    with pytest.raises(typer.Exit) as one:
+        cmd_exit_one()
+    assert one.value.exit_code == 1
+    with pytest.raises(RuntimeError, match="engine unreachable"):
+        cmd_raises()
+    assert _rows(home) == [("cmd_ok", "ok"), ("cmd_exit_zero", "ok"),
+                           ("cmd_exit_one", "error"), ("cmd_raises", "error")]
+
+
+def test_audited_keeps_the_command_signature_for_typer():
+    def cmd(limit: int = 5, target: str | None = None) -> None:
+        return None
+
+    assert list(inspect.signature(audited(cmd)).parameters) == ["limit", "target"]

{queue_aiops-0.9.2 → queue_aiops-0.9.4}/uv.lock

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