vmware-debug 1.12.2__tar.gz → 1.13.0__tar.gz

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "vmware-debug",
   "displayName": "VMware Debug",
-  "version": "1.12.2",
+  "version": "1.13.0",
   "description": "VMware incident timeline, root-cause routing, local case ledger; no vSphere access. 14 MCP tools.",
   "author": {
     "name": "Wei Zhou",

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/.mcp.json

@@ -5,7 +5,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "vmware-debug==1.12.2",
+        "vmware-debug==1.13.0",
         "vmware-debug-mcp"
       ]
     }

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vmware-debug
-Version: 1.12.2
+Version: 1.13.0
 Summary: VMware diagnostic brain — offline incident triage, log/event correlation, and root-cause routing across the VMware skill family
 Project-URL: Homepage, https://github.com/vmware-skills/VMware-Debug
 Project-URL: Repository, https://github.com/vmware-skills/VMware-Debug

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/RELEASE_NOTES.md

@@ -1,3 +1,28 @@
+## v1.13.0 — exclusion is per hypothesis
+
+Found in a real investigation of an Aria "vCenter app health is affected" alert on 2026-09-15, then corrected
+after an independent review the same day.
+
+**Ruling out one hypothesis no longer excludes the case.** Two sources ruled out H2 (host memory reclaim) while the
+leading H1 stayed open behind three gaps, and `case_grade` graded the whole case Excluded — which reads as "the
+answer was ruled out". Now the case is Excluded only when every registered hypothesis is ruled out; otherwise it
+is graded for what remains.
+
+* **Only evidence that rules nothing out counts for the hypotheses still open.** Evidence records what it
+  falsifies, never what it supports. The first version of this change counted the observations that ruled H2 out
+  as corroboration for H1, and a hypothesis added with no evidence at all inherited Probable. Independent sources
+  and decisive items for the open hypotheses are now counted only from items with an empty `falsifies`.
+* A gap whose `blocks` lists only ruled-out hypotheses no longer holds the grade back; the reasons list it under
+  "No longer blocking" instead of "Blocking gap(s)".
+* **Behaviour change:** `case_grade` returns `hypotheses`, every registered hypothesis as `{id, status}` with
+  status `open` or `excluded`. A case directory without a readable `hypotheses.md` is graded as if none were
+  registered, with a reason, instead of failing.
+* Re-running the same investigation after the change: H2 and H3 excluded, H1 open, **Probable** from two sources
+  that rule nothing out, held below Confirmed by four open gaps.
+
+Known and unchanged: excluding a hypothesis still needs two independent sources across the whole case, not two
+that falsify that hypothesis; `case_hypotheses` marks a hypothesis refuted on a single falsifier.
+
 ## v1.12.2 — every tool call is audited, failures included
 
 Until now no vmware-debug MCP tool wrote to `~/.vmware/audit.db`. The server said that was on

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/openclaw.plugin.json

@@ -11,7 +11,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "vmware-debug==1.12.2",
+        "vmware-debug==1.13.0",
         "vmware-debug-mcp"
       ]
     }

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zw008/vmware-debug",
-  "version": "1.12.2",
+  "version": "1.13.0",
   "description": "VMware incident timeline, root-cause routing, local case ledger; no vSphere access. 14 MCP tools.",
   "private": true,
   "license": "MIT",

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vmware-debug"
-version = "1.12.2"
+version = "1.13.0"
 description = "VMware diagnostic brain — offline incident triage, log/event correlation, and root-cause routing across the VMware skill family"
 readme = "README.md"
 license = "MIT"

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/vmware-skills/VMware-Debug",
     "source": "github"
   },
-  "version": "1.12.2",
+  "version": "1.13.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "vmware-debug",
-      "version": "1.12.2",
+      "version": "1.13.0",
       "runtimeHint": "uvx",
       "packageArguments": [
         {

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/skills/vmware-debug/SKILL.md

@@ -51,7 +51,7 @@ write tools touch only the local case ledger.
 ## Quick Install
 
 ```bash
-uv tool install vmware-debug==1.12.2
+uv tool install vmware-debug==1.13.0
 vmware-debug categories          # see what it can diagnose
 ```
 
@@ -175,7 +175,10 @@ ledger — submit the missing evidence, or record the gap that is blocking it.
 - **Confirmed** — that, plus a decisive item: a direct hardware diagnostic, a
   version-checked knowledge-base entry, or a vendor SR; and no gap left open
 - **Excluded** — an observation that actually rules it out. "We looked and found
-  nothing" is a gap, not an exclusion
+  nothing" is a gap, not an exclusion. Exclusion is per hypothesis: the case is
+  Excluded only when every registered hypothesis is ruled out. Otherwise
+  `case_grade` grades what remains, counting only evidence that rules nothing
+  out, and lists each hypothesis as `open` or `excluded` in `hypotheses`
 
 `case_plan` is not a checklist: submit evidence and the next plan is shorter,
 lose a source and it routes around it. Its `unavailable` half is the important

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/skills/vmware-debug/references/setup-guide.md

@@ -6,7 +6,7 @@ is a pure, offline correlation engine. There is no `config.yaml` and no `.env`.
 ## Install
 
 ```bash
-uv tool install vmware-debug==1.12.2
+uv tool install vmware-debug==1.13.0
 vmware-debug categories      # verify it runs
 ```
 
@@ -15,7 +15,7 @@ vmware-debug categories      # verify it runs
 ```json
 {
   "command": "uvx",
-  "args": ["--from", "vmware-debug==1.12.2", "vmware-debug-mcp"]
+  "args": ["--from", "vmware-debug==1.13.0", "vmware-debug-mcp"]
 }
 ```
 

vmware_debug-1.13.0/tests/test_case_grading_per_hypothesis.py

@@ -0,0 +1,131 @@
+"""Excluded is a verdict about a hypothesis, not about the whole case.
+
+2026-09-15, a real investigation of a vCenter app-health alert: two sources
+ruled out H2 (host memory reclaim) while the leading H1 stayed open behind three
+gaps. ``case_grade`` graded the whole case Excluded, which reads as "the answer
+was ruled out". The investigator had to explain in prose that only H2 was.
+
+The first version of the fix over-corrected, and an independent review caught
+it: the observations that ruled H2 out were then counted as corroboration for
+H1, and a hypothesis added with no evidence at all inherited Probable. Evidence
+records only what it falsifies, never what it supports, so an item that rules a
+hypothesis out must not count for the ones left open.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from vmware_debug.ops.cases.api import grade
+from vmware_debug.ops.cases.evidence import Evidence, Gap, record_evidence, record_gap
+from vmware_debug.ops.cases.grading import grade_case
+from vmware_debug.ops.cases.hypotheses import add_hypothesis
+from vmware_debug.ops.cases.model import Scope
+from vmware_debug.ops.cases.store import create_case
+
+AT = "2026-09-15T13:30:00Z"
+
+
+@pytest.fixture(autouse=True)
+def isolated_home(tmp_path, monkeypatch):
+    monkeypatch.setenv("OPS_HOME", str(tmp_path / "vmware"))
+
+
+@pytest.fixture
+def two_hypotheses():
+    cid = create_case(
+        Scope(
+            summary="vcenter app health",
+            determined_by="aria alert",
+            product_versions={"vsphere": "8.0.3"},
+        ),
+        at=AT,
+    ).case_id
+    add_hypothesis(cid, "appliance memory pressure")  # H1
+    add_hypothesis(cid, "host reclaims appliance memory")  # H2
+    return cid
+
+
+def _evidence(skill: str, falsifies: tuple[str, ...] = ()) -> Evidence:
+    return Evidence(
+        source_skill=skill,
+        source_tool="t",
+        query={},
+        fetched_at="2026-09-15T13:31:00Z",
+        summary="s",
+        falsifies=falsifies,
+    )
+
+
+def _gap(blocks: tuple[str, ...], could_falsify: bool = True) -> Gap:
+    return Gap(
+        what="swap history",
+        why="not collected",
+        blocks=blocks,
+        could_falsify=could_falsify,
+        how_to_close="vami",
+    )
+
+
+def test_ruling_out_one_hypothesis_does_not_exclude_the_case(two_hypotheses):
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor", falsifies=("H2",)))
+    r = grade_case(two_hypotheses)
+    assert r.grade == "candidate"
+    assert r.hypotheses == (("H1", "open"), ("H2", "excluded"))
+    assert any("Still open: H1" in reason for reason in r.reasons)
+
+
+def test_the_case_is_excluded_when_every_hypothesis_is_ruled_out(two_hypotheses):
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H1", "H2")))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor"))
+    assert grade_case(two_hypotheses).grade == "excluded"
+
+
+def test_evidence_that_rules_one_out_is_not_corroboration_for_the_rest(two_hypotheses):
+    """aria rules H2 out; monitor says something unrelated. Nothing is about H1."""
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor"))
+    assert grade_case(two_hypotheses).grade == "candidate"
+
+
+def test_a_new_hypothesis_does_not_inherit_probable(two_hypotheses):
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H1", "H2")))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor", falsifies=("H1", "H2")))
+    assert grade_case(two_hypotheses).grade == "excluded"
+    add_hypothesis(two_hypotheses, "something else")  # H3, no evidence at all
+    r = grade_case(two_hypotheses)
+    assert r.grade == "candidate"
+    assert ("H3", "open") in r.hypotheses
+
+
+def test_a_gap_that_blocks_only_a_ruled_out_hypothesis_holds_nothing_back(two_hypotheses):
+    """Otherwise a question nobody needs answered any more pins H1 at Candidate."""
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor"))
+    record_evidence(two_hypotheses, _evidence("vmware-log-insight"))
+    record_gap(two_hypotheses, _gap(blocks=("H2",)))
+    r = grade_case(two_hypotheses)
+    assert r.grade == "probable"
+    assert not any(reason.startswith("Blocking gap(s)") for reason in r.reasons)
+    assert any("No longer blocking" in reason for reason in r.reasons)
+
+
+def test_a_gap_that_still_blocks_an_open_hypothesis_still_holds(two_hypotheses):
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor"))
+    record_evidence(two_hypotheses, _evidence("vmware-log-insight"))
+    record_gap(two_hypotheses, _gap(blocks=("H1", "H2")))
+    assert grade_case(two_hypotheses).grade == "candidate"
+
+
+def test_the_tool_result_lists_each_hypothesis(two_hypotheses):
+    record_evidence(two_hypotheses, _evidence("vmware-aria", falsifies=("H2",)))
+    record_evidence(two_hypotheses, _evidence("vmware-monitor"))
+    out = grade(two_hypotheses, at=AT)
+    assert out["hypotheses"] == [
+        {"id": "H1", "status": "open"},
+        {"id": "H2", "status": "excluded"},
+    ]

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/uv.lock

@@ -1293,7 +1293,7 @@ wheels = [
 
 [[package]]
 name = "vmware-debug"
-version = "1.12.2"
+version = "1.13.0"
 source = { editable = "." }
 dependencies = [
     { name = "mcp", extra = ["cli"] },

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/vmware_debug/__init__.py

@@ -6,4 +6,4 @@ remediation to vmware-aiops / vmware-pilot. Never writes to any VMware system
 and never executes fixes; its only writes go to the local case ledger.
 """
 
-__version__ = "1.12.2"
+__version__ = "1.13.0"

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/vmware_debug/mcp_server/server.py

@@ -572,11 +572,17 @@ def build_server() -> FastMCP:
         decisive item: a direct hardware diagnostic, a version-checked
         knowledge-base entry, or a vendor SR, and no gap left open); Excluded
         (an observation that actually rules the hypothesis out — "we looked and
-        found nothing" is a gap, not an exclusion).
+        found nothing" is a gap, not an exclusion). Exclusion is per
+        hypothesis: ruling out H2 does not exclude the case while H1 is still
+        open. The case is Excluded only when every registered hypothesis is
+        ruled out; otherwise the grade is for what remains, and gaps that block
+        only ruled-out hypotheses no longer hold it back.
 
         RETURNS: {grade, previous, direction, reasons, ceiling, ceiling_reasons,
-        rules_source, rules_origin}. `direction` is initial/up/down/unchanged —
-        grades may go DOWN, and the history records it when they do.
+        rules_source, rules_origin, hypotheses}. `hypotheses` lists every
+        registered hypothesis as {id, status: open|excluded}. `direction` is
+        initial/up/down/unchanged — grades may go DOWN, and the history records
+        it when they do.
 
         GOTCHAS: on a stock install `ceiling` is "probable", because Confirmed
         needs a decisive source and there is neither a hardware-diagnostic

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/vmware_debug/ops/cases/api.py

@@ -223,6 +223,7 @@ def grade(case_id: str, at: str | None = None) -> dict[str, Any]:
         "ceiling_reasons": list(result.ceiling_reasons),
         "rules_source": result.rules_source,
         "rules_origin": result.rules_origin,
+        "hypotheses": [{"id": h, "status": status} for h, status in result.hypotheses],
     }
 
 

{vmware_debug-1.12.2 → vmware_debug-1.13.0}/vmware_debug/ops/cases/grading.py

@@ -24,7 +24,8 @@ from typing import Any
 from vmware_policy.paths import ops_path
 
 from vmware_debug.ops.cases.evidence import load_evidence, load_gaps
-from vmware_debug.ops.cases.store import load_case
+from vmware_debug.ops.cases.hypotheses import load_hypotheses
+from vmware_debug.ops.cases.store import CaseError, load_case
 from vmware_debug.ops.skill_names import group_by_skill
 
 PACKAGED_RULES = Path(__file__).resolve().parents[2] / "rules" / "grading_rules.yaml"
@@ -41,6 +42,24 @@ class GradeResult:
     ceiling_reasons: tuple[str, ...]
     rules_source: str
     rules_origin: str
+    hypotheses: tuple[tuple[str, str], ...] = ()
+    """``(hypothesis_id, "open" | "excluded")`` for every registered hypothesis,
+    in registration order. The case is Excluded only when none is left open."""
+
+
+def _registered_hypotheses(case_id: str, reasons: list[str]) -> tuple[str, ...]:
+    """Hypothesis ids from the ledger; an unreadable ledger grades as none registered.
+
+    Grading worked on a case directory without ``hypotheses.md`` before
+    exclusion became per hypothesis. Refusing to grade it now would turn a
+    missing bookkeeping file into no conclusion at all, so the gap is said
+    instead.
+    """
+    try:
+        return tuple(h.hypothesis_id for h in load_hypotheses(case_id))
+    except CaseError as exc:
+        reasons.append(f"Hypothesis ledger unreadable, graded as if none were registered: {exc}")
+        return ()
 
 
 def site_rules_path() -> Path:
@@ -169,7 +188,6 @@ def grade_case(case_id: str) -> GradeResult:
     by_skill = group_by_skill([e.source_skill for e in evidence])
     sources = set(by_skill)
     blocking = tuple(g for g in gaps if g.blocks)
-    falsifiable = tuple(g for g in blocking if g.could_falsify)
     reasons: list[str] = []
 
     if evidence:
@@ -187,22 +205,87 @@ def grade_case(case_id: str) -> GradeResult:
             )
     else:
         reasons.append("No evidence recorded yet.")
-    if blocking:
+
+    # Exclusion is per hypothesis. A falsifying observation rules out the
+    # hypotheses it names, not the case: on 2026-09-15 two sources ruled out H2
+    # while the leading H1 was still open behind three gaps, and the whole case
+    # was graded Excluded — which reads as "the answer was ruled out".
+    excluded_ids: frozenset[str] = frozenset()
+    if _check_excluded(grades.get("excluded") or {}, evidence, sources, reasons):
+        excluded_ids = frozenset(h for e in evidence for h in e.falsifies)
+    registered = _registered_hypotheses(case_id, reasons)
+    still_open = tuple(h for h in registered if h not in excluded_ids)
+    statuses = tuple((h, "excluded" if h in excluded_ids else "open") for h in registered)
+    # A gap that blocks only ruled-out hypotheses no longer holds the case back.
+    live_blocking = tuple(g for g in blocking if any(h not in excluded_ids for h in g.blocks))
+    retired = tuple(g for g in blocking if g not in live_blocking)
+    falsifiable = tuple(g for g in live_blocking if g.could_falsify)
+    if live_blocking:
         reasons.append(
             "Blocking gap(s): "
             + "; ".join(
                 f"{g.gap_id} {g.what} (blocks {', '.join(g.blocks)}"
                 + (", could overturn it)" if g.could_falsify else ")")
-                for g in blocking
+                for g in live_blocking
             )
             + "."
         )
+    if retired:
+        reasons.append(
+            "No longer blocking, because every hypothesis they block is ruled out: "
+            + ", ".join(g.gap_id for g in retired)
+            + "."
+        )
 
-    excluded = _check_excluded(grades.get("excluded") or {}, evidence, sources, reasons)
-    if excluded:
+    if excluded_ids and not still_open:
         grade = "excluded"
-    elif _meets_probable(grades.get("probable") or {}, sources, falsifiable):
-        grade = (
+    else:
+        open_evidence = evidence
+        open_sources = sources
+        if excluded_ids:
+            # Evidence carries no link to the hypothesis it supports, only to the
+            # ones it falsifies. An item that ruled one hypothesis out says
+            # nothing for the others, so it must not buy them corroboration —
+            # otherwise the observations that excluded H2 promote H1 to
+            # Probable, and a brand-new hypothesis with no evidence at all
+            # inherits the same grade (independent review, 2026-09-15).
+            open_evidence = tuple(e for e in evidence if not e.falsifies)
+            open_sources = set(group_by_skill([e.source_skill for e in open_evidence]))
+            reasons.append(
+                f"Ruled out: {', '.join(sorted(excluded_ids))}. Still open: "
+                f"{', '.join(still_open)}. The grade is for what remains, counting "
+                f"only evidence that rules nothing out: {len(open_sources)} "
+                f"independent source(s)."
+            )
+        grade = _grade_open(
+            grades, open_evidence, open_sources, live_blocking, falsifiable, reasons, scope
+        )
+
+    ceiling, ceiling_reasons = _ceiling(rules)
+    return GradeResult(
+        case_id=case_id,
+        grade=grade,
+        reasons=tuple(reasons),
+        ceiling=ceiling,
+        ceiling_reasons=ceiling_reasons,
+        rules_source=source,
+        rules_origin=origin,
+        hypotheses=statuses,
+    )
+
+
+def _grade_open(
+    grades: dict[str, Any],
+    evidence: tuple,
+    sources: set[str],
+    blocking: tuple,
+    falsifiable: tuple,
+    reasons: list[str],
+    scope: Any,
+) -> str:
+    """Candidate / Probable / Confirmed for the hypotheses that are still open."""
+    if _meets_probable(grades.get("probable") or {}, sources, falsifiable):
+        return (
             "confirmed"
             if _meets_confirmed(
                 grades.get("confirmed") or {},
@@ -214,7 +297,7 @@ def grade_case(case_id: str) -> GradeResult:
             )
             else "probable"
         )
-    elif _meets_confirmed(
+    if _meets_confirmed(
         grades.get("confirmed") or {},
         evidence,
         blocking,
@@ -225,21 +308,9 @@ def grade_case(case_id: str) -> GradeResult:
         # Only reachable when the rules file relaxes `confirmed.requires`.
         # Mutation-testing found that key was never read: changing it looked
         # like it worked and did nothing, which is worse than not offering it.
-        grade = "confirmed"
-    else:
-        grade = "candidate"
-        reasons.append(_why_not_probable(grades.get("probable") or {}, sources, falsifiable))
-
-    ceiling, ceiling_reasons = _ceiling(rules)
-    return GradeResult(
-        case_id=case_id,
-        grade=grade,
-        reasons=tuple(reasons),
-        ceiling=ceiling,
-        ceiling_reasons=ceiling_reasons,
-        rules_source=source,
-        rules_origin=origin,
-    )
+        return "confirmed"
+    reasons.append(_why_not_probable(grades.get("probable") or {}, sources, falsifiable))
+    return "candidate"
 
 
 def _meets_probable(rule: dict[str, Any], sources: set[str], falsifiable: tuple) -> bool: