quantum-reasoning-skill 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,51 +0,0 @@
-# Changelog
-
-All notable changes to this project are documented here.
-
-## [Unreleased]
-
-## [0.3.1] - 2026-09-07
-
-### Added
-
-- Community benchmark contribution policy in `CONTRIBUTING.md`.
-- GitHub **Benchmark result**, **Bug report**, and **Feature request** issue forms.
-- Pull-request checklist for tests, documentation, benchmark integrity, and sensitive-data hygiene.
-- Draft 2020-12 JSON Schemas for benchmark cases, result rows, experiment metadata, and comparison output.
-- `benchmark/validate_submission.py` for machine-validating reproducible community benchmark bundles.
-- Tests that reject missing benchmark artifacts, tampered comparisons, and incomplete integrity metadata.
-- Capability-based host compatibility contract in `docs/COMPATIBILITY.md`.
-- Generic native-skill, persistent-instruction, and controller-assisted integration examples.
-- `SECURITY.md` vulnerability-reporting policy.
-- `CITATION.cff` research-software citation metadata.
-
-### Changed
-
-- Benchmark documentation now explicitly assigns real-model evaluation to users and contributors rather than requiring maintainer-run access to every model/provider.
-- Community benchmark PRs now include the exact `cases.jsonl` used and are re-evaluated by CI from their raw baseline/skill files.
-- Third-party benchmark submissions are treated as reproducible external measurements, not automatic project endorsements or universal performance claims.
-- Release publishing now runs only after `validate-skill` succeeds on `main`; a failed validation cannot publish a release.
-- GitHub Actions dependencies are pinned to exact commit SHAs and CI enforces future pinning.
-- CI now validates schemas, version/citation consistency, host/documentation links, and community result bundles.
-
-## [0.3.0] - 2026-09-07
-
-### Added
-
-- Deterministic reference branch controller with explicit scoring and state transitions.
-- Shared-assumption and semantic-correlation penalty.
-- Quantified dormant/rejected state rules and branch revival triggers.
-- Uncertainty-based recommended search width.
-- Explicit collapse criteria and leader-margin checks.
-- Measurement specification documenting formulas and calibration requirements.
-- Reproducible baseline-vs-skill benchmark protocol.
-- Seed benchmark cases and JSONL result schema.
-- Benchmark evaluator for accuracy, token/tool cost, latency, branch diversity, error recovery and contradiction resolution.
-- Behavioral unit tests for the branch controller and benchmark evaluator.
-- CI checks for Python compilation, benchmark schema validation and behavioral tests.
-- Automated GitHub tag and Release publishing driven by the `VERSION` file.
-
-### Changed
-
-- `SKILL.md` now distinguishes qualitative protocol rules from unvalidated reference thresholds.
-- `README.md` now documents the measurable framework and makes clear that empirical performance improvement has not yet been demonstrated.

package/CITATION.cff

@@ -1,17 +0,0 @@
-cff-version: 1.2.0
-message: "If you use this software or reasoning protocol, please cite it using the metadata below."
-title: "Quantum Reasoning Skill"
-type: software
-authors:
-  - name: "Furox-Art"
-repository-code: "https://github.com/Furox-Art/quantum-reasoning-skill"
-url: "https://github.com/Furox-Art/quantum-reasoning-skill"
-license: MIT
-version: 0.3.1
-date-released: 2026-09-07
-keywords:
-  - reasoning
-  - language-models
-  - agent-systems
-  - test-time-compute
-  - benchmarking

package/CONTRIBUTING.md

@@ -1,88 +0,0 @@
-# Contributing
-
-Contributions are welcome for the reasoning protocol, reference controller, tests, documentation, benchmark cases, host integrations and independently run model evaluations.
-
-Before changing host-facing behavior, read [`docs/COMPATIBILITY.md`](./docs/COMPATIBILITY.md). Executable behavior changes should include tests.
-
-## Community-run benchmarks
-
-The project does **not** require the maintainer to purchase access to every model or provider. Real model evaluations are intentionally community-run.
-
-The repository provides:
-
-- the benchmark protocol;
-- deterministic seed cases;
-- machine-readable JSON Schemas;
-- the result evaluator;
-- a reproducible submission validator;
-- CI validation and comparison tooling.
-
-Users may run controlled baseline-vs-skill experiments on models and providers they already have access to and submit the results for review.
-
-### Required metadata
-
-Every submitted model evaluation must identify at least:
-
-- provider;
-- exact model and model version when available;
-- run date;
-- skill version/commit when available;
-- baseline and skill prompt/instruction configuration;
-- temperature/sampling parameters;
-- context and output limits;
-- tool availability;
-- number of repetitions per case;
-- random seed when supported;
-- local hardware/runtime details for local models;
-- whether failures, refusals and timeouts were retained.
-
-Do not omit failed runs.
-
-### Required artifacts for a benchmark PR
-
-Place each submitted run under:
-
-```text
-benchmark/results/community/<provider>-<model>-<YYYY-MM-DD>/
-```
-
-Every bundle must include:
-
-```text
-metadata.json
-cases.jsonl
-baseline.jsonl
-skill.jsonl
-comparison.json
-README.md
-```
-
-The exact contracts are in [`benchmark/schemas/`](./benchmark/schemas/). `cases.jsonl` must contain the exact evaluated cases, including custom cases when used.
-
-`comparison.json` must be produced by `benchmark/evaluate.py` from the submitted raw result files rather than edited manually. Before submitting, run:
-
-```bash
-python benchmark/validate_submission.py --root benchmark/results/community
-```
-
-CI recomputes the comparison and rejects a bundle when its raw evidence and reported comparison disagree.
-
-### Result integrity
-
-- Use the same model/version, task set, tools, sampling settings and budget policy for baseline and skill conditions.
-- Do not expose or submit private chain-of-thought.
-- Do not fabricate missing telemetry.
-- Clearly disclose custom benchmark cases, prompt wrappers, provider-specific adapters and any modifications to `SKILL.md`.
-- Third-party benchmark submissions are measurements from their submitters, not project-maintainer endorsements.
-- A single positive run is not sufficient to establish a general performance claim.
-
-### How to submit
-
-You can either:
-
-1. open a **Benchmark result** issue using the repository issue template and link to your artifacts; or
-2. open a pull request containing the reproducible result bundle described above.
-
-For ordinary defects, use the **Bug report** form. For proposed behavior or protocol changes, use the **Feature request** form.
-
-For code or protocol changes, include tests when the change is executable and explain which behavior is being changed. Follow the pull-request checklist in `.github/PULL_REQUEST_TEMPLATE.md`.

package/SECURITY.md

@@ -1,17 +0,0 @@
-# Security policy
-
-## Supported versions
-
-Security fixes are applied to the current `main` branch and the latest published release.
-
-## Reporting a vulnerability
-
-Do not publish exploit details, credentials, tokens, private benchmark data, or other sensitive material in a public issue.
-
-Prefer GitHub's private **Report a vulnerability** / Security Advisory flow when it is available for this repository. If that private channel is unavailable, open a minimal public issue that only requests a private contact path and does not include vulnerability details.
-
-## Scope
-
-Relevant reports include vulnerabilities in repository automation, benchmark ingestion/validation, release workflows, or reference code that could cause untrusted contributed content to execute unexpectedly, alter releases, or expose secrets.
-
-Reasoning-quality disagreements and ordinary protocol bugs are not security vulnerabilities; use the normal bug-report issue form for those.

package/benchmark/README.md

@@ -1,134 +0,0 @@
-# Benchmark protocol
-
-This directory measures whether the skill improves results rather than merely producing more reasoning text.
-
-## Who runs the benchmarks
-
-Real model evaluations are intentionally **community-run**. The repository supplies the benchmark protocol, seed cases, JSON Schemas, evaluator and submission validator; users run experiments on the models/providers they have access to.
-
-Maintainer-run access to every commercial or local model is not required. The project therefore separates **benchmark infrastructure** from **third-party empirical results**.
-
-Submitted results are evidence from the contributor who produced them. They are not automatically endorsed by the project and should not be generalized beyond the tested model/version/configuration without replication.
-
-## Principle
-
-Run the **same model, model version, task set, tool access, temperature/sampling settings, and token budget policy** twice:
-
-1. baseline: normal instructions without `SKILL.md`
-2. skill: the same setup with `SKILL.md`
-
-Do not compare different models and attribute the difference to the skill.
-
-## Seed cases
-
-`cases.jsonl` contains deterministic smoke-test cases. They are intentionally small and are **not sufficient evidence of reasoning improvement**. A serious evaluation should add difficult held-out tasks from the target domains and report their provenance/licensing.
-
-Each case has:
-
-```json
-{"id":"...","domain":"...","prompt":"...","accepted_answers":["..."]}
-```
-
-## Machine-readable schemas
-
-The contracts are versioned with the repository:
-
-- [`schemas/case.schema.json`](./schemas/case.schema.json) — one benchmark case
-- [`schemas/result.schema.json`](./schemas/result.schema.json) — one baseline/skill result row
-- [`schemas/metadata.schema.json`](./schemas/metadata.schema.json) — experiment metadata
-- [`schemas/comparison.schema.json`](./schemas/comparison.schema.json) — evaluator comparison output
-
-A result row requires:
-
-```json
-{
-  "case_id": "math-arithmetic-001",
-  "answer": "323",
-  "tokens": 120,
-  "tool_calls": 0,
-  "latency_ms": 950
-}
-```
-
-Failed/refused runs should still be represented rather than silently removed. The optional `status` field may be `ok`, `refusal`, `timeout`, or `error`.
-
-Skill-aware runners may additionally record observable aggregate telemetry such as `branches_total`, `branches_distinct`, `revived_branches`, `recovered_errors`, `contradictions_found`, and `contradictions_resolved`. Do not store private chain-of-thought.
-
-## Evaluate one run
-
-```bash
-python benchmark/evaluate.py \
-  --cases benchmark/cases.jsonl \
-  --skill path/to/skill-results.jsonl
-```
-
-## Compare baseline vs skill
-
-```bash
-python benchmark/evaluate.py \
-  --cases benchmark/cases.jsonl \
-  --baseline path/to/baseline-results.jsonl \
-  --skill path/to/skill-results.jsonl \
-  --output comparison.json
-```
-
-The evaluator reports exact-answer accuracy, mean token use, tool calls, latency, branch diversity, revival/error recovery, contradiction resolution, and baseline-to-skill deltas.
-
-## Required experimental controls
-
-For a publishable comparison, record at minimum:
-
-- provider and exact model/version
-- date of the run
-- decoding/sampling parameters
-- context and output limits
-- tool availability
-- prompt wrapper/system instructions
-- number of repetitions per case
-- random seed when the provider supports one
-- hardware/runtime details for local models
-- failures, refusals and timeouts rather than silently dropping them
-
-Use multiple repetitions for stochastic models and report confidence intervals. Keep benchmark cases separate from any prompts used while designing or tuning the skill.
-
-## Submitting community results
-
-Results can be submitted in either of two ways:
-
-1. Open a **Benchmark result** issue and provide the required metadata plus links/attachments to the result artifacts.
-2. Open a pull request containing a reproducible result bundle under:
-
-```text
-benchmark/results/community/<provider>-<model>-<YYYY-MM-DD>/
-```
-
-Every benchmark-result PR bundle must contain:
-
-```text
-metadata.json
-cases.jsonl
-baseline.jsonl
-skill.jsonl
-comparison.json
-README.md
-```
-
-Including `cases.jsonl` inside the bundle makes the exact evaluated case set immutable and reviewable even when custom cases are used.
-
-Generate `comparison.json` with `benchmark/evaluate.py`; do not hand-edit it. Before opening a PR, validate the bundle:
-
-```bash
-python benchmark/validate_submission.py --root benchmark/results/community
-```
-
-CI runs the same validator. It rejects missing artifacts, incomplete metadata, duplicate/missing case results, and a `comparison.json` that differs from a fresh evaluator recomputation.
-
-See [`../CONTRIBUTING.md`](../CONTRIBUTING.md) for the complete submission and integrity policy.
-
-## Interpretation
-
-A useful result is not simply "skill accuracy is higher". Report the trade-off between accuracy and compute. A skill that gains 1 percentage point while using 5x tokens may be undesirable for many workloads.
-
-The reference thresholds in `reference/branch_controller.py` are defaults to test, not validated constants. Benchmark evidence should drive later calibration.
-
-The project makes no universal performance claim from a single model, provider, benchmark or contributor submission. Independent replication is preferred.

package/benchmark/cases.jsonl

@@ -1,6 +0,0 @@
-{"id":"math-arithmetic-001","domain":"mathematics","prompt":"Compute 17 * 19.","accepted_answers":["323"],"notes":"Exact-answer sanity case."}
-{"id":"math-algebra-001","domain":"mathematics","prompt":"Solve x^2 - 5x + 6 = 0. Return the roots in ascending order separated by a comma.","accepted_answers":["2, 3","2,3"],"notes":"Checks independent verification of a simple factorization."}
-{"id":"logic-contradiction-001","domain":"logic","prompt":"Premises: All A are B. No B are C. Some A are C. Are the premises jointly consistent? Answer yes or no.","accepted_answers":["no"],"notes":"Requires contradiction detection."}
-{"id":"debug-python-001","domain":"debugging","prompt":"A Python function is intended to return the first item of xs: def first(xs): return xs[1]. What integer index should replace 1?","accepted_answers":["0"],"notes":"Minimal root-cause diagnosis."}
-{"id":"science-units-001","domain":"scientific-reasoning","prompt":"A car travels at 20 m/s for 15 s at constant speed. How many meters does it travel? Return only the number.","accepted_answers":["300"],"notes":"Simple quantitative verification case."}
-{"id":"probability-001","domain":"probability","prompt":"A fair coin is flipped twice. What is the probability of exactly one head? Return a decimal.","accepted_answers":["0.5",".5"],"notes":"Checks enumeration versus shortcut reasoning."}

package/benchmark/evaluate.py

@@ -1,257 +0,0 @@
-"""Evaluate baseline and quantum-reasoning runs from JSONL files.
-
-The evaluator uses only the Python standard library. It does not call a model.
-External runners can write one result row per case and this script will validate,
-score, summarize, and compare those runs without inventing missing measurements.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import statistics
-from pathlib import Path
-from typing import Any, Iterable
-
-
-REQUIRED_RESULT_FIELDS = {
-    "case_id",
-    "answer",
-    "tokens",
-    "tool_calls",
-    "latency_ms",
-}
-
-OPTIONAL_TELEMETRY_FIELDS = {
-    "branches_total",
-    "branches_distinct",
-    "revived_branches",
-    "recovered_errors",
-    "contradictions_found",
-    "contradictions_resolved",
-}
-
-
-def read_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    with path.open("r", encoding="utf-8") as handle:
-        for line_number, raw in enumerate(handle, start=1):
-            line = raw.strip()
-            if not line:
-                continue
-            try:
-                value = json.loads(line)
-            except json.JSONDecodeError as exc:
-                raise ValueError(f"{path}:{line_number}: invalid JSON: {exc}") from exc
-            if not isinstance(value, dict):
-                raise ValueError(f"{path}:{line_number}: row must be a JSON object")
-            rows.append(value)
-    return rows
-
-
-def normalize_answer(value: Any) -> str:
-    return " ".join(str(value).strip().casefold().split())
-
-
-def validate_case(case: dict[str, Any]) -> None:
-    for field in ("id", "domain", "prompt", "accepted_answers"):
-        if field not in case:
-            raise ValueError(f"case missing required field: {field}")
-    if not isinstance(case["accepted_answers"], list) or not case["accepted_answers"]:
-        raise ValueError(f"case {case['id']!r}: accepted_answers must be a non-empty list")
-
-
-def validate_result(result: dict[str, Any]) -> None:
-    missing = REQUIRED_RESULT_FIELDS - set(result)
-    if missing:
-        raise ValueError(
-            f"result {result.get('case_id', '<unknown>')!r} missing fields: "
-            + ", ".join(sorted(missing))
-        )
-    for field in ("tokens", "tool_calls", "latency_ms"):
-        value = result[field]
-        if not isinstance(value, (int, float)) or value < 0:
-            raise ValueError(f"result {result['case_id']!r}: {field} must be non-negative")
-    for field in OPTIONAL_TELEMETRY_FIELDS:
-        if field in result:
-            value = result[field]
-            if not isinstance(value, (int, float)) or value < 0:
-                raise ValueError(
-                    f"result {result['case_id']!r}: {field} must be non-negative"
-                )
-    if "branches_distinct" in result and "branches_total" in result:
-        if result["branches_distinct"] > result["branches_total"]:
-            raise ValueError(
-                f"result {result['case_id']!r}: branches_distinct cannot exceed branches_total"
-            )
-    if "contradictions_resolved" in result and "contradictions_found" in result:
-        if result["contradictions_resolved"] > result["contradictions_found"]:
-            raise ValueError(
-                f"result {result['case_id']!r}: contradictions_resolved cannot exceed contradictions_found"
-            )
-
-
-def answer_is_correct(case: dict[str, Any], answer: Any) -> bool:
-    normalized = normalize_answer(answer)
-    accepted = {normalize_answer(value) for value in case["accepted_answers"]}
-    return normalized in accepted
-
-
-def safe_mean(values: Iterable[float]) -> float | None:
-    materialized = list(values)
-    if not materialized:
-        return None
-    return statistics.fmean(materialized)
-
-
-def safe_ratio(numerator: float, denominator: float) -> float | None:
-    if denominator == 0:
-        return None
-    return numerator / denominator
-
-
-def summarize(cases: list[dict[str, Any]], results: list[dict[str, Any]]) -> dict[str, Any]:
-    for case in cases:
-        validate_case(case)
-    for result in results:
-        validate_result(result)
-
-    case_by_id = {str(case["id"]): case for case in cases}
-    if len(case_by_id) != len(cases):
-        raise ValueError("case ids must be unique")
-
-    result_by_id: dict[str, dict[str, Any]] = {}
-    for result in results:
-        case_id = str(result["case_id"])
-        if case_id in result_by_id:
-            raise ValueError(f"duplicate result for case_id {case_id!r}")
-        if case_id not in case_by_id:
-            raise ValueError(f"result references unknown case_id {case_id!r}")
-        result_by_id[case_id] = result
-
-    missing_cases = sorted(set(case_by_id) - set(result_by_id))
-    evaluated = []
-    for case_id, result in result_by_id.items():
-        case = case_by_id[case_id]
-        evaluated.append((case, result, answer_is_correct(case, result["answer"])))
-
-    total = len(evaluated)
-    correct = sum(int(is_correct) for _, _, is_correct in evaluated)
-
-    branch_rows = [
-        result
-        for _, result, _ in evaluated
-        if "branches_total" in result and "branches_distinct" in result
-    ]
-    contradiction_rows = [
-        result
-        for _, result, _ in evaluated
-        if "contradictions_found" in result and "contradictions_resolved" in result
-    ]
-
-    total_branches = sum(row["branches_total"] for row in branch_rows)
-    distinct_branches = sum(row["branches_distinct"] for row in branch_rows)
-    contradictions_found = sum(row["contradictions_found"] for row in contradiction_rows)
-    contradictions_resolved = sum(
-        row["contradictions_resolved"] for row in contradiction_rows
-    )
-
-    return {
-        "cases_defined": len(cases),
-        "cases_evaluated": total,
-        "missing_case_ids": missing_cases,
-        "accuracy": safe_ratio(correct, total),
-        "mean_tokens": safe_mean(float(result["tokens"]) for _, result, _ in evaluated),
-        "mean_tool_calls": safe_mean(
-            float(result["tool_calls"]) for _, result, _ in evaluated
-        ),
-        "mean_latency_ms": safe_mean(
-            float(result["latency_ms"]) for _, result, _ in evaluated
-        ),
-        "branch_diversity_ratio": safe_ratio(distinct_branches, total_branches),
-        "revival_rate_per_case": safe_mean(
-            float(result.get("revived_branches", 0)) for _, result, _ in evaluated
-        ),
-        "error_recovery_rate_per_case": safe_mean(
-            float(result.get("recovered_errors", 0)) for _, result, _ in evaluated
-        ),
-        "contradiction_resolution_rate": safe_ratio(
-            contradictions_resolved, contradictions_found
-        ),
-    }
-
-
-def percent_change(new: float | None, old: float | None) -> float | None:
-    if new is None or old is None or old == 0:
-        return None
-    return ((new - old) / old) * 100.0
-
-
-def absolute_change(new: float | None, old: float | None) -> float | None:
-    if new is None or old is None:
-        return None
-    return new - old
-
-
-def compare(baseline: dict[str, Any], skill: dict[str, Any]) -> dict[str, Any]:
-    return {
-        "accuracy_delta": absolute_change(skill["accuracy"], baseline["accuracy"]),
-        "tokens_percent_change": percent_change(
-            skill["mean_tokens"], baseline["mean_tokens"]
-        ),
-        "tool_calls_percent_change": percent_change(
-            skill["mean_tool_calls"], baseline["mean_tool_calls"]
-        ),
-        "latency_percent_change": percent_change(
-            skill["mean_latency_ms"], baseline["mean_latency_ms"]
-        ),
-        "branch_diversity_delta": absolute_change(
-            skill["branch_diversity_ratio"], baseline["branch_diversity_ratio"]
-        ),
-        "contradiction_resolution_delta": absolute_change(
-            skill["contradiction_resolution_rate"],
-            baseline["contradiction_resolution_rate"],
-        ),
-    }
-
-
-def ensure_finite(value: Any, label: str) -> None:
-    if isinstance(value, float) and not math.isfinite(value):
-        raise ValueError(f"{label} is not finite")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--cases", type=Path, required=True)
-    parser.add_argument("--skill", type=Path, required=True)
-    parser.add_argument("--baseline", type=Path)
-    parser.add_argument("--output", type=Path)
-    args = parser.parse_args()
-
-    cases = read_jsonl(args.cases)
-    skill_results = read_jsonl(args.skill)
-    skill_summary = summarize(cases, skill_results)
-
-    payload: dict[str, Any] = {"skill": skill_summary}
-    if args.baseline:
-        baseline_results = read_jsonl(args.baseline)
-        baseline_summary = summarize(cases, baseline_results)
-        payload["baseline"] = baseline_summary
-        payload["comparison"] = compare(baseline_summary, skill_summary)
-
-    for section_name, section in payload.items():
-        if isinstance(section, dict):
-            for key, value in section.items():
-                ensure_finite(value, f"{section_name}.{key}")
-
-    rendered = json.dumps(payload, indent=2, sort_keys=True)
-    print(rendered)
-    if args.output:
-        args.output.parent.mkdir(parents=True, exist_ok=True)
-        args.output.write_text(rendered + "\n", encoding="utf-8")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/benchmark/schemas/case.schema.json

@@ -1,20 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/Furox-Art/quantum-reasoning-skill/blob/main/benchmark/schemas/case.schema.json",
-  "title": "Quantum Reasoning benchmark case",
-  "type": "object",
-  "additionalProperties": true,
-  "required": ["id", "domain", "prompt", "accepted_answers"],
-  "properties": {
-    "id": {"type": "string", "minLength": 1},
-    "domain": {"type": "string", "minLength": 1},
-    "prompt": {"type": "string", "minLength": 1},
-    "accepted_answers": {
-      "type": "array",
-      "minItems": 1,
-      "items": {}
-    },
-    "source": {"type": ["string", "null"]},
-    "license": {"type": ["string", "null"]}
-  }
-}

package/benchmark/schemas/comparison.schema.json

@@ -1,64 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/Furox-Art/quantum-reasoning-skill/blob/main/benchmark/schemas/comparison.schema.json",
-  "title": "Quantum Reasoning benchmark comparison output",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["baseline", "skill", "comparison"],
-  "properties": {
-    "baseline": {"$ref": "#/$defs/summary"},
-    "skill": {"$ref": "#/$defs/summary"},
-    "comparison": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "accuracy_delta",
-        "tokens_percent_change",
-        "tool_calls_percent_change",
-        "latency_percent_change",
-        "branch_diversity_delta",
-        "contradiction_resolution_delta"
-      ],
-      "properties": {
-        "accuracy_delta": {"type": ["number", "null"]},
-        "tokens_percent_change": {"type": ["number", "null"]},
-        "tool_calls_percent_change": {"type": ["number", "null"]},
-        "latency_percent_change": {"type": ["number", "null"]},
-        "branch_diversity_delta": {"type": ["number", "null"]},
-        "contradiction_resolution_delta": {"type": ["number", "null"]}
-      }
-    }
-  },
-  "$defs": {
-    "summary": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "cases_defined",
-        "cases_evaluated",
-        "missing_case_ids",
-        "accuracy",
-        "mean_tokens",
-        "mean_tool_calls",
-        "mean_latency_ms",
-        "branch_diversity_ratio",
-        "revival_rate_per_case",
-        "error_recovery_rate_per_case",
-        "contradiction_resolution_rate"
-      ],
-      "properties": {
-        "cases_defined": {"type": "integer", "minimum": 0},
-        "cases_evaluated": {"type": "integer", "minimum": 0},
-        "missing_case_ids": {"type": "array", "items": {"type": "string"}},
-        "accuracy": {"type": ["number", "null"]},
-        "mean_tokens": {"type": ["number", "null"]},
-        "mean_tool_calls": {"type": ["number", "null"]},
-        "mean_latency_ms": {"type": ["number", "null"]},
-        "branch_diversity_ratio": {"type": ["number", "null"]},
-        "revival_rate_per_case": {"type": ["number", "null"]},
-        "error_recovery_rate_per_case": {"type": ["number", "null"]},
-        "contradiction_resolution_rate": {"type": ["number", "null"]}
-      }
-    }
-  }
-}