Add report generation functionality and CI configuration

- Implement report generation with `ccw-report` command.
- Create report configuration and writing functions.
- Add tests for report generation and validation.
- Configure GitHub Actions for running tests on multiple Python versions.

Author: arcticoder

.github/workflows/pytest.yml

@@ -0,0 +1,30 @@
+name: pytest
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+
+      - name: Run tests
+        run: |
+          python -m pytest

docs/TASKS.md

@@ -0,0 +1,72 @@
+# Task list: next steps (cosmological constant workbench)
+
+As of Jan 10, 2026:
+- We have **not** solved the cosmological constant problem.
+- We *have* built a reproducible baseline + toy-mechanism/sweep framework.
+- The next steps are to (1) harden reproducibility, (2) encode falsifiable constraints, and (3) only then explore mechanisms.
+
+## Status legend
+
+- `[ ]` not started
+- `[-]` in progress
+- `[x]` complete
+
+---
+
+## Phase A — Reproducibility & auditability (researcher-friendly)
+
+1. [x] Add CI to run tests on GitHub Actions.
+   - Validate: clean install + `pytest` on at least Python 3.10–3.12.
+
+2. [x] Add a `ccw-report` command that produces a small, paper-friendly summary (JSON + Markdown):
+   - Baseline observed $(\rho_\Lambda, \Lambda)$
+   - Naive QFT estimates for multiple cutoffs
+   - Optional mechanism sweep summary (min/max, ratio vs observed)
+   - Validate: deterministic outputs with fixed inputs.
+
+3. [x] Add “known-number” regression tests against standard reference values:
+   - Example: $(H_0, \Omega_\Lambda)=(67.4,0.6889)$ should yield $\rho_\Lambda\sim 6\times 10^{-10}$ J/m³ and $\Lambda\sim 10^{-52}$ m⁻².
+   - Validate: tight enough to catch accidental unit regressions, loose enough to avoid false precision.
+
+---
+
+## Phase B — Constraints (what any proposal must satisfy)
+
+4. [ ] Add a minimal cosmology observable layer (flat FRW):
+   - Implement $H(z)$ for ΛCDM and for mechanisms providing $\rho_{DE}(z)$.
+   - Add distances: comoving distance and luminosity distance.
+   - Validate: sanity checks vs ΛCDM limits.
+
+5. [ ] Encode “must-not-break” constraints as unit tests (model-agnostic):
+   - $\rho_{DE}(z) > 0$ over a chosen redshift range (configurable)
+   - If a mechanism provides $w(z)$, ensure it stays within declared bounds
+   - Smoothness/continuity checks (no singularities for default params)
+
+---
+
+## Phase C — Mechanism deepening (only after A+B)
+
+6. [ ] Replace the CPL-only quintessence placeholder with an actual scalar-field evolution (toy but explicit):
+   - Choose 1–2 potentials (e.g., exponential, inverse power-law)
+   - Integrate background evolution (ODE) to get $\rho_{DE}(z)$ and $w(z)$
+   - Validate: reproduces ΛCDM-like behavior in an appropriate parameter limit.
+
+7. [ ] Add “sequestering-like” and “unimodular-like” *explicit* toy bookkeeping that yields a derived residual (not just a constant addend):
+   - Keep it transparent; no hidden tuning.
+
+---
+
+## Phase D — Integration + comparison
+
+8. [ ] Add an optional adapter that can *compare* against outputs from `lqg-cosmological-constant-predictor` (without making it a dependency).
+   - Validate: adapter is guarded and never breaks core install.
+
+---
+
+## Paper readiness gate
+
+We only start a paper draft if we can claim one of the following, with reproducible evidence:
+- A mechanism that **suppresses vacuum energy gravitation** without fine-tuning and produces at least one **distinctive, testable prediction**.
+- A **new constraint** (e.g., a bound on a parameter family) derived from null results / consistency requirements.
+
+Right now: **no novel discovery** suitable for a strong paper claim.

pyproject.toml

@@ -29,6 +29,7 @@ dev = ["pytest>=7.4"]
 [project.scripts]
 ccw-baseline = "ccw.cli:main"
 ccw-sweep = "ccw.cli_sweep:main"
+ccw-report = "ccw.cli_report:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

src/ccw/cli_report.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from .report import ReportConfig, generate_report, write_report
+
+
+def _parse_grid_json(grid_json: str | None) -> list[dict] | None:
+    if grid_json is None:
+        return None
+    obj = json.loads(grid_json)
+    if not isinstance(obj, list) or any(not isinstance(x, dict) for x in obj):
+        raise ValueError("--grid-json must be a JSON array of objects")
+    return obj
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="ccw report: baseline + optional mechanism summary")
+    p.add_argument("--h0", type=float, default=67.4)
+    p.add_argument("--omega-lambda", type=float, default=0.6889)
+    p.add_argument("--omega-m", type=float, default=0.3111)
+    p.add_argument("--omega-r", type=float, default=0.0)
+    p.add_argument("--omega-k", type=float, default=0.0)
+
+    p.add_argument("--cutoffs", type=str, default="electroweak,1TeV,planck", help="Comma-separated cutoff names")
+
+    p.add_argument("--mechanism", type=str, default=None, help="Optional: cpl | rvm | unimodular | sequestering")
+    p.add_argument("--grid-json", type=str, default=None, help="Optional JSON array of mechanism param dicts")
+    p.add_argument("--z", type=str, default="0,1,2", help="Comma-separated z values")
+
+    p.add_argument("--out-json", type=str, default="results/report.json")
+    p.add_argument("--out-md", type=str, default="results/report.md")
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = build_parser().parse_args(argv)
+
+    cutoffs = tuple(s.strip() for s in str(args.cutoffs).split(",") if s.strip())
+    z_values = tuple(float(s.strip()) for s in str(args.z).split(",") if s.strip())
+
+    cfg = ReportConfig(
+        h0_km_s_mpc=args.h0,
+        omega_lambda=args.omega_lambda,
+        omega_m=args.omega_m,
+        omega_r=args.omega_r,
+        omega_k=args.omega_k,
+        cutoffs=cutoffs,
+        mechanism=args.mechanism,
+        grid=_parse_grid_json(args.grid_json),
+        z_values=z_values,
+    )
+
+    report = generate_report(cfg)
+    write_report(report, Path(args.out_json), Path(args.out_md))
+    print(f"Wrote {args.out_json} and {args.out_md}")

src/ccw/report.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .baseline import BaselineInputs, BaselineOutputs, compute_baseline
+from .mechanisms import CosmologyBackground
+from .sweep import SweepRow, run_sweep
+
+
+@dataclass(frozen=True)
+class ReportConfig:
+    h0_km_s_mpc: float = 67.4
+    omega_lambda: float = 0.6889
+    omega_m: float = 0.3111
+    omega_r: float = 0.0
+    omega_k: float = 0.0
+    cutoffs: tuple[str, ...] = ("electroweak", "1TeV", "planck")
+
+    mechanism: Optional[str] = None
+    grid: Optional[List[Dict[str, Any]]] = None
+    z_values: tuple[float, ...] = (0.0, 1.0, 2.0)
+
+
+def _markdown_table(rows: List[Dict[str, Any]], headers: List[str]) -> str:
+    lines = ["| " + " | ".join(headers) + " |", "| " + " | ".join(["---"] * len(headers)) + " |"]
+    for r in rows:
+        lines.append("| " + " | ".join(str(r.get(h, "")) for h in headers) + " |")
+    return "\n".join(lines)
+
+
+def _stringify_params(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for r in rows:
+        r2 = dict(r)
+        if isinstance(r2.get("params"), dict):
+            r2["params"] = json.dumps(r2["params"], sort_keys=True)
+        out.append(r2)
+    return out
+
+
+def generate_report(cfg: ReportConfig) -> Dict[str, Any]:
+    bg = CosmologyBackground(
+        h0_km_s_mpc=cfg.h0_km_s_mpc,
+        omega_lambda=cfg.omega_lambda,
+        omega_m=cfg.omega_m,
+        omega_r=cfg.omega_r,
+        omega_k=cfg.omega_k,
+    )
+
+    baselines: List[Dict[str, Any]] = []
+    for c in cfg.cutoffs:
+        out: BaselineOutputs = compute_baseline(
+            BaselineInputs(
+                h0_km_s_mpc=cfg.h0_km_s_mpc,
+                omega_lambda=cfg.omega_lambda,
+                cutoff_name=c,
+            )
+        )
+        baselines.append({"cutoff": c, **out.naive_qft})
+
+    report: Dict[str, Any] = {
+        "inputs": asdict(cfg),
+        "observed": {
+            "h0_km_s_mpc": cfg.h0_km_s_mpc,
+            "omega_lambda": cfg.omega_lambda,
+            "rho_lambda0_j_m3": bg.rho_lambda0_j_m3,
+        },
+        "naive_qft": baselines,
+    }
+
+    if cfg.mechanism:
+        grid = cfg.grid if cfg.grid is not None else [{}]
+        rows: List[SweepRow] = run_sweep(mechanism=cfg.mechanism, grid=grid, z_values=cfg.z_values, bg=bg)
+        report["mechanism"] = {
+            "name": cfg.mechanism,
+            "z_values": list(cfg.z_values),
+            "grid": grid,
+            "rows": [asdict(r) for r in rows],
+        }
+
+    return report
+
+
+def write_report(report: Dict[str, Any], out_json: Path, out_md: Path) -> None:
+    out_json.parent.mkdir(parents=True, exist_ok=True)
+    out_md.parent.mkdir(parents=True, exist_ok=True)
+
+    out_json.write_text(json.dumps(report, indent=2, sort_keys=True))
+
+    md_lines: List[str] = []
+    md_lines.append("# CCW report")
+    md_lines.append("")
+    md_lines.append("## Observed")
+    md_lines.append(f"- H0: {report['observed']['h0_km_s_mpc']} km/s/Mpc")
+    md_lines.append(f"- ΩΛ: {report['observed']['omega_lambda']}")
+    md_lines.append(f"- ρΛ,0: {report['observed']['rho_lambda0_j_m3']:.3e} J/m³")
+    md_lines.append("")
+
+    md_lines.append("## Naive QFT cutoffs")
+    table_rows = [
+        {
+            "cutoff": r.get("cutoff"),
+            "E_cut (J)": f"{r.get('e_cutoff_joule', 0.0):.3e}",
+            "rho_naive (J/m³)": f"{r.get('rho_naive_j_m3', 0.0):.3e}",
+            "ratio": f"{r.get('rho_naive_over_rho_lambda', 0.0):.3e}",
+        }
+        for r in report.get("naive_qft", [])
+    ]
+    md_lines.append(_markdown_table(table_rows, ["cutoff", "E_cut (J)", "rho_naive (J/m³)", "ratio"]))
+    md_lines.append("")
+
+    if "mechanism" in report:
+        md_lines.append("## Mechanism")
+        md_lines.append(f"- name: {report['mechanism']['name']}")
+        md_lines.append("")
+        md_lines.append(
+            _markdown_table(
+                _stringify_params(report["mechanism"]["rows"]),
+                ["mechanism", "z", "rho_de_j_m3", "w_de", "params"],
+            )
+        )
+
+    out_md.write_text("\n".join(md_lines) + "\n")

tests/test_baseline.py

@@ -14,6 +14,18 @@ def test_observed_lambda_reasonable_magnitude() -> None:
     assert 1e-53 < lam < 1e-51
 
 
+def test_observed_lambda_regression_band_planck2018_like() -> None:
+    # A slightly tighter regression band to catch unit mistakes.
+    out = compute_baseline(BaselineInputs(h0_km_s_mpc=67.4, omega_lambda=0.6889, cutoff_name="electroweak"))
+    rho_lambda = out.observed["rho_lambda_j_m3"]
+    lam = out.observed["lambda_m_inv2"]
+
+    # Typical reference values are around:
+    # ρ_Λ ~ 6e-10 J/m^3 and Λ ~ 1.1e-52 m^-2.
+    assert 4e-10 < rho_lambda < 9e-10
+    assert 7e-53 < lam < 2e-52
+
+
 def test_naive_qft_cutoff_scaling_is_huge() -> None:
     out = compute_baseline(BaselineInputs(cutoff_name="planck"))
     ratio = out.naive_qft["rho_naive_over_rho_lambda"]

tests/test_report.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ccw.report import ReportConfig, generate_report, write_report
+
+
+def test_generate_report_has_expected_keys(tmp_path: Path) -> None:
+    cfg = ReportConfig(mechanism="cpl", cutoffs=("electroweak", "planck"), z_values=(0.0, 1.0))
+    report = generate_report(cfg)
+
+    assert "observed" in report
+    assert "naive_qft" in report
+    assert isinstance(report["naive_qft"], list)
+
+    out_json = tmp_path / "r.json"
+    out_md = tmp_path / "r.md"
+    write_report(report, out_json, out_md)
+
+    assert out_json.exists()
+    assert out_md.exists()
+    assert out_md.read_text().startswith("# CCW report")