causal-worlds 0.7.0__tar.gz

causal_worlds-0.7.0/.claude/settings.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "f=$(jq -r '.tool_input.file_path // empty'); case \"$f\" in *.env|*/.env|*.env.*) echo 'Refusing to edit secrets (.env) via Claude.' >&2; exit 2;; uv.lock|*/uv.lock) echo 'uv.lock is managed by uv — run `uv lock`, do not hand-edit.' >&2; exit 2;; esac"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "f=$(jq -r '.tool_input.file_path // empty'); case \"$f\" in *.py) ( cd \"$CLAUDE_PROJECT_DIR\" && uv run ruff format --force-exclude \"$f\" >/dev/null 2>&1; uv run ruff check --fix --force-exclude \"$f\" >/dev/null 2>&1 ) || true ;; esac"
+          }
+        ]
+      }
+    ]
+  }
+}

causal_worlds-0.7.0/.claude/skills/causal-worlds-conventions/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: causal-worlds-conventions
+description: >-
+  Engineering + research conventions for the causal-worlds Python package. Load and apply BEFORE writing,
+  refactoring, or reviewing ANY code in this repo (src/, tests/, cli, the package), and before adding a dependency
+  or a design pattern. Encodes Clean Code (Uncle Bob), SOLID-via-Protocols, the earned-patterns rule, the uv/ruff/
+  mypy/pytest/CI toolchain, src-layout, and the research discipline. Full detail in docs/engineering.md.
+---
+
+# causal-worlds conventions
+
+Apply these when touching this package. Full reference: [docs/engineering.md](../../../docs/engineering.md).
+Mix of engineering + research; CLI-first (typer); Gemini is an *independent* judge (≠ author model family).
+
+## Before you write code
+- **Clean Code (all of it), NOT Clean Architecture.** Small functions that do one thing at one level of
+  abstraction; intention-revealing names; **≤2 args** (bundle into a value object), **no flag args**, **no hidden
+  side effects**, **Command-Query Separation**. **Exceptions, not error codes; never return/pass `null`/`None`-as-
+  error.** No commented-out code (delete it). No magic numbers (named constants). Respect the Law of Demeter.
+- **SOLID via `typing.Protocol`.** The four variation points get Protocols + injected impls:
+  `Discoverer` (grader), `Judge` (LLM), `Substrate`/`World`, `Gate`. Depend on the Protocol; **never** let
+  `causal-learn`/`gies`/Gemini types leak past an **adapter**.
+- **Patterns are earned** (Strategy/Adapter for discoverer·judge·substrate; Pipeline for gates). **No speculative
+  abstraction.** If you add a pattern, name it and justify it in the PR.
+- **Separate construction from use:** build/inject dependencies at the edge (`cli`, factories); the core never
+  news-up collaborators.
+- **Structure:** `src/causal_worlds/<feature>/`; tests mirror; third-party imports only inside a feature's adapter.
+- **Docstrings:** Google style. **Type everything** (mypy strict).
+- **`from __future__ import annotations` only when needed** (TYPE_CHECKING-only annotation imports / forward refs);
+  **never** in typer CLI or pydantic modules (they read annotations at runtime). 3.13 needs no future import for
+  `X | None` / `tuple[...]`.
+
+## Before you commit — run the gate (it must be green)
+```bash
+make validate    # or:
+uv run ruff format --check . && uv run ruff check . && uv run mypy && uv run pytest
+```
+CI runs the same and **fails** on any violation; CI-green is the merge gate. Conventional Commits, atomic, **no
+`Co-Authored-By` trailer**. Push/PR only when asked.
+
+## Tests (F.I.R.S.T.)
+Fast · Independent · Repeatable · Self-validating · Timely. One concept per test. Prefer **Hypothesis property
+tests** for invariants (acyclicity, interventions break the right edges, seed→determinism) over fixed-output tests.
+
+## Research code (`spikes/`, `experiments/`)
+NOT shipped; lint/type/coverage-exempt. Held to "**is the finding real and honestly reported**," not production
+polish. **Measured, not asserted:** every claim has a runnable script that prints the evidence. Reproducible via
+**seed + `uv.lock` + pinned model ids** (e.g. `gemini-3.5-flash`). Report honest negatives. Use an **independent
+judge** for LLM-output quality (don't grade a model with itself). A proven spike **graduates** into `src/` rebuilt
+to the standards above — the spike is the proof, not the implementation.
+
+## Boundaries, LLM I/O & observability
+- **Data models per use-case:** frozen `@dataclass` in the pure core (valid-by-construction; parse-don't-validate);
+  **pydantic v2** only at boundaries (LLM output, CLI, config) — convert the pydantic boundary model into the
+  dataclass core IR at the edge.
+- **LLM structured output:** use **instructor** (pydantic models, **bounded** re-ask on validation failure, then
+  raise — never fabricate) behind the `Judge`/author adapter; Gemini is the independent judge.
+- **Observability from day 1:** **Langfuse (OTEL-based)** spans around LLM calls + each pipeline stage, behind a
+  thin tracing seam (optional at runtime). Three channels, never conflated: logs (shell), traces (Langfuse/OTel),
+  exceptions (control flow). The pure core stays silent.
+- **Errors & logging:** root `CausalWorldsError` + domain subclasses; **fail loud**; library logs to
+  `getLogger("causal_worlds")` + `NullHandler` (the app/CLI owns handlers); **never log secrets.**
+
+## Adding a dependency
+Justify it; pin via `uv`; wrap it behind a Protocol+adapter; prefer the standard library and reuse over new deps.

causal_worlds-0.7.0/.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.py]
+indent_style = space
+indent_size = 4
+max_line_length = 100
+
+[*.{json,yml,yaml,toml}]
+indent_style = space
+indent_size = 2
+
+[Makefile]
+indent_style = tab

causal_worlds-0.7.0/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.13"
+
+      - name: Sync (deps + dev tools)
+        run: uv sync
+
+      - name: Format check (ruff)
+        run: uv run ruff format --check .
+
+      - name: Lint (ruff)
+        run: uv run ruff check .
+
+      - name: Type check (mypy strict)
+        run: uv run mypy
+
+      - name: Tests + coverage floor
+        run: uv run pytest

causal_worlds-0.7.0/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to PyPI
+
+# Publishes on a GitHub Release via PyPI Trusted Publishing (OIDC) — no API token is stored anywhere.
+# One-time setup on PyPI is required first; see RELEASING.md.
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # required for trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Build sdist + wheel
+        run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

causal_worlds-0.7.0/.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+env/
+
+# Env / secrets
+.env
+.env.*
+!.env.example
+
+# Tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.ipynb_checkpoints/
+
+# OS / editor
+.DS_Store
+*.swp
+.idea/
+.vscode/
+
+# Generated worlds / scratch / logs
+/out/
+/scratch/
+*.log
+
+# coverage data
+.coverage

causal_worlds-0.7.0/.pre-commit-config.yaml

@@ -0,0 +1,19 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-merge-conflict
+      - id: check-added-large-files
+        args: ["--maxkb=1024"]
+      - id: detect-private-key
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.4
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+      - id: ruff-format

causal_worlds-0.7.0/CHANGELOG.md

@@ -0,0 +1,182 @@
+# Changelog
+
+All notable changes to causal-worlds are documented here. Format: [Keep a Changelog](https://keepachangelog.com/);
+this project follows [Semantic Versioning](https://semver.org/).
+
+## [0.7.0] — 2026-06-23
+
+**Temporal worlds (foundation).** Worlds can now carry *time* — lagged edges and autoregression —
+not just cross-sectional structure. (Time-series *grading* + baselines land next.)
+
+### Added
+- **Lagged IR** (`schema`): `Term.lag` (default 0). Only the contemporaneous (lag-0) subgraph must be
+  acyclic; lagged edges — including autoregressive self-loops — are valid (they read the past).
+- **Temporal substrate** (`sample`): when any lag is present, sampling becomes sequential over
+  timesteps with a burn-in (near-stationary); `do()` interventions hold across time. Cross-sectional
+  worlds keep the original vectorized i.i.d. path unchanged.
+- **`temporal_answer_key(spec)`** → lagged ground truth `(src, dst, lag)` incl. autoregression; the
+  summary `answer_key` now collapses lags and drops self-loops, so existing tooling is unaffected.
+- **Built-in `supply`** — a temporal world (autoregressive lead time + inventory, a hidden logistics
+  confounder), in a separate registry (`worlds.temporal_names()`) so the still-contemporaneous CLI
+  `grade`/`gate` don't mis-score it.
+
+[0.7.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.7.0
+
+## [0.6.1] — 2026-06-23
+
+### Docs
+- Rewrote the README around a getting-started flow (honest shipped-vs-roadmap; the gym/temporal/
+  counterfactual claims are now roadmap, not overclaims), with a lead example, the measured crossover
+  result, install/extras, concepts, and a roadmap.
+- Added a guided [`docs/getting-started.md`](docs/getting-started.md) and runnable
+  [`examples/`](examples/) (grade-your-discoverer, inspect-a-bundle — keyless — and author-a-world).
+
+[0.6.1]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.6.1
+
+## [0.6.0] — 2026-06-23
+
+**Use the benchmark.** Grading your own discoverer against a shipped world is now a first-class,
+typed, tested feature — the package's whole purpose.
+
+### Added
+- **`bench`**: `grade_spec(spec, discoverer)` and `grade_bundle(bundle_dir, discoverer)` → a `Report`
+  scoring any `Discoverer` against a world's declared answer-key (defaults to the reference grader).
+- **CLI `score`**: `causal-worlds score <bundle> [--discoverer module:Class]` grades a discoverer
+  (the reference by default, or any importable one) on a persisted world.
+- **Typed distribution**: ship a PEP 561 `py.typed` marker, plus PyPI metadata (classifiers,
+  keywords, project URLs).
+
+[0.6.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.6.0
+
+## [0.5.0] — 2026-06-23
+
+**Scale resolves the difficulty question.** A 36-world set across an easy→hard complexity spread gives
+the analyses real range — and structural difficulty turns out to predict the observational collapse.
+
+### Added
+- **Author complexity knob** (`author`): `ClaudeAuthor(..., complexity="easy"|"standard"|"hard")`
+  varies how many hidden confounders / regime sign-flips to inject, spreading structural difficulty.
+  Recorded per world in the manifest (`Provenance.complexity`).
+- **Scaled benchmark** (`benchmark/v0.5`): 35/36 admitted across complexity levels — mean structural
+  difficulty by level 0.0 / 1.4 / 3.0; reference-grader SHD 0.36 / 1.75 / 2.33.
+- **Parameterized evals**: the crossover and structural-difficulty harnesses take a benchmark dir;
+  results nest under `evals/*/v0.5/`.
+
+### Findings (powered, n=35)
+- **Crossover strengthens**: the interventional-CI grader keeps **confounded-kept = 0** (never reports
+  a hidden-confounded pair as causal) at SHD 1.47 / F1 0.91, while PC/FCI/GIES keep 8–17 and post SHD
+  2.7–6.7.
+- **Structural difficulty predicts observational error (corr +0.62)** where name-guessability does not
+  (+0.14) — the hardness is structural (confounders + sign-flips), resolving v0.4's open question and
+  turning difficulty into a usable instrument.
+
+[0.5.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.5.0
+
+## [0.4.0] — 2026-06-23
+
+**A structural-difficulty axis.** v0.3 showed name-guessability difficulty doesn't predict discovery
+error — the hardness is structural. This adds that axis and tests it honestly.
+
+### Added
+- **Structural difficulty** (`difficulty`): `structural_difficulty(spec)` scores discovery-hardness
+  from the structure — hidden confounders, confounded pairs, regime **sign-flips**, edge density — with
+  a headline trap-count `score`. Pure, deterministic, unit-tested.
+- Structural difficulty is now recorded in every admitted world's `manifest.json`.
+- **Re-analysis** (`evals/structural-difficulty`): reuses the crossover report (no new runs) to test
+  whether structural difficulty predicts the collapse.
+
+### Findings (honest)
+- At n=12 with a narrow difficulty range, **neither** name-guessability nor structural difficulty
+  cleanly predicts the *magnitude* of error (correlations −0.39…+0.14) — a statistical-power problem,
+  not a refutation. The v0.3 crossover (standard methods collapse, grader holds) is unaffected.
+  Resolving difficulty-predicts-error is deferred to the scaled set (v0.5).
+
+[0.4.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.4.0
+
+## [0.3.0] — 2026-06-23
+
+**The decisive experiment.** Proves the benchmark's central claim beyond the single `coffee` world:
+standard discovery collapses on our worlds where the reference interventional-CI grader holds.
+
+### Added
+- **Baseline suite** (`baselines`): PC, GES, FCI (`causal-learn`) and GIES (`gies`) wrapped behind the
+  `Discoverer` Protocol as adapters — lazy-imported (the `discover` extra), so the package imports and
+  CI run without them; graph-parsing logic is pure and unit-tested. `BaselineResult` carries directed
+  edges, bidirected (confounding) marks, and the skeleton for a fair cross-method comparison.
+- **Crossover eval** (`evals/baseline-crossover`): every benchmark world vs every method across seeds →
+  skeleton-SHD, directed F1, and *confounded-pair-kept-as-causal* (the trap). **Result (n=12): GO.**
+  Standard methods keep the hidden-confounded pair as causal in 7.3–10.0 of 12 worlds (PC/FCI/GIES) and
+  post 2–4× the skeleton error; the interventional grader stays at confounded-kept 0.33, SHD 1.31,
+  F1 0.91.
+- **Difficulty-vs-error analysis** — *honest negative*: name-guessability difficulty does not yet
+  predict discovery error (corr ~0.1); the hardness is structural (confounder+regime). Sharpens v0.4.
+- **Publication artifacts**: a technical blog post (`docs/blog-the-decisive-experiment.md`) and a
+  Framing-B paper skeleton (`paper/`).
+
+### Notes
+- `causal-learn`'s GES is numpy-2 incompatible (errors on every world) — reported, not hidden.
+
+[0.3.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.3.0
+
+## [0.2.0] — 2026-06-23
+
+Closes the generative loop: **natural language in, an admitted causal world out**, plus persistence
+and a shipped benchmark set. The LLM seams are real but isolated — the package still imports and CI
+still runs with no API key (the adapters are unit-tested against fakes).
+
+### Added
+- **NL author** (`author`): `ClaudeAuthor` turns a plain-language operation into a `WorldSpec` via
+  `instructor` (bounded re-ask), steered toward recoverable, anti-cliché worlds (a hidden confounder
+  + a regime sign-flip). Behind the `Author` Protocol; provider SDK lazy-imported.
+- **Independent judge** (`judge`): `GeminiJudge` guesses the structure from names/roles alone (the
+  anti-cliché signal) and scores faithfulness — a *different model family* than the author.
+- **T4 anti-cliché gate** (`gates`): with a judge + prose, rejects unfaithful or guess-from-priors
+  worlds and records a `difficulty` score (`1 - F1(judge_prior, truth)`).
+- **The loop** (`generate`): `generate` (author→gate→admit with feedback-driven re-author) and
+  `generate_many` (never-raising batch) → `AdmittedWorld`.
+- **Artifact persistence** (`artifact`): self-describing on-disk bundle (`spec.json` / `data.npz` /
+  `answer_key.json` / `manifest.json`) with full provenance (models, grader version, seed, grade).
+- **Boundary model** (`serde`): one pydantic `WorldSpecModel` — the author's output target and the
+  persisted JSON shape — converting to/from the frozen core IR.
+- **CLI**: `generate <prompt> <out>` and `benchmark <prompts_file> <out>`; author/judge resolved
+  through the DI container.
+- **Author-model bake-off** (`evals/author-model-bakeoff`): a reproducible, judged comparison that
+  picks the default author model with numbers, not assertion — shipped with the release.
+- **Benchmark set** (`benchmark/v0.2`): 12 authored, admitted worlds across distinct operations —
+  mean difficulty 0.28, faithfulness 1.00, reference-grader directed SHD 1.25 / F1 0.92.
+
+### Changed
+- Version is single-sourced from `_version.py` (hatchling dynamic). `.coverage` is no longer tracked.
+
+[0.2.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.2.0
+
+## [0.1.0] — 2026-06-22
+
+First release: **the deterministic benchmark engine**. Generate (programmatically-specified) fictional causal
+worlds with a ground-truth answer-key, sample them, grade a causal-discovery method, and score it — runnable as a
+library and a CLI, with no LLM or API key required.
+
+### Added
+- **Schema / IR** (`schema`): `WorldSpec` as the single source of truth (variables incl. hidden confounders +
+  generative `Mechanism`s with regime-switching); the `AnswerKey` (observed edges + confounded pairs) is *derived*,
+  never stored; `validate()` static gate.
+- **SCM substrate** (`sample`): a deterministic, seeded executable world; `do()` interventions (constant or
+  per-row array). The functional core.
+- **Reference grader** (`discover`): `InterventionalCiDiscoverer` — a spec-blind interventional-CI discoverer that
+  recovers the confounder + regime-flip trap (directed SHD 0) where standard observational/score-based methods
+  (PC, GES, GIES, FCI) fail.
+- **Scoring** (`evaluation`): directed/skeleton SHD, F1, and `confounded_reported` (flags a causal edge claimed for
+  a hidden-confounded pair); `Report`.
+- **Validity gates** (`gates`): `run_gates` → T1 (validity) · T2 (sample-sanity) · T3 (non-triviality vs a
+  per-world random-graph null). Admits only if all pass.
+- **Built-in worlds** (`worlds`): `coffee` (the confounder + regime-flip trap) and `ecommerce` (easy control).
+- **CLI** (`causal-worlds`): `version` · `worlds` · `grade <world>` · `gate <world>`.
+- **Wiring**: pydantic-settings `config`, a small DI `container`, and a no-op `Tracer` observability seam.
+- **Quality**: uv + ruff (`select=ALL`) + mypy `strict` + pytest with a coverage floor, enforced by CI.
+
+### Not yet (tracked as v0.2 issues)
+NL/`WorldBrief` → spec **author**, the independent **Gemini judge** + the T4 anti-cliché gate, conversational
+**elicitation**, the **Langfuse (OTEL)** tracing adapter, **artifact/manifest persistence**, grader **hardening**
+(FCI-with-interventions) + world-diversity sweep + knob calibration, and more built-in/temporal worlds.
+
+[0.1.0]: https://github.com/noumenal-ai/causal-worlds/releases/tag/v0.1.0

causal_worlds-0.7.0/CLAUDE.md

@@ -0,0 +1,34 @@
+# causal-worlds — AI working agreement
+
+Short, binding agreement for working in this repo. Keep it short; depth lives in
+[docs/engineering.md](docs/engineering.md), auto-applied via the skill
+[.claude/skills/causal-worlds-conventions/](.claude/skills/causal-worlds-conventions/SKILL.md).
+
+## What this is
+A public (MIT) Python package: **generate a fictional-but-coherent causal *operation* from a natural-language
+description** — an executable simulator, the time-series it emits, and a **declared ground-truth causal structure
+(the answer-key)** — for benchmarking causal-discovery agents. A **mix of engineering and research**. CLI-first
+(typer). Consumes **Gemini** as an *independent* LLM judge (must differ from any author model family). Concept &
+approach are **validated** (see [docs/validation.md](docs/validation.md)); this is the production build.
+
+## Non-negotiables (full detail in docs/engineering.md)
+- **Clean Code (Uncle Bob) — all of it, NOT Clean Architecture.** **SOLID** via Python `Protocol`s.
+- **Design patterns only at proven variation points** (Strategy/Adapter for discoverer·judge·substrate, Pipeline of
+  gates). **No abstraction for hypothetical futures.** Reuse over fork.
+- **Wrap every third-party lib** (`causal-learn`, `gies`, Gemini) **behind our own Protocol + adapter.**
+- **Tooling:** `uv` · `ruff` (`select=ALL` + curated ignores, line 100, `ruff format`) · `mypy strict` · `pytest`
+  with a coverage floor · pre-commit · **CI that fails**. `src`-layout, feature/capability modules. Google docstrings.
+- **Run the gate before committing:** `make validate` (or `uv run ruff format --check . && uv run ruff check . &&
+  uv run mypy && uv run pytest`). **CI green is a merge gate** — that's how we avoid re-leaving the same review comment.
+- **Measured, not asserted.** Every behavioral claim is backed by a runnable script/test.
+- **`spikes/` and `experiments/` are research, NOT shipped** (lint/type/coverage-exempt); reproducible via seed +
+  `uv.lock` + pinned model ids; honest negatives.
+- **Commits:** Conventional Commits, atomic, **no `Co-Authored-By` trailer**. Push/PR only on explicit request.
+
+## Map
+- [docs/scope.md](docs/scope.md) · [docs/hld.md](docs/hld.md) · [docs/lld.md](docs/lld.md) ·
+  [docs/validation.md](docs/validation.md) — product/design + the validation evidence.
+- [docs/architecture.md](docs/architecture.md) — the finalized system design (pipeline, seams, data contract, DI,
+  config, artifact, elicitation).
+- [docs/engineering.md](docs/engineering.md) — the binding code-quality + research guidelines.
+- `spikes/` — the validation spikes (research; the proof, not the implementation).

causal_worlds-0.7.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Noumenal AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

causal_worlds-0.7.0/Makefile

@@ -0,0 +1,26 @@
+.PHONY: install fmt lint type test check validate hooks
+
+install:  ## sync env + dev tools
+	uv sync
+
+fmt:  ## auto-format
+	uv run ruff format .
+
+lint:  ## lint (with autofix)
+	uv run ruff check --fix .
+
+type:  ## strict type-check
+	uv run mypy
+
+test:  ## tests + coverage floor
+	uv run pytest
+
+check:  ## the read-only gate (what CI runs, minus tests)
+	uv run ruff format --check .
+	uv run ruff check .
+	uv run mypy
+
+validate: check test  ## the full gate — run before every commit
+
+hooks:  ## install pre-commit hooks
+	uv run pre-commit install