From 0e19b3bdd529d4815b65afb6d70d93969bec8881 Mon Sep 17 00:00:00 2001 From: Daniel Ari Friedman <6911384+docxology@users.noreply.github.com> Date: Mon, 16 Nov 2026 20:59:18 -0800 Subject: [PATCH 1/2] fix: integrate guarded software against current GNN pin - Port only accepted original software improvements onto authoritative main2d159, preserving all seven upstream cutover paths and historical/scientific holds. - Bind qualified e04 bootstrap and exact v5.1.0/75c834/43b3 authority; keep authentic fresh installation, complete content and parser verdict requirements. --- .aii/README.md | 10 +- .aii/config.yaml | 10 +- .aii/docs/INTEGRATION.md | 6 +- .github/GNN.md | 53 +- .github/README.md | 8 +- .github/gnn/gnn_bootstrap.py | 1400 +++++++++++++++++ .github/gnn/v5.1.0-source-manifest.json | 1 + .github/scripts/gate.py | 97 +- .github/scripts/gnn_conformance.py | 167 +- .github/scripts/gnn_runtime.py | 114 ++ .github/scripts/tests/pdf_fixtures.py | 102 ++ .github/scripts/tests/test_gnn_conformance.py | 111 +- .../tests/test_gnn_prepared_exemplar.py | 92 ++ .github/scripts/tests/test_gnn_runtime.py | 623 ++++++++ .github/scripts/tests/test_pdf_batch.py | 218 +++ .github/scripts/tests/test_pdf_counts.py | 84 + AGENTS.md | 6 +- CONTRIBUTING.md | 5 +- Literature_Analysis/PDF_Scrape/README.md | 18 +- Literature_Analysis/PDF_Scrape/dataImport.py | 8 +- Literature_Analysis/PDF_Scrape/docResults.py | 15 +- Literature_Analysis/PDF_Scrape/manager.py | 47 +- .../PDF_Scrape/streamingExport.py | 19 +- Literature_Analysis/Pubmed_to_Coda/README.md | 28 +- Literature_Analysis/README.md | 8 +- README.md | 10 +- TO-DO.md | 10 +- docs/README.md | 12 +- docs/RUN_GUIDE.md | 53 +- docs/architecture.md | 16 +- docs/provenance.md | 2 +- docs/quickstart.md | 27 +- docs/workflows/publishing.md | 9 +- 33 files changed, 3122 insertions(+), 267 deletions(-) create mode 100644 .github/gnn/gnn_bootstrap.py create mode 100644 .github/gnn/v5.1.0-source-manifest.json create mode 100644 .github/scripts/gnn_runtime.py create mode 100644 .github/scripts/tests/pdf_fixtures.py create mode 100644 .github/scripts/tests/test_gnn_prepared_exemplar.py create mode 100644 .github/scripts/tests/test_gnn_runtime.py create mode 100644 .github/scripts/tests/test_pdf_batch.py create mode 100644 .github/scripts/tests/test_pdf_counts.py diff --git a/.aii/README.md b/.aii/README.md index 1674011..4c552cc 100644 --- a/.aii/README.md +++ b/.aii/README.md @@ -1,7 +1,7 @@ # .aii — InstituteOS sidecar -This folder is the committed [InstituteOS](https://github.com/ActiveInferenceInstitute/InstituteOS) -sidecar for **`ActiveInferenceInstitute/Knowledge-Engineering`**. It records curated institutional metadata that the GitHub +This folder is the committed InstituteOS sidecar for **`ActiveInferenceInstitute/Knowledge-Engineering`**. +It records curated institutional metadata that the GitHub API cannot provide — identity, category, maturity, ecosystem relations, key artifacts, provenance, and portable tasks — so InstituteOS can federate a unified view across Institute repositories without touching this project's own content. The schema is @@ -45,10 +45,10 @@ Institute repositories without touching this project's own content. The schema i | `notebooks` | `python .github/scripts/gate.py notebooks` | `.` | Check notebook JSON and absence of outputs. | | `checkpoints` | `python .github/scripts/gate.py checkpoints` | `.` | Reject tracked Jupyter checkpoints. | | `archive` | `python .github/scripts/gate.py archive` | `.` | Run the archive checks and Publishing digest checks. | -| `tests` | `python .github/scripts/gate.py tests` | `.` | Run dependency-free gate tests. | -| `gnn` | `python .github/scripts/gate.py gnn` | `.` | Check GNN conformance using .github/gnn-pin.json. | +| `tests` | `python .github/scripts/gate.py tests` | `.` | Run dependency-free gate contracts and controlled scraper regressions. | +| `gnn` | `python .github/scripts/gate.py gnn` | `.` | Verify the pinned parser's installed origin/content and sketch or exemplar conformance. | | `fast` | `python .github/scripts/gate.py fast` | `.` | Run archive checks and tests; no manuscript command exists. | -| `full` | `python .github/scripts/gate.py full` | `.` | Run fast and GNN conformance. | +| `full` | `python .github/scripts/gate.py full` | `.` | Run fast checks, then the same qualified GNN conformance. | | `timings` | `python .github/scripts/gate.py timings` | `.` | Measure offline arms and regenerate docs/gate-timings.md. | ## Links diff --git a/.aii/config.yaml b/.aii/config.yaml index 2eb52d7..c1abaa3 100644 --- a/.aii/config.yaml +++ b/.aii/config.yaml @@ -1,7 +1,7 @@ # AII sidecar — InstituteOS metadata. Schema: aii_platform.aii_sidecar meta: sidecar_version: 1.2.1 - updated: '2026-11-12' + updated: '2026-11-16' repo: name: Knowledge-Engineering slug: knowledge-engineering @@ -105,16 +105,16 @@ tasks: description: Run the archive checks and Publishing digest checks. tests: cmd: python .github/scripts/gate.py tests - description: Run dependency-free gate tests. + description: Run dependency-free gate contracts and controlled scraper regressions. gnn: cmd: python .github/scripts/gate.py gnn - description: Check GNN conformance using .github/gnn-pin.json. + description: Verify the pinned parser's installed origin/content and sketch or exemplar conformance. fast: cmd: python .github/scripts/gate.py fast description: Run archive checks and tests; no manuscript command exists. full: cmd: python .github/scripts/gate.py full - description: Run fast and GNN conformance. + description: Run fast checks, then the same qualified GNN conformance. timings: cmd: python .github/scripts/gate.py timings description: Measure offline arms and regenerate docs/gate-timings.md. @@ -124,6 +124,4 @@ docs: - docs/INTEGRATION.md - docs/README.md - docs/AGENTS.md -- ../docs/documentation-index.md -- ../docs/workflows/publishing.md schema: aii-sidecar/v1 diff --git a/.aii/docs/INTEGRATION.md b/.aii/docs/INTEGRATION.md index 2f2616d..c3aaafd 100644 --- a/.aii/docs/INTEGRATION.md +++ b/.aii/docs/INTEGRATION.md @@ -62,10 +62,10 @@ | `notebooks` | `python .github/scripts/gate.py notebooks` | `.` | Check notebook JSON and absence of outputs. | | `checkpoints` | `python .github/scripts/gate.py checkpoints` | `.` | Reject tracked Jupyter checkpoints. | | `archive` | `python .github/scripts/gate.py archive` | `.` | Run the archive checks and Publishing digest checks. | -| `tests` | `python .github/scripts/gate.py tests` | `.` | Run dependency-free gate tests. | -| `gnn` | `python .github/scripts/gate.py gnn` | `.` | Check GNN conformance using .github/gnn-pin.json. | +| `tests` | `python .github/scripts/gate.py tests` | `.` | Run dependency-free gate contracts and controlled scraper regressions. | +| `gnn` | `python .github/scripts/gate.py gnn` | `.` | Verify the pinned parser's installed origin/content and sketch or exemplar conformance. | | `fast` | `python .github/scripts/gate.py fast` | `.` | Run archive checks and tests; no manuscript command exists. | -| `full` | `python .github/scripts/gate.py full` | `.` | Run fast and GNN conformance. | +| `full` | `python .github/scripts/gate.py full` | `.` | Run fast checks, then the same qualified GNN conformance. | | `timings` | `python .github/scripts/gate.py timings` | `.` | Measure offline arms and regenerate docs/gate-timings.md. | ## Validation diff --git a/.github/GNN.md b/.github/GNN.md index fb15243..187ebc2 100644 --- a/.github/GNN.md +++ b/.github/GNN.md @@ -9,16 +9,24 @@ The conformance arm reads `.github/gnn-pin.json` (`gnn-importer-pin/v1`), which pins `ActiveInferenceInstitute/Generalized_Notation_Notation` at tag `v5.1.0`, revision `75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf` (recorded `2026-11-16`). +The checked bootstrap is the producer's [strict-origin artifact](https://raw.githubusercontent.com/ActiveInferenceInstitute/Generalized_Notation_Notation/5fb702ddd4b589b74baac86c86899bfaf4b9fffa/interop/gnn_bootstrap.py) +(SHA-256 `e04e9114c860a622f26ee8d323ac44b77c6484f5a29bdc7654fb298a9b58c3b2`). +That independently qualified resource revision is not the parser pin; the v5.1.0 +manifest and parser revision above remain unchanged. Installed origins require +an exact parsed GitHub authority and complete repository path, without query, +fragment, credentials, or explicit port. Bare `org/repo` remains pin syntax +only, not installed-origin evidence. Controlled rejection fixtures are not +real installed-origin success proof. + What it validates, in order: 1. The pin's schema, repository identity, tag shape, 40-hex revision, and recorded date. -2. The installed `gnn.__version__` against the tag without its `v`. -3. Every `*.gnn.md` sketch in the repository: full parse, syntax validation, and - type checking of the collected models. When the repository has no sketch it - downloads the pinned upstream `input/gnn_files/basics/static_perception.md` - exemplar at the pin's revision and validates that instead, and the JSON - receipt says `"source": "pinned-exemplar"`. +2. Independently frozen reviewed bootstrap and complete v5.1.0 manifest bytes, checked before any `gnn` import. Default installed mode additionally requires matching PEP610 Git origin and full package content, not just a version string. +3. Version, parser, syntax, and type-check imports/calls run within the canonical source-qualification guard, including final origin/content rechecks. A verified receipt can escape only after that guard exits successfully. +4. Sorted tracked `*.gnn.md` paths from Git inventory. Untracked/ignored sketches are excluded; inventory errors refuse. Only an empty tracked selection downloads the pinned `input/gnn_files/basics/static_perception.md` exemplar and reports `"source": "pinned-exemplar"`. + +`--gnn-source-root /exact/checkout/src/gnn` explicitly selects the narrower independently manifested source mode (`vcs_verified=false`). It is incompatible with `--install`; installed refusal never falls back to source. Each verdict requires a fresh process. `source` describes model provenance; `source-qualification` describes parser provenance, not scientific validity. The type checker's verdict is tri-state, not boolean: `validate_gnn_files` returns `True` when every file validated, `2` when one or more files had @@ -26,12 +34,27 @@ type/consistency problems **or when no GNN file was found**, and `False` on a hard failure. Only the literal `True` passes the arm. `2` is truthy, so a truthiness test would report an invalid model set as `"result": "verified"`; instead any other value exits non-zero and the refusal names the value the -checker returned. `.github/scripts/tests/test_gnn_conformance.py` pins all four -outcomes (`True`, `2`, `False`, `None`/`0`) without needing the parser -installed. - -The arm needs network access and a Python version the pinned release supports -(`>=3.11,<3.15`); CI uses 3.12. The local recipe, including a throwaway virtual -environment, is in [`RUN_GUIDE.md`](../docs/RUN_GUIDE.md#running-the-gnn-arm-locally). -A green result is a pipeline and pin conformance baseline, not a claim that this -repository contains a model. +checker returned. Controlled fixtures also reject integer `1`, corrupted authority/content, cached or foreign modules, missing installed origin, and source drift across verdict execution. They do not establish installed-runtime provenance. + +The pinned release supports Python `>=3.11,<3.15`; CI uses 3.12. Explicit installation and exemplar acquisition need separate authority. Source mode alone does not prepare the exemplar; without the explicit prepared selector below, an empty tracked set still needs the pinned HTTPS download. See the [run guide](../docs/RUN_GUIDE.md#running-the-gnn-arm-locally). + +For separately authorized offline qualification, prepare the authentic complete +pinned Git project, its locked declared dependencies, and an installer-generated +immutable VCS wheel cache in task-owned storage. Preserve the installer's real +origin metadata; a source-only export, copied installed package, or rewritten +`direct_url.json` is not a fresh installation. Bind the prepared artifacts in the +native execution inputs, use a fresh supported target environment, and keep +`gnn --install` as the actual gate command. Pip's ordinary offline/cache settings +may consume those exact resources; setup itself is not a conformance verdict. + +`GNN_PREPARED_EXEMPLAR=/prepared/static_perception.md` explicitly separates +acquisition of the unchanged upstream exemplar from the offline verdict. Its +bytes must match SHA-256 +`1ddd0fbde8155e2083d586a368503278373f26f6aae11dd4a2b4adfdf5ea7b8c` +at the pinned revision. Missing, empty, symlinked, or changed prepared inputs +refuse without a network fallback. With no selector, the same pinned HTTPS +download remains available and must match that digest. Tracked-model selection, +fresh installed-origin/full-content admission, parse/syntax/literal-`True` type +checks, and the `pinned-exemplar` receipt semantics are unchanged. + +A green parser result is not a model of this archive, dependency-lock qualification, or scientific evidence. diff --git a/.github/README.md b/.github/README.md index 5821e3e..3622bda 100644 --- a/.github/README.md +++ b/.github/README.md @@ -11,10 +11,10 @@ - [`scripts/archive_checks.py`](scripts/archive_checks.py) — the dependency-free archive checks (relative Markdown links, tracked-Python compilation, notebook JSON and committed outputs, tracked Jupyter checkpoints). -- [`scripts/gnn_conformance.py`](scripts/gnn_conformance.py) — pin validation, - pinned-parser install, and sketch/exemplar conformance. -- [`scripts/tests/test_gate.py`](scripts/tests/test_gate.py) — the gate's own - tests, run by the `tests` arm. +- [`scripts/gnn_conformance.py`](scripts/gnn_conformance.py) — pin validation, guarded parser execution, and tracked-sketch/exemplar conformance. +- [`scripts/gnn_runtime.py`](scripts/gnn_runtime.py) — pre-import reviewed-bootstrap/full-manifest admission and explicit installed/source lifetime. +- [`gnn/gnn_bootstrap.py`](gnn/gnn_bootstrap.py), [`gnn/v5.1.0-source-manifest.json`](gnn/v5.1.0-source-manifest.json) — exact independently approved producer artifacts, not a local validator fork. +- [`scripts/tests/`](scripts/tests/) — dependency-free gate contracts and controlled CSV/text scraper regressions. PDF fixtures replace extraction; controlled parser fixtures do not qualify installed provenance. - [`dependabot.yml`](dependabot.yml) — dependency update configuration. - [`gnn-pin.json`](gnn-pin.json) — the `gnn-importer-pin/v1` pin used by the conformance arm: repository, tag `v5.1.0`, revision diff --git a/.github/gnn/gnn_bootstrap.py b/.github/gnn/gnn_bootstrap.py new file mode 100644 index 0000000..22cb54c --- /dev/null +++ b/.github/gnn/gnn_bootstrap.py @@ -0,0 +1,1400 @@ +"""Downstream importer conformance: read a repository's GNN pin, validate its specs. + +A repository that applies Generalized Notation Notation records which upstream +revision it consumes in a pin file, and keeps one or more ``*.gnn.md`` +specifications that must parse under that revision. Every importer used to +carry its own script for this; the shapes drifted (``commit`` vs ``revision``, +``tag`` vs ``release``, four different file locations), so nothing could check +the estate as a whole. + +This stdlib-only module is also the pre-import bootstrap: execute this exact, +reviewed file with the target interpreter's ``-I`` flag, independently of the +GNN revision that interpreter consumes. A separately trusted source manifest +binds that revision's complete package content, including its importer and +verdict modules. Consumer pins and their recorded parser hashes are not changed. + +Canonical pin (``schema``: :data:`PIN_SCHEMA`):: + + { + "schema": "gnn-importer-pin/v1", + "repository": "ActiveInferenceInstitute/Generalized_Notation_Notation", + "tag": "v5.0.3", + "commit": "8f293d9ba810e6eda5c09842d9c7ed9ffa5f92c1", + "recorded": "2026-11-12", + "spec_files": ["models/gridworld_3x3.gnn.md"] + } + +Earlier shapes are read, never rewritten: ``revision`` is accepted for +``commit``, ``release`` for ``tag``, ``repository`` may be an ``org/name`` or a +URL, and ``spec_files`` is optional (absent means "discover ``*.gnn.md``"). + +Two shapes need a hint from the caller: + +* **A two-party custody pin.** ``fep_formal`` records ``fep_lean`` and ``gnn`` + as separate sub-objects of ``specs/gnn-bridge-w2-source-custody/source-pin.json`` + with per-file SHA-256 owners instead of a release tag. ``--pin`` names the + file and ``--pin-party gnn`` names the sub-record; the reader normalizes it + to the same :class:`ImporterPin`. +* **A differently directed pair pin.** The upstream GNN checkout pins its + downstreams in ``.github/gnn-pair.json``; discovery would read that as a GNN + pin and report a fork. ``--pin`` is how a caller with a non-conventional pin + states which file it means. + +``--require-pointer`` additionally checks ``.github/GNN.md``: the pointer must +name the pin file, the pinned revision and — when given — the conformance +workflow and job key. It is opt-in because a repository adopts it deliberately, +in the same change that writes the pointer. + +Usage (the reviewed bootstrap and consumed parser need not be the same release):: + + python -I /reviewed/gnn/importers.py source-manifest \ + --package-root /qualified/artifact/gnn --commit FULL_PINNED_COMMIT + python -I /reviewed/gnn/importers.py check --repo /consumer \ + --source-manifest /trusted/source.json --source-manifest-sha256 TRUSTED_SHA256 + python -m gnn.importers check --repo . --no-validate --json + +The manifest producer's source identity and this bootstrap file's own bytes +remain independently owner-qualified inputs. Do not derive the trusted manifest +hash from the installation being checked. ``-m`` imports GNN too early for +pre-import admission; use the standalone file for a real verdict. Metadata-only +inspection remains available without a manifest and never claims qualification. +""" + +from __future__ import annotations + +import argparse +import hashlib +import importlib.abc +import importlib.machinery +import importlib.metadata +import importlib.util +import json +import os +import re +from urllib.parse import urlsplit +import stat +import sys +from collections.abc import Iterator, Mapping +from contextlib import contextmanager +from dataclasses import dataclass, field +from pathlib import Path, PurePosixPath +from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union + +__all__ = [ + "IMPORTER_VARIABLES_SCHEMA", + "PIN_SCHEMA", + "POINTER_PATH", + "ImporterPin", + "PinError", + "SOURCE_MANIFEST_SCHEMA", + "SOURCE_QUALIFICATION_SCHEMA", + "SourceQualificationError", + "build_source_manifest", + "check_importer", + "check_pointer", + "discover_specs", + "find_pin", + "importer_variables", + "main", + "normalize_repository", + "qualified_source", + "qualify_source", + "read_pin", + "source_manifest_bytes", +] + +#: Schema identifier a canonical importer pin declares. +PIN_SCHEMA = "gnn-importer-pin/v1" +SOURCE_MANIFEST_SCHEMA = "gnn-importer-source/v1" +SOURCE_QUALIFICATION_SCHEMA = "gnn-importer-source-qualification/v1" +_DISTRIBUTION_NAME = "generalized-notation-notation" +_PACKAGE_PREFIX = "src/gnn/" + +#: The upstream a pin is expected to name. A pin that names a fork is a real +#: finding: the consumer is tracking code this distribution does not publish. +UPSTREAM_REPOSITORY = "ActiveInferenceInstitute/Generalized_Notation_Notation" + +#: Pin locations in precedence order. The first file that exists wins; the +#: order is canonical-location-first so a repository that adopts +#: ``.github/gnn-pin.json`` keeps one reader even if an older file remains. +PIN_CANDIDATES: Tuple[str, ...] = ( + ".github/gnn-pin.json", + "specs/gnn-pin.json", + "gnn/upstream.json", + "models/gnn-pin.json", + "models/gnn.pin.json", + "NHIM/gnn-pin.json", + ".github/gnn-pair.json", +) + +#: The human-readable pointer every importer publishes beside its pin. It +#: records what the conformance job parses, so a reader can reach the pin, the +#: revision and the job from one file instead of reconstructing them from a +#: workflow definition. +POINTER_PATH = ".github/GNN.md" + +#: Directories never searched for specifications. +SKIP_DIRS = frozenset( + { + ".git", + ".hg", + ".svn", + ".venv", + "venv", + "env", + "node_modules", + "__pycache__", + ".mypy_cache", + ".ruff_cache", + ".pytest_cache", + "dist", + "build", + "site-packages", + "output", + "cache", + "tmp", + } +) + + +class PinError(ValueError): + """A pin file exists but does not record a usable upstream revision.""" + + +class SourceQualificationError(ValueError): + """Source admission failed before a qualified verdict could be issued.""" + + def __init__(self, code: str, message: str) -> None: + super().__init__(message) + self.code = code + + +@dataclass(frozen=True) +class ImporterPin: + """A normalized importer pin. + + ``commit`` is the only required identity: a tag can move, a commit cannot. + ``schema`` and ``recorded`` are ``None`` for pins that predate the + canonical schema; :func:`check_importer` reports that as a finding rather + than failing, so an importer can adopt the schema deliberately. + """ + + path: Path + commit: str + tag: Optional[str] = None + repository: Optional[str] = None + schema: Optional[str] = None + recorded: Optional[str] = None + spec_files: Tuple[str, ...] = () + #: Sub-record this pin was read from, for a two-party custody pin that + #: nests one object per repository (``fep_formal`` records ``fep_lean`` and + #: ``gnn`` in one file). ``None`` for the ordinary flat pin. + party: Optional[str] = None + raw: Dict[str, Any] = field(default_factory=dict) + + +def _normalize_repository(value: Any, *, allow_bare: bool) -> Optional[str]: + """Parse an exact repository identity; installed origins require a real URL.""" + if not isinstance(value, str) or any(ord(char) < 32 or ord(char) == 127 for char in value): + return None + text = value.strip() if allow_bare else value + if not text or any(char.isspace() for char in text) or "\\" in text: + return None + if "?" in text or "#" in text: + return None + if text.startswith("git@"): + authority, separator, path = text.partition(":") + if not separator or authority[4:].lower() != "github.com": + return None + elif "://" in text or text.startswith("//"): + try: + parsed = urlsplit(text) + if parsed.hostname != "github.com" or ":" in parsed.netloc: + return None + if parsed.scheme in ("http", "https"): + if parsed.username is not None or parsed.password is not None: + return None + elif parsed.scheme == "ssh": + if parsed.username != "git" or parsed.password is not None: + return None + else: + return None + if not parsed.path.startswith("/"): + return None + path = parsed.path[1:] + except ValueError: + return None + elif allow_bare: + path = text + else: + return None + if path.endswith("/"): + path = path[:-1] + if path.endswith(".git"): + path = path[:-4] + if re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", path) is None: + return None + if any(part in (".", "..") for part in path.split("/")): + return None + return path + + +def normalize_repository(value: Any) -> Optional[str]: + """Normalize a bare pin identity or a structurally valid GitHub URL.""" + return _normalize_repository(value, allow_bare=True) + + +def find_pin(repo_root: Path) -> Optional[Path]: + """Return the first pin file that exists under ``repo_root``.""" + for relative in PIN_CANDIDATES: + candidate = repo_root / relative + if candidate.is_file(): + return candidate + return None + + +def _json_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]: + result: dict[str, Any] = {} + for key, value in pairs: + if key in result: + raise ValueError(f"duplicate JSON member {key!r}") + result[key] = value + return result + + +def _relative_source_name(value: Any) -> str: + """Admit a canonical, portable relative filename, never an escape.""" + if ( + not isinstance(value, str) + or not value + or "\\" in value + or ":" in value + or "\0" in value + ): + raise PinError(f"unsafe relative source path {value!r}") + path = PurePosixPath(value) + if ( + path.is_absolute() + or any(part in (".", "..") for part in value.split("/")) + or str(path) != value + ): + raise PinError(f"unsafe relative source path {value!r}") + return value + + +def _pin_record(pin: ImporterPin) -> Dict[str, Any]: + source = pin.raw.get(pin.party) if pin.party is not None else pin.raw + if not isinstance(source, dict): + raise PinError("pin sub-record is not an object") + return source + + +def read_pin(path: Path, *, party: Optional[str] = None) -> ImporterPin: + """Read and normalize one pin file. + + Args: + path: The pin file. + party: Sub-record to read, for a custody pin that nests one object per + repository. ``None`` reads the file as a flat pin. + + Raises: + PinError: the file is not JSON, records no commit/revision, or the + requested ``party`` sub-record is absent. + """ + try: + payload = json.loads( + path.read_text(encoding="utf-8"), object_pairs_hook=_json_object + ) + except (OSError, UnicodeError, ValueError) as exc: + raise PinError(f"{path}: not readable JSON ({exc})") from exc + if not isinstance(payload, dict): + raise PinError(f"{path}: pin must be a JSON object") + + source = payload + if party is not None: + nested = payload.get(party) + if not isinstance(nested, dict): + raise PinError( + f"{path}: records no {party!r} sub-record " + f"(file names {sorted(payload)})" + ) + source = nested + + commit = source.get("commit") or source.get("revision") + if not isinstance(commit, str) or not commit.strip(): + raise PinError(f"{path}: pin records no commit/revision") + if source.get("commit") and source.get("revision"): + if source["commit"] != source["revision"]: + raise PinError(f"{path}: commit and revision disagree") + tag = source.get("tag") or source.get("release") + if source.get("tag") and source.get("release"): + if source["tag"] != source["release"]: + raise PinError(f"{path}: tag and release disagree") + repository = normalize_repository(source.get("repository")) + if source.get("repository") is not None and repository is None: + raise PinError(f"{path}: repository is not a usable repository identity") + spec_files = source.get("spec_files", []) + if isinstance(spec_files, str): + spec_files = [spec_files] + if not isinstance(spec_files, list): + raise PinError(f"{path}: spec_files must be a string or list of strings") + spec_files = [_relative_source_name(item) for item in spec_files] + if len(set(spec_files)) != len(spec_files): + raise PinError(f"{path}: spec_files contains duplicate paths") + parser_files = source.get("parser_files", {}) + if not isinstance(parser_files, dict): + raise PinError(f"{path}: parser_files must be an object of SHA-256 hashes") + for relative, digest in parser_files.items(): + _relative_source_name(relative) + if not relative.startswith((_PACKAGE_PREFIX, "gnn/")): + raise PinError(f"{path}: parser file is outside the GNN package: {relative}") + if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None: + raise PinError(f"{path}: invalid parser SHA-256 for {relative}") + return ImporterPin( + path=path, + commit=commit.strip(), + tag=tag.strip() if isinstance(tag, str) and tag.strip() else None, + repository=repository, + schema=source.get("schema") if isinstance(source.get("schema"), str) else None, + recorded=source.get("recorded") + if isinstance(source.get("recorded"), str) + else None, + spec_files=tuple(spec_files), + party=party, + raw=payload, + ) + + +def _contained_spec(repo_root: Path, relative: str) -> Path: + relative = _relative_source_name(relative) + candidate = repo_root / relative + current = repo_root + for part in PurePosixPath(relative).parts: + current = current / part + if current.is_symlink(): + raise PinError(f"specification path contains a symlink: {relative}") + try: + candidate.resolve().relative_to(repo_root.resolve()) + except (OSError, RuntimeError, ValueError) as exc: + raise PinError(f"specification path escapes its repository: {relative}") from exc + return candidate + + +def _walk_specs(repo_root: Path) -> Iterable[Path]: + def fail(error: OSError) -> None: + raise PinError(f"cannot discover specifications: {error}") from error + + for directory, directories, filenames in os.walk(repo_root, onerror=fail): + directories[:] = sorted( + name + for name in directories + if name not in SKIP_DIRS and not (Path(directory) / name).is_symlink() + ) + for name in sorted(filenames): + if name.endswith(".gnn.md"): + path = Path(directory) / name + yield _contained_spec(repo_root, path.relative_to(repo_root).as_posix()) + + +def discover_specs(repo_root: Path, pin: Optional[ImporterPin] = None) -> List[Path]: + """Admit declared or discovered repository-local specification paths. + + Explicit ``spec_files: []`` is authoritative; only an absent declaration + enables discovery. Symlinks and noncanonical/outside paths raise PinError + before any specification content is read. + """ + repo_root = repo_root.resolve() + if pin is not None and (pin.spec_files or "spec_files" in _pin_record(pin)): + return [_contained_spec(repo_root, relative) for relative in pin.spec_files] + return sorted(_walk_specs(repo_root)) + + +def _source_error(code: str, message: str) -> SourceQualificationError: + return SourceQualificationError(code, message) + + +def _package_files(package_root: Path) -> Dict[str, str]: + """Hash every regular package file except unused Python bytecode caches.""" + if package_root.is_symlink() or not package_root.is_dir(): + raise _source_error("source-root-invalid", "GNN package root is not an ordinary directory") + files: Dict[str, str] = {} + + def fail(error: OSError) -> None: + raise _source_error("source-unreadable", f"cannot inventory GNN source: {error}") from error + + try: + for directory, directories, filenames in os.walk(package_root, onerror=fail): + directories[:] = sorted(name for name in directories if name != "__pycache__") + for name in directories: + if (Path(directory) / name).is_symlink(): + raise _source_error("source-path-unsafe", "GNN source contains a redirected directory") + for name in sorted(filenames): + if name.endswith((".pyc", ".pyo")): + continue + path = Path(directory) / name + if not stat.S_ISREG(path.lstat().st_mode): + raise _source_error("source-path-unsafe", "GNN source contains a nonregular file") + relative = path.relative_to(package_root).as_posix() + _relative_source_name(relative) + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1 << 20), b""): + digest.update(block) + files[_PACKAGE_PREFIX + relative] = digest.hexdigest() + except (OSError, PinError) as exc: + raise _source_error("source-unreadable", f"cannot read GNN source: {exc}") from exc + return dict(sorted(files.items())) + + +def _module_source(module: str, files: Mapping[str, str]) -> Optional[str]: + if not isinstance(module, str) or re.fullmatch(r"gnn(?:\.[A-Za-z_][A-Za-z_0-9]*)*", module) is None: + return None + stem = "src/" + module.replace(".", "/") + for relative in (stem + "/__init__.py", stem + ".py"): + if relative in files: + return relative + return None + + +def _manifest_record(payload: Any) -> Dict[str, Any]: + fields = {"schema", "repository", "commit", "files", "verdict_modules"} + if not isinstance(payload, dict) or set(payload) != fields: + raise _source_error("source-manifest-invalid", "source manifest must contain exactly schema/repository/commit/files/verdict_modules") + if payload["schema"] != SOURCE_MANIFEST_SCHEMA: + raise _source_error("source-manifest-invalid", "unsupported source manifest schema") + if payload["repository"] != UPSTREAM_REPOSITORY: + raise _source_error("source-manifest-invalid", "source manifest names a different producer") + if not isinstance(payload["commit"], str) or re.fullmatch(r"[0-9a-f]{40}", payload["commit"]) is None: + raise _source_error("source-manifest-invalid", "source manifest requires a full lowercase commit") + files = payload["files"] + if not isinstance(files, dict) or not files: + raise _source_error("source-manifest-invalid", "source manifest requires a complete nonempty package inventory") + try: + for relative, digest in files.items(): + _relative_source_name(relative) + if not relative.startswith(_PACKAGE_PREFIX): + raise PinError("source manifest file is outside src/gnn/") + parts = PurePosixPath(relative).parts + if "__pycache__" in parts or relative.endswith((".pyc", ".pyo")): + raise PinError("bytecode caches are not source manifest inputs") + if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None: + raise PinError(f"invalid source SHA-256 for {relative}") + except PinError as exc: + raise _source_error("source-manifest-invalid", str(exc)) from exc + modules = payload["verdict_modules"] + if ( + not isinstance(modules, list) + or not modules + or not all(isinstance(module, str) for module in modules) + or len(set(modules)) != len(modules) + ): + raise _source_error("source-manifest-invalid", "verdict_modules must be a nonempty unique string list") + required = {"gnn", "gnn.parsers.basic"} + if _PACKAGE_PREFIX + "importers.py" in files: + required.add("gnn.importers") + if not required.issubset(modules) or any(_module_source(module, files) is None for module in modules): + raise _source_error("source-manifest-invalid", "manifest omits the package/importer/verdict source coverage") + return payload + + +def build_source_manifest( + package_root: Path, + *, + commit: str, + verdict_modules: Sequence[str] = ("gnn.parsers.basic",), +) -> Dict[str, Any]: + """Inventory an independently trusted, exact-revision GNN package. + + This producer does not discover or authenticate a Git revision. The owner + supplies the already-qualified commit and package artifact. Freeze the + resulting bytes/hash independently of the target being checked; generating + a manifest from that target itself does not establish trusted provenance. + All package files, not only a legacy pin's five parser files, are covered. + """ + files = _package_files(Path(package_root)) + modules = set(verdict_modules) | {"gnn", "gnn.parsers.basic"} + if _PACKAGE_PREFIX + "importers.py" in files: + modules.add("gnn.importers") + return _manifest_record( + { + "schema": SOURCE_MANIFEST_SCHEMA, + "repository": UPSTREAM_REPOSITORY, + "commit": commit, + "files": files, + "verdict_modules": sorted(modules), + } + ) + + +def source_manifest_bytes(manifest: Mapping[str, Any]) -> bytes: + """Return canonical ASCII JSON: sorted keys, compact separators, final LF.""" + payload = _manifest_record(dict(manifest)) + return ( + json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True, allow_nan=False) + + "\n" + ).encode("ascii") + + +def _source_origin( + pin: ImporterPin, package_root: Path, origin_mode: str +) -> Dict[str, Any]: + if origin_mode == "source": + return { + "kind": "explicit-source", + "package_root": str(package_root), + "identity_basis": "independently-trusted-manifest", + "vcs_verified": False, + } + if origin_mode != "installed": + raise _source_error("source-origin-invalid", "origin_mode must be installed or source") + try: + distribution = importlib.metadata.distribution(_DISTRIBUTION_NAME) + if Path(distribution.locate_file("gnn/__init__.py")).resolve().parent != package_root: + raise _source_error("source-origin-mismatch", "selected gnn package is not the named installed distribution") + text = distribution.read_text("direct_url.json") + if text is None: + raise _source_error("source-origin-unavailable", "installed distribution has no exact VCS direct_url.json") + origin = json.loads(text, object_pairs_hook=_json_object) + if not isinstance(origin, dict): + raise ValueError("direct_url.json is not an object") + vcs = origin.get("vcs_info") + if not isinstance(vcs, dict) or vcs.get("vcs") != "git": + raise _source_error("source-origin-unavailable", "installed origin does not record an exact Git revision") + if vcs.get("commit_id") != pin.commit: + raise _source_error("source-origin-mismatch", "installed origin commit differs from the consumer pin") + if _normalize_repository(origin.get("url"), allow_bare=False) != UPSTREAM_REPOSITORY: + raise _source_error("source-origin-mismatch", "installed origin repository differs from the GNN producer") + return { + "kind": "installed-vcs", + "distribution": _DISTRIBUTION_NAME, + "version": distribution.version, + "package_root": str(package_root), + "repository": UPSTREAM_REPOSITORY, + "commit": pin.commit, + "direct_url_sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(), + "vcs_verified": True, + } + except (importlib.metadata.PackageNotFoundError, OSError, UnicodeError, ValueError) as exc: + if isinstance(exc, SourceQualificationError): + raise + raise _source_error("source-origin-unavailable", f"installed origin is unavailable: {type(exc).__name__}") from exc + + +@dataclass +class _AdmittedSource: + pin: ImporterPin + package_root: Path + files: Dict[str, str] + receipt: Dict[str, Any] + origin_mode: str + + def read(self, path: Path) -> bytes: + try: + relative = _PACKAGE_PREFIX + path.relative_to(self.package_root).as_posix() + expected = self.files[relative] + if not stat.S_ISREG(path.lstat().st_mode): + raise OSError("source is not a regular file") + data = path.read_bytes() + except (OSError, KeyError, ValueError) as exc: + raise _source_error("source-path-unsafe", "import requested undeclared or redirected GNN content") from exc + if hashlib.sha256(data).hexdigest() != expected: + raise _source_error("source-content-mismatch", f"GNN source changed before use: {relative}") + return data + + def verify_unchanged(self) -> None: + if _package_files(self.package_root) != self.files: + raise _source_error("source-content-mismatch", "GNN package inventory changed during qualification") + if _source_origin(self.pin, self.package_root, self.origin_mode) != self.receipt["origin"]: + raise _source_error("source-origin-mismatch", "GNN origin changed during qualification") + + +_ACTIVE_SOURCE: Optional[_AdmittedSource] = None + + +def _admit_source( + pin: ImporterPin, + *, + manifest: bytes, + manifest_sha256: str, + package_root: Optional[Path], + origin_mode: str, +) -> _AdmittedSource: + if any(name == "gnn" or name.startswith("gnn.") for name in sys.modules): + raise _source_error("source-already-imported", "qualification requires a fresh process before importing any gnn module") + if ( + not isinstance(manifest, bytes) + or not isinstance(manifest_sha256, str) + or re.fullmatch(r"[0-9a-f]{64}", manifest_sha256) is None + or hashlib.sha256(manifest).hexdigest() != manifest_sha256 + ): + raise _source_error("source-manifest-hash-mismatch", "manifest bytes do not match their independently trusted SHA-256") + try: + payload = _manifest_record( + json.loads(manifest.decode("utf-8"), object_pairs_hook=_json_object) + ) + except (UnicodeError, ValueError) as exc: + if isinstance(exc, SourceQualificationError): + raise + raise _source_error("source-manifest-invalid", f"source manifest is not valid JSON: {exc}") from exc + if payload["commit"] != pin.commit or pin.repository not in (None, UPSTREAM_REPOSITORY): + raise _source_error("source-pin-mismatch", "source manifest does not bind the consumer's exact repository/commit") + if origin_mode == "source" and package_root is None: + raise _source_error("source-root-invalid", "source mode requires an explicit package_root") + try: + spec = importlib.util.find_spec("gnn") + if spec is None or spec.origin is None or spec.submodule_search_locations is None: + raise _source_error("source-origin-unavailable", "target interpreter cannot locate an ordinary gnn package") + selected = Path(spec.origin).resolve().parent + if package_root is not None and Path(package_root).resolve() != selected: + raise _source_error("source-origin-mismatch", "import resolution selects a different GNN package root") + files = _package_files(selected) + if files != payload["files"]: + missing = sorted(set(payload["files"]) - set(files)) + extra = sorted(set(files) - set(payload["files"])) + changed = sorted(path for path in files.keys() & payload["files"].keys() if files[path] != payload["files"][path]) + raise _source_error( + "source-content-mismatch", + f"GNN package differs from trusted inventory (missing={missing}, extra={extra}, changed={changed})", + ) + parser_files = _pin_record(pin).get("parser_files", {}) + for relative, expected in parser_files.items(): + canonical = relative if relative.startswith(_PACKAGE_PREFIX) else "src/" + relative + if files.get(canonical) != expected: + raise _source_error("source-parser-digest-mismatch", f"recorded parser digest differs: {relative}") + origin = _source_origin(pin, selected, origin_mode) + bootstrap = Path(__file__).resolve() + receipt = { + "schema": SOURCE_QUALIFICATION_SCHEMA, + "ok": True, + "status": "admitted", + "repository": UPSTREAM_REPOSITORY, + "commit": pin.commit, + "manifest_sha256": manifest_sha256, + "package_root": str(selected), + "origin": origin, + "file_count": len(files), + "verdict_modules": list(payload["verdict_modules"]), + "pinned_parser_files": dict(parser_files), + "importer_coverage": "pinned-module" if _PACKAGE_PREFIX + "importers.py" in files else "external-bootstrap", + "bootstrap": {"path": str(bootstrap), "sha256": hashlib.sha256(bootstrap.read_bytes()).hexdigest()}, + "preimport": True, + "imports_verified": False, + "loaded_modules": {}, + "execution_verified": False, + "scope": "GNN package source only; not dependency, semantic-result, publisher, or hostile-filesystem attestation", + } + return _AdmittedSource(pin, selected, files, receipt, origin_mode) + except (OSError, RuntimeError, ImportError) as exc: + raise _source_error("source-origin-unavailable", f"cannot admit GNN package: {type(exc).__name__}") from exc + + +def qualify_source( + pin: ImporterPin, + *, + manifest: bytes, + manifest_sha256: str, + package_root: Optional[Path] = None, + origin_mode: str = "installed", +) -> Dict[str, Any]: + """Admit exact target origin/content without importing GNN. + + Load this reviewed file as a standalone module, not via ``import gnn``. + The manifest hash must come from independent owner custody, not from a + manifest generated by the target installation. Installed mode additionally + requires matching PEP 610 Git origin. Explicit source mode binds the selected + package root by complete content, without claiming Git checkout verification. + Use qualified_source for verdict execution, not this observation alone. + """ + return _admit_source( + pin, + manifest=manifest, + manifest_sha256=manifest_sha256, + package_root=package_root, + origin_mode=origin_mode, + ).receipt + + +class _CheckedSourceLoader(importlib.machinery.SourceFileLoader): + def __init__(self, name: str, path: Path, admitted: _AdmittedSource) -> None: + super().__init__(name, str(path)) + self.admitted = admitted + + def get_data(self, path: str) -> bytes: + return self.admitted.read(Path(path)) + + def get_code(self, fullname: str) -> Any: + # Compile the checked bytes, never a stale or substituted .pyc. + return compile(self.get_data(self.path), self.path, "exec", dont_inherit=True) + + +class _CheckedSourceFinder(importlib.abc.MetaPathFinder): + def __init__(self, admitted: _AdmittedSource) -> None: + self.admitted = admitted + self.directories = { + parent.as_posix() + for relative in admitted.files + for parent in PurePosixPath(relative).parents + } + + def find_spec(self, fullname: str, path: Any = None, target: Any = None) -> Any: + if fullname != "gnn" and not fullname.startswith("gnn."): + return None + relative = _module_source(fullname, self.admitted.files) + if relative is None: + directory = "src/" + fullname.replace(".", "/") + if directory not in self.directories: + raise _source_error("source-module-undeclared", f"module is outside the admitted GNN source: {fullname}") + spec = importlib.machinery.ModuleSpec(fullname, loader=None, is_package=True) + spec.submodule_search_locations = [ + str(self.admitted.package_root / directory[len("src/gnn/"):]) + ] + return spec + source = self.admitted.package_root / relative[len(_PACKAGE_PREFIX):] + loader = _CheckedSourceLoader(fullname, source, self.admitted) + locations = [str(source.parent)] if source.name == "__init__.py" else None + return importlib.util.spec_from_file_location( + fullname, source, loader=loader, submodule_search_locations=locations + ) + + +@contextmanager +def qualified_source( + pin: ImporterPin, + *, + manifest: bytes, + manifest_sha256: str, + package_root: Optional[Path] = None, + origin_mode: str = "installed", +) -> Iterator[Dict[str, Any]]: + """Admit source before imports and guard exact bytes for one verdict scope. + + Run in a fresh target process. This supports legacy v5.0.3 packages without + gnn.importers as well as v5.1.0 packages whose importer is itself covered. + Import the pinned verdict modules only inside this context. On normal exit + the inventory/origin and every loaded GNN module are rechecked; only then + imports_verified becomes true. It is not scientific execution attestation. + """ + global _ACTIVE_SOURCE + if _ACTIVE_SOURCE is not None: + raise _source_error("source-session-active", "a GNN source qualification is already active") + admitted = _admit_source( + pin, + manifest=manifest, + manifest_sha256=manifest_sha256, + package_root=package_root, + origin_mode=origin_mode, + ) + finder = _CheckedSourceFinder(admitted) + admitted.receipt["ok"] = False + _ACTIVE_SOURCE = admitted + sys.meta_path.insert(0, finder) + try: + yield admitted.receipt + loaded: Dict[str, Any] = {} + for name, module in tuple(sys.modules.items()): + if name != "gnn" and not name.startswith("gnn."): + continue + spec = getattr(module, "__spec__", None) + loader = getattr(spec, "loader", None) + if isinstance(loader, _CheckedSourceLoader) and loader.admitted is admitted: + source = Path(loader.path) + if ( + getattr(module, "__file__", None) != loader.path + or getattr(spec, "origin", None) != loader.path + ): + raise _source_error( + "source-loaded-module-mismatch", + f"GNN module changed its admitted origin: {name}", + ) + admitted.read(source) + relative = _PACKAGE_PREFIX + source.relative_to(admitted.package_root).as_posix() + loaded[name] = {"path": loader.path, "sha256": admitted.files[relative]} + continue + directory = "src/" + name.replace(".", "/") + expected = str(admitted.package_root / directory[len(_PACKAGE_PREFIX):]) + if ( + directory not in finder.directories + or _module_source(name, admitted.files) is not None + or spec is None + or spec.origin is not None + or list(spec.submodule_search_locations or ()) != [expected] + ): + raise _source_error( + "source-loaded-module-mismatch", + f"GNN module did not use admitted source: {name}", + ) + loaded[name] = {"path": expected, "sha256": None, "namespace": True} + admitted.verify_unchanged() + admitted.receipt.update( + ok=True, + status="qualified", + imports_verified=True, + loaded_modules=loaded, + ) + except BaseException: + admitted.receipt.update(ok=False, status="failed", imports_verified=False) + raise + finally: + sys.meta_path[:] = [item for item in sys.meta_path if item is not finder] + _ACTIVE_SOURCE = None + + +def _validate_spec(path: Path) -> List[str]: + """Validate one specification with the installed parser; return errors.""" + from gnn.parsers.basic import validate_gnn_syntax + + try: + is_valid, errors = validate_gnn_syntax(path) + except SourceQualificationError: + raise + except ( + OSError, + UnicodeDecodeError, + ValueError, + TypeError, + KeyError, + RecursionError, + ) as exc: + # A document from another repository is untrusted input: a validator + # failure on it is a finding about that document, not a crash here. + return [f"validator raised {type(exc).__name__}: {exc}"] + if is_valid: + return [] + return [str(error) for error in errors] or ["invalid specification"] + + +def _relative(path: Path, root: Path) -> str: + """Return ``path`` relative to ``root`` when it is inside it, else the name.""" + try: + return str(path.relative_to(root)) + except ValueError: + return path.name + + +def check_pointer( + repo_root: Path, + pin: ImporterPin, + *, + workflow: Optional[str] = None, + job: Optional[str] = None, +) -> List[Dict[str, str]]: + """Check the importer's ``.github/GNN.md`` pointer against its pin. + + The pointer is what a human reads and what the estate's online re-read + looks for; a pointer that names a different pin, revision or job is a + finding, not a documentation preference. Every check is textual: the + pointer is prose, so the reader asks whether the facts appear, not whether + the file has a schema. + """ + findings: List[Dict[str, str]] = [] + path = repo_root / POINTER_PATH + if not path.is_file(): + return [ + { + "level": "error", + "code": "pointer-missing", + "message": f"{POINTER_PATH} is absent; it must name {_relative(pin.path, repo_root)}, " + f"{pin.commit[:12]} and the conformance job", + } + ] + try: + text = path.read_text(encoding="utf-8") + except (OSError, UnicodeDecodeError) as exc: + return [ + { + "level": "error", + "code": "pointer-unreadable", + "message": f"{POINTER_PATH} is not readable text ({exc})", + } + ] + + pin_name = _relative(pin.path, repo_root) + if pin_name not in text: + findings.append( + { + "level": "error", + "code": "pointer-pin-unnamed", + "message": f"{POINTER_PATH} does not name the pin file {pin_name}", + } + ) + if pin.commit not in text and pin.commit[:12] not in text: + findings.append( + { + "level": "error", + "code": "pointer-revision-unnamed", + "message": f"{POINTER_PATH} does not name the pinned revision {pin.commit[:12]}", + } + ) + if workflow and Path(workflow).name not in text: + findings.append( + { + "level": "error", + "code": "pointer-workflow-unnamed", + "message": f"{POINTER_PATH} does not name the workflow {workflow}", + } + ) + if job and job not in text: + findings.append( + { + "level": "error", + "code": "pointer-job-unnamed", + "message": f"{POINTER_PATH} does not name the job key {job}", + } + ) + return findings + + +#: Schema identifier for the GNN-derived subset of a manuscript variable map. +IMPORTER_VARIABLES_SCHEMA = "gnn-importer-variables/v1" + + +def importer_variables( + pin: ImporterPin, + *, + repo_root: Path, + job: Optional[str] = None, + job_name: Optional[str] = None, +) -> Dict[str, str]: + """Return the GNN-derived manuscript variables for one importer. + + A repository whose manuscript states which GNN release it consumes needs + the same seven facts this reader already normalizes. Producing them here + means the prose and the conformance job cannot disagree about the pin, and + a consumer does not re-read the JSON in its own variable script. + + ``gnn_job_key`` and ``gnn_job_name`` are the conformance job the registry + row records; a caller that has them passes them, because the reader does + not parse workflow YAML. + """ + return { + "schema": IMPORTER_VARIABLES_SCHEMA, + "gnn_pin_path": _relative(pin.path, repo_root), + "gnn_pin_schema": pin.schema or "", + "gnn_repository": pin.repository or "", + "gnn_tag": pin.tag or "", + "gnn_commit": pin.commit, + "gnn_job_key": job or "", + "gnn_job_name": job_name or "", + } + + +def check_importer( + repo_root: Path, + *, + expected_commit: Optional[str] = None, + expected_tag: Optional[str] = None, + expected_repository: Optional[str] = UPSTREAM_REPOSITORY, + validate_specs: bool = True, + require_pin: bool = True, + pin_path: Optional[Path] = None, + pin_party: Optional[str] = None, + require_pointer: bool = False, + pointer_workflow: Optional[str] = None, + pointer_job: Optional[str] = None, + source_manifest: Optional[Union[bytes, Path]] = None, + source_manifest_sha256: Optional[str] = None, + package_root: Optional[Path] = None, + origin_mode: str = "installed", +) -> Dict[str, Any]: + """Check one importer checkout and return a JSON-ready report. + + Findings carry ``level`` (``error`` fails the check, ``warning`` does not) + and ``code`` so a caller can filter without parsing prose. + + Args: + pin_path: Read this pin instead of discovering one. Needed where a + repository keeps a differently named custody pin + (``fep_formal``'s ``source-pin.json``) or where the conventional + candidate list would pick a *different repository's* pin (the + upstream GNN checkout pins its downstreams in + ``.github/gnn-pair.json``). + pin_party: Sub-record to read inside ``pin_path`` for a two-party pin. + require_pointer: Also require ``.github/GNN.md`` to name the pin, the + revision and the declared workflow and job. + source_manifest: Independently trusted complete-package manifest bytes, + or a path to those exact bytes. Required before a real verdict. + source_manifest_sha256: SHA-256 bound by independent producer custody. + package_root: Explicit expected target package directory; required in + source mode. Never changes import resolution or sys.path. + origin_mode: Installed VCS origin plus content, or explicitly selected + source content. Neither mode changes the consumer pin. + validate_specs: False is inspection only and never imports GNN here. + """ + repo_root = repo_root.resolve() + findings: List[Dict[str, str]] = [] + report: Dict[str, Any] = { + "repo": str(repo_root), + "pin": None, + "specs": {"count": 0, "files": [], "invalid": [], "validated": 0}, + "findings": findings, + "ok": False, + "mode": "conformance" if validate_specs else "inspection", + "qualified": False, + "verdict_scope": "normative-syntax" if validate_specs else None, + "source_qualification": { + "schema": SOURCE_QUALIFICATION_SCHEMA, + "ok": False, + "status": "not-requested", + "preimport": False, + "imports_verified": False, + "loaded_modules": {}, + "execution_verified": False, + }, + } + if not repo_root.is_dir(): + findings.append( + {"level": "error", "code": "repo-missing", "message": "importer repository is not an existing directory"} + ) + return report + + pin_file = find_pin(repo_root) + if pin_path is not None: + pin_file = pin_path if pin_path.is_absolute() else repo_root / pin_path + if not pin_file.is_file(): + findings.append( + { + "level": "error", + "code": "pin-missing", + "message": f"the declared pin {_relative(pin_file, repo_root)} is absent", + } + ) + pin_file = None + pin: Optional[ImporterPin] = None + if pin_file is None: + if pin_path is not None: + pass # the absent declared pin is already the finding + elif require_pin: + findings.append( + { + "level": "error", + "code": "pin-missing", + "message": "no GNN pin file found (looked for " + + ", ".join(PIN_CANDIDATES) + + ")", + } + ) + else: + findings.append( + { + "level": "warning", + "code": "pin-missing", + "message": "no GNN pin file; exact-pin verdicts are unavailable", + } + ) + else: + try: + pin = read_pin(pin_file, party=pin_party) + except PinError as exc: + findings.append( + {"level": "error", "code": "pin-unreadable", "message": str(exc)} + ) + else: + report["pin"] = { + "path": _relative(pin.path, repo_root), + "party": pin.party, + "commit": pin.commit, + "tag": pin.tag, + "repository": pin.repository, + "schema": pin.schema, + "recorded": pin.recorded, + "spec_files": list(pin.spec_files), + } + if not re.fullmatch(r"[0-9a-f]{40}", pin.commit): + findings.append( + { + "level": "error", + "code": "pin-commit-shape", + "message": f"pin records {pin.commit!r}, which is not a 40-character commit id", + } + ) + if pin.schema != PIN_SCHEMA: + findings.append( + { + "level": "warning", + "code": "pin-schema-unversioned", + "message": f"pin declares schema {pin.schema!r}, not {PIN_SCHEMA!r}", + } + ) + if expected_commit and pin.commit != expected_commit: + findings.append( + { + "level": "error", + "code": "pin-commit-mismatch", + "message": f"pin records {pin.commit}, expected {expected_commit}", + } + ) + if expected_tag and pin.tag != expected_tag: + findings.append( + { + "level": "error", + "code": "pin-tag-mismatch", + "message": f"pin records tag {pin.tag!r}, expected {expected_tag!r}", + } + ) + if ( + expected_repository + and pin.repository + and pin.repository != expected_repository + ): + findings.append( + { + "level": "error", + "code": "pin-repository-mismatch", + "message": ( + f"pin names {pin.repository}, expected {expected_repository}; " + "a pin that names a fork tracks code this distribution does not publish" + ), + } + ) + + try: + specs = discover_specs(repo_root, pin) + except (PinError, OSError) as exc: + specs = [] + findings.append( + {"level": "error", "code": "spec-path-unsafe", "message": str(exc)} + ) + report["specs"]["count"] = len(specs) + report["specs"]["files"] = [path.relative_to(repo_root).as_posix() for path in specs] + available: List[Path] = [] + for spec in specs: + if not spec.is_file(): + findings.append( + { + "level": "error", + "code": "spec-missing", + "message": f"{spec.relative_to(repo_root)} is declared by the pin but absent", + } + ) + else: + available.append(spec) + + def validate() -> None: + for spec in available: + # Recheck path admission immediately before the validator opens it. + _contained_spec(repo_root, spec.relative_to(repo_root).as_posix()) + errors = _validate_spec(spec) + report["specs"]["validated"] += 1 + if errors: + report["specs"]["invalid"].append( + {"file": spec.relative_to(repo_root).as_posix(), "errors": errors} + ) + findings.append( + { + "level": "error", + "code": "spec-invalid", + "message": f"{spec.relative_to(repo_root)}: {errors[0]}", + } + ) + + if validate_specs and available and not any(item["level"] == "error" for item in findings): + try: + if pin is None: + raise _source_error("source-pin-required", "exact-pin validation requires a readable consumer pin") + if _ACTIVE_SOURCE is not None: + admitted = _ACTIVE_SOURCE + if admitted.pin.commit != pin.commit or pin.repository not in (None, UPSTREAM_REPOSITORY): + raise _source_error("source-pin-mismatch", "active source qualification belongs to a different pin") + for relative, digest in _pin_record(pin).get("parser_files", {}).items(): + canonical = relative if relative.startswith(_PACKAGE_PREFIX) else "src/" + relative + if admitted.files.get(canonical) != digest: + raise _source_error("source-parser-digest-mismatch", f"recorded parser digest differs: {relative}") + report["source_qualification"] = admitted.receipt + validate() + else: + if source_manifest is None or source_manifest_sha256 is None: + raise _source_error( + "source-manifest-required", + "use the reviewed standalone bootstrap with an independently trusted source manifest/hash", + ) + try: + manifest_bytes = source_manifest.read_bytes() if isinstance(source_manifest, Path) else source_manifest + except OSError as exc: + raise _source_error("source-manifest-unreadable", "source manifest cannot be read") from exc + with qualified_source( + pin, + manifest=manifest_bytes, + manifest_sha256=source_manifest_sha256, + package_root=package_root, + origin_mode=origin_mode, + ) as qualification: + report["source_qualification"] = qualification + validate() + except (SourceQualificationError, PinError, ImportError, OSError) as exc: + code = exc.code if isinstance(exc, SourceQualificationError) else "source-verdict-unavailable" + report["source_qualification"].update(ok=False, status="failed") + findings.append({"level": "error", "code": code, "message": str(exc)}) + + if pin is not None and not specs: + findings.append( + { + "level": "warning", + "code": "spec-absent", + "message": "pin present but the repository carries no *.gnn.md specification", + } + ) + + if require_pointer: + if pin is None: + findings.append( + { + "level": "error", + "code": "pointer-unchecked", + "message": f"{POINTER_PATH} cannot be checked without a readable pin", + } + ) + else: + pointer_findings = check_pointer( + repo_root, + pin, + workflow=pointer_workflow, + job=pointer_job, + ) + findings.extend(pointer_findings) + report["pointer"] = { + "path": POINTER_PATH, + "ok": not pointer_findings, + } + + report["ok"] = not any(item["level"] == "error" for item in findings) + report["qualified"] = ( + report["ok"] + and validate_specs + and report["specs"]["validated"] > 0 + and report["source_qualification"]["ok"] + and report["source_qualification"]["imports_verified"] + ) + return report + + +def _format_text(report: Dict[str, Any]) -> str: + lines = [f"importer: {report['repo']}"] + pin = report["pin"] + if pin: + party = f" [{pin['party']}]" if pin.get("party") else "" + lines.append( + f" pin: {pin['path']}{party} -> {pin['tag'] or '(no tag)'} @ {pin['commit'][:10]}" + f" (schema {pin['schema'] or 'unversioned'})" + ) + else: + lines.append(" pin: none") + lines.append(f" specs: {report['specs']['count']}") + pointer = report.get("pointer") + if pointer: + lines.append( + f" pointer: {pointer['path']} -> {'ok' if pointer['ok'] else 'FAILED'}" + ) + for item in report["findings"]: + lines.append(f" [{item['level']}] {item['code']}: {item['message']}") + lines.append(" verdict: " + ("ok" if report["ok"] else "FAILED")) + return "\n".join(lines) + + +def main(argv: Optional[Sequence[str]] = None) -> int: + """Run inspection or qualified checking; this file also runs with ``-I``.""" + parser = argparse.ArgumentParser( + prog="python -m gnn.importers", + description="Check a downstream repository's GNN pin and specifications.", + ) + subparsers = parser.add_subparsers(dest="command", required=True) + manifest_parser = subparsers.add_parser( + "source-manifest", help="inventory an independently qualified exact-revision package" + ) + manifest_parser.add_argument("--package-root", type=Path, required=True) + manifest_parser.add_argument("--commit", required=True) + manifest_parser.add_argument("--verdict-module", action="append", default=[]) + check = subparsers.add_parser("check", help="check one importer checkout") + check.add_argument("--repo", default=".", help="repository root to check") + check.add_argument( + "--expected-commit", default=None, help="upstream commit the pin must record" + ) + check.add_argument( + "--expected-tag", default=None, help="upstream tag the pin must record" + ) + check.add_argument( + "--expected-repository", + default=UPSTREAM_REPOSITORY, + help="repository the pin must name (empty string disables the check)", + ) + check.add_argument( + "--no-validate", + action="store_true", + help="read the pin and list specifications without parsing them", + ) + check.add_argument( + "--allow-missing-pin", + action="store_true", + help="treat a missing pin as a warning instead of an error", + ) + check.add_argument( + "--pin", + default=None, + help="read this pin instead of discovering one (for a differently named custody pin)", + ) + check.add_argument( + "--pin-party", + default=None, + help="sub-record to read inside --pin for a two-party custody pin", + ) + check.add_argument( + "--require-pointer", + action="store_true", + help=f"also require {POINTER_PATH} to name the pin, revision, workflow and job", + ) + check.add_argument( + "--workflow", + default=None, + help="conformance workflow the pointer must name (with --require-pointer)", + ) + check.add_argument( + "--job", + default=None, + help="conformance job key the pointer must name (with --require-pointer)", + ) + check.add_argument("--source-manifest", type=Path, default=None) + check.add_argument("--source-manifest-sha256", default=None) + check.add_argument("--package-root", type=Path, default=None) + check.add_argument("--origin-mode", choices=("installed", "source"), default="installed") + check.add_argument("--json", action="store_true", help="emit the report as JSON") + args = parser.parse_args(argv) + if args.command == "source-manifest": + try: + payload = source_manifest_bytes( + build_source_manifest( + args.package_root, + commit=args.commit, + verdict_modules=args.verdict_module or ("gnn.parsers.basic",), + ) + ) + except (SourceQualificationError, OSError) as exc: + print(json.dumps({"ok": False, "error": {"code": getattr(exc, "code", "source-unreadable"), "message": str(exc)}})) + return 1 + sys.stdout.buffer.write(payload) + return 0 + + report = check_importer( + Path(args.repo), + expected_commit=args.expected_commit, + expected_tag=args.expected_tag, + expected_repository=args.expected_repository or None, + validate_specs=not args.no_validate, + require_pin=not args.allow_missing_pin, + pin_path=Path(args.pin) if args.pin else None, + pin_party=args.pin_party, + require_pointer=args.require_pointer, + pointer_workflow=args.workflow, + pointer_job=args.job, + source_manifest=args.source_manifest, + source_manifest_sha256=args.source_manifest_sha256, + package_root=args.package_root, + origin_mode=args.origin_mode, + ) + if args.json: + print(json.dumps(report, indent=2, sort_keys=True)) + else: + print(_format_text(report)) + return 0 if report["ok"] else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/.github/gnn/v5.1.0-source-manifest.json b/.github/gnn/v5.1.0-source-manifest.json new file mode 100644 index 0000000..b6cb463 --- /dev/null +++ b/.github/gnn/v5.1.0-source-manifest.json @@ -0,0 +1 @@ +{"commit":"75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf","files":{"src/gnn/0_template.py":"9ca33ac270c158b72b07a93b387e33643190989079e55edc278caa0f9a6a72eb","src/gnn/10_ontology.py":"b7eb5997fec26537946cb61c2e09eb44dbab020c0532a26d4c73485ef40f625a","src/gnn/11_render.py":"318fd154a2eeec4577e6abb43b0e4fe3b31cb36418a2d7518504acfb2ed3c1a0","src/gnn/12_execute.py":"baaa5b057142a88f515b51bff1a17479479e9a2f780053da06f40c0a9242cce1","src/gnn/13_llm.py":"c78547e3c987b6d1a7a757ca9849222fc3ca198ccb5c5573fdd1c2a18a431e18","src/gnn/14_ml_integration.py":"b4fe04e9c9ea82478f86fc4c09d5badb8aab44ce09ed379a83f293fa7491ccb1","src/gnn/15_audio.py":"07903db6efaf7057c11787d1cc4731f27c49bf448e348950d848ae2591ae0183","src/gnn/16_analysis.py":"8b9e86923087cf75beec32b3b754cb3f0117b4c41294e185959de78ca7c1de5f","src/gnn/17_integration.py":"e40727262d1927b527b9828247241d51f500c89d3e3fd147aefb4277653c5cda","src/gnn/18_security.py":"84f3a7fca39d9b9eb213eb483c1a403fe97cc3dac5eda46e13a6fded389b364c","src/gnn/19_research.py":"8601ed4b730aa5376a307c0cd26a8ebd884dcc40fa640c8ea24b07140ae2c7e0","src/gnn/1_setup.py":"e41dc8598d999692da26aa9729f814f47c1103edd98fe0af1e294354d222b168","src/gnn/20_website.py":"eebb5211a0463f0f6ec5a8508e274ca4ae1c1e23d38da8064f0755a2fcc8c5ca","src/gnn/21_mcp.py":"e73c6abcb94d99ec360b1ce6437172327d9b37316f46d7cd07c164ed0a8d4cfb","src/gnn/22_gui.py":"f35a1311e3437492580b4b705565b5bbf9ec75e068918acb39b5f341e1b72ad9","src/gnn/23_report.py":"fcfc310854d5b014fec65678e4093e74fada56c824a1c02e9ee4f5853db0371f","src/gnn/24_intelligent_analysis.py":"faff981111c5410f92362d0716e4ff0869beaf234dafdd867b4c5da6e950d522","src/gnn/2_tests.py":"cf867ee6233d7808644c6bbf48c6b3c210ff033bb46831a78a3893189a75e926","src/gnn/3_gnn.py":"89c57a20ea0ab7c01359f3fa670d4b9c5433f010b99cb844c457069ca58ae4d7","src/gnn/4_model_registry.py":"8988063b6f423610fb95f64b9868332939bb20e5b87ff9cfbf00ccab8b999f80","src/gnn/5_type_checker.py":"acaf0f2fa9cbc8d926fc08aeee0828646155bfb1751bfdd0e594664b4722cc8f","src/gnn/6_validation.py":"2d1100471b9c0e0a6af841781caf06bf2705f881c34a607b310fa895207e9f1a","src/gnn/7_export.py":"b4b4ac3fd93e99a315f67e89c83380ff6e95eff89da75b8b225da929086f273c","src/gnn/8_visualization.py":"52dc8533b6df5d5cc39d7a91e31620a08dc87800227a835d6db3f04bfaf2f575","src/gnn/9_advanced_viz.py":"dac2d851e01925703751a54904ead9d64216589771802737f2de95539948dfa3","src/gnn/AGENTS.md":"19c40e88307fd07627aa0ef92fa286ec49b57b19190a04f5e7b6f394a42ff209","src/gnn/README.md":"76977b6ec758063444ab8a6cb581599ab556b01fdcefc7e49b6f30c3813a9cb8","src/gnn/SKILL.md":"90cb2edd858633a89bbac91d8d91a62d1472f714438b42bee5ca7333dd4fcb88","src/gnn/SPEC.md":"e26a489c9e46dc6e09bffc25170a9a6773c9cb9c8c2bcf9c98a55a6b8979526b","src/gnn/STEP_INDEX.md":"7a4a58bbaf6113cbb14cc74db2c38b6c398fe23aa38678f20322dc49db03f850","src/gnn/__init__.py":"908848847f2fb938f65b3ea0b17252ab6d2129ad2f0b427bca8761a81083d10d","src/gnn/advanced_visualization/AGENTS.md":"9442fca7ad4af839a3ccd6494b7af6f3282f1bd06f6ea7587c29969cde2ee2eb","src/gnn/advanced_visualization/D2_README.md":"5929bda4b0e539df635b1d087b9a5c399852e5136bdb6cafe87922f8f42dab0b","src/gnn/advanced_visualization/README.md":"99b3cac26aeb98befec6254b78d55da2d48ca81e67325fca36419cb7b2f69b8d","src/gnn/advanced_visualization/SKILL.md":"2af52c9bb75be3e9fb553fff6ae2e67bbc0fdaaa417d61a08f084436685cc4a6","src/gnn/advanced_visualization/SPEC.md":"65965c973a61159d722bf802fdb567b7a6c71c0f4bbfe7219e065e3b0d7d7f7b","src/gnn/advanced_visualization/__init__.py":"4a01ece62af204fdbc76310bb94f4f53bf008bbf79b7c4d0c11731ccb4f29540","src/gnn/advanced_visualization/_shared.py":"7b5e1d349f9e2171ae70b20fe1a51b6668bba92e79dee741579decbe5d0a3862","src/gnn/advanced_visualization/_theme.py":"514448ceed632b22cc87b9885e85c3bbddf7fde205e392c2c959c280557a18fe","src/gnn/advanced_visualization/d2_visualizer.py":"76ce9a473d92d8d5b20782a6f17f57be1c18cf8413f58aef03cb5cee7a5b2fea","src/gnn/advanced_visualization/dashboard.py":"c0a37cc35da08f03bfa6f709e64207d5c97fc9289acb3b4e3a846543a8090858","src/gnn/advanced_visualization/data_extractor.py":"cb993ef9ef12381e644c11432fb9b8f6fdf8eb2ac56acdc14df04a6fcbac6152","src/gnn/advanced_visualization/html_generator.py":"6952889d69f4dc4830914378514e86cc258a6e44b415eb142473ea5e277f4f84","src/gnn/advanced_visualization/interactive_viz.py":"9c26944c9e2eaee2e04628d14cba9e68e50ad4b76ef0f0a2c51116b475ce6546","src/gnn/advanced_visualization/mcp.py":"d2a6e2f9a9cb26ab56aa69a649b6c91b4b586326a7e41863aa3564bed148738f","src/gnn/advanced_visualization/network_viz.py":"7add36c8546dd4d82b0e3bffd240348679ba953f6ffa6d65efe6b474ba434652","src/gnn/advanced_visualization/processor.py":"eb0d12b405cc98e4f39bb4f7dd62470d794ca3c80f7bb5b8e013c9f08fcc46a9","src/gnn/advanced_visualization/statistical_viz.py":"e1bb21068400b8145e1218088dc7e42484bc3c6c35bc22c2e466d4ea56f0df9f","src/gnn/advanced_visualization/visualizer.py":"d58607d3363caa056832b6fe122b6e56ba4af6726650476f1662102f09c2c6a0","src/gnn/analysis/AGENTS.md":"bb3c555298bf68a024cc547a0eb8adb907549fd7013ee448936ae053f972a886","src/gnn/analysis/PERFORMANCE.md":"4b274e5eb4f7be9145ec9b1c3c67c0bb807b6f7810659b0329a2340a0c486ff4","src/gnn/analysis/README.md":"d09b0504c8d1dc5cce30beccdf6d42a47134b0142920aabfa791f79852639010","src/gnn/analysis/SKILL.md":"419525566753862e0449a299d03c5644d8923ff096c304a824a54cfcf7f32d8c","src/gnn/analysis/SPEC.md":"500b8da620f4abd3b834e8e0cdb0f4b4808e97a19f364957b0af4bd378b2b646","src/gnn/analysis/__init__.py":"9832042434a20e5624205cdd414358cd9621fcccfdd77939d97d0b19a02102ae","src/gnn/analysis/activeinference_jl/AGENTS.md":"9ff60b74bb79c97bb505301c2295cc88c6542b2f5ae8372f26fcac3839d72b71","src/gnn/analysis/activeinference_jl/README.md":"4fcc8e2fbe70c6a2a60c57cddf4580838c7cdc264334dda8812a3dc16882a4fb","src/gnn/analysis/activeinference_jl/SPEC.md":"f00b9bc22b109ad6c420bfec074298b7639ae5cfa23f391d6aa00327fb48beef","src/gnn/analysis/activeinference_jl/__init__.py":"59beacd13d61bda1ccc37b3601a389e546d4a9343b7765d671502e1b1040c4bd","src/gnn/analysis/activeinference_jl/advanced_pomdp_analysis.jl":"070b238ed56ddbed43834f04de97b5a5b0f866d815d7639c976d935cd8d3343f","src/gnn/analysis/activeinference_jl/analysis_suite.jl":"a06bb46500e499c6f31ba25231bd254dbcf59a7a2cdb3f75bc89191244c8e83a","src/gnn/analysis/activeinference_jl/analyzer.py":"ee350306ff20e2e25327e5133ebed8dd3639a8e8dc42c73a8a9907bb86fee9b1","src/gnn/analysis/activeinference_jl/meta_cognitive_analysis.jl":"2d88610f51d2afc59745e6f5ce99a585274c0b3e60c1414f3ab481b9e4c905b4","src/gnn/analysis/activeinference_jl/multi_scale_temporal_analysis.jl":"44f4f0a93b1a22cf6b557de2f9e5a098c7b073f16fe40ddfb6e3695169502d46","src/gnn/analysis/activeinference_jl/statistical_analysis.jl":"7acdb215c6a5cabc8e508b6519eb9e3796e0b3257b3cac985d72d6364b96cc80","src/gnn/analysis/activeinference_jl/uncertainty_quantification.jl":"fef5e0b43fa6111fdab6a3ba6780610818e522c4bcea3bafd594fa44fdf623e5","src/gnn/analysis/activeinference_jl/visualization_suite.jl":"6d17aff3cf85173aad4a0a2bbb1940c108601bc866612fc5371ac1990db7b394","src/gnn/analysis/activeinference_jl/visualization_utils.jl":"c7e223adc36a499a7dbbdd16c751740659feb26c9bc4cf92838b80523a886471","src/gnn/analysis/analysis_complexity.py":"ba36d555b29f2bea394b6742bc99c52af63bb7967ea2df4f7c8be32aa7a8c09f","src/gnn/analysis/analysis_extraction.py":"57555906f1a20258deec1debf42e1b1a5fb4cfcaf07bd84d6a6cb62057de3886","src/gnn/analysis/analysis_statistics.py":"9efcc58e9a86d2f0aed84f691f29e84acb3d4936dfb131b127c039bd176c8419","src/gnn/analysis/analyzer.py":"0a7aa92737f022b97396ca85111dc0507bea37f93e716b3076a98643f85b2650","src/gnn/analysis/comparison_contract.py":"a506c68f1d598d1d9b20603dc53aedd9e12e10095f5412e2109507ae3db8b6aa","src/gnn/analysis/complexity/AGENTS.md":"9c45dee9a5112d80fd34ffcc662a4eca209f2bf2829ff8bfff35ce1fd4989413","src/gnn/analysis/complexity/README.md":"862aabcfd2ed3c326a72a443fde97d98cbfad63ce9f29313bc3920c9c8498310","src/gnn/analysis/complexity/__init__.py":"3ea4a7c72ccf4b07a59d22e7a2d07542382a981b4c983ce5b4c4f2a79757102d","src/gnn/analysis/complexity/benchmark.py":"4ee9372424d0d299a319dd10458f90ce0c252794386fb0a0343e4f8a7c1c8145","src/gnn/analysis/complexity/bounds.py":"3ff20b953265149e76a0412bc5eb903af1699a03788bc621191df94776cedd54","src/gnn/analysis/complexity/estimator.py":"5a22bbe638185a3125cdd9598785cf34961569b51d1b96454e796f8599615352","src/gnn/analysis/cpomdp/AGENTS.md":"47eaff8c8ed9d275fd9bcf3319e9a20875dd20fc407925313520a1cd63bc45ae","src/gnn/analysis/cpomdp/README.md":"958e859bb25c24c1dcf5699644ca20f62c2f5801f97c5c12ca5912a79255638d","src/gnn/analysis/cpomdp/SPEC.md":"baec98b88e0ccd8a739d0d974d4c9e61d5eff3309e8518693ab965fd915e1bfd","src/gnn/analysis/cpomdp/__init__.py":"e015dd943bb8bc14b5684067355f07f7550820b9770c0b1f167f904765b77605","src/gnn/analysis/cpomdp/analyzer.py":"ebbae6231e7bf20cf631e392b5f9f367641d9c0233cd3d54ac1f70c35eb09357","src/gnn/analysis/discopy/AGENTS.md":"99b1dfaf901905bb89cb5ae599a5a92e7775bae2bb9fd57bc05ac2ea5838018c","src/gnn/analysis/discopy/README.md":"081eaabd5cf131bcb14fed23468f3c957c6309c10fccee702d069de853783374","src/gnn/analysis/discopy/SPEC.md":"6c55a45f6376b3c69a79ca6010234a7a38c48bf9ac2846abdaa9b5cca30e9fb6","src/gnn/analysis/discopy/__init__.py":"cd3fce647aea97fbb8fbbf1e873a350f93e69fb248d769bc98238c3613f2ac04","src/gnn/analysis/discopy/analyzer.py":"f91613389540a293ab1609db781d889853c024151afe4475c3b1bcac8b22b49f","src/gnn/analysis/flat_payload_analyzer.py":"458ffb14215afe00b53bde49f5bdac135187b4cd5f754c5a0ebeb77bbe4c69f7","src/gnn/analysis/framework_common.py":"60bc6f644b07d3b9b0e2242399bd3657ed505692a348fb630f687af87de26a89","src/gnn/analysis/framework_comparison.py":"06fd58a4b2e732c25c0fb76f3bdea2d3d98ab4118228e4d4560d0e819a539039","src/gnn/analysis/framework_extractors.py":"e69eba5dda0b8a4833543d17d6aee1b7c5fd96b3b6e441482f89dbe0948d8008","src/gnn/analysis/generate_cross_model_report.py":"3b747f5bbe5f10c489368a2b85a8e0435363d6f84ee61fac8662aaec6a8afd84","src/gnn/analysis/interpretability.py":"ad8574711358a32a95f6eb7539290dfe2abbfb518402a9d5deb160f1f11c4b76","src/gnn/analysis/jax/AGENTS.md":"f6f193c5287f147137dc5672d3143f3f97db62192b7b479d3c4d554286a50fbe","src/gnn/analysis/jax/README.md":"390d9d2ce55304019d248442d4fb609374f597867f9a1508fd4b4399fa13662b","src/gnn/analysis/jax/SPEC.md":"375cd286bc4b12f98fd091e670173511c7aa871632f867dcaa5d3a8b135045d2","src/gnn/analysis/jax/__init__.py":"0b0530335b5f4c9fd267b01339da9c271c0d9fd06acdb7e2a2bd1d488cb995f5","src/gnn/analysis/jax/analyzer.py":"3c15fcb682e91d740c01d7654eb45f3d45ce418d32ba1b1faa112866cda37e40","src/gnn/analysis/math_utils.py":"69050d947c3bf82cc55b0db82eb36282e315f2cb0d49d5c418c46b84c5d2237d","src/gnn/analysis/mcp.py":"2015bd45b853c58c41f103113c4e3f755e6f51209c516ecf6c6567b1f19bfc02","src/gnn/analysis/numpyro/AGENTS.md":"3f416632065fa0d5e42b70f50b44d5a01b6a2e0b0e12b3c6c29c6ebbcf136e98","src/gnn/analysis/numpyro/README.md":"ccebb18e1e2d43ed611b5e8ea83700e74b1b13cc334b22195365d1212b5458cf","src/gnn/analysis/numpyro/SPEC.md":"7c4768b3f568f1cb11e413f8a149bf13b898e31fc140ceda55321a03fc121457","src/gnn/analysis/numpyro/__init__.py":"b10a7ac33315e4b0640f09e4a17127c0b0f733e8d8d8ce7bfc8d15f2606c1862","src/gnn/analysis/numpyro/analyzer.py":"e60475d0c67fb45ffc9e134f93e932c92718db05ef8726144b67e96639278354","src/gnn/analysis/performance_benchmark.py":"49004324c2d6e0831ade39cf80e95b1ff80b7aa57977210b884e798662cb6e94","src/gnn/analysis/performance_measurements_410.json":"e542235f5dd90708fca1aacd4f9139726dfc0b87716d78a83473e2557e16736a","src/gnn/analysis/post_simulation.py":"82d3ab56a1d90af5df68b1a412d549e47c6e20431fc439aa96019f2552ef0eb2","src/gnn/analysis/processor.py":"49d6fb5f57ec0dcad29d945a5cc6b4b5dbd4127010fa5c8371650d58121947e5","src/gnn/analysis/pymdp/AGENTS.md":"15177700759f9563c17e9a406220f09cb7690f0faf44d9b06464d8f111c5c09d","src/gnn/analysis/pymdp/README.md":"1c8d632fcdd4b76a9fc3d813ba55b64d69e41f752057540fbfb952bf686ed5a0","src/gnn/analysis/pymdp/SPEC.md":"0fabb732863f22e8cb6a16c74d2ec0dcde972d3f6bea213092c434f37cdd0554","src/gnn/analysis/pymdp/__init__.py":"f916e88acf437527778c9a1dc0bd5d597d898a6088b6e9de761b1c427cbb843a","src/gnn/analysis/pymdp/analyzer.py":"23a1053fa4e68f3d38a6f2e890dc5f430e043debd48e2077e3bb5e8ddcd8ac0f","src/gnn/analysis/pymdp/visualizer.py":"166e433077abc96546a2b26cfaaaa5406aee65262c68eeb3e12c883a504f53af","src/gnn/analysis/pytorch/AGENTS.md":"20c80dd72a64444830f2f24cb8053acc7fc8b78d0e4071e8d6705a449ac25610","src/gnn/analysis/pytorch/README.md":"f6d4aafc9cb2912233c64eedb0b2405e515c60ac1a4b7c533c220cf59d2c5f67","src/gnn/analysis/pytorch/SPEC.md":"72c6d199021355aa3411abe9d601c091a58f35d11bf979bef3221035c99ba024","src/gnn/analysis/pytorch/__init__.py":"50069393e8e3f3a979da1a708964f7e034bc3534359dc817263ad83abbcb682f","src/gnn/analysis/pytorch/analyzer.py":"7c7b07a0af039d7dfdfdbbb7f42a58c85255acac97c9c949d11fbb2f296400f7","src/gnn/analysis/pytorch/torchlens_fidelity.py":"86e9b5823b21d18c34a53e90688a630d59ef7b9ee010b7e7333032674c727080","src/gnn/analysis/result_adapter.py":"6ca712eda80043546398b6cd42bdbc5c4119e0cfbe0729732fbf1496767cdf80","src/gnn/analysis/rxinfer/AGENTS.md":"82a3ccb8e2b799799c849f3a01c58ef84d0fa2a3d1d485b2f25292ac043165a7","src/gnn/analysis/rxinfer/README.md":"72eca39f88c51946dbbdbcb303d4146acbeb6006461d5d90d4afb9d42d284ebc","src/gnn/analysis/rxinfer/SPEC.md":"b4aa55f1d080e1311af7467bf5c80091a17b7082c2f0b30fc92d90f39a15fa1e","src/gnn/analysis/rxinfer/__init__.py":"c55c302ca7c1de7bfe1ae337d15ba587753fbaf5443a139eb655093372bea0cd","src/gnn/analysis/rxinfer/analyzer.py":"a79e0e084bea98e44de7be59313736024fd575a61f303093fdc81973528fd618","src/gnn/analysis/rxinfer/animator.py":"d74905dad7b2941125806f4577ede1cd66aee83dc0aaa8d760dfa3fb1eb370f4","src/gnn/analysis/rxinfer/cross_framework.py":"70063eec5c06c6c5b5de70c8228c4ff508a5a6e9ee012a4b7d15a603097afbbd","src/gnn/analysis/rxinfer/dashboard.py":"44dddbf77b49b38975c8762681ab7d1c2b04a8e16b8c8066f95c9e696bd0736a","src/gnn/analysis/rxinfer/family_visuals.py":"f503361473f8da6df9a6263693520fd40e7cacbcbfe722413855adf44f7a134c","src/gnn/analysis/rxinfer/gif_animator.py":"d699fcb72224d1b75a3554e63508e229efb55b55755f9cef6dbcc2e54bda77a1","src/gnn/analysis/rxinfer/metrics.py":"9f6b6f0932e24d297d92b815f4e7bd288c8d6478d29049c0974b63893b2e235c","src/gnn/analysis/rxinfer/result_ingestion.py":"4af0112954927e2ffa82a6da00f2411af6ed06ef2e2c5054439ab741f91c9fe0","src/gnn/analysis/simulation_visualizations.py":"7242036f9ab34ac89139c430a012c572b8170c6065f2f9189d2b4cd414ba5e40","src/gnn/analysis/thrml/AGENTS.md":"da05ed6649ec8cc0b80f45d7787263bbdbaf4fe1fa516d22ddcfcc9995d246f2","src/gnn/analysis/thrml/README.md":"eca42a1c0e32dd36f73ed14c5730222657a851aa7f6fc447dc90704b83804d63","src/gnn/analysis/thrml/SPEC.md":"3d3f8b59c421ba3f838151248f062c9282d0ff0633cda140ad86b026a7d4eb81","src/gnn/analysis/thrml/__init__.py":"c668fa45ddcd76fa8116bd08377d957a73446c3de669c2fffb9ddff0fb3ce204","src/gnn/analysis/thrml/adapter.py":"473e85d6a2b26ab49166db8a373947f7d2f4cbc1bb15201c51c81538ba48e8db","src/gnn/analysis/thrml/analyzer.py":"c13f1ffdb20ce8d723ec268876864627ec16012a6830c73aa0bbb22bd63b47aa","src/gnn/analysis/trace_analysis.py":"cb5bf34d410dfdc4f0b8ee55a9cedc52e35d43b006cab69c1ab3e7856f625675","src/gnn/analysis/visualizations.py":"6539a89a9bb80201ca2c2f681db56b3d2a6935f602f1d4f92578d13531ab6d75","src/gnn/analysis/viz_animations.py":"8c3991798a854abf4635230f41ccef083e4a71ab8d0a0df1a586725defbd7757","src/gnn/analysis/viz_base.py":"ae64735804d3e55c7e4fb417069d787d71d28a71612518ca0c1f40b21cdf7245","src/gnn/analysis/viz_dashboard.py":"099aeb5376e48a41fc3c230506b3d3a99653af17db65c9ba93d2e03182b8166b","src/gnn/analysis/viz_manifest.py":"d08413b855e86d59e3be24d86a3d63efd2ce363024b60b332e51570908380f11","src/gnn/analysis/viz_plots.py":"34c2d271fb6d2c85d57b195211c4b954bfa645ad30803f7b823dd102b6a72c41","src/gnn/analysis/viz_schema.py":"9d863e40add7711644405844910364f4c6fddb77e6ad7563b070a2427259c26f","src/gnn/api/AGENTS.md":"7680b29502cb337aa224672e2ae99d1c587a7d95948b8468f03bc93b626cf12f","src/gnn/api/README.md":"8309b585f7352d929583ac2dd52cce6d591dc13d74a72ade76e49bf98a7c10fb","src/gnn/api/SKILL.md":"065f47d63363a768373e1af31ddd5381e44b5c7951f108dd2fe3e41f77a2436e","src/gnn/api/SPEC.md":"e905935e55ef873250447909079341fbd13a2cec52e10a698627b0b09adf047b","src/gnn/api/__init__.py":"8f5a2ed2d1ff1c75339637883b3a0b6f1ab6132fe54460a3e018a99d0b0f7c8e","src/gnn/api/app.py":"2977f17ab2a5db84c6e1527db3c35928bfaf8a54ecc846a6e533f001d7e64504","src/gnn/api/auth.py":"a1d24596834f4a9540698191cc9bbbb276882b487edd4f2f22c3fb9c4ba40fbc","src/gnn/api/mcp.py":"ceefef4b69d4ffc32b8b530aa95ca1a0074f35159325aafcad25107d3f669bf1","src/gnn/api/models.py":"8132aaa65943683b2714cc7fc73ddc3755177d41998aaac6c83c3c74bdf0b190","src/gnn/api/parity.py":"1bbfaad046c9c3152a04988f25f2a378a821f5e9fccefda19fdbe86c8121a78d","src/gnn/api/path_utils.py":"1a4d496dfd3c29147ac1225d65322affd9c61a030e5b9307d99dccdfbc5ed58b","src/gnn/api/pipeline_runner.py":"14153beb44cae976c4d88f1d38724836f09afa0e45d5060f96aa16d2401ba284","src/gnn/api/process_supervision.py":"54c9bcdb41df99c612a8d829fb285a5d13e11c6a4c69bd7888de352a21708491","src/gnn/api/processor.py":"7a409e8d9612d82cec38bbdf23ef26e600702e87eb31d06ccb6506c4001b17f4","src/gnn/api/rate_limit.py":"61cb0419621c2121e4d94a8c377760d05e32cd01a6896465148c8338891e0f8f","src/gnn/api/responses.py":"083a88ab3fc64e69ceb2d20d0d30cfd4983b6e9875f37c1562cf4500f49ca1f8","src/gnn/api/server.py":"f9a864825d44896c1229e9d35d494bb8c336e45bd8ac958a1ada47cd88a788ed","src/gnn/audio/AGENTS.md":"c3231f97d8fe3c96d7fe122839c4b7d89533a8734972f689f57af04e9bb961bc","src/gnn/audio/README.md":"9d9e262497df4530b0554551e402cd61bffd62e3d2b8c2a1cea69938e91e4dd2","src/gnn/audio/SKILL.md":"f9c341fd97128eee5d95db4ef0886d1dd66af8b3be8ef76dc929f45fc06daa23","src/gnn/audio/SPEC.md":"e2cbc1a624a338f961ba12d78b4b2037f1e3e53b5a5f1d1a35c11b3a6b8a2bee","src/gnn/audio/__init__.py":"f4d09839a3ee0b8dd4c23003f638a6ee69f293f38e050b8ea0f29ae827c82d99","src/gnn/audio/analyzer.py":"5485b357a17c34235e5bf8bd8a7bb0cc37879c6445c92eb29776f42c746abf53","src/gnn/audio/classes.py":"2c02d7597e904f28edae240a74e8cace04d161200f423fd48700dbd4455f82da","src/gnn/audio/effects.py":"79fabaadbe83e0309b7d1066afbd44c360a53b3489d38b29f52903ecb165a6c4","src/gnn/audio/generator.py":"9e54a87a29dbf98941d6c50e7fc386fc67a3efc980c734e93c2bf65ea2829e16","src/gnn/audio/mcp.py":"d4923df457ebe20f87c490b1b11eefed970af807141989957bfe3034859b59ec","src/gnn/audio/pedalboard/AGENTS.md":"bc44e1e12c9238446cb9a4148acaf671101fa88b4d5f66d6e8cd5bc88c6b1d4e","src/gnn/audio/pedalboard/README.md":"c4cda3170e254ccc84c0d1f2bc15fb7396f4a77596582b29264be6a4f0db88bd","src/gnn/audio/pedalboard/SPEC.md":"444590e688eaef1aecefe1532fd12a56ce3cd2ea5a947bd596480b1247502610","src/gnn/audio/processor.py":"b05490e715cbbb41db49290678118855c3c56d051b713c4422550abd620ecb81","src/gnn/audio/sapf/AGENTS.md":"5f938a7bf04ac5b5f9f6662b0f1c985b9aeab690180dff502056f2861a33b1c9","src/gnn/audio/sapf/README.md":"aa9d239886cc7827337026aa12d5087444109ae777f05781093aed8d4224091b","src/gnn/audio/sapf/SPEC.md":"f83e0448b91d274190d282c8db94edb7528c1640c23232bc3b996b4cbaf61160","src/gnn/audio/sapf/__init__.py":"69ec60611a5135270c36662760d5c21dbc7c28aafece00561836e9a86f616184","src/gnn/audio/sapf/audio_generators.py":"0ff4f8a0ace7c6263e34e125bbd717b8ad14dd7456010835568ab639ea5a9cd6","src/gnn/audio/sapf/mcp.py":"843a396d579f0aed812275bf844e51c62bd0d7486ad60482b123ae4e5e85bba9","src/gnn/audio/sapf/module_info.py":"60e0d377354d2616f204557a9108c1d83bb73eaf5c49815259e096f1a147b9ac","src/gnn/audio/sapf/processor.py":"cb0778b1e7e28099725f4f7b89bcd0acf711c3d10e02d50f528a07f6b9cb7e34","src/gnn/audio/sapf/sapf_gnn_processor.py":"38de4123cc0338d9c59ce27b9bf811d46cdc0621a9ab01f44f498207938ac7d7","src/gnn/audio/streaming.py":"576015668ab139fe60ef748ece05e0a4b0f8e34257a56e2c6af8992055c78459","src/gnn/audio/validation.py":"eabfcd5ae64402aec34b39df4fb0cd41b65fb56bc6f6d16413f50a4f9b2d80fe","src/gnn/cli/AGENTS.md":"8d07fd37ad9b07b484ac28e321d40a88a2c8230758fa213c4a74f102822dd701","src/gnn/cli/README.md":"d9b3d82ddad8e40d1284875ad6cfca615d83fd6e4c3dd7d08564abb3b4fe6522","src/gnn/cli/SKILL.md":"d1a781cf2549a9c381919a2af82b0ad4ad081df3dc736177ff160810d24fb606","src/gnn/cli/SPEC.md":"e89ddea4f7a3cdcd91d27ea60878de3346437a272e3c5e171fb524ba99dd7fc1","src/gnn/cli/__init__.py":"c83b2da091de7ea6a4bf724f96a1f3f93bf85fdc697183946b36b75f66edb33c","src/gnn/cli/__main__.py":"fa1fb6c6ce2c69ce19a05c38977a770ce6393ce5f7c7ed4bb37d08b5cba3382d","src/gnn/cli/commands.py":"0a80a44268f0abd573b050f8b819ec6f9f9a35116b2ae6e86ada7d1c51326119","src/gnn/cli/handlers_complexity.py":"42d613cecf8472c1fd4d1cb87a9c257c3a229dc808423044ea84697b55a4b938","src/gnn/cli/handlers_library.py":"b09a68197e50f068bcfaf729fd37b2799effe0e7e0c5920e360fee6e98b4118d","src/gnn/cli/handlers_ops.py":"5f301a1efb72c21f2482cdd7be91983858faed88b8429c0d794b145f5df4496e","src/gnn/cli/handlers_pipeline.py":"618c15ce90ebc5042e100f4979fafd2db141583f151e3bc483efaada4af96cd7","src/gnn/cli/handlers_service.py":"6ec1e32e093ed6c24880935f36a0907d31036c4557299f9d9a95e254b7ad9e5c","src/gnn/cli/helpers.py":"cbb71c9864c65ccb2d2528d412fd961bd9152aa41974270d3668d13cb49a3cb3","src/gnn/cli/lsp.py":"01d4995255574ccce7211fbf3d8bc51076570dee7db69c69175dfad8eddc62ce","src/gnn/cli/mcp.py":"c092605aeb26e4a7af092e89c9de293003a4672cd1cac308d54457c307085611","src/gnn/cli/parser.py":"e4ce1dd8db5998b439a9c886f107719b8fe5e2d9e38a9d7888539823df6bfeb0","src/gnn/cli/template_assets/actinf_pomdp_2state.md":"36581ad4d126e79a8b339a8411cbe58f14fddef4beb617a051ad5d2c59e89e5d","src/gnn/cli/template_assets/multi_agent_coordination.md":"3dc6e754c4e197a3ef18b7c8cde936041205ecb64f72ba67bc4fe07b030d6346","src/gnn/cli/template_assets/pomdp_gridworld_3x3.md":"a87cdc89163bcd1b612f902d21ad16f95e3d25c7ff59e3718fa0179b1bc4d302","src/gnn/cli/template_index.json":"aacef2746e2662b0bddc8a96722aeaf5f79411582930f9e154431c5d9e0e1c20","src/gnn/cli/templates.py":"796c392c668719184aadf6f1148a8e471ff5c3eb212c9dc66ed86ee3f8fc5af4","src/gnn/cli/watcher.py":"0fd3b6142b231b23f5c4285cb16502034baeefdf5abe7adf62a0d49a105fdf02","src/gnn/doc/AGENTS.md":"89a825ea20cebf226b9ab7ccd0418c09ce2039c36597ae3a383c69e3dc4f7e4c","src/gnn/doc/CHANGELOG.md":"463ad7a0963ffc2ca3e50f19ffc4e2217cc5d59f450f6643b55dec15014ea20f","src/gnn/doc/QUICK_REFERENCE.md":"314bdc0b2a8a22da457237a02ce6dce9ca55f3eb8c8a4f6a62a2502a8fb3b07e","src/gnn/doc/README.md":"39382d504c06ec8cc914f5d07549d50bd7970c07f81374fd190fbf3efdf705ce","src/gnn/doc/SKILL.md":"0ba58c72c0fed16a22b37e039e0272aa763fffe80936d5b2ba55fee2994fb259","src/gnn/doc/SPEC.md":"cd39dc95950c6904271e7de8769bbedae135599663c47cdf81645c9495e5c1a5","src/gnn/doc/__init__.py":"ead01e4d8ceb483187bad3caca48b69d6b3be1171402cc918d462ee0246164fd","src/gnn/doc/cognitive_phenomena/AGENTS.md":"72cfec415aead46ff10c943d57762eb7d607de72597f38f174cadfbef5ca4425","src/gnn/doc/cognitive_phenomena/README.md":"ea2d17beebffbe31f098e26782acc9ebaae0f10d35d76a5a470dc8341c56636b","src/gnn/doc/cognitive_phenomena/SPEC.md":"4c681d607925296ea4600569ef0fee0f6370ba9fa0a455d6ee6aa5f34fec0534","src/gnn/doc/cognitive_phenomena/effort/AGENTS.md":"0f2a74681ac73d51dd0c8824671f21f76a59bd75dc95b0c99d24bbe976063e60","src/gnn/doc/cognitive_phenomena/effort/README.md":"648194d1637de1645bddfda99bed6d6523738a8c2255bf7b5dc85ddb9f93aa90","src/gnn/doc/cognitive_phenomena/effort/SPEC.md":"63378278f38499b167887f9640b174dd606c5b13bbf218cf7b6f883d6c8e236b","src/gnn/doc/cognitive_phenomena/effort/effort_model.md":"383d63fff7ade5282897ba30426b73bac27be81aea277bcb144e127d7b262c01","src/gnn/doc/cognitive_phenomena/memory/AGENTS.md":"996a561ed295ab65cef44fef3b29d9609847914f7e67ff40758f7b22a59fb7b2","src/gnn/doc/cognitive_phenomena/memory/README.md":"bbb547094bba9cf768cc10cfba03dfa41908be7c7180bb882fcdb9fe7bf9bd9f","src/gnn/doc/cognitive_phenomena/memory/SPEC.md":"241d60964d8785e998b764117f84c1f154e13ad8c7523d6f45afaa290cf4428a","src/gnn/doc/cognitive_phenomena/memory/memory_model.md":"3215f4f9071dbffc3d0ea0a2b90b83fdbdce09d63bbc81cff5662de4cba1b01a","src/gnn/doc/mcp.py":"10c4a8ff0436227a08f3f63f079c348fcab52bc09ecc8cd336302d26f8e90dee","src/gnn/documentation/AGENTS.md":"f3cf2a4c8ff3c41a84c39d3dadee6bff8530473bc9a177eac921f733062afd94","src/gnn/documentation/README.md":"7cc6ac21389983d5f6326f09ba74f7b8b4c81899bd3fceaeafa2ad91dffb5b51","src/gnn/documentation/SPEC.md":"62923625b5085e8c17913e74ccb0ba8acb47c5bf7f4b3205094cc55dde7df1f1","src/gnn/documentation/__init__.py":"d3c82918a08f54e2f708cecc12f0cc1024e217943c139b76e7a53a66d6898f70","src/gnn/documentation/file_structure.md":"cab37d65e5dfcb915cb98f4b7a4173c31722447a8b5ed8b973bc0666651a70da","src/gnn/documentation/punctuation.md":"f5b0dcf1f20c9d2771daa9089500840203180c0373053063b6ae86fc5f8b01ec","src/gnn/execute/AGENTS.md":"0ffc1b50bc0971e8a1b9c7ba35f0f77ededa6b9980863cdbfd93b6dfebca2c1f","src/gnn/execute/README.md":"171b3ca737297240a7a507e82e2b88c4463b103cf878cef7536daef370eeea6c","src/gnn/execute/SKILL.md":"e15086dfef29c8789c70000cbae95dcae8ac00cb18b28f2fa875f9b05c747459","src/gnn/execute/SPEC.md":"8e49103f29bfc491e1b274a6fa871b21c4577835fd337eba338399bb42f28a9f","src/gnn/execute/__init__.py":"5119b703424a680faca1be0914f0821a3828ec213c9498612fe69ac653e15d8e","src/gnn/execute/activeinference_jl/AGENTS.md":"a10883a995aa50626fc50590d69c3d3e8c3d337b78f8c0e5ba86f879f3ba50e4","src/gnn/execute/activeinference_jl/Manifest.toml":"f7b3b86639cbee5c6f464d2eb4b9306529a35df6b37c0429c3c449b64c18ea09","src/gnn/execute/activeinference_jl/Project.toml":"1f60ede7f8f04efa6cf3012778fdc86cf69cc133137c329c70c6357f0b7810ae","src/gnn/execute/activeinference_jl/README.md":"af78defc744c373b54382820b6f7b732eafced3f4b79ed11687452c585f79562","src/gnn/execute/activeinference_jl/SPEC.md":"fe2146d975cdcb83d0218e2d663a7df4d340389375777968f1fcb86a47f6b5c0","src/gnn/execute/activeinference_jl/__init__.py":"953cafb57f60401a8e537a9080f933089cb55a9781d1421922454ce9c0ee5831","src/gnn/execute/activeinference_jl/activeinference_runner.jl":"f8511c18095e44ccf77f72456aed7b97d07c9f7001a1f870612376a6ad27f5b8","src/gnn/execute/activeinference_jl/activeinference_runner.py":"7ee97eac573fca8bb100221a6b0eed0cc229a5cbf8221875bf77af21b66d3256","src/gnn/execute/activeinference_jl/adaptive_precision_attention.jl":"4792ec2d1889ddbe763d036b4282ccd825104d1d678ed0268740fa2301a5990e","src/gnn/execute/activeinference_jl/counterfactual_reasoning.jl":"dab3615dfbc836da2c1bca63d917e5092e0120e3bcfd9a18cf4c7c270578222d","src/gnn/execute/activeinference_jl/export_enhancement.jl":"18977347e946ca74608c927698e5255f55bdc2d35e05c9778f68c471d2b86007","src/gnn/execute/activeinference_jl/integration_suite.jl":"4a70898dad769df8b01101e4dbe1721356ff1add2fdb3a8f815126acbe7d9b79","src/gnn/execute/activeinference_jl/setup_environment.jl":"aedbad898295ce08a3999e80a3229855c64bc78c1e9b3d6cc99095b80c15aefd","src/gnn/execute/activeinference_jl/src/GnnActiveInferenceModels.jl":"455990a0a9e8589348b12261697bcac525d42dde024f1fd46d44d0c91baa75e9","src/gnn/execute/bnlearn/AGENTS.md":"bc9a844e0e3b551de9872a868e2bf36d79cb7d3d18b7f4022b4ced49d2150cb1","src/gnn/execute/bnlearn/README.md":"67339f5efcb58ba8511afcc2b2c61b64a62c951e9a37f6752e7d76cfa77a47e0","src/gnn/execute/bnlearn/SPEC.md":"25659da36ce0021653ec272c7d2ba555215138ea9669459a8ac356cd60e5a0cc","src/gnn/execute/bnlearn/__init__.py":"4825088d05665f865579488987342212dee2285eaafdbff7c0549df088e5be7f","src/gnn/execute/bnlearn/bnlearn_runner.py":"62e50db64f3d5173cea9e4a4f6a630cd24ab29b126727ead070ac385434af115","src/gnn/execute/data_extractors.py":"0ef72fbe786e3632a75bad80ab6cb97033d7f41d6c7758557daf1a455089666f","src/gnn/execute/detection.py":"c8bf3a67dd31b34b65e7d5e83446ae6f382c5b5b7468e6d71ac39c696ddcaf73","src/gnn/execute/discopy/AGENTS.md":"99e5b65a4618225b3f5ddb71a29abb871a30e0b09d4ccad92611c478bdba757e","src/gnn/execute/discopy/README.md":"f2b8eb6cdf4bd2ce4f14b59e79af1f202b063e946efe4525aa3315f6b6dc722d","src/gnn/execute/discopy/SPEC.md":"433298d4b8801dbd3d7e94b690e236e7a305d82b4a7c7620eea0b8cbf7ef4dab","src/gnn/execute/discopy/__init__.py":"d8ebaa036b34be632a228426763382395d490a9a7eadd2729fca1b8297d3e597","src/gnn/execute/discopy/discopy_executor.py":"040018537c4222b4e5d035befccf0567dba8768db98550367ca5e04aeef0970a","src/gnn/execute/discopy_translator_module/AGENTS.md":"446adfe22e7d73fb0796c4824376825aa5f12cddc96a3cdcac113324c5f6e46e","src/gnn/execute/discopy_translator_module/README.md":"abd140524def522d386cfdaaf8f561b654f8b58312f21ea277e878d066bd548f","src/gnn/execute/discopy_translator_module/SPEC.md":"3748c4ed64fa1710eb753a43e1572a6ab9da1661e6151d8ee50d65be3053d775","src/gnn/execute/discopy_translator_module/__init__.py":"7dd22bd768938100c5e5bee644cbdc563f85325d65c68fb0bfb53bddfbacd896","src/gnn/execute/discopy_translator_module/translator.py":"24b3e894c90c59c4ee32afb2457eb9c84dedce7354eb3e6d104c9f0d9f23ea5f","src/gnn/execute/discopy_translator_module/visualize_jax_output.py":"c20f0d98f9b6f62c2db90d182978836d98ac9d9157bba1fe8ebee54874a480b6","src/gnn/execute/distributed.py":"4657b078307d68b26735ed62cbb42887332938a4b46cfad8d9f9e121fd2ed08e","src/gnn/execute/doctor.py":"935bb10679298c1fb1f2851d98722249dfcb9ffc882861a27b64c1be81fca44a","src/gnn/execute/executor.py":"eccdb55ca9b2dd91ef5c9ff7edf04bf4a18d46e681c02221112613e6c4431960","src/gnn/execute/executor_report.py":"653dc7ae83d6a7a6acb56333d59d60019f4fed2a771c6e0ea85b58b13daa4473","src/gnn/execute/executor_specs.py":"f3dbe46dc1f119fc7d4233a192fa2470c024236b5eb644ad90d13772f91fed8f","src/gnn/execute/jax/AGENTS.md":"79b530137ca40f8595cf83055bfd67515754856d29f6599b1cabe6d71db35983","src/gnn/execute/jax/README.md":"849f298d3c2a3beb0d83febd1fa14fca5f20e84284bacf9745b7e3f3a519e580","src/gnn/execute/jax/SPEC.md":"b2ee58737752e50ca633c30aa41412d97aaa582b648e7c9642ecac580f28ac4d","src/gnn/execute/jax/__init__.py":"7b39d2cc6991b76e4511a9b1cd8e23199febdec54850e1889d777b6e7f1dfae3","src/gnn/execute/jax/episodic_contingent.py":"3a8b3e0c1eee2baaecad2df13b478ab1e0ce445f8f913b4b630405664f1417bc","src/gnn/execute/jax/jax_results.py":"ac562389b3f72dfdea79f534cdbe98127fab1c04fa862d4166309b44284268ee","src/gnn/execute/jax/jax_runner.py":"2cd2954759773ef35eb9f84c37ae4daadc0c80d4f91adea202db88ce0fdc47dc","src/gnn/execute/jax/kronecker_executor.py":"aff5fafd1c41f27cea644d4bbe5f4d1e85cab9cc2dcb59d26342939a8fcd26e9","src/gnn/execute/jax/kronecker_factorized.py":"4dbdd5469b63446d9b91c88ae33436f32a839dedd9df4f6a15d07517bfea604f","src/gnn/execute/jax/semantic_runner.py":"b682f0be03ead79846166cbcf02a9319043b17c9e16e6c8fba634df59c76d107","src/gnn/execute/julia_env.py":"756648281828a2dbdfe8d637d3e5a9717dae680786a4c2d52af33bf8ceca3674","src/gnn/execute/julia_setup.py":"32c169ffefc8a080253cff8a3b10424f3b79cc674ec5ebcff41c5375ed46e6d8","src/gnn/execute/lean/AGENTS.md":"7fee74d0d6781618a96d3c03527e2073db9bd55bd4b13c4cf31fa84b8d02d2a2","src/gnn/execute/lean/README.md":"23ff0127898a10fa1b35181b174fa1c01ffc1ad5a4da2747eb0e4f77359fe10e","src/gnn/execute/lean/__init__.py":"032b40338cbca9e8eb1bcbfe5a7a8914a4737fa9c61a506e736310f74b50f248","src/gnn/execute/lean/lean_runner.py":"8043462a544970d3a470a4684eac275c3af18bad546ef4c53630f4f492bd26b3","src/gnn/execute/mcp.py":"08eebe803698feb65b417e5877422c16130b452d20eed4c9f81fde8b2b302a97","src/gnn/execute/metadata.py":"db89c94549e458d1065e5e0b1a65ba744cdae74b9371aeb7e2996fe04631ddd4","src/gnn/execute/ngclearn/AGENTS.md":"762d2afe917d6c722633136b569ad76daae220a061129476a9336786fa1cd068","src/gnn/execute/ngclearn/README.md":"1944701a93f483a35791db664f12b9bd003443e107600a22f25f914c877dfdba","src/gnn/execute/ngclearn/SPEC.md":"380f7026ea59f9498a14c33e3a7982893697c01eceb7680df198482f0104dcf2","src/gnn/execute/ngclearn/__init__.py":"c44d4f745edac07c365438e03bb0993f74b8ba49a0438c67ace07b8dd56bf056","src/gnn/execute/ngclearn/ngclearn_runner.py":"f04103b5a64105173a8429340810006d70c9dbd3c70d2f60c7db2bfe8729d103","src/gnn/execute/numpyro/AGENTS.md":"5922d669180d8b33f22b0806fca602af0723160a6bc2f0e381b99b5df248b244","src/gnn/execute/numpyro/README.md":"4914c0bcc6d51227d3d01c1eaf4cd642587d328c4e5038d39ee47f786208f6f7","src/gnn/execute/numpyro/SPEC.md":"b83e8acef00600d8b4f4344837b78c7ab9dfccb06e19e16496b73565a70ebfcb","src/gnn/execute/numpyro/__init__.py":"3ec236223481a1b67273ce2c321873f91243f3e25a17a41affbd4fb69bf8ef6f","src/gnn/execute/numpyro/numpyro_runner.py":"30dc7aebc43bb087913639bc00a995d32fda666db8501dd2711293206c894e47","src/gnn/execute/planning.py":"ea21f974f2ea81d6621ac8b96b6f62b88ff743838f1902b1e6f0bef5cdd0f6d2","src/gnn/execute/preconditions.py":"1e9e93b4f0bde3bc447f399d1e15c3c8ce878e5555d9e9e515d7900d74d0189e","src/gnn/execute/processor/AGENTS.md":"0bbd54efea7a37ce31f48947cd725a8d3537d7f8a11b2a12b6901416f600736c","src/gnn/execute/processor/README.md":"4d7bd9eac1b67470a62e0796adba34f4cc0c9305b2f4b6b15892d2e44a4d23da","src/gnn/execute/processor/__init__.py":"cfebe8c79e6b89a5cdf9b82f80fea9f002f48ce082d6d0a622f14dfb985e3acb","src/gnn/execute/processor/envelope.py":"7a3c598e10f4ceb8e347de5a7599c42593779ba7d263938899835a547adbfffd","src/gnn/execute/processor/pipeline.py":"bfab7ccb84ac861828e7073e1c811423a73b5cfa319aae944e785b772462133b","src/gnn/execute/processor/single.py":"40914f6d80e54380dea88a8cb44df564cd419aba7c0626526f5339578715ea4c","src/gnn/execute/processor/summary.py":"1951de5304aad69dde40c6cd66dd07efa8fe845134aa0dec84eb25b1731a051a","src/gnn/execute/processor/workers.py":"68d1f8a3ec32e5aacc2450c4c1d70039b46835f9c4624ccf308de5f978daeee9","src/gnn/execute/pymdp/AGENTS.md":"41e87d2e0bb4e17a58951abee54bdcffe85cd17fdf58f55f2d072cceaf21da2f","src/gnn/execute/pymdp/README.md":"4eecf775409c4b3459ee15357b6d7331b435ea2de4df66d70ddfd590ce049f60","src/gnn/execute/pymdp/SPEC.md":"a78f3b5b267cecd6a5ba2bc1d3d1994f5a7059316b299b77019242a039037b3c","src/gnn/execute/pymdp/__init__.py":"5ec278d4a84fa554b2b9055b351e9403da4db9efe647d76afda69963f9747ef5","src/gnn/execute/pymdp/context.py":"82ed31caf5b6fd4424461e6aae2c97f484d49d153915a472320b0ed097e34511","src/gnn/execute/pymdp/execute_pymdp.py":"6ee17a4fc6bd824a6bca64b62603eade47d864eaed613317409c3893292adf69","src/gnn/execute/pymdp/executor.py":"7a6a52171f6efb8224fa8cb8a09426a3783a9ec5ba7ac40b6f0034cdfa0e5c8a","src/gnn/execute/pymdp/mcp_child.py":"2eaade4985ef85e9f9668f177484aaa514e355c21574a2a9991588a45ca029ad","src/gnn/execute/pymdp/package_detector.py":"c929f2779813fdf465b3ec44f4fef2e3718b3199f0b397ece3ffe3d5a3590544","src/gnn/execute/pymdp/pymdp_runner.py":"d25debf577bc824d787ac948cc3c2a94029a69484667688a05ef7240c8b28ad2","src/gnn/execute/pymdp/pymdp_simulation.py":"1107d9192cea5101a4bd22d5c3c8529abbd1205544687c3ab33391be45b9d001","src/gnn/execute/pymdp/pymdp_utils.py":"85a29bfb54881e3045454096ddd8d83788048d7cd60f860198252e9b37918864","src/gnn/execute/pymdp/simulation.py":"5a9ce849731778ce87c4a411d4985a8231fed3e399253523b0e10c496307ab3b","src/gnn/execute/pymdp/validator.py":"ba69a5fd2c04db65be88bc887a71d9ab95eeed092f65d709a0145e035086455b","src/gnn/execute/pytorch/AGENTS.md":"8305694a571c9832d1a06705373df96588fc848ed7533496eb6f455aedc54ed2","src/gnn/execute/pytorch/README.md":"1f6cfc7bcc747d9f051c38bbc40966d08f2a7d306ed68cf45f6610dfa44eebf6","src/gnn/execute/pytorch/SPEC.md":"b8f27a0edd4ab06da044fc4677e7412f76deeb7ba7b9770c620f9129c9fe331b","src/gnn/execute/pytorch/__init__.py":"1f463afe6fb5f417c48277a463d24228fc7c1e1ccd46638630877e73f5fc5ff5","src/gnn/execute/pytorch/pytorch_runner.py":"ebd6d846158884289a769a6de64ee07c1b585af2554154cb8aa05b63c56ccd41","src/gnn/execute/result_cache.py":"fee460b6eb4f7688d061f49b2f14bcdf1635572bc91ac35859bad67c0413a572","src/gnn/execute/rxinfer/AGENTS.md":"5a6f7292b19f6d85de3887296fbf0af74d6d43c585a78cb5a28ca23325d8b27d","src/gnn/execute/rxinfer/Manifest.toml":"e3ec39ffcbabd85495f4ef74d7a7995cef1958c230fcce025d7849e24598b5ac","src/gnn/execute/rxinfer/Project.toml":"13c9bb7bc658b0644dc91428e0b7b86c6c676f17d3475cac62f2dd5f1aba9cb5","src/gnn/execute/rxinfer/README.md":"fea9c01d0ad466b3bff49afb1757e167499466af7ac27295410e7cbea33d94e4","src/gnn/execute/rxinfer/SPEC.md":"d6e4f4012cf86746466a989fabc277aead0e6b59ed04ae64d4a2df36c383ff36","src/gnn/execute/rxinfer/__init__.py":"c48428aa54627adf014de7f54a50b4b717e45eee6e6a565ba84ea96165c98c22","src/gnn/execute/rxinfer/rxinfer_results.py":"b65969c33418a4a217d70fe88549664d8d5fb25f818f664b1434820b4e66cb6a","src/gnn/execute/rxinfer/rxinfer_runner.jl":"8acdc87892e058e9d660f6db3d187f9622e0c9eb4ae5a721f431d25acb59dd53","src/gnn/execute/rxinfer/rxinfer_runner.py":"80d071a71ce96a1cbadd8e40a2da61f17b5fa23d5a916f897cbfa8ef9d0655db","src/gnn/execute/rxinfer/setup_environment.jl":"09c66e116f9a76ef340bff18f4f773dfe1ef1ee2dcdc00111caf048bc6d535d9","src/gnn/execute/rxinfer/src/GnnRxInferModels.jl":"54d8bdfc2deea9ced6f90d20f853319d044754c864c35efc791329657ff310d8","src/gnn/execute/rxinfer/test_models.jl":"a4db3f51d7d84718ccfda2ba2f82e32969d81ebbca7195562f2134c3edc06c7b","src/gnn/execute/sandbox.py":"6f2d6ff5afc449d591e79749b3860921c785f2502f3430b8034d3ee292256cae","src/gnn/execute/security_gate.py":"35557ee078442d8909085475a27887255fb3fcdba11c1dfc698080de839434c8","src/gnn/execute/stan/AGENTS.md":"bc21ca8c4276675ecd9510e664c6156e74355516dc214ce3f499d6441bf9d284","src/gnn/execute/stan/README.md":"af41ef258932ff3a8cdbe894dc4418ae22557340ab904085e1d96d3178e1a674","src/gnn/execute/stan/SPEC.md":"d5601aee057b27bf0c0e1e94603012c70c78d7681256307fbb8fae68b082a9a0","src/gnn/execute/stan/__init__.py":"93976e5ddfd1ccc9f0fbc70790a82eff374b52a1d63018e8de9ee1a6de797da1","src/gnn/execute/stan/stan_runner.py":"3e87dfe4ef7ea3dab9ddc3bf286602410b24a9f048f85477762bbfc52e2f99e6","src/gnn/execute/subprocess_envelope.py":"8e5bb38f4ee0d2a6bf58bbcd6aa257f91f7694fbd79561af4a4ceaf9298c3092","src/gnn/execute/thrml/AGENTS.md":"88a8fa59b66d1cefabe348417c1d38563524dabd4df54b97c86616af2f5b908f","src/gnn/execute/thrml/README.md":"6fe02627c2466e64495644474b892a8b4e47a6b205ab180c9f6fa2b5cbbdc19a","src/gnn/execute/thrml/SPEC.md":"5d6aa38c4dac0f24b858c01b84561b06812574d9bc85de3e25730d33d14f9959","src/gnn/execute/thrml/__init__.py":"f2c2d2990c4dea7b375e6938fa6d93b443dc0bd94a2f4b63f4cbaec672b2d6f8","src/gnn/execute/thrml/thrml_runner.py":"ec99851329c09b4619733c568d444cabc7ff73f49b2af0e995c1173813b1ad8f","src/gnn/execute/types.py":"10f4bae2188a8e3fd350ac06ce2c218ade5766cf5b774a1df1026d3516af1d56","src/gnn/execute/validator.py":"1b7f9cef59cdddbafbc2d4c8cdbfe9a217fc8c165297d5d227d1ea2c5814373b","src/gnn/export/AGENTS.md":"8f864be6d7ed47d8be56c97d8d0572ac3c816bd3c807113d8198d88d154e1101","src/gnn/export/README.md":"d35e800210e4450de385e2a67f99bdca209bdb579dd12ef42f3b8b7f6e6501c3","src/gnn/export/SKILL.md":"1d24b8a409bc1c6ecaf038a327e37cdc15736899b5f910e1443b3b81d1a9aa56","src/gnn/export/SPEC.md":"000564194461791c7dd376f0bac4f4fe69e5342cc2ec9fbe3be47601e9dac18a","src/gnn/export/__init__.py":"4f062a238485b91a25e9e6875568001bffd8a43915f72c560b7194d97873be18","src/gnn/export/core.py":"cceb7347de76e0578e8526d2ce1dcbcbb0eb807d28abaec4ec7ace2dccff4607","src/gnn/export/format_exporters.py":"14187c15a33458c3173c6339de43d874d707368656ce65762d7f9f0fb2698c73","src/gnn/export/formatters.py":"e6fe07ea872882e1335cf7d3e411120f98d307c31df33c52eb418cf5650db174","src/gnn/export/geo_infer.py":"af771d84aee70a107dba087e5afdb17a490235db1db8c21ba4ee80f33b1c1124","src/gnn/export/geo_infer_contract.md":"ffd97cbb7dfbe7aecdb2df93271c04daa74bc668ba4affcc5689f700b05935aa","src/gnn/export/geo_infer_factored.py":"6de3490d1c2e7bc8d292d6bce4b0c0430735de8ed7d155bdbd4a41d86d0dc90d","src/gnn/export/geo_infer_factored_contract.md":"036d828c01a03f82803b7b1baef819e0b63b226c38c4006834c4d5dada9573e8","src/gnn/export/geo_infer_gaussian.py":"71f71576d9efe80fdc568053bf30f724ed6631e7e5aac3bebd229c3681ac2702","src/gnn/export/mcp.py":"8bd2d4edfaaeec3d4c5d674705bdd5bcd44698a7da24fdd2ca07aed60cf3a05b","src/gnn/export/notation_metadata.py":"a737e12b731cc3a5ecde0ca5a7908c973eb4f81057eb3da9f6a0dac817c1d9a6","src/gnn/export/options.py":"fcbc9905b5d1b33be8dfc3a3fdd73706faf1a0d50a91eb59b9b22a62cdcf78c7","src/gnn/export/processor.py":"da2291ab8b57dc24e6b8b368a6cfda3aea9d78ae1b781566e44f5d01448b47e1","src/gnn/export/registry.py":"cefbeeeff1532b07ee421387794bfdeedd9cedb66addad4572b0ef10c8215414","src/gnn/export/utils.py":"d6e4c89aea0cc9684714304e38005ac36094b415f505bf1ad4e21a2f429ea0ee","src/gnn/extract/AGENTS.md":"d3e7f0f1e643e60050501051665eabe1d659b451ef5246f2427e3331e145ce8b","src/gnn/extract/README.md":"87d02f46311e4e1d298466315d6d74a8ff60716658c008cfeeed4eda0afa619f","src/gnn/extract/SPEC.md":"aaf44022a4004a13995103275abe7bc3b030faa497868d01280d7ea773c58b12","src/gnn/extract/__init__.py":"baedcbf88025e9ddc77a594f7df6c60c90b262422b55486ff0580349e0f5d3ab","src/gnn/extract/__main__.py":"eb164f49b092dec754873bce34907a1bf569dac969d96a926c701788b6e53a29","src/gnn/extract/mcp.py":"8f8715cb6f6ee9e072d0ad32f48cfa572936c2c5e4a85c4472afc209d9a447f7","src/gnn/extract/pomdp_extractor.py":"82590677034c17517873e4ae1ca950775663b2a7e6061582d17bc1e6d9689905","src/gnn/extract/pomdp_orientation.py":"ddad6cc147634312ba8dab0510281aebea89aff9d9398a4420518df1c941b5d4","src/gnn/extract/pomdp_parameters.py":"90021cc5a513660ff8e1311224b0d34d3e16a892e76d3defaf061c8bce04585a","src/gnn/extract/pomdp_sections.py":"ea58a304c83a01e7f28ce30bbf94fb5bfd438f7123b0dbdad7ed188a9cab6878","src/gnn/extract/pomdp_state.py":"05ee843e1329485f4d9b525843c2277dbdb2c93264d97c60e4c98ab893f09cd3","src/gnn/extract/pomdp_support.py":"c77d109e390061fe6ea5281b9858fd472c801e7b740c3834d3fed8b9f82ea7a8","src/gnn/formal_specs/AGENTS.md":"b2d175ad8c08e74f75ab8318e04a2607296623c7bc66b21ffae82276569f6cf8","src/gnn/formal_specs/README.md":"5891d99ce1e726171a1e920ae9394799c657d694f487c7443371be21b74c2ba8","src/gnn/formal_specs/SPEC.md":"3018f7c7cd157a49045e96c5a38b1c9f9f51e4d16924fb4b791c97419441986e","src/gnn/formal_specs/__init__.py":"d7950e023dabb5311a42dd70100241d9212b5836b3977956b33fb8b5ceefa82e","src/gnn/formal_specs/agda.agda":"c697b0039a1637becac66be0e9609231c42ce1312023d0f0a8608459dc46136e","src/gnn/formal_specs/alloy.als":"2f402df66820b4a2d6ac01110db91457247e8d5b0cecfdb76f59f9cfe91e79b7","src/gnn/formal_specs/coq.v":"a7ffb0917fe8e85b63e01da9a0baa6d00646e6e7881f5fb3599c4aaa40ede78d","src/gnn/formal_specs/isabelle.thy":"bc3118340d5207926e258cd32ef772ba932671c6681033db093b2b66e4a5eb5f","src/gnn/formal_specs/lean.lean":"501432b658a88c7e884f3fc24fa9fc0da08dc54117efe9e47edeab5f0902febe","src/gnn/formal_specs/maxima.mac":"b1d0fcbaab25beb68c2bce2b904c539d876ac86fa38ca5b42ea0e88873a6b988","src/gnn/formal_specs/tla_plus.tla":"aec34a340583e40b8407a47d81a3f23ad0aa6c4b74fd37b895a53f11033d72f3","src/gnn/formal_specs/z_notation.zed":"e933ab55b6e0e27168b03d46be64b7b87dff476307274ac839df0026299622ce","src/gnn/frameworks.py":"99a62126aa8b86b3428878a052ede1f1f022de102db99cc7381090b883eb3133","src/gnn/gnn_examples/AGENTS.md":"87106e8d3acf0cc262f4c7a76d119c14d1203a79b49d00c708475f07ccf1123d","src/gnn/gnn_examples/README.md":"23efaa049ceed5be8c6384c01c5819b17ba47a04fdb4eab1f16c410b2097a517","src/gnn/gnn_examples/SPEC.md":"ea1e7927c26f1b333161c7966eb64dc357a8414f7b1cb51e852d0b116c1ffc16","src/gnn/gnn_examples/actinf_pomdp_agent.md":"76291fde1990d152b0b21fff1733fc7cca5eb61eb16972fb0b4e606cf41df804","src/gnn/grammars/AGENTS.md":"3a8e5743fae6f0a09b7044b3e020a4006b576f210df0414f31eb0f7630ca26fc","src/gnn/grammars/README.md":"a30c6da4aafbb81cad851364ad46caae3dc82a2c81339340c2d0ad3fd217f648","src/gnn/grammars/SPEC.md":"cc73f9bb4d27af03d6403aa4ea1292ff744d9dcded83a658c45fd1898e8dc5b2","src/gnn/grammars/__init__.py":"7c9abcf3a413d143604bdf7ba740191cf83fa70d54115f042347bd4718c8462e","src/gnn/grammars/bnf.bnf":"f3d40b65cbb44616808392f3491919bc6bd2ee379d5d08756a5ef53fea674ad2","src/gnn/grammars/ebnf.ebnf":"1c6ff084121afbaac1401758e894b6ef5c1defb9a7d341e7eaf0d9c41120a330","src/gnn/gui/AGENTS.md":"df0e2e4d809a2fbd88c3ab091e1c27b8bebc3285795a262204ef6476d8a03a08","src/gnn/gui/README.md":"6b652f724567ef59396cb82daace373999888bce59a84e4396b51696b6f31a92","src/gnn/gui/SKILL.md":"aae81da30f2517d38b3296e63ed93d53d0ad1f83a741225c67493d9c0a26893b","src/gnn/gui/SPEC.md":"307072914b1d3af797bc3dacae9aa3f8fe531c03f35d82c63972d16ebde929a3","src/gnn/gui/__init__.py":"011a805315fd8b256dc4b90567678fa4602b07d4574eeb81776e191610f014b5","src/gnn/gui/backend.py":"30110f844e0095f6ff38a35f114924e7338627b471a9e3a48d32ed070fb5b786","src/gnn/gui/gui_1/AGENTS.md":"4779f4089f83bcf5ea7c13af3146507e85a6948bdefa7da3391a85eb916d6fa3","src/gnn/gui/gui_1/README.md":"d993100afd5c210e630dccbaa3e1180d9ab0012632da4abd7a54b399623c9686","src/gnn/gui/gui_1/SKILL.md":"ea433b22d51efaeff723a3881e49e66a079b3664ec989efb73e2861f5ff3885b","src/gnn/gui/gui_1/SPEC.md":"167f0e7911385d106c167af8b9aed09578dad6e3b4b31f0df4bdc7b0db98eddd","src/gnn/gui/gui_1/__init__.py":"3e7ba1739b1ea4b33ed99da956da2ecb0fbc998e0a68b23d84c70fd84a8ef5a3","src/gnn/gui/gui_1/markdown.py":"cf457a48ca4fd2474ebe05e1b3cf8eddab68d4e1f1ecf56b0e8964c395c591ba","src/gnn/gui/gui_1/mcp.py":"da52524d4df18b528ad92efe083d7e4b97761204526f093bad6fe479e885559e","src/gnn/gui/gui_1/processor.py":"b8ce783238928944baa7e7f9957aa7081c3d753f10ba25f9eda21431f334720d","src/gnn/gui/gui_1/ui.py":"46c1a6802b4494979eb6dccd32377113d7d0747d0edb59c47b39febc267d90bf","src/gnn/gui/gui_2/AGENTS.md":"7353c6c79de1401b9833b206023461d0da28192fb42a1e149d5775868678dc0a","src/gnn/gui/gui_2/README.md":"d9a1325e0c13af77d1b206a2551c1a537fa9680969b86192ee9b6a152b1db61d","src/gnn/gui/gui_2/SPEC.md":"b768bf1623d0433efe86231c794c3c3ba49855fad998195d3c5b694eff66baae","src/gnn/gui/gui_2/__init__.py":"a656b35cb59db6f98aa880b0021604051db128084de3f6967b15a2cf394d2cf3","src/gnn/gui/gui_2/matrix_editor.py":"51c8835d3ff1f755198ff9d5a304ef83055e8e2b3c7f2ba2dee450fbd0e5e7f1","src/gnn/gui/gui_2/processor.py":"ab8b70b57f964650d76b663c1c64314118d6da70f8dfb137f8c0d6bbcec8daae","src/gnn/gui/gui_2/ui.py":"a1b0774a47a416f2bbf26caf64cc809c744e3802b565a1112ba7c8e0477864d9","src/gnn/gui/gui_3/AGENTS.md":"e7e9c1d43e614c0887c1a8c23d27948f2df54dde455d3b68b3548c6ff2c789d7","src/gnn/gui/gui_3/README.md":"6fca874fcafe32aada92f5aa31324a37477eea50d521718ec8512581f2d13d45","src/gnn/gui/gui_3/SPEC.md":"72268dfec5d8ee19acc1bedbce8bd1b1bfcb3d60be69a59ca1cbebabb8b49730","src/gnn/gui/gui_3/__init__.py":"534c2f7d63089745935858c9ca9054c3718a36e577eb32e390f7379db68dce1a","src/gnn/gui/gui_3/processor.py":"952ccec45445132402e5df5437c5c551cea09d3fd3801c463c100412511bb96b","src/gnn/gui/gui_3/ui_designer.py":"e280d1410e69ac6424f933f4b00fcc67b61e033d5db280d732219b473eb8ca82","src/gnn/gui/mcp.py":"7bd9ef45f82159abbf2d09621c2d0c0e84af84b154011a66f34fd161bc8e1f4c","src/gnn/gui/oxdraw/AGENTS.md":"78ff3df3ae203dc2519e9cb913141ed42a24a82ced254811f7388c8efb3c40a9","src/gnn/gui/oxdraw/README.md":"e51f81cb1c46eb2ee00ee5bde861743f2947137890bc1c1224ca4329173bdb86","src/gnn/gui/oxdraw/SKILL.md":"830b27f6e4ddd08d1df6b86824757b2d0e3db74d6ff76d48296b03001952e9b3","src/gnn/gui/oxdraw/SPEC.md":"458e2c8d0be2eacdd19f5e74e9414d58666456825ebdc8978dd092c5c3819915","src/gnn/gui/oxdraw/__init__.py":"a62ab4c501aea6b207397a58019711c3a5104a68c89d1fc9fa79a8d83e133903","src/gnn/gui/oxdraw/mcp.py":"4c3f7d588472b2d3e987e716756a21308cd089b5e36a575308547fde3076450a","src/gnn/gui/oxdraw/mermaid_converter.py":"4d262fe3847f9796bdb27da63ccbb92adbf02c70efa23b728b71f21a788151f2","src/gnn/gui/oxdraw/mermaid_parser.py":"1c1c2e9eed084fab710e4a217eec582e6e2f5c1c0af368369a49494d35eaf895","src/gnn/gui/oxdraw/processor.py":"5f9030c69792517c39fef5aecac5b5b2cff42d392c66b6bddd5cc50cb0a767ec","src/gnn/gui/oxdraw/utils.py":"4b5a8627dce2dc44f101defa2ba830670ccd0cfd52784607b3bdacb3c45dd03f","src/gnn/gui/processor.py":"c584e86e71f2b8baf2ae3dc498d906a0206c7253ddbc3b3dcc30c0aa057b0964","src/gnn/gui/runner.py":"b41a140803dbe9c49dafbd16e6ce6d24081acd71b3ff26ec8705a8eafe40b323","src/gnn/gui/websocket_bridge.py":"3c20813d195b40ba4a2689d1f2b8b6507e8095e8709f972417914a10a76a1bb4","src/gnn/importers.py":"be6b1be4b95411edbef3eb11ec817ba2324222a42b49866a6bba0439ae0c333c","src/gnn/integration/AGENTS.md":"59769ee1c9a7269beb1603b7c250f081d700f26189542b1c1d27fbdbd72f6c74","src/gnn/integration/README.md":"415e9e268e8962cdc0b873cf719f1275560d42744fbfa5fdcb6b44dd1125db88","src/gnn/integration/SKILL.md":"25fd65ec9489b4fcd09bf7a0d16b934877793eaed5f7be629dc0039eaae8ac28","src/gnn/integration/SPEC.md":"32478bed3da1400e60db611342dc02419884501df8e3567dcf0b498f555cfa2f","src/gnn/integration/__init__.py":"4fdff5966a0811eeca95730a8d6351b94c18aad491111c0d40011289465026ab","src/gnn/integration/graph.py":"fbdf15c57ee330b3bce491bb3c37911f72d452e71d2e6cb32495fc55ca8a2cef","src/gnn/integration/mcp.py":"1afe37d8ec74190308b9abb0a4cdd9850ef489a21325c6af13d8a7a4f9a4a4b6","src/gnn/integration/meta_analysis/AGENTS.md":"18b7e4eb6006640d43e9c84acf015b74b9d85120fb93931263909cc2785106ec","src/gnn/integration/meta_analysis/README.md":"f120d6ffb7ba80503eade23e534b09aeaf940d68fc411048f3816e309029c3bb","src/gnn/integration/meta_analysis/SPEC.md":"3beb0cc32be9a496dbac6f7629fc467bb436044dfbe793b13e1deef1875e1ba9","src/gnn/integration/meta_analysis/__init__.py":"c60bc27683888b83d05d770130924fdd167f4c7260b52ad113aa82cb7e5b7881","src/gnn/integration/meta_analysis/collector.py":"1351709a0d24507dac41171d748f53f4c110991e5272a14615427aa13be90cb1","src/gnn/integration/meta_analysis/reporter.py":"55cfb957c4275f2bc05eab700f285874553854fe126e927f71e67f33767eb4b5","src/gnn/integration/meta_analysis/statistics.py":"8ba36ea303bd97ee38f9185caed0a2f4657373c02bec26a1bee71de003b7f271","src/gnn/integration/meta_analysis/validator.py":"fcc39f0303d916f10ca8a1ac66417df1a42fae5bbc7d960b5a0d675ff4971446","src/gnn/integration/meta_analysis/visualizer.py":"74d077b141117bf837f97448b1f9c1bd6eb386deb011b5a70658b2321a8032d3","src/gnn/integration/meta_analysis/visualizer_export.py":"d5d9dd17b4e571d312a3452b296b4ad3da52c8d3828a83b467cc2695e1b92a91","src/gnn/integration/meta_analysis/visualizer_metric_plots.py":"f090c7015e0e4ab2b915faacace0f3f830d24b5d9b69150e51e0106a0d85b9a2","src/gnn/integration/meta_analysis/visualizer_runtime_plots.py":"0f065fe45d10df34184fcf3322ad1a1f31187e8aa8ff7428ee9a690754a312cb","src/gnn/integration/meta_analysis/visualizer_style.py":"6d33dc1bdaba952f271c01d34892d091c25b2284b3a043e09ad6f42f3667bcb9","src/gnn/integration/meta_analysis/visualizer_summary_plots.py":"7a88c5b96599aa376f3bdccf50b7f2efbbc3a0866b9505150cc11e36ea177819","src/gnn/integration/parsing.py":"0a87ce18a1ea423854f16afaa0ecdef4c8558d87fe96e92006895a4e51bbc984","src/gnn/integration/processor.py":"1f213a1341105af8503f7179a0f38b619d1bd95abf4dd9a82f595de772b09835","src/gnn/intelligent_analysis/AGENTS.md":"8d0a787005dd9ca952165b07e91b86c3384153536cae5b6c0ec21a2ef4c677a6","src/gnn/intelligent_analysis/README.md":"42b8dc08350c1631650f0e2aebb2732354d21e25392a3a7215d8bb7c114ed7a7","src/gnn/intelligent_analysis/SKILL.md":"ccc623f72db6342d002b54fba567657ef10c164e43c971420f8a695b734be967","src/gnn/intelligent_analysis/SPEC.md":"b9da069a3deb7915c38d8686ca90894e2f710c1de6b29e7f93fb7302c1401e6a","src/gnn/intelligent_analysis/__init__.py":"ee794499db0a2cc834064fd66c8306362ff34ebc0c3794575182951f2ad7255f","src/gnn/intelligent_analysis/analyzer.py":"24cd2caec55367d2ca8921de462c0c8bfd7b210e29c5480d2b4d15c0ca88f2cf","src/gnn/intelligent_analysis/evidence.py":"2d4b8dc865fcb360375b90408dce933dd70ea1e0123ec2d093833f7407020b5b","src/gnn/intelligent_analysis/history.py":"3743cc53f04ea2e01fd9cccc0ed1d722e574369d265b9a25126b603bb0a25293","src/gnn/intelligent_analysis/mcp.py":"85fbe1f056740adaec3eed17cad0ab8c462d55ca038f8b2b2aa2e3b59409a3ab","src/gnn/intelligent_analysis/processor.py":"67378cbc7b9c0677d1931bc26853dec6a4910f56941a024464532c4591ea105f","src/gnn/intelligent_analysis/remediation.py":"98b0e7b0c633491b205fc1948207fe739f8b57a735fa9c5946d13c25a95f601b","src/gnn/llm/.env.example":"ab8b4784c33d7fcffd822ee6a8becb1f5e3d56f9700cbe04c349d556f47764e0","src/gnn/llm/AGENTS.md":"a5844adb9d73aa3c3af48941546173d90b286a0b85c9d12054166501785e666a","src/gnn/llm/README.md":"400764ff85607d1f3d2d45374682345299eaef6d4f3dabff653b620052026dac","src/gnn/llm/SKILL.md":"470ba04b0c7f42024327fee88467061ff54e90f2d90a4b69f73e282f137510c7","src/gnn/llm/SPEC.md":"df3ecfb7bd7202b331e2c8fc3d70434ddae86a9b58f3b833555294ca39dec387","src/gnn/llm/__init__.py":"3d2c51eac6a364a9867c8d55f93e8fd22c5a231158624eb05862b4319df239cd","src/gnn/llm/analyzer.py":"99f03875920cf93f9fabaddb0264866525002c1522437f8db61b4f90596988d4","src/gnn/llm/cache.py":"59c1d096edc33230192e28e347b00b21e1c2847b8839bcf8692bcc80b9ff3cfd","src/gnn/llm/context_admission.py":"ea85e8fb25d8f46316b153fe288fd190911a252b32986532a30b9a6ba5215ea2","src/gnn/llm/corpus_runner.py":"9d526498ef40ce98a712f24b098184d8f2ea48c653f1d25e28d22303ce1f7ed4","src/gnn/llm/corpus_synthesis.py":"277feeda6d6141e28c3710d7f234c605128e975e336faebb6f936773825b0006","src/gnn/llm/cross_part_synthesis.py":"e846c52826ffa56337aa7000e7b46383120ebb30c2de21d673a0ef27e455c6d4","src/gnn/llm/defaults.py":"2b0a881def77d32861923d0f6749c3c1dbf7006c5c7a2ba495b18dbe1a86a9e0","src/gnn/llm/generator.py":"c120093af6bea0667b1690787ae28447c43828d1c4611e75cae9776101769133","src/gnn/llm/llm_operations.py":"2655ce0643378e194989df552635109ac1ca184a3ec66301fcd7daf4e3becdef","src/gnn/llm/llm_processor.py":"e5fef80460a553d114a652174ddf16e9dde0d672d2e11b64ab3ca0d9c3b385c5","src/gnn/llm/mcp.py":"3200ea74db822142303c867fc22bdd403e2d4e46b9061dcc8a168903f83bcc4d","src/gnn/llm/processor.py":"81135cfdafc955d02658209d86f2eb9b9de5aee7723ff15dc5341f44c48aab7d","src/gnn/llm/prompt_batch.py":"08ada5712faddeae80080a5be61facf29dbd26d69626bfaa1fde9ff7c12152cc","src/gnn/llm/prompts.py":"afdd6e4b947ecf3acf387baf54b666e44eb119f12a5c1e5a553bbcf17bb20ee0","src/gnn/llm/provider_identity.py":"f364ec32d8a46d811c04d7890e8507cd5de7358b44e025d5f754229692e25f1d","src/gnn/llm/providers/AGENTS.md":"15ba87fec5297ec6b96bdaab50ac27f928aff038c710f583a737f50c58554cc9","src/gnn/llm/providers/README.md":"dd75cf49d73fb27f53959cf22fa49e969e12862f55c256fd8095b61dd70c4de9","src/gnn/llm/providers/SPEC.md":"3f106bed91a6e9b89bb1bbb8e23ac99fda0d3f10574766f84e070b9551b43317","src/gnn/llm/providers/__init__.py":"6d937101ddb38c2eb6eebb3c8a8107e7a0704ce40acaa779ddb782eff28685e3","src/gnn/llm/providers/base_provider.py":"22644018a279914a5304183f0b4f48599de69954e8846c51da615e4c0b9c35ab","src/gnn/llm/providers/ollama_provider.py":"f900aebd04bc1e60df6cc4010ffd2cd9ab9c65cc8c7474f94b8cb05859182f88","src/gnn/llm/providers/openai_provider.py":"0d3c41b6aaf70b55919170297430115cf33f03d108c7cece054f50c7127b77d8","src/gnn/llm/providers/openrouter_provider.py":"58af495ca8c4e8acd185d9b74238cf926c0a630027a71f3482f85d50b06c0418","src/gnn/llm/providers/perplexity_provider.py":"7d8c4f58f16e9b80e41e0bf5f3cfefa6c1fcaeac90a20dde7b4a29dbb164a12a","src/gnn/llm/request_worker.py":"16359eb9ac5496e203e5efb2a3b63ad15f0fbbc6e115cdce0ed63c92dc4ed451","src/gnn/llm/source_parts.py":"542b8d82846ea4a9e67b063a489ee3ddfb3fda3133a5b5d0a79c1fd9ffda90e2","src/gnn/llm/sync_bridge.py":"86ae1fbc7e9530a5e1da784ffdf1837eb3928a5a9e1142a8a210542cc2041bbc","src/gnn/lsp/AGENTS.md":"5120f967d309263526b01999577597db460bbc9302acd0c4a3d26e422927267e","src/gnn/lsp/README.md":"89167cf0cea209236f53583a2c7afc1cbc49ae66144ebcea19f9acbbec0af790","src/gnn/lsp/SKILL.md":"081eaef115e432437c0147bec98f961523e5f29e57f467fbbdc10b9369257dbd","src/gnn/lsp/SPEC.md":"d65a430c493ee5ff68a51b91e7f7ddad356c9ece3613ec9162d38763b6a75a32","src/gnn/lsp/__init__.py":"151b224239915ecc4d13ed340287ee774d1486092f4d1e537e845a9861afe1c0","src/gnn/lsp/completions.py":"ce9924436aeca344ad2a778cfbb1c7b6a092ce0823f280023e6f3cdfe3796f5f","src/gnn/lsp/mcp.py":"62f78ce34895e9ab8a4b41f87b5640e618fb5b4780973303ebbd5d7f2aa55fa5","src/gnn/main.py":"6c988ec84ad65d07c85b8e6a00456e8f7fa256564325687bce16839754958d6e","src/gnn/manuscript/AGENTS.md":"e42d0bb48565a1dad3d351327cf43966db9ab354ede27dd44ed84f867ab392ff","src/gnn/manuscript/README.md":"4b37fd5eb6a22f0e6ac7d9b4c7f4f73fafdb006d093729b3d440ca4e114e0a72","src/gnn/manuscript/SPEC.md":"01a4a9ecf22167401772a3d9afc7aae81825b193cf138afef1c490edc330f870","src/gnn/manuscript/__init__.py":"1aa5418d69e4f46b9e160507c63e592674da3616ee5b1a4966f613a95391ceae","src/gnn/manuscript/gate_baseline.py":"dbde2e902a9cf39545e798574b4227d8b3c9986cc82f828410459192a729ae3f","src/gnn/manuscript/render_custody.py":"954936107d61dd6238be287d0505a15ff78c6ce9e7593d79dd678d55cfd8a107","src/gnn/manuscript/snapshot.py":"0aeb54b5eb9b3715dd458756c78f31c5d7d836eb42d0386d2ac3a3f4c7716817","src/gnn/manuscript/sources.py":"42d172926a6966596b798f2f7b2a3e72d9fa016df1b49c9d4254d6d36aa10666","src/gnn/manuscript/substitution.py":"ebfee78742d4713f530b82d5ee476d4347eecfa9b4972000c8826a41156d1bb5","src/gnn/manuscript/tables.py":"fcbbb61c3a839ff0abfba22aab9be5e9a1d669cafbb303918e7c72c336cb81d0","src/gnn/manuscript/variables.py":"f0770f854a60ccabb86ac034b87646044200974ac0940426a3667851b3827a1d","src/gnn/mcp/AGENTS.md":"9afbb5fe06d3e707c66fb460ee645c55a073656922607cf2d038bdbe34274092","src/gnn/mcp/MCP_DOCUMENTATION.md":"fea9ea5348fbc78d6665bdeea9107efa932cde0a5398b14cc74b0bb5a3f19bf7","src/gnn/mcp/README.md":"033fdbe83d7134abc819d26b4ce121beba68152a22a99fdcf12f581f682045b5","src/gnn/mcp/SKILL.md":"ff192dbd46f17429430b4c3c6185807113a78e24dc27d30def8d04fad9a598e1","src/gnn/mcp/SPEC.md":"ff1113b83318b439d2ad6a5f66958919622e0580e74f48ea2e1a27fd9384eb16","src/gnn/mcp/__init__.py":"29e6ee653772fc9aeca5d4b638b8f5b79de87da1b2a00c08ee4303977e472d0e","src/gnn/mcp/_late_binding.py":"27d5a4cecf34d9357f4d6c26580e62a7be9501b4598663b77a3927f0a881757d","src/gnn/mcp/audit_report.json":"83c84cc448f69c90e0e2acaac9233669cddfc0766264fe065974ddda86d478d5","src/gnn/mcp/cli.py":"3b73c1481b915f3fad51daa83b9924190de0745c4f3d4690923b92101437659e","src/gnn/mcp/discovery.py":"aeaa141d8d17cd24c2c029c2e8fbd6d54742f854aceed20e837f590b42f3d635","src/gnn/mcp/exceptions.py":"faff5e94b1f03c6f766cfb45f18d2ab802c1489871fa06aa03a437e3a6db39a9","src/gnn/mcp/execution.py":"3e984078e7e80642cd914fd0adee43624f753b9b3eed48e5d5ec88d13bfe616b","src/gnn/mcp/gnn_root.py":"e1c5004dca8db6c00715a99d28bb160fd8bfda01a7c2147ad4a832bdd74b6ace","src/gnn/mcp/introspection.py":"6289ccb6ef20bf578166ec916778385d0919144e3a0d768b4334d617a0bb6e8b","src/gnn/mcp/jsonrpc.py":"2d4c1341d52c9c688a34ec2111135967e7c2686adf606de21ab09d69f3c2fef8","src/gnn/mcp/mcp.py":"3836b063a485a21939f280a9bd01dc490ce2a5f002fec1ec6be76a5513a92dfa","src/gnn/mcp/mcp_implementation_spec.md":"0090f10d6ddb5cdc5625f51dae41c8d08c673e13411ef7b4de743677ca6a6b16","src/gnn/mcp/meta_mcp.py":"92d15fb60fcdf9d29d48c4b8ae1431011f4f6b8445273689b300a9d046c08cbc","src/gnn/mcp/metrics.py":"b2af96c0145fd43827ab0f537875bb1f196f3ec42f8c6ba00c86af24e3e251e2","src/gnn/mcp/model_context_protocol.md":"9f66a159f84d905e79a5c89201c6186f543c99463c2ff530f418cb1ccfc5a37a","src/gnn/mcp/models.py":"18eaeab2e58dc34792c5bfb8498f8c332ac3776bcf10e33ef3ffe1f3bab818c1","src/gnn/mcp/npx_inspector.py":"b971e88adacfedf9ac1972dfaa55a64880775f4de1876de8fde07f6ba0d827b2","src/gnn/mcp/processor.py":"0137031480d91c620f52a0a980f202a277f08c977ceffe6cb646437ab7cffc18","src/gnn/mcp/processors.py":"5a06735daf79958955012548e10456221db9fd78ac2962cfea91583bdf75297a","src/gnn/mcp/registry.py":"66c8bae04ce9ef74be3239d8d9aac8069767c23b6e0412aa3a2d4795efe0fcdb","src/gnn/mcp/sdk/AGENTS.md":"72dc8b219824c88c18df8dbe79807337fbac421c2c217a598ab6b64dbdb8aa92","src/gnn/mcp/sdk/README.md":"8bc004af5aab8140797c8dcb446e8e708ace7e9576e56ca528ecd833f3994198","src/gnn/mcp/sdk/SPEC.md":"0f54361d45c7e1ac596dbbcc33b389bb53b2f8a1da7b8a2236c5a43b85b0df06","src/gnn/mcp/sdk/__init__.py":"3efa41884ecdff6cd42d5a06472c9dace4915f3e4f35667f8baa817bd0588be9","src/gnn/mcp/sdk/capabilities.json":"1f87df566b97e379b3ab21f5d260fa032a08982e93844410c2cb5b64e1adb45b","src/gnn/mcp/sdk/client.py":"ce632e74cf9bcbaaa12edaa08480ffba50edb1bc5efa13c18f43d4bba2dd16f7","src/gnn/mcp/sdk/mcp.py":"04ac05cabb560998a07d8dac84c45473c993afc6bcfd8bbadae4c86b86dc41ba","src/gnn/mcp/sdk/server.py":"56c7fcedb41fd312a937653068b040c53b12fcecaa9e38cdabc8e5e3f13c855f","src/gnn/mcp/sdk/version.txt":"59854984853104df5c353e2f681a15fc7924742f9a2e468c29af248dce45ce03","src/gnn/mcp/server.py":"375809879b14dbe6285ce7af20640a28a55188b615116e574488fe10d16087df","src/gnn/mcp/server_core.py":"87766e40b059b69c27c9872232f831104633ca79d457afff79fb14cdbad0bfd1","src/gnn/mcp/server_http.py":"32758c8e10c64c7a4ba57421e42d501676d2d32c1c9e6db30ff0b1a80865ddcf","src/gnn/mcp/server_stdio.py":"9a7f0f49ab4ff44be90e5bc0a4cc9620a4efff112e27951c1466d0e3fbb05d81","src/gnn/mcp/sympy_mcp.py":"13a08b49bae1ff4a868d64ba32ca26265879194fc9e899ca8cedb980d542a589","src/gnn/mcp/sympy_mcp_client.py":"385dc1addf386fa7d2d161a2b28a44e926b027b630a54d3091f446568b36a9be","src/gnn/mcp/validate_tools.py":"f3833931055e476c0e66c27f92155d74ef8bf4ed23033d38dd6c155ff3017314","src/gnn/mcp/validation.py":"e89d8027130682dd1beaef9bd7ebacf41aace5d425f0f06c6bf514848685ef24","src/gnn/ml_integration/AGENTS.md":"333f5463ea057d4e240708a85a0e90a39fac281d71fe958356a1a1707bebdd74","src/gnn/ml_integration/README.md":"69e7535945ee8beafc5cd08070c6e382bf23ff28d5a3fd2ce42b72b652f0dcfa","src/gnn/ml_integration/SKILL.md":"4e6082785ded46d90eeafadda4fbd70d313e89e909a414c30545035329664076","src/gnn/ml_integration/SPEC.md":"6c98f1d43194e1b069a9487047f903f8e88223ed68d07f6f50f2cd4558a5ce3d","src/gnn/ml_integration/__init__.py":"94fab597c1de20a76df3e823e2817e5954c7aaf5890adc95f868c5b6a4df2384","src/gnn/ml_integration/frameworks.py":"f500e7df14868c8ca516ccc31fdda52ab561cfc660330209183aca58a715f635","src/gnn/ml_integration/inference.py":"e439d7f0016830167fc2e341a50854c047081f5ef26934ce78a92cd7521a321e","src/gnn/ml_integration/mcp.py":"bb4296c3dc5c26743dbb2b2d9b31f76ca44fe7d3b4101df879fddf267110cd73","src/gnn/ml_integration/processor.py":"4efeffabca58d3049a052b5911b0c1eb2670ec2db2392a23b78809b763a3155e","src/gnn/model_registry/AGENTS.md":"79ab17178cbeff30c2f0f5612d3660e0721f841c53157a3f95cfcfe87842e498","src/gnn/model_registry/README.md":"27719f05290b381789f1e4c1fd4e0de322f515d18c8e4c0f29d6b760f6ad6773","src/gnn/model_registry/SKILL.md":"762362142aa2a408cb9bdbe8ec34352aeeac7775d7bfe84af0b79b43b13b6a15","src/gnn/model_registry/SPEC.md":"543bd00af2ef8488557ffb8cf84a53f78284ee49d920ced568c6314212e75482","src/gnn/model_registry/__init__.py":"69b660c661e61383344e9921bf56e035b001c9724436a838216aa5ab0744ab98","src/gnn/model_registry/mcp.py":"71071ab16db46ff9c4c53ffd27e94098f4d3abfa67d1b2274822f89d689579cc","src/gnn/model_registry/registry.py":"a61aa978c773c79c41b78eb544c0b2049805acce5350e09b8d2887adaab0e3cd","src/gnn/multimodel/AGENTS.md":"dc84279e40c2c7015ea4ab91cce719549baca27dbc61fa795eeefac27b86a55a","src/gnn/multimodel/README.md":"c887b16b5c490defd7a89a99da13fa3ef084703c77687387adea5fbf6b86aa9e","src/gnn/multimodel/SPEC.md":"792b6a7b1093a70eb185f4be7f30dfc2116c7f21603e20f9b23d5a632142c32e","src/gnn/multimodel/__init__.py":"25ec51d4a585973193aa94b60f4ccd04adfaeff714bafaf9af4f005e8bea3209","src/gnn/multimodel/dep_graph.py":"249c6935ec04568bd494dfd744f71ab61277a02c24e1b8ca084fdca25b7c0534","src/gnn/multimodel/mcp.py":"d55e9ff219787d6d2d34366ed7aeec7f1aa27e7ff9176bec0c97ca47b6433875","src/gnn/multimodel/multimodel.py":"8392a6871ad3c96d2f4fd6dc8523cff8b4d1fced385c666b2901de6e9f23490c","src/gnn/ontology/AGENTS.md":"1024d5ff642ed77eaa993e92659cf63be4c322d3d6be2aab747cd7c8a2af2ef6","src/gnn/ontology/README.md":"5dc23e61d52ec9f0441da72318c3e2d6d5885dac09ca4c26e0fab4c654a1abec","src/gnn/ontology/SKILL.md":"061dc206c064b6daeb9d9307f87b402d4065648e9c2182b964609633641b3f3a","src/gnn/ontology/SPEC.md":"46d313dacc2b78cc6fe3e65c6e2eb4d5a6e07013905b71b84948a4e3df8bc96c","src/gnn/ontology/__init__.py":"c9944fce1b586e0e42dffcc235d42b040c672c6a5afc1d07e971c04a7c8e2dfc","src/gnn/ontology/act_inf_ontology_terms.json":"a9639fbabc2e227adcf00450aad23638ceaaa384caea29824ae2d063a4559d1c","src/gnn/ontology/active_inference_ontology_terms.json":"b19e3d4c70cb7d47276978f4b1f21777089243f6a8514e86656b9e15f639656a","src/gnn/ontology/bridge.py":"a0c6e19feefa073d9e1b1c7a8ca60854f7336c29bcfd3cf6e247ec529180d4bb","src/gnn/ontology/mcp.py":"145e1752306c429ec6a135aa74801cbbacf15dbe011b63c8d2c050217a456af8","src/gnn/ontology/ontology-pin.json":"3978640ba02be6feb5fbd70dc70c1e37aedfb17960325d5e4928a20f491a24fe","src/gnn/ontology/processor.py":"659c94f670a27d50f44f04bf64d8c453129f105692c092956e9ee3da689564af","src/gnn/ontology/utils.py":"270adae1d5940a8f92798e0900874b4f25b831e7f0d0485efd6a5e4f0cd8fcd0","src/gnn/parsers/AGENTS.md":"3367c996c26858e26b5d7298af0451819e87db0ddb243765631ac90b04429cde","src/gnn/parsers/README.md":"06d694fc3f744bb1a11cf6c48b9e9ae8c9e42579c57131031a6025f6e4845404","src/gnn/parsers/SPEC.md":"575b503c35fbdb68e8acdeb8cf1caea27fb9995ec096c2a28dc6c12e4b8b95e5","src/gnn/parsers/__init__.py":"a08df88ecf239a094254f7dc4ef0ea57aff697075f777a3993702ca8d45803ea","src/gnn/parsers/alloy_serializer.py":"bd01c0ef6cbceb4e19ed9d8b8d01b94e631e17f340adbb50bf9b953f16fa9840","src/gnn/parsers/asn1_serializer.py":"e3afe43a7a6fec82d7608d9c16cef49e8f1b3e4420a25d78b5df5976e323037a","src/gnn/parsers/base_serializer.py":"4604e615edd74218a74d1bfbeef9f36b23b90d7dc0a1640dd7f54d165c0b26ac","src/gnn/parsers/basic.py":"78942a0f5d22f4ff16a6787e4d87bb579b136232a62728b15212a7155831d15d","src/gnn/parsers/binary_parser.py":"1d4f420db7b6021f69b7ed18c81bb4ad1dc9e93c3c60ab3d7a6558501de373ca","src/gnn/parsers/binary_serializer.py":"d187923fff8c487f1285387491395e2505cfc14eee731e09750cf8b025ab9c19","src/gnn/parsers/common.py":"ade640beffbf18e6f99dc7b9e3ac5993e5a183652da096ceeb0014b77f3f5527","src/gnn/parsers/converters.py":"e1ef9366ee5f3014fed75867f1b02c4f141b8496819b3bb47d6eaa5915fed9c0","src/gnn/parsers/coq_parser.py":"13729eb749d1522ab34f391269c8c83f83a0d3d39ab0b6906c932ebb3876287e","src/gnn/parsers/coq_serializer.py":"4f4aff83b457a50376f62b1a680f27e681a9980261b3c9d0846906d95620a08f","src/gnn/parsers/frontmatter.py":"ff570ac6a83405c408f52272e666ba2fada8f763d762c66ad3bc74b876cee942","src/gnn/parsers/functional_parser.py":"30d0ad1096928ebef78cc95212dfcdad99ffdd336ed1c83f8184e755ec8fa38c","src/gnn/parsers/functional_serializer.py":"78a0c3a844df5f37a81fd1a6d34f4c0ef32dac340a4609a078fa3ccd9b55d334","src/gnn/parsers/grammar_parser.py":"32022ee2b47edb87914650cd36707061184717c341434f5835fc846ef887c541","src/gnn/parsers/grammar_serializer.py":"a0ab2dd3c86acb232933ff269c97f115bdc514693e5b7a637b49a06811772538","src/gnn/parsers/isabelle_parser.py":"517528f63b7340457e0b6dfd4429f2f9468382dc679bf2f75abe1b219a39101f","src/gnn/parsers/isabelle_serializer.py":"240b70000ac26ba8d6676ca71f3a97e12a58b3c6793e0c97450a8d74f12a467a","src/gnn/parsers/json_parser.py":"6db10ede764af6ec41249dd4348a70e5042835273a6ee04a5402dbb211eb09ab","src/gnn/parsers/json_serializer.py":"4c5b95d5d287cdd8edf4630a879540558b51cb83327e015cbbe59e047f689520","src/gnn/parsers/lean_parser.py":"c14395bb7ae7100a98e6dbace5f77b4e845145faa7a58beaca1f249e961bdb43","src/gnn/parsers/lean_serializer.py":"f395625636e4bfa462196ce349858579ccc14ebd244ea375e11c981c9c662d88","src/gnn/parsers/markdown_parser.py":"150f2994dc7e95bea30e7b226d86220eb319fcff64489503df20a307cf7b097c","src/gnn/parsers/markdown_parser_parameter.py":"2e94e88c79b8998387f2a1c53fe88dcc45adc498c47c30f7ec3bd577a8072061","src/gnn/parsers/markdown_serializer.py":"601db6cd6d27db2177006f9de0bff757fa80e0e87ce51cee4dfde710a4ee3784","src/gnn/parsers/maxima_parser.py":"020caf88ed81db5d6353598c0bb24c3064632419b39916e09eb949191f1b1f82","src/gnn/parsers/maxima_serializer.py":"bb9b806e99e0b8228d0d5832a5d90a9aa13dfa56776c881ed1b02c895fda9e49","src/gnn/parsers/pkl_serializer.py":"9a562eb4fda84138f3f188169eca263ee669b3922ca57b15c89e40cbff017c0e","src/gnn/parsers/protobuf_parser.py":"59e167e75bba1ea9268f0ecdc44a0799eff9cac2c2c7b216540fc4730abd000b","src/gnn/parsers/protobuf_serializer.py":"984f6b1cc82f4072fa69f8ab5cba1aa49ab39b4ddd4cd0b86cd33cfc8a6c61a6","src/gnn/parsers/python_parser.py":"0f6bd6506353e25a52776cee08afe53275b5979f6912e1469483536f93e869a5","src/gnn/parsers/python_serializer.py":"46ac6a9a86bcdce380a80c41f4df6d5600c6d39ae050bc5267b040dc81bd7e0f","src/gnn/parsers/scala_parser.py":"54c415699728a19be1830eb3c54e05feb56476e0e90d4dd3e0a48271dbcdd500","src/gnn/parsers/scala_serializer.py":"5d4de4914f083e9b7a9a504546bdea959341cbd5a1bf3fec11f6266ffba743b9","src/gnn/parsers/schema_parser.py":"5cc7c5c5180b58adca322a0bcaf5c8a5dbd9b69ee6a88b015cf4e73a8d84a8f3","src/gnn/parsers/schema_serializer.py":"ef44f87ff710187297367178bd7792e200fe4846651747d7d794b925c65aa8e1","src/gnn/parsers/system.py":"137abdf98ce81ee9482c5562c0191e39e6da1bfef0ee843b7c132991ad484bde","src/gnn/parsers/temporal_parser.py":"809fc03d63664d43573524ff00f37da77331bcfa41866dd457eaa5f443960d74","src/gnn/parsers/temporal_serializer.py":"f71f744f0d6b8ccc0a4a4077cbfd8bcc8d22a31307f92d5ebdd23c19cd34e1e2","src/gnn/parsers/unified_parser.py":"25f446a4174952d4df2dabe8ac750e5c2470ffa65a5e8fd420e384f3e4d8a870","src/gnn/parsers/validators.py":"ea35a419dcc811da56021b9f3a5050b9dfa27a3c0515a744599107976c9fc11a","src/gnn/parsers/xml_parser.py":"ec81207542783a5009b9b3f11e1139d8139cff2fa8611be58676a2f650fba090","src/gnn/parsers/xml_serializer.py":"4ae7e97eaad76b8df99c06a9006dc6dbbcf141cb34a1d3a955c0019ec448957e","src/gnn/parsers/xsd_serializer.py":"8c4434b0ffde8faa04cc419e37e2b98a03647b038ae2244076b7050239f68f9d","src/gnn/parsers/yaml_parser.py":"86670aed8a81116a54a2fdcdfea1139c7eb387d7444883640d0e02fc8d3fa99b","src/gnn/parsers/yaml_serializer.py":"5addbf37cc8e11e74b876bc421480833e69d7316539359984ee66189d0437343","src/gnn/parsers/znotation_serializer.py":"fa3375bad47c5e087dde0cc03bf1281099f2936a7b6a80c1fa6cd9121ddef84c","src/gnn/pipeline/AGENTS.md":"9cfc35600de185869bf5f0e6c2da5f9baecc0542cd4828a298154db53cebfd72","src/gnn/pipeline/README.md":"7e40129b3632c16113d3355a5578c08baad7a4363024c64d7cab801519fad160","src/gnn/pipeline/SKILL.md":"0e9f9851d9f0a577da8f4d083d674e481733cdf92d3f39262024a4d1b368c3a0","src/gnn/pipeline/SPEC.md":"9e3e945f81b1f60b087a3bdbedc280bf18a1156809c655e130b5136c1fda1c92","src/gnn/pipeline/__init__.py":"77247437e7155308e992dd1d8f577fc476ff3434bd7286e7e02b64786cb21359","src/gnn/pipeline/_io.py":"7a57ae261113f9269ffaca8e2ec639c41aef76f357f4b63d2bd25747ca1f7603","src/gnn/pipeline/_version.py":"92467f686d1cee76c335e3583a8cd3c7b5b8750f5a761bc92f8060ad40f939f7","src/gnn/pipeline/admission.py":"dc920dd95f9a9b1171d7d2611c82e43aa63ffe096eff54ff744e79a4bb77c33a","src/gnn/pipeline/artifact_ownership.py":"c7a06cdb81f1648ea5f6ae7dd44135e9eacb61611d210c8aa13276ac4b2fd31d","src/gnn/pipeline/autonomous.py":"eda3248beeb42397dbc0570b49975620f170b83210175d4bb2e1329f1adfc090","src/gnn/pipeline/config.py":"798096afdece0dabd2c879a36cbc8795746c2ec0f7c7cb67c61d454767af30bf","src/gnn/pipeline/container_plan.py":"3de13149a9937bb52ee6f51bd0898d8e8367a58bdb7db29acd4a9ed2cd0a8ed2","src/gnn/pipeline/cross_framework_reliability.py":"f52b2dca8f15b6c9b9f4bb5ee65402051a79d1323bb090b1ae003016056727f6","src/gnn/pipeline/dag.py":"1fc3071422a1b3cfdd724b7b9b93ef9ba7f0435b8b50459100a484d52df6f892","src/gnn/pipeline/diagnostic_enhancer.py":"81c11efa561b6dc60b482227dcd831dd87378778d947e48dafac63f4926278c3","src/gnn/pipeline/discovery.py":"d3ce60799885141739985ac0d6d5afab46735085055b608fed35efb73bc197d2","src/gnn/pipeline/durable_streams.py":"7ad49c682647fcf918785ff1e8bc7040ab513ed8ff9c16befd299d16891dfea8","src/gnn/pipeline/execution.py":"d57edc9b9c62073f589695caba0589733872913fe04e22462cfaf699370b4dc0","src/gnn/pipeline/finalization.py":"24153705e2153431fe5abc257fde85dc4261d151b8cf8e995eae8075e1135c8b","src/gnn/pipeline/hasher.py":"24ff8de47978c1e6896d3a445e6721e1a542cf078320b06e21d57060b434b5d3","src/gnn/pipeline/health_check.py":"49e98cf144c2d7590e279264b1db2f4f6f8075da84fd76d4ed9a559d1a8ed113","src/gnn/pipeline/logging_config.py":"a04c2e2276082408ed487b1939d99930d1b1d6af01edefabdccf26cdb9e50bbe","src/gnn/pipeline/mcp.py":"8a27d78f4f37685b5ba711deaa5556ba1e42abcad6f8867c5583c28dc88cb8c0","src/gnn/pipeline/model_family_acceptance.py":"4b4aabf6af02f1bc6103f9c704b6554714c7d6c3c379ac9b501cba3ae779ed9a","src/gnn/pipeline/output_lease.py":"df9b3b883f0cdb376e680aa39f66ff35eb142c32e6e9489aa7bc6b318fe46a8f","src/gnn/pipeline/parse_receipt.py":"54986d1892488a9d4ea4411df0d598e026875b0791e4b4739c748acdb90b7ddd","src/gnn/pipeline/performance_dashboard.template.html":"b7cf42d00c0022e6e30c690f68257df26cf8abd71d847bcc29aac8c876ba5d8c","src/gnn/pipeline/pipeline_container_plan.py":"be12677d6a63c3235350b52dc9abae933a8765a36ef53ec5583095b7390d1a63","src/gnn/pipeline/pipeline_runtime_validator.py":"b0aac966e01be69fc9a9cc4186a586c9748b640939c8d6cdce285c2454a34054","src/gnn/pipeline/preflight.py":"bad83915dfa073aaa4b57d72689a5bf10c251459fade0388c1bef18182cac7c2","src/gnn/pipeline/run_context.py":"14ec16b1a0d4dcea3cc4da5d449a77178ec875073c75dc30cf8fc03b2ff2a74e","src/gnn/pipeline/run_manifest.py":"c7483b8f4171fd17cac2301da18056993a223d774655baa51813cda1e7d3fd4e","src/gnn/pipeline/run_session.py":"8ea32af24ba08bcaa927ed928bf11a34e9f4deffa0cefc7064c35e68e5b3af75","src/gnn/pipeline/run_session_wiring.py":"1f0dc7c3ed9f8ddab79cc1325ae87f8dc7081b444344cf8a7da138939099d093","src/gnn/pipeline/schemas.py":"ac559069a6ae9c82b26c897e2484ded4817ccfa23b822c5160a5f33d01377a7e","src/gnn/pipeline/semantic_fidelity.py":"d69f69e207ac349f6effb08ac22d822c2365adbe612bac55ca88ba62ebe0458f","src/gnn/pipeline/session_acceptance.py":"502ba9690858dfcc66551099775f0aa9b5cd3aa74b2738afc3e17508a1b1ad61","src/gnn/pipeline/step_executor.py":"ecaaef51d3ab0539f39598047dc0d4687c45ba30054228e565d8697125a14771","src/gnn/pipeline/step_registry.py":"023c091b73a6a76a8d0344c40d1b33e8e03f79a8168171c655de7a3e71339144","src/gnn/pipeline/step_timeouts.py":"4929ec54346d97904c308d1b30d79d4047809c21778fcc13f8bb9f968a13e871","src/gnn/pipeline/summary_wiring.py":"3784ed1a92fb3e424f376db2773f0a57eedbe81b3dfeea160d23e39e9ca8b463","src/gnn/pipeline/verify_pipeline.py":"f8c3d2831fddc875a293de1fbf6ab96ca098ecd3dbd2887c35c503b4cc718423","src/gnn/processing/AGENTS.md":"95df73a4d4abc891db9631e3d33b8844e51c5fd45a04de8b5977c6c8ad413c1a","src/gnn/processing/README.md":"ab289a80eceee123be61d455e8f51c43413a99944d8168dd90065ff53cf38209","src/gnn/processing/SPEC.md":"eaa11808a19b54c7f6fec728dc5087a10ef84e65a2b32993900ebff27a2601ae","src/gnn/processing/__init__.py":"12ce67e5066487ee7bf2544b4d4d5f3b2b26ebc09942a5028ec9cbd493fe6de0","src/gnn/processing/__main__.py":"295a3fc45c712eb2a29e1d8e0d977c2487f03c7b5c3b57afde13e8ce96606bb3","src/gnn/processing/core_processor.py":"aa360fcd273eecfd85516b797d116fd4a5124d72e799884cf5ac4da389d35360","src/gnn/processing/discovery.py":"6d50331e2965f32141241554db0d8f96f3175e1ce5c83140ff9e615c9ec67d78","src/gnn/processing/mcp.py":"19caf6f9275c2d229717d20701085dfceb2e56873e91bca170d6a9be03dc1831","src/gnn/processing/multi_format_processor.py":"fbf8e7b2c00503de19769086779ddee2a0a97c9fb0942c9680e1b09cc5d25998","src/gnn/processing/processor.py":"2044def354f2628dd9c0544a8646b6c55b856d6e62cd846b1072551334044e3d","src/gnn/processing/profiling.py":"8095156314abdabd6321068751a2d9aa6551b05b4b77cca79afb8428f79ad1a6","src/gnn/render/AGENTS.md":"36419082510907a3f38faa619f788d0be6d1962621504a3c56e9d9c7d01d0ab3","src/gnn/render/README.md":"2bb8bd56d9bd3178564a5e5528ec500224342df10f54068e9f4c22831b449bb8","src/gnn/render/SKILL.md":"a70fafb4cf3e5b721ea2187c37df32be4275286d0ef03cbd970d467c77cacdaf","src/gnn/render/SPEC.md":"3fc3af29b8b3c8e81108b287606a28be701f980e59f3700af0b99e2b54e2a6b5","src/gnn/render/__init__.py":"2b29e84496e32ac3da0ed7b6fd86845695ccc718d34f10f2dd5ca0cf1aca4010","src/gnn/render/activeinference_jl/AGENTS.md":"fa46dd4610dae814268a80730846bcc3e91cfe91ea01d3c22893519f3c1a7f92","src/gnn/render/activeinference_jl/README.md":"de89d4ef3eedbda5c655eba27452dd8683757e672fa6c6ee9069a883d74c4f77","src/gnn/render/activeinference_jl/SPEC.md":"55b3b5373be75b36846c7d620e5c97dcd5eb8f7c9fe96cdbcbb1013ed0165a86","src/gnn/render/activeinference_jl/__init__.py":"d12841fdc6ed86eb350eed46d0098aa6d02a7a4c4a0fdace880a4b53f8e2d386","src/gnn/render/activeinference_jl/activeinference_renderer.py":"2b48d9884e6c03cc2cc83ccc026973647d7bc060b3d9a1972f1a8721a151786f","src/gnn/render/admission.py":"ca4a41f1b8031f6967bb454a5a20c550b4c9cfd4b0092ccad9e484f8e2a87671","src/gnn/render/bnlearn/AGENTS.md":"009f50f4c418880efa71efdb1acf8641be4a13cc48ec60445e1208ec78f6cd60","src/gnn/render/bnlearn/README.md":"99ac35f4f67019b7bed2d9ccc18053060bc4b430dd45140fb33b522ec8327b9e","src/gnn/render/bnlearn/SPEC.md":"c06a371b749b017a26080f2343f4f4009d1bfb3d3b8c589bfeb017dee9dac3c9","src/gnn/render/bnlearn/__init__.py":"1eb90729a27b2faf3233e243294a28a973d5e7c7b0195d5c32eee86c4857d5b2","src/gnn/render/bnlearn/bnlearn_renderer.py":"a35dc31f3900c96e6e1a39a0699ec2f9d50e1c61d85025d7e5645cf852be2593","src/gnn/render/bnlearn/source_program.py":"77efab4052591cb4dc8d292631830a33b858fe9aec30210d30a4a8b2830389c0","src/gnn/render/continuous_common.py":"768ce5b2fd227ab7a8e55371e9ee70906f886080ea21dada2cac6ee7182616bb","src/gnn/render/continuous_script.py":"151ac9963c440d5bbe861bad075b055afc8c83f245245b9b8b78a536a297b0bc","src/gnn/render/contracts.py":"45703540cf67690fed47adc6404340cd7877f5ab642ac1e822b74ae7b6eb72c3","src/gnn/render/cpomdp/AGENTS.md":"8fba09c862fa63465ea1607401438c2f8f108202cd7d5eaf32c95696c4640ae6","src/gnn/render/cpomdp/README.md":"b1bf0da7b477efd95ef236d533da4b7ea58a6230f3f1c5bc33c703be2144a834","src/gnn/render/cpomdp/SPEC.md":"f0976c9b8a1b3da5d94f89db4fead307e95fb23b892881effb88fcbf00028d5d","src/gnn/render/cpomdp/__init__.py":"8d6c4d6aca41df14366518fac1d1860fb97656fe863a556acfb8dac607bab778","src/gnn/render/cpomdp/admission.py":"783a9501feda0388c5e6a24bc7136e041448c9b170d637a1fcd4a129d2bc3bfc","src/gnn/render/cpomdp/cpomdp_renderer.py":"1483653774baf6ab755f0147a315a59333b589d63abb2f6fb45893fdb5ed78e5","src/gnn/render/cpomdp/finite_controls.py":"44c52fd1870184d4cf62ea91c968122c9abcd635ede61d55c1bd14495bd82f52","src/gnn/render/cpomdp/script_template.py":"461abd57ee78a049f5eadd03c8ad54b64fcce0ab32b5e5326a61cb712b9c6b26","src/gnn/render/discopy/AGENTS.md":"c3f1c2e153bb147def278dfc7a78e3ffbc3ccefcfb235eb6ffe846eab9bb3c41","src/gnn/render/discopy/README.md":"c6614f44813abb3ee1594382981badd802fdebd7cafbb637157be0cfce68440c","src/gnn/render/discopy/SPEC.md":"5053d41f25c11b8e760a0fa94eed333a0d6432a4daf97a57e26ce4c02cb185f0","src/gnn/render/discopy/__init__.py":"4ea5d67181ebf8181b14b911469158264bcbfdf1a39063441a6870b3a6954d13","src/gnn/render/discopy/bootstrap.py":"1df91fe01c6dcb7c2c4799a57293e21bc4351f97274bf0010e5c255fa1049440","src/gnn/render/discopy/code_templates.py":"092d0c1e8a141a940c39f819e11bd3f7a35484b4434daa2151e7e73fb8f2358d","src/gnn/render/discopy/diagram_builders.py":"a2afa4192ea67f68759256596151f5c9460e6190457f77253361600652848b2a","src/gnn/render/discopy/discopy_renderer.py":"884cfce875b267e11fecd831355563564bd5401c6cb448db2ae24a98a7031263","src/gnn/render/discopy/file_translation.py":"ce8547057f37b7160de8c26cd6ae0512495270850161df4d175f8d7cd2067651","src/gnn/render/discopy/gnn_parsing.py":"c7294b690d4920f545105d1ca79891c35af6faab0698998c0f7fba7f0d31497e","src/gnn/render/discopy/matrix_builders.py":"9bd63388f09edb2e94c1f37542c841826a11dad344f65382f3b289c9e944a961","src/gnn/render/discopy/symmetry.py":"50884b7c208993968ff7a302013f68246ec0e2251ceaeabe83bb305a44f70505","src/gnn/render/discopy/translator.py":"c115ba65ff95f15d12639625904769dcb2875518ca1ec50ab167b3ec55384617","src/gnn/render/emitted_artifact_checks.py":"5e2d2d28a8bf5acf8c40dae208445ebe863282951e08a717e751ca6cf39accad","src/gnn/render/execution_contracts.py":"060e981c807fa7333a0ce3c43c61fdf879edff7d7e2cda0ab2038ae080822ab4","src/gnn/render/framework_registry.py":"6a9dc452a6e89ad8505d7ae5fa8aee31ef12d2e785473b879e6094b891a95d7b","src/gnn/render/generators.py":"c34efbc7817f178f58c612c7c6c1cdc0b64832895becdf22803538877c03cf74","src/gnn/render/health.py":"5da1773df773b2b98c9aa9e1032a43c153911a669f0a8f0a38a656e9e6e028c7","src/gnn/render/jax/AGENTS.md":"818253e68ac6d28088ce82e6388c43f24555e83bf5d9d9198f9410578988134c","src/gnn/render/jax/README.md":"aab00ca948b8d067c14dc864b8fefb544e275f1ca4415cac556350da0902b3ce","src/gnn/render/jax/SPEC.md":"320605ac6c878f908b328a65bda4f476a2b141a8b3f3b05d70e914f50ceb7ad1","src/gnn/render/jax/__init__.py":"e4396c85eedc5a84e81336be7d4e78e919ea5aa717852ea5a866ef7cdaf0844c","src/gnn/render/jax/gpu_utils.py":"753b4f37efe544f3584f6bc6b9543b9ac3050f6a28cacd5c8c3b4cceffb30e61","src/gnn/render/jax/jax_combined_generator.py":"aa34a2308ce94fe31105dc6ead37b09ba04cf5c3e21639a63360fa096914bfe2","src/gnn/render/jax/jax_factorized_generator.py":"a49a03d769311fef9ba83a67778a38ee434d42207210608ff1f389d845ed571d","src/gnn/render/jax/jax_model_generator.py":"26ffa06727be7b3e4d909b855d81b492789d6bdd28682486e5350f3d366687f0","src/gnn/render/jax/jax_pomdp_generator.py":"2ae04757182957e7cbc9a7a47747c03fe0f6f8d50ee79f2b48ef88e7582af325","src/gnn/render/jax/jax_renderer.py":"538d26392f4df7dc3ed4d5548a2bee6007bda85a74acfdf8fe7b57c739e207d4","src/gnn/render/jax/jax_spec_extract.py":"ce35b8d93540898d6d5cc8080fa9da4f56df682f741632dbbfd9f68ad6b1b36e","src/gnn/render/jax/templates/AGENTS.md":"194c7c69bf9918883ee64157dbc22c344f89f8dbbe7f7f9c2550152d8cf85531","src/gnn/render/jax/templates/README.md":"a3d4b4f66159c2bebca048114e4da78bc343f0d82cbdabf69241e4961f329756","src/gnn/render/jax/templates/SPEC.md":"ae40f052b5c602a3d418bc47e537e67a6e467cee98e6056d78fd68c4b5ee2f09","src/gnn/render/jax/templates/__init__.py":"eaf142c034df1e658a62fd72703ccf3f0eb61d1be555dfb665739081384fb6cd","src/gnn/render/jax/templates/combined_template.py":"2b33341d3ad954d8a481b0e38d87d21c03d4865291361a6b4a8cf0011e029fc5","src/gnn/render/jax/templates/general_template.py":"c1d1c9a01f7cdbcebb3389babae29eb331e50e6d86ed0fdfff40d65c8767fceb","src/gnn/render/jax/templates/pomdp_template.py":"79353ffbeb39caad7bd56592031799e8d8d52be1966e9b732062924b202c607e","src/gnn/render/matrix_utils.py":"437b8f241fa79c0ca94e56633998d38dd1eaa1877efe4d674228aeb238bdb4a9","src/gnn/render/mcp.py":"e23ecc4e826b44e53d71230bc95a23b80fb57943d8b87c96bd3bfd0a569e1b60","src/gnn/render/multi_agent_common.py":"57f410ffc7c9cc1244c41cf65493607fb705cb06f44b4dc8b5b145c5bacebc32","src/gnn/render/multi_agent_continuous.py":"c84db7dec16ef3372b123f6b2004372088c3a5cbf5e43a9d95d0ac9d54fce62a","src/gnn/render/naming.py":"a97e3f6dd3037b25328e381d95f1a6b8cfd768933bfe968d897b48d4279cc0ab","src/gnn/render/ngclearn/AGENTS.md":"4a660235da21148c839e0633876f644e8d7948d06bde07ade86369d694b0d1f1","src/gnn/render/ngclearn/README.md":"77a522b269c21c7f06045925fc5ec8a2ff364957f7a2098db19093f86c023db6","src/gnn/render/ngclearn/SPEC.md":"68fbe48da76e856fad87fd89443b680fd80d58791daacd24ebc8dee6382d723f","src/gnn/render/ngclearn/__init__.py":"06ccb3e8c6c519708a87ed8e9e02907da4c33ed591a6d967d7fe54a35dd4fb01","src/gnn/render/ngclearn/ngclearn_renderer.py":"d8aee590d2fb359849f5f52fcd7758e5b2f9e230e7b1a0a4ddc9fecde1dc4034","src/gnn/render/numpyro/AGENTS.md":"5fa0f3d6d4ce74af3f91d73191b8fbd3330668d4ad6c7d583762852e380726d4","src/gnn/render/numpyro/README.md":"08d5ff66f75c4eed39e1e74662412d6795420a76a3f30338e8f86327daddbe00","src/gnn/render/numpyro/SPEC.md":"fb741b00ce6887cd90050576b179a3a30cf9c158df362f39e8a8138c091d1ce8","src/gnn/render/numpyro/__init__.py":"dd580b77ca7b879ba80a550dce84424e84a7e79db25405cfbe77c3741478b7b0","src/gnn/render/numpyro/numpyro_renderer.py":"cc51dbb046b91173e347dd587faf2c174f6278b18e43fa9a8aa544f890ff14c5","src/gnn/render/planning_admission.py":"bef281492d414de904ed029a48d31cc5a36f6f015bb1500c468e8e6dbe8d53ce","src/gnn/render/pomdp_contract.py":"7361599879c471a4e3af7df91ed6ce95087662796c050bf29beeb3c10b32674d","src/gnn/render/pomdp_math.py":"3321eae1600832d81f496a62eba6ba4b71ad273b4ddb570edf72f492565da28c","src/gnn/render/pomdp_processor/AGENTS.md":"42f69935619ca5f2394e44c379ce2575d22852eba4b403b15fc939419f9e7196","src/gnn/render/pomdp_processor/README.md":"ffce862bc226af9cb26ed7836281700fdf9fae9195f749fe4cd34ee6a3f90ae6","src/gnn/render/pomdp_processor/__init__.py":"55b0c7b4fa741025ff54929335274138b2bd5d39f29eac22df5e96a52d75b37b","src/gnn/render/pomdp_processor/_canonical.py":"6224ed37369c6cd73e67fad0668e28738211ae597808947fca3f4a9646049a1d","src/gnn/render/pomdp_processor/_documentation.py":"ad41dc24959c7620d6e06f668756920a14dcfaa0e9f38233001422c444d8e5ad","src/gnn/render/pomdp_processor/_flow.py":"3841b79450bf98af2ae1ac399372bf62c29778e6667741412f2a701b7c7c6cba","src/gnn/render/pomdp_processor/_renderer_dispatch.py":"2f0639f52b3681f58cc193ab04617bd58910117e329e2bab2eba11d47d12f018","src/gnn/render/pomdp_processor/_routes.py":"7e97c5771aeb561702183a10a58bebf1e74668c9f76465372177c4981c465e1a","src/gnn/render/pomdp_processor/_spec_generation.py":"ee1808038eb74cdc4494a64f3fce820bcdefe6f2bd19458a9b935c6deff3833b","src/gnn/render/pomdp_processor/_support.py":"ce2b21b43e6fec4f3b2291ddcd29326548fa4688cac931dc19d2199c886cd026","src/gnn/render/pomdp_processor/_validation.py":"f1aff2b75a0fc99680e883223f607ec71cc1e7feb61b8970329150bc707371c7","src/gnn/render/processor/AGENTS.md":"8299873c2a13d3c535a7fba4c89daa095fcf3f95d26a91ac4ca364d8a7183d1b","src/gnn/render/processor/README.md":"2e8bfa53543e65b14211dbf640bdd147ed96d17dbee005a4e9b7f3611e822ef3","src/gnn/render/processor/__init__.py":"6653953caaef35fef0de5e29ebfe69d8bc7893018ce7e6913d0709e492a253e9","src/gnn/render/processor/metadata.py":"ced2fe696874d52dcb21b1bf2d453dc582a8b74d8635d3204bc6c671a81b3f2d","src/gnn/render/processor/parsing.py":"54ec910308f7e66dc2e9028636909370ef430147a436b6f4e5f04e940f4e923d","src/gnn/render/processor/pipeline.py":"90a76b729e3d8b068f0eea414f4457a57ba9556c6b64db48425373a107df3247","src/gnn/render/processor/receipts.py":"1f04ed76a5c3102648ce237128ccfdb441fad0850947f41247147a3d05d73758","src/gnn/render/processor/rendering.py":"4c593e1c6f77230f144fc68628174a7a1c5409f4f274ff7056c4548da5c30a06","src/gnn/render/pymdp/AGENTS.md":"9b266bd9498ce1ac3423711ee63fc1b0e88c8072c5ac6599fb3a6ced201ff3c3","src/gnn/render/pymdp/README.md":"2a2a32d6fa3d059f91d2ec91f0e5c9a40c66b35500e5463cb6cc92cff81bf81e","src/gnn/render/pymdp/SPEC.md":"310284cf2e464a74acb2b6234067d4af4fbd3b555dc7758abb526f5e7f0479f5","src/gnn/render/pymdp/__init__.py":"9225018600b07f1bb0e94cb4292fddd2fd8ca285fe4be639c403999cc41ad7b5","src/gnn/render/pymdp/pymdp_renderer.py":"7f370aa72fe8b752006ec898663e535c5c3ac0eae6a0c72e598fbd2b064a44d6","src/gnn/render/pymdp/pymdp_templates.py":"7a50c1f78cea819bc5d7b2d1336da787e331437f27097d0e15d1735ebb7964f0","src/gnn/render/pymdp/pymdp_utils.py":"1d85c0f06ab90a56ca53178fa3d0bf089a01907cd6868d3c53eea1f86717f6f7","src/gnn/render/pymdp_template.py":"b69917d0bba44a91f22fe953ec71cda65f1755b21f16040ab5eb673e469b351f","src/gnn/render/pytorch/AGENTS.md":"039785cd5f592b78c92fbea94ec66801296cfde4686c0bc81fe27844c397de85","src/gnn/render/pytorch/README.md":"68740aad74ad5690a756edb83e83961b1a8b4e12ef45ac1b14ed793a92c11da7","src/gnn/render/pytorch/SPEC.md":"611df4057726440ed137ec70e3501480597a1c782a8a93eebf712eaf12d80f3f","src/gnn/render/pytorch/__init__.py":"357966c7d98b5cd4e14792bb4b979d786cf91dcee43bd5c6b1cb14dc8413a00e","src/gnn/render/pytorch/discrete_script.py":"16d1b3ff531aab60adfddeb31dd929289c9ff4dc03d9a3dbdd75b2f51333bf4e","src/gnn/render/pytorch/pytorch_renderer.py":"d065026da3b28a1318e4d01f8e683499e2d349bf0fd16dde61624dbe1180fb72","src/gnn/render/pytorch/sites.py":"23f56e546d8ae9a51cc3b7352f27c7dfdf880c344b383072356bcfa88ffa382a","src/gnn/render/render.py":"b85fdec6ee9c439af53f1a6aa57ec313287da2b3740048166f4714c996fc0a08","src/gnn/render/rxinfer/AGENTS.md":"38f7fe86c890e05dea9a2cb58d005658f357a4ace4551c73e8d8662ca139dccf","src/gnn/render/rxinfer/README.md":"664fa8c6b7e4d6d9135cb1c922861425b7cc27a6b7a5af892cb562922211d086","src/gnn/render/rxinfer/SPEC.md":"6032a161ad7e523133f055abaa322453f09a4436ab9ae14e7842fe20afb8cdae","src/gnn/render/rxinfer/__init__.py":"4939fa536ba57e8a44a408a2fb9357e11d3946d48f8fc07d35f2a7a3896b99e0","src/gnn/render/rxinfer/_common.py":"f099086ce121736801fcf9a0bd216284c230e3a86a579dd716a33571bfbb5110","src/gnn/render/rxinfer/_strategies_continuous.py":"cfe3cba5d072a425884e20a0e5feb614098d434c7827002aeb505b1ffa75d4ea","src/gnn/render/rxinfer/_strategies_factored.py":"87cf67f43c25bc1f048bb62a34bf142f6e00c79b8cdc95d3fde55cb4e46f9fb4","src/gnn/render/rxinfer/_strategies_flat.py":"e20aaf2bcf160cac4cb8aeb23b262dceb252de8e8e50eac7cc28c924984bc6b8","src/gnn/render/rxinfer/_strategies_hierarchical.py":"1e0c289f56a6fc3abbb31e9e023db310c55b57b3a282fc7b33c5583a773d7275","src/gnn/render/rxinfer/_strategies_learning.py":"dbe4966e4ba6af05b63aec3c0e6cf96362aa57d5bb1088f391164301754e3a5f","src/gnn/render/rxinfer/_strategies_multiagent.py":"78edffda894ecde256680aef2d0f48fdb8aa92fd4a8789c5701c069fd777a107","src/gnn/render/rxinfer/gnn_parser.py":"32b8bb7f8e715cd081a78fb3836c7499978d7f8ad9f97ead73314c062c9a019b","src/gnn/render/rxinfer/minimal_template.jl":"f1eb937b533924dcbab222c5497e8c5c45dbb0889f889234812395b0256240e0","src/gnn/render/rxinfer/model_contracts.py":"af1e9fbc63e6483bad31ca939be1fee57ebb3dbe96dc97ef07cc892c7aa01f9f","src/gnn/render/rxinfer/model_strategies.py":"c544aa1eccc9d88c57b898950bf29ccbedab54b5f24fc06faa48ee2bdb0c4234","src/gnn/render/rxinfer/rxinfer_renderer.py":"0cb8edee7a724e285adaa9612c154f9604f7bfdb4ee904c48dc97ba02744e527","src/gnn/render/rxinfer/simple_template.jl":"1be519f9d29fb9f11e6909ea4dedaa522690e31fef76415904907ff8d8487660","src/gnn/render/spec_matrices.py":"9de8fa983a3b25907bb74b08ef87ce1a13eb21031602f23c401f83da266e8eab","src/gnn/render/stan/AGENTS.md":"292baf497c1c03de0742d5db5339a7c4808f1e51aeefd88e4141df45145c61a3","src/gnn/render/stan/README.md":"b3cf49ab82ec3df06e10562ecb74232e4227eb1d838163b098641169ba087241","src/gnn/render/stan/SPEC.md":"77c1d47e5b7ac3f48af15460f4f291b01f4ab50f0de6930a2bf7c125dcf6ab9f","src/gnn/render/stan/__init__.py":"2f5a64879243ba3d6e0fa1ac761da59946b113105b83622537f30e33d7608ca5","src/gnn/render/stan/stan_renderer.py":"1ac244b3e1ea3922ce8c7d3ed838576f5aa6c8f170956dcd1ebc3516fa7b52d4","src/gnn/render/thrml/AGENTS.md":"e222a0dc790bdecbd949a337d6af38c4f4fe1cf547071df5c383d1da3b6b56a3","src/gnn/render/thrml/README.md":"7293d7f6a8490bf08f3a6207ec7143e3b53c4c3ffe1fb7d2d082ce8dd7a0917c","src/gnn/render/thrml/SPEC.md":"9fd30df976a9758fdf655f66cba0af547fce96e21d2e67043d40122be60cfd1c","src/gnn/render/thrml/__init__.py":"48d59156d20416546f09ce0d60dc4bacd9e39bcda305b1b16a756154274737f4","src/gnn/render/thrml/adapter.py":"2d4da7a9e8cb6c4bc74282dadb2f7060fc9dff95389e8d66c175276b4a13ae29","src/gnn/render/thrml/composition.py":"c618979f860fc7acbc7fa58a4551d1fa915f9c0e6d81c16ebfe5e8400a5720f3","src/gnn/render/thrml/runtime.py":"ccb25087b1cc8de5e767543db5b288b9b4773f1ef1172134483e29cc1395e5a2","src/gnn/render/thrml/script_template.py":"e8cd3ee6ad484c32d5b1cb3fcf5c29a777ca96de698c6da1f15fb7451dc5e25a","src/gnn/render/thrml/thrml_renderer.py":"7cc50eabaf6f4100ff7f569eabb48230f8d18439c69c68b3c13b864866a5fc72","src/gnn/render/visualization_suite.py":"cfb74c44e0935c9317de6bdffed293d67376c0d2e9a88385efad3a16ceb4dbb8","src/gnn/report/AGENTS.md":"fd7259791f8c5e4304828682f0b2b6248c68895d0e03fe37b98b79c54430fb5f","src/gnn/report/README.md":"6acde4c2b3ed64447311d8b87a13f8e8d1b9cb20af379156ee650d76849d50ee","src/gnn/report/SKILL.md":"61e8fa7464550264fb029773e5d6abd65e4b65ecb7b4359b0f85c2efb933ae49","src/gnn/report/SPEC.md":"c78b14818c5361eda768a26d48d28e9dd16f975768b7b83017041a292b182284","src/gnn/report/__init__.py":"fa80dca89b017aeae3bcf71c7f105084295311210cf99131bea27d3fecfad755","src/gnn/report/analyzer.py":"f26414eb842486608333c79ee292def3edf17f1f51abaabb6f502fc45d40b8f8","src/gnn/report/cross_framework_reliability.py":"7ebec249cf2bbc95280cf8d40c7bfab58aa281c21687bd750f4bb64e9864aa0c","src/gnn/report/diff_report.py":"e2df9a390217f19f4614542f609dd4e3cc9eb8dcc788412174146cb0cb5feb97","src/gnn/report/formatters.py":"570738820c1706ba66d9092d31b58b293b250a5cc72aaae15de2196d8f2b3ff0","src/gnn/report/generator.py":"6c7654c0e99a0e813d2e0394f3d401a37d6f336a1b9b380b666783f0939f4cd1","src/gnn/report/mcp.py":"48543d4d1dc0f90e0f82a7d346427cefc5e1704375e1dad7045d408e2042e844","src/gnn/report/model_family.py":"6d5422a074af64db0a6d8e110966054c311c461032ecab9afbde14232c273336","src/gnn/report/pipeline_report.py":"905cdd25a1aea1b34bf9ac953d562e2c47ce23a86597b790887dfcf30ad7e27d","src/gnn/report/processing_report.py":"ed88c1d757806dc61316e5f341173097a0c35ee02eb5d8974593968475117546","src/gnn/report/processor.py":"601a42e7e5b68083f955bc372ae1421ec9885735c93bb4cbefe123f1382ee6a3","src/gnn/report/semantic_fidelity.py":"ac789ba1349a2598a1ac06ee1dae5d22688015cbf44786d48a11135faa20b6b7","src/gnn/research/AGENTS.md":"f4b59685a9c330df111b207c1bcb7467857f51978bcdffd7a8c676d91b83f7f9","src/gnn/research/README.md":"394d8180fab010a947020bb0211bfd906d07de3b73c2993dd059e49c8be79f38","src/gnn/research/SKILL.md":"e89a5a3d8cdc945eb38b5206fb95ce5eefe14d8efda97ea1fb969c53118fada5","src/gnn/research/SPEC.md":"8095c9839d1b2ec44f419ee600b6c6724c43cfebd4175661b7c2659c32b30b77","src/gnn/research/__init__.py":"086a5fb150601dd3574fd3233a15bdabc21f268f9efeb508f437719f48aa1241","src/gnn/research/mcp.py":"ce971860d7dc1fd403e99f666083b302a98a58dfbd73c3e9ca77f3182f927214","src/gnn/research/processor.py":"780fb2c7b9cdc103948bbc27aa751d195ce4133862055a6641688e5b8e1f48c2","src/gnn/rxinfer_bridge.py":"8588972beb4186dcc45e8a94fc71d7aa1dbcbf06d8e477932764d68be6d0b183","src/gnn/rxinfer_interchange/AGENTS.md":"db3636c12cd315500cf7981e329834b0d38072efb69f89a336f5dff81413424f","src/gnn/rxinfer_interchange/README.md":"dddec822297c0093a98aad3399388dde3d18e7843ac7e4ba74f60ceb832f8bf4","src/gnn/rxinfer_interchange/SPEC.md":"581c52f8e68a47989f8bf2afd81ff044f26f05b8f18f888d6f31d19d5caafb3a","src/gnn/rxinfer_interchange/__init__.py":"bb37e0b4ce81ab17485875d6423649d54917e5622310b0f4e71c2d7d9dd2aa42","src/gnn/rxinfer_interchange/graphspec.py":"adb09d409dd3c3e3a2358156b7ddd83273bddb21c7f9c798114f92a0b152df22","src/gnn/rxinfer_interchange/julia_emitter.py":"e3f74547748408dd2685b1a1286c5a4dbfcfa2c2e9b1ff9fd9c0ffa442b99dc0","src/gnn/rxinfer_interchange/marginals.py":"5097a5904f813fca8cb9de6175cc1220c58ef1cb343817752e2f9931d59038ed","src/gnn/rxinfer_interchange/subset.py":"a4d8099e9fdce3ac9abfc3a8fc1a685ae9c07809c0604fc3bea24d305fb6191a","src/gnn/schema/AGENTS.md":"198efa62b37e8842e38b9d55e46492bc89cd7a6fab336cdd17096d5e4cac29ff","src/gnn/schema/README.md":"a4fb5bf21f60b3084cccc844b8aedf63eb2b21e21ebe664bd3af1a294541a2b1","src/gnn/schema/SPEC.md":"8c5cad4774f4794d01e9bb65f0fd695a51b63736a886489d5f4dc528e90c73bd","src/gnn/schema/__init__.py":"1b23317366387d73c410400f05ef58ffbac972278e3fdbb95a8ec6089780060e","src/gnn/schema/parameter_dimensions.py":"42d1bb31ce04c0c3a232b0855689003bc780a285c88d2e8abe8e1ada71be85cf","src/gnn/schema/parser.py":"4913fdd970ea046917bd1f02460bf3b3c3cbe42cca47651e9a8b95cd064506f4","src/gnn/schema/types.py":"a644ff8628e83fa56387b6c4ba171ba240f3aa89c67715e2e750dd34858e143c","src/gnn/schema_validator/AGENTS.md":"75dc968c2d2acbe101dc243730d0e79f106c92955dd3e1d55c9701c23fc5479e","src/gnn/schema_validator/README.md":"d8385646de601c64632eae2aa96687d636a9acc508fa9f74f205780a7820f1e0","src/gnn/schema_validator/SPEC.md":"7d209c99feb0bfdb65eb9dba9cbe42be703f9a7d26f782140811925080e8f9dd","src/gnn/schema_validator/__init__.py":"d6d97584374c2c2f9dfecf079c9615f58a8675ce7e94b4afcb88995d5695af0c","src/gnn/schema_validator/cross_format.py":"968b2f94dfd048ea952453b223c79ea68b2535edfa85c2d7203dfe067b1422fb","src/gnn/schema_validator/format_detection.py":"dd52f103f98e3d1485c59f0f910e98a84d7138fff109a3f04f8548bda318a2cf","src/gnn/schema_validator/mcp.py":"7dcffde6618103e1414dcc5e11e499daec4c7606a96fed5af49a328fbec20c56","src/gnn/schema_validator/round_trip_checks.py":"638f18a339dc914ff6e73991352e2371aa113a0f886f31babbf08bd3d2250889","src/gnn/schema_validator/section_parsers.py":"d1c68ae5d2038497764bae7e94a2a4508bca11472db9dcfc7faf42ff74d77b63","src/gnn/schema_validator/semantic_checks.py":"e92ac8ed8162b5e8261ac1d2e94bd12e7e8be7271e399c54d9efb27c3140c939","src/gnn/schema_validator/structural_checks.py":"3439b1c38fee7dd46734aa88e2dae067e8f5c08f40336dd6647991a8811c8b98","src/gnn/schema_validator/syntax.py":"ee1b5d8abc32d6242381e1d7f273fb85c9eaeeec95e6a8963b3f47fc177cda33","src/gnn/schema_validator/validation_levels.py":"6a3dfb9b516bc3a564cf1725480e7e461f4251e58872e7d5fd77adab5e7a60a7","src/gnn/schema_validator/validator.py":"0afdb021f42516bbba8471d14bbcdd81fc92edc76fed4c5d40e5047d5935977a","src/gnn/schemas/AGENTS.md":"3d9003f3aa0fc185bdbd9f8c746ba047382f6153b640745a54ded8f5de1118da","src/gnn/schemas/README.md":"031a9249b778b16b04f507ac56db6567ce19cc48993d5e9f4dcb39bdc0c6b707","src/gnn/schemas/SPEC.md":"3a07449ce4b9d564eb3ce4b18d789823d2f596cc81e7fd9606729f56177b08dd","src/gnn/schemas/__init__.py":"e6dc460f951e4f32ec6fa7fe5afccade3a8e54be74c912c456649d6107510ef0","src/gnn/schemas/asn1.asn1":"b7ccd02d8c34c05924121b5a5e61d9254ee6263df7232ff8bf6b88bc07e641af","src/gnn/schemas/json.json":"a475e544bf22f24d880264df1efc48a14f23a3e546f7dc641e25ea4c063c29f0","src/gnn/schemas/pkl.pkl":"a3cd7d36f70edf2296bdcfab3ae3914e59589b3999159ea50f010684af8200e4","src/gnn/schemas/proto.proto":"9fd3f85a7d54d2011b5acb642216f40501bdf3a3a7751b3823baac3aa0036503","src/gnn/schemas/section_contract.py":"279447305b5c9edcdd1e4e266e86337ee4741c1fb7a82cf741e0b2d4e82afc9b","src/gnn/schemas/xsd.xsd":"65470e47c3f524e77fa3e26cecaee77e8d7dec2728bc04d45bd626b05602892e","src/gnn/schemas/yaml.yaml":"daab8550a8e7f2a792b13d3e1bd6427741ca4a2544ca5eed3480e9b9b2c61fad","src/gnn/security/AGENTS.md":"148bb282a6820149ecf812994afc459e71c960891292f46088ef8bfa9c885819","src/gnn/security/README.md":"d203b11985d1eaf119273f05c9094db07d80a3908251e48cb84367228c1d3481","src/gnn/security/SKILL.md":"a3a5c487bb920847d861be0db9d647e89435aaf22f59bb4f9c632c9c552893d1","src/gnn/security/SPEC.md":"cd1239cdffa73187651e9fcc0656afb2b83544672c890bd52c05f130697b7c97","src/gnn/security/__init__.py":"9b28b50222b088af89d0176e1b9fbb7bb1097ad6d7a69ad3d3a7cea53744681a","src/gnn/security/mcp.py":"498909192c9423166f73315d5a8d28613fd82a4b6d9275f5ae73ccd7b4a75f85","src/gnn/security/processor.py":"155c044fe75c41e3436e64f9834acdabffeca74b3af908dbfea19f890bf9dd1b","src/gnn/setup/AGENTS.md":"4475a25ff05835452ab634156178646f4c1ef7608e5b47f5a2a2579ae65bda4b","src/gnn/setup/README.md":"6dec9a5cecb2e8d95038be1fa1f72d58a5d006f0394f660c71ef571c84c96831","src/gnn/setup/SKILL.md":"f9715c23f4f1b45dea8d4c6f02abb954feaaa6206065e45be7e66d48fb14b47a","src/gnn/setup/SPEC.md":"1b925c39720ccb60c5a44339be2137c5dfad4334ceb24221f4d817ca079dec04","src/gnn/setup/__init__.py":"c908915d8d2d8c0f3a4c6458df78de566ba38615f936fae83c3683812087b886","src/gnn/setup/constants.py":"5f5664896c9baf396272160212bc62aa012cdd7ce46e69995244874ae472506c","src/gnn/setup/dependency_setup.py":"56f256bd2b987149a1fb514195fbfd11aeed7ed181437983242ee4b3aff6826d","src/gnn/setup/mcp.py":"3d88e059b26682c48e7cdca28d53cfca3d8732386814a15309516f6d60a1ea18","src/gnn/setup/package_names.py":"7abcf31c3c3571381414382f93ef4ff2a037f87b6a19a044d6249ce9207e2797","src/gnn/setup/setup.py":"8fbfa855e22b6a0d84cf3bef290fd70cfbac0c8c65e45e735437f1df21ee03f1","src/gnn/setup/utils.py":"b1f877f5a264fde5af07b6b7db659266b13efa901843f66f8c8f7ae059005d92","src/gnn/setup/uv_management.py":"69e16cb881ac2269df7808c3db55a9f71e5216dcbe3f785afbead9a2382ac0ec","src/gnn/setup/uv_package_ops.py":"b4e1b062618933a8fd7f4482bc84f83d9470b61f7250729a963de0016ddd0147","src/gnn/setup/validator.py":"661d602e2ab0c1df65c4580c3be700ce7a14e02852450e7b4f1c9f2ba37291a7","src/gnn/template/AGENTS.md":"4fd6874646d88673105d07129d734e5659c8907ba81e3304401e929a4fca04c5","src/gnn/template/README.md":"b86730d3d05064d104d8a2d2c445f3ff7be1627914fd374765a9b5a9f9b71042","src/gnn/template/SKILL.md":"e63b3d30b4aad57870cfdd5989b68d5751d4cc027051e6ca57c0096c1738da41","src/gnn/template/SPEC.md":"bef7ce549d3d280e0eaf6374bc7ee08910e2377c0849dd0ed54ec263558d5629","src/gnn/template/__init__.py":"0899e14114dedcb67878d70a77ad5bcc5f61cf3059d0055a3bb7c1393c56412e","src/gnn/template/mcp.py":"6736a6ef19f065ff9353413a25b2ed63cf34700606659ea4c41f79d44850361f","src/gnn/template/processor.py":"2f569ddd9745b6cf912682dbcd0a1420b4abe193dd25f458f5919288bc3f9ebc","src/gnn/template/utils.py":"b09009162ac884a3b68cbb37713616d03bcf261d51e321f53213d3577f152a94","src/gnn/testing/AGENTS.md":"b6195164bc37edc61fa81a342899e84dfb77584d5e5e3902f3bc217e91315ecb","src/gnn/testing/README.md":"d978575d5c72e2c0c492e56b3a47a1fec74f21e65cb364074cf8fe48f9777ebb","src/gnn/testing/README_round_trip.md":"dbaf1a773dacd9f1355880fa0d5ebc22c9e227a2d1e588fde9e56758112d06f2","src/gnn/testing/SPEC.md":"3cfb25c32cc2c89e1b19dbeb70e5cafb08e7bbef47fca3b5c3a33d938643b801","src/gnn/testing/__init__.py":"29176654d7cfe6f8fc338e43849b89562b75c85fd33ca72ee0d1f7f55ffd3908","src/gnn/testing/alignment_status.md":"d86e2d1705b9df210e8e9c92a790cacc692c13085ff00d6bd93a0d13f086a156","src/gnn/testing/performance_benchmarks.py":"c8022f373a840003e2953b6b2c8ce187720b2acc08a1435684e9db1d6388d959","src/gnn/testing/round_trip_availability.py":"d1c03c7d29e99aa720a244a4414057e9dbe9815372efd026f7ba4d32e8c26885","src/gnn/testing/round_trip_comparison.py":"733401ec1078b8af28a944ee2b6defe9954c4fdfccf1d44d28db1a7c9c0d59b9","src/gnn/testing/round_trip_config.py":"46806f87359969f280ccbf9aa98e0e823b623eea6b1aef1ab492c7db75b47b2b","src/gnn/testing/round_trip_markdown_parser.py":"876ca9b6b7552bb5f67f577c572e3a3c1f0068b315a0cb6945049f7b5a0cbd15","src/gnn/testing/round_trip_report.py":"0064a78da84b9c7aee40fc31cbad7dccb67adb1acd12a7347d483cd45b6325a6","src/gnn/testing/round_trip_reports/AGENTS.md":"f6303c60317f87a83c26908910dfdf2a0d2ee45a1f142e5ab9c5f9606d8b7e43","src/gnn/testing/round_trip_reports/README.md":"87edddc8dc7f3f48182eb96e22f9968b25bd110ab2848e0523a34638dda4f761","src/gnn/testing/round_trip_reports/SPEC.md":"a1a53a807ad321afdb7b673482b09dbecc1f4fffb6e140a9d1325d91a948b5f7","src/gnn/testing/round_trip_reports/round_trip_report_20250718_160034.md":"d35bc6620fdff48023d699862019eb4defc4a8cb2d772e5a609d8a8eba7d66dd","src/gnn/testing/round_trip_reports/round_trip_results_20250718_160034.json":"0e98dfbe28a91ae01f37eca388e18bae86b5d138bb724d545577dda372bb3193","src/gnn/testing/round_trip_results.py":"6020e5403f464787ce2adb204610feb8d01716323512354665e33dd7ae8ee11e","src/gnn/testing/round_trip_strategy.py":"c9c82b14eec5e8389578b54db219461b90235ce3b559cdf4c2b554d9ab3ac04c","src/gnn/testing/round_trip_tester.py":"a2fcb5873cefcb1843814f90a294c50f49f782c1d482fc22936c7d3da3d52b48","src/gnn/type_checker/AGENTS.md":"2b1703e9ec09e1b2d8cadbeff23bf220d529a1aefd708419a31ca5df8b7025e0","src/gnn/type_checker/README.md":"cebf6e57d94a6315b1b0469df7217e93bf52826614171a654a78fc44ede65e79","src/gnn/type_checker/SKILL.md":"41f654cd26982a9e2ba9899d58a501ab25f93bc52c304cb4e78e0ba459915f08","src/gnn/type_checker/SPEC.md":"f07bc78ecd50c5c9240f391905fd193210b18e228545a23f7031337b7eac8496","src/gnn/type_checker/__init__.py":"ad8f43ca08908a4417563f57a5b837831df4b158d70b1257360432c88c1b0fda","src/gnn/type_checker/__main__.py":"243ba510bfcf3e8457e40a2fa15e9c9b2e905e666b1d1fddd76744960c0f4d15","src/gnn/type_checker/analysis_utils.py":"474f41a0532b2d41b2a7ba123d34002842ebf8461cbf3585837bbec764eaa8dd","src/gnn/type_checker/checking/AGENTS.md":"543942401f2b5ce9858dea691a4530593d073c56654f6a05c71ffd9dbfeda156","src/gnn/type_checker/checking/README.md":"360faa278e8879d88b5d9e704c748657cea44c0c511c99e4545476119c9dccc2","src/gnn/type_checker/checking/__init__.py":"938335ad6e8f130d28f9f089af9ddcdb03030e4e6fb04b522d0e269c548c3e51","src/gnn/type_checker/checking/core.py":"e6d64b46b5c680fb5fde4566da78bbfe8a5e996125eceb0c92c09947eca8f936","src/gnn/type_checker/checking/dimensions.py":"5f3d005146f0e16318eb6574222f58fca39b4273b66ca7c931c45b456eb90613","src/gnn/type_checker/checking/rules.py":"a0339549b8d3a86c2cebd16e175eb7148d4fa7dd24b05f2b5603dff287d6502f","src/gnn/type_checker/checking/sections.py":"f184d461764732d1cef46a90bcb5917096478d95fb6d1e4abf29e72766b5ffcf","src/gnn/type_checker/checking/summary.py":"c56369de76e39ec4fda04587b96f0606e5e685e9151565069dfd9996838c2bb2","src/gnn/type_checker/cli.py":"d399f341b3376e8e0c4d2c0e7b32689483d45d7b5d36b4c08660f5d139eaafa2","src/gnn/type_checker/estimation/AGENTS.md":"402838f6e9ed256050d1c1d0e78c0f1a054cbd0967fe5810f9bdd48fa8ef3173","src/gnn/type_checker/estimation/README.md":"afc79f0d41ba76474332b65db2bb9faeb3dab9d1d9d49c537f517bef91efa697","src/gnn/type_checker/estimation/__init__.py":"b81d20ad1fba9fd78ca602fefaefa306abd43e614ffcfc859510d2e74a1b8cdb","src/gnn/type_checker/estimation/estimator.py":"8646dc46f019357f18732064374e0d6d2bc142dd3497c510f7404bceae464497","src/gnn/type_checker/estimation/report_html.py":"420c277f642daf9cb735289acb1a2cce15d17db4b3f6a6a9ba9864b95bdf7ce9","src/gnn/type_checker/estimation/report_markdown.py":"1c35e63b29e25d6e6232254deddd485b964df8053030960bb854594cda9a3374","src/gnn/type_checker/estimation/strategies.py":"8ad2a123b408b6aad9476c8aac9c61895204ed5776cffcc093e04d3d0233afc1","src/gnn/type_checker/estimation_strategies.py":"7348c3c3996064828ff304ebea6c9ec0b4c028b53a80b275468045b3107a25a3","src/gnn/type_checker/mcp.py":"9f73069de7e446ad99cecadc7d27bd79accb34eadc07720d3f51fb4d20ee9b54","src/gnn/type_checker/output_utils.py":"60883494f3305db5daad1d98b8011553e6eefc9e23329fbb60532a6583251c92","src/gnn/type_checker/processor.py":"1289c55c2106fa0dc3097958d02b84afb919da16b1b0d029a7bdbfbba1dd9bea","src/gnn/type_checker/resource_estimator.py":"e6272e7d5ad5123a75e7ec40c728627d03a1bb636398fda3994bf97fa4ca0cf2","src/gnn/type_checker/visualizer.py":"2f33f8888ebc47b822bf5785e9bca404041202e92e482a2cc8e2670a168eab30","src/gnn/type_systems/AGENTS.md":"ab807f4d2342a731a87696141546b5587e3011a12174b64823d6d2d8ca89b5fd","src/gnn/type_systems/README.md":"1bdc439f3f5b81246c7b0916e010c80a3ccfe5e8e04dbc132ae5e269d0f3a39e","src/gnn/type_systems/SPEC.md":"5801d43a42e3401a0eb7ee974eba7ae1afda424bfb50106910aa12d42a3e083f","src/gnn/type_systems/__init__.py":"a3889a68b9bceb2a803bd4fd119c7be1f894b7758d343824e095cb0d8cdba2f0","src/gnn/type_systems/categorical.scala":"ef2937a970d7c9b3f64d83cc61a18a9cecd973f7544812dcc52985b9323ba9a6","src/gnn/type_systems/examples/AGENTS.md":"4b0e54497e7f1e97ec2256731ebfc5453f7b1daa22d3c5188bebeabebde3b8cb","src/gnn/type_systems/examples/README.md":"d5cea16b2056909fcf003c99a441fe7710bb1deeda808b202f4aeed3deed515b","src/gnn/type_systems/examples/SPEC.md":"671af6ac0e37aec744c1bae5b1b8896056565cdd5420df6eac0364be6528709d","src/gnn/type_systems/examples/pomdp_example.scala":"cdc12cff3530215b23ae8539443310212ee74e7d550990fc9d2af6590d4b4dbc","src/gnn/type_systems/haskell.hs":"759d087e8d2565319f8c3c754b94a517af23940417a7b91296001eefdc792653","src/gnn/type_systems/mapping.md":"9170c8b8791bb4fc92285b0945a1bd527d2c5d49e50039f635454caf794e59b7","src/gnn/type_systems/scala.scala":"675ffcaa29de0c001060a9849f54864d1d3ef3d4482c16a29a4941a1af1c6837","src/gnn/types/AGENTS.md":"ef891675da8307329b3345d02e2fabc56d06ec35b980dbc6b35c1f65a90d1ff9","src/gnn/types/README.md":"062a67796c54bf17ccc48937242d296360d799e3d1c59d676b25357d0e8b0c52","src/gnn/types/SPEC.md":"5a6372b8689aa4e1d9780c20d22a09e235106e5ac656bba6430210b689f44bd8","src/gnn/types/__init__.py":"8d538992e1fa1015387e7bcdec184265b825bc378f75f86ff967ecc578a52f6b","src/gnn/types/definitions.py":"d3f8368788033a99468d64ecb9040a2d1b1d93ab548a0b5898daa1af25c78405","src/gnn/utils/AGENTS.md":"292a33838328e3e8977db8f4de6c053ca6d1a8adb63699908522f4bd6f4a4791","src/gnn/utils/README.md":"c422639a2092f53ffdb4aaa0e54817a8b77d1128f26845d28212218f9f4f82d0","src/gnn/utils/SKILL.md":"fb6f8bb343b188207a075db97cb7f3a9970bd4fd14978c804416e078ddc800e5","src/gnn/utils/SPEC.md":"319c667f30c36ba762b76d1d3eb74c701324a6afcd7244ca7954b6af043080e7","src/gnn/utils/__init__.py":"c948c6cc2e6ed378c4ef959b00e37b42aa358fd9f549ef3b3e7381e899eba02e","src/gnn/utils/arguments/AGENTS.md":"05d8c83fe09f4a28f48393aa035eb19a6a8273b0c9652fb8a0b497fe8e99b00a","src/gnn/utils/arguments/README.md":"069ba5c749adfcd562f09a21e2aefb89f8deb0db6b0fa0ddefc2072c4fd04d64","src/gnn/utils/arguments/__init__.py":"2c288d7f5c4e4b818f93730ae175b777818e0866cd6a1e12447a6fb611233d8f","src/gnn/utils/arguments/arg_definitions.py":"140dd31179b297d43db964d19f3ae5cb989bf75e64c949da1fd431a3de9ca6fa","src/gnn/utils/arguments/arg_parsing.py":"35f7e3025e631ad8a828f1faba455753fcc96ab1dac9a71cc50999eecd7048ea","src/gnn/utils/arguments/argument_catalog.py":"2cae7a89d5d2d36b51e05adfe141656e8ddd9e291c9fde0e6c08a3cbc7a1cf20","src/gnn/utils/arguments/path_conversion.py":"32b78668623bb8d41e28242785e799c0810f5a06f2c856907ae494682ace7a72","src/gnn/utils/arguments/pipeline_arguments.py":"2254019cf5e99ddc0a41a45307aac63d83bd78585fd83268116b4b721947003b","src/gnn/utils/arguments/pipeline_config_merge.py":"339d8e12d5548297ad42f6287247f3a4a082fd1f06db75f4625a67b67582eeb5","src/gnn/utils/arguments/step_config.py":"087d56977c08d3c222afe4df04ffca0fa4e145e2f4a278b1559f129e614e6272","src/gnn/utils/config_io/AGENTS.md":"6f9c47da7adf082b7ae4cfc2f2b3c2913dd232ebb93a08a1e0a5a8bc0ef47a29","src/gnn/utils/config_io/README.md":"ba4fef11fd673b37520940289642ee04572f100b9ddbc7eaa8301e17777c368e","src/gnn/utils/config_io/__init__.py":"e742bcb3d1049c0dad880a9ff580763231b3c1e05bc4ab22c1d8cb0b91ecc939","src/gnn/utils/config_io/code_metrics.py":"2e15716028d60e46821ad53b0dd780a9b9515a70701525cd73d2591648259649","src/gnn/utils/config_io/config_loader.py":"ff1dd41e77f39ae088f130eab15141d9697125f19451a972099725d5e7bbfa8c","src/gnn/utils/config_io/io_utils.py":"5f4342dd189df95d893284f1d00a7ec6a638e73d71d78968ff29546c9a57b975","src/gnn/utils/config_io/path_utils.py":"05ff6abc5dfcd60c1779454fdd04127fecb117e1d652181dd42922214335e6e4","src/gnn/utils/errors/AGENTS.md":"f4a933f86761b565c8191d4af4812faa4ac7d55bca9c2345d50331a5607f68b6","src/gnn/utils/errors/README.md":"21ed9be4a24ec5373ea8d145fdc32f3daca1e1280acac23e343c09fb820084e3","src/gnn/utils/errors/__init__.py":"291090fb4e8700269d4321e4c72c5fd2d5d32352257aa29e594cfc56851fd156","src/gnn/utils/errors/error_handling.py":"d3193af4680f0d1a880cce6807715f6fffc9ea74f3a92d30f5d8c09ffbc11233","src/gnn/utils/errors/error_recovery.py":"a5a276b34dc0db854724b990fa35e943e6c75eaca484c14bf0d40ffc54cc533b","src/gnn/utils/file_workers.py":"1e666e01de42438c478f0f6abb74bfa4c8a15ebface2584a2d68c48de61a3d0a","src/gnn/utils/julia_runtime.py":"e6eca5776ee658d2688e63ff66a4bd510f2c68e2e7e99cc9845284a65e52397c","src/gnn/utils/logging/AGENTS.md":"7c18992a6b76b007a005705c40266a5fb709831f47ec5cb6a666b353ba59655a","src/gnn/utils/logging/README.md":"06ea0cb7ffde5c9f8a8d5dfc17adbd29f515e4951b5408a09e9feb8313031a69","src/gnn/utils/logging/SPEC.md":"893fde46223c9214c939910f9e9d24d6ca02146135e9b153d700cfd8ec9085b1","src/gnn/utils/logging/__init__.py":"319c1ab523a4a7d533c33c527cba8eedf13b7bd7f9ba2818ba65b214bb4c726e","src/gnn/utils/logging/formatters.py":"d04ff221630dd56a1998d98fb6e957407f629298194082abf85ae6c459122f8b","src/gnn/utils/logging/logging_utils.py":"aa758af3f6ead417cff68af2912cd3ff26b6eedab9a39c26c0d19976525ec1a5","src/gnn/utils/logging/visual.py":"71ec65eb5d715517b2f454e8c55f8ef176977ee4b03a8bd62de064cd2ead3245","src/gnn/utils/logging_utils.py":"5d886bc94670fa7c6a471aff901ba3fb8a057c1c078f4f8b303b15878a58717f","src/gnn/utils/mcp.py":"75b5747acfea430fe14450d3c4d0a148dd17e0b671be3b4ebff242bdbaf4bb18","src/gnn/utils/mcp/AGENTS.md":"1b593245238e15413f3e92953999a201c4c25e435703a441cb2a98d04afc0943","src/gnn/utils/mcp/README.md":"aa3237305635add826d9b7d38a4b0ce78caa4ca6265d3f974ec4b8847b5bd8be","src/gnn/utils/mcp/__init__.py":"6c2d8f6ecadd164a4eff28fb1d1c05c342aa552a8f1990dbd536b6dad7eb12e0","src/gnn/utils/mcp/dispatch.py":"5f46c6a0034d330b4df649313f78de4512cd9cb84d66fb5171e0eebfafdd6947","src/gnn/utils/mcp/server.py":"032222e572731c97410c09afa8a82413134843dc93d909f784f2595325c9c571","src/gnn/utils/observability/AGENTS.md":"f949d993cdd79804a9a033343dea4a62239db805a5c193d6fd86d941be10707e","src/gnn/utils/observability/README.md":"592bfa84da1a0a8a3cb1c4d199fc934c63f898c1784f46b9de2ee82a76afdfa9","src/gnn/utils/observability/__init__.py":"70e69c49685d30b499febb9af9751ff1599dc0dd9cff9e75ab17483d1187ab84","src/gnn/utils/observability/performance_tracking.py":"8386bd9736a3031bedca716c519d46da6fc5ef644e4eacb7200cfd61bd38f368","src/gnn/utils/observability/structured_logging.py":"3a5abc172ceaca214c348d861b9f892dfef83bbf9e919c9af312acee14350905","src/gnn/utils/observability/visual_logging.py":"66cd39320b82503a6b4cd019db63a3a7d071e2ce7aca2defdc10cafb63d93f06","src/gnn/utils/pipeline_orchestration/AGENTS.md":"d46d51d1daf9b62b0b76fdea88b1d963eafa747f8b55d98f72382cde0a31188f","src/gnn/utils/pipeline_orchestration/README.md":"66dfc7f769241ae34a4c4b87ef6295a9aea418f898a1c44e93255c880f134660","src/gnn/utils/pipeline_orchestration/__init__.py":"01d6ca103c19081b4fc3dbcb234ec90b1d39e83e80e335bc520c24688c651a19","src/gnn/utils/pipeline_orchestration/base_processor.py":"3793aa672ffb21881c341ce2473ecb8a41dbfccfa75928bd9129e70af166c824","src/gnn/utils/pipeline_orchestration/execution_utils.py":"cdc675f8a279a456f53203eca63ceb1b1f37f56101e9dfee8c5070f97e3e2e93","src/gnn/utils/pipeline_orchestration/pipeline_dependencies.py":"389cd319eaa01381414d626898908b6c4ccce2d54b157676eda62cf706773be2","src/gnn/utils/pipeline_orchestration/pipeline_monitor.py":"f8347661c534a1850b6b44ea8482fc65f239973c7c48f92a26292b0fe9e84bd8","src/gnn/utils/pipeline_orchestration/pipeline_step_dependencies.py":"7a5eb065e325cb2cd0aaa931b40fddb62e588d00ea4c2dca4c35fa89bee2b373","src/gnn/utils/pipeline_orchestration/pipeline_template.py":"5adea98412cdc15da8170eea3cc5c37fc79ef2e8f75deb5af1cb4570994d33c8","src/gnn/utils/pipeline_orchestration/pipeline_validator.py":"cc38850eea3cef63663a3bdb0a6f461003401fe4c24fda704a4ccd47ba3e8cb9","src/gnn/utils/runtime_safety/AGENTS.md":"c775a978c6180e0454f8543a207a03a2854d255fc4aa894f0951d4362cb6673a","src/gnn/utils/runtime_safety/README.md":"a5384280b55804b8714f232b00bf5c656598031bd8c7ece27a7b38979a0c2b47","src/gnn/utils/runtime_safety/__init__.py":"50545392d380534a3fdd0060314a426f31c737f9ec0dc9f4397ed947a18ee4b7","src/gnn/utils/runtime_safety/dependency_validator.py":"a5f561ce2b1b02f36a70e82aa2f9a57aa45ec628f7439a0b6d620f076f68c15a","src/gnn/utils/runtime_safety/filesystem.py":"fdd39fb3589fc039c6968c972461e28ef8a397ad418960a1fe31f402e368fa04","src/gnn/utils/runtime_safety/framework_availability.py":"2a8841339a47f0bb2f2300cdd5df0a04b68f33c659043c6b52a96b9a3d9d4aa5","src/gnn/utils/runtime_safety/jax_stack_validation.py":"03b66246f38c5ab50847a3c320e5ec1ea4590ad04d9ead69b617bb04c72fd4c7","src/gnn/utils/runtime_safety/process_budget.py":"70401b65717b9b02fc28100231857c9a69584b0cddd8664a242e8cf19e2cd946","src/gnn/utils/runtime_safety/process_tree.py":"89856da721b041469d49640fbd853f4396fd24b2c10cf937c59737c181d3a667","src/gnn/utils/runtime_safety/resource_manager.py":"11bc4755cd72859bf67b649173cc1c08ede4530cf625734a592f42a118aabcab","src/gnn/utils/runtime_safety/safe_eval.py":"54dcec0a6cad18bf20d72f7d2f43ea5859a64f4f802f2789766b31001895c67c","src/gnn/utils/runtime_safety/timeout_manager.py":"32f6f059e8817f79866e8f8145b5f64b43cf0675ec8a586c614c69fe43efadf0","src/gnn/utils/runtime_safety/validation_schemas.py":"d6d072540a315d2f3466320e9d1c80f016e6374f941ecfc40758f5da242c0325","src/gnn/utils/system_env/AGENTS.md":"f86f461413c0e4df7a705a347b7022c3619abe89c6be6b29d7d9051c69cf5433","src/gnn/utils/system_env/README.md":"6c52271eb0c7665dcd2384e40fef9e6783a1494fc661d4454d1d08fe12fc5443","src/gnn/utils/system_env/__init__.py":"2cb396c2209175af411df115056a9b5b2f725b042cda65aea1f0a9ce101693e9","src/gnn/utils/system_env/matplotlib_setup.py":"b2dcc0504084274c9fa7de62f7c7d5734fb201f1827d66befafd44e747589016","src/gnn/utils/system_env/system_utils.py":"c4c7403f05b0734e102eff91a2c1e4e77eb8077a6a53d680d706f2a2d35ae716","src/gnn/utils/system_env/venv_utils.py":"455569530f7af1847e7d92c377f25357bb2958f0bd4dbefe1f119725ba9819ef","src/gnn/utils/testing/AGENTS.md":"bc4ea621322cb869cba834170e416c995cad202271c087095cbbe1f736880404","src/gnn/utils/testing/README.md":"39b8114853762a0975bb8e6e2c19d1aa14a0cb43661dd8c8fc00a2c63013338f","src/gnn/utils/testing/__init__.py":"a0a98b92bc67413808d5bbacd46df8256dcc733e6a7962dd52c2c5caf4554706","src/gnn/utils/testing/assertions.py":"6dc176e66c03bc2ad55d37894cbcfe4cec343f2c276efc28a93b7f012e3c1c4c","src/gnn/utils/testing/constants.py":"759dd057f6279f0c6823ceec4f121810d42b4ddd71795e5b059eac7488a477d1","src/gnn/utils/testing/environment.py":"0506a1e734d4c9ae313893ff9246458a5bc6c54c89069fb4a18af0fb1925a99e","src/gnn/utils/testing/fixtures.py":"04982d17958e5d540b87a995f1eeb13399890317fec15c6aca48e3f029e5a1d0","src/gnn/utils/testing/perf.py":"4be58f7c7688adaf0ca9248f8730cdb27d5c99a4ab54dc3c3adff4d4902a4596","src/gnn/utils/testing/reports.py":"44f2ef0067515ab54ddead58a77980950148b2d0ccaf9cdf3d4ce7a041968f1d","src/gnn/utils/testing/runner.py":"5c867c2ceb207ae73cbff169c841209a6d50e9817d0d583a6caaf4b277248372","src/gnn/validation/AGENTS.md":"0f19e22eb0d6d1b365934ca2d3abd6590eb0f628bd95fc7d11ca4acbb4abafd4","src/gnn/validation/README.md":"ce0c3158b8ed04d5bf8ae412ce1162511202e6d1aea3d9a829d625a7ae19969d","src/gnn/validation/SKILL.md":"7e560461cd4cfb9d2410b9f8c8ac9a8cb5c5b295935052c0c4c0c2cb704d08ca","src/gnn/validation/SPEC.md":"38ff8293f7b711ad6a9c65ce677e91a6f9f9486731357003b4d72f66750e0c2e","src/gnn/validation/__init__.py":"8be5779dc4e9934843e69410dc701309a15e03b36172a95dcbdf7e13004a8add","src/gnn/validation/consistency_checker.py":"52371f1a84a88aa1c897aa3b256ffe851485795d2ef494240387eb9bdf037de9","src/gnn/validation/mcp.py":"912b13b3794a65b523f4b6cd78dd0310221d7bf5d62ee287f9d13ef4925944f5","src/gnn/validation/orientation.py":"e2336596d90c46e51d14eab4c3c444eaa646c722211fbe243332dbe9d71c0265","src/gnn/validation/performance_profiler.py":"109cac2a5741f4d1a3af6655a0fa0653fbace0a450d10a18774a62b5dbb60ddc","src/gnn/validation/semantic_validator.py":"575dda02acf01989a1bbc217923748dc180741dacb97e682e30e4323670aedfb","src/gnn/validation/semantic_witness.py":"353178acc5e803a3b07dc7dbd7c00bbc7deee6384d6f333532cd736ad431a131","src/gnn/validation/simple.py":"cbd8a8320fc44577a961c226bbf95425bafc5222dbaf4a4c58e46ed081140570","src/gnn/validation/structure.py":"292c2742e274f9d057a9bbbb6cf0cae9b4f0034bd9ca98ff1da7e15cfbee447c","src/gnn/validation/witness_composition.py":"56c133615c167d50d036bcd8868d8373399721807b2e62f0ab350dab911c4af6","src/gnn/validation/witness_composition_source.py":"6fd281cb7053e80cd2f3fb92e9c9c0dbc16f901dff29ef0903dd2645e1852857","src/gnn/validation/witness_source.py":"a1b4d2b1f3b209c540cfe8a226b0a546365533f9e192727ccf5108a116eacdfa","src/gnn/validation/workflow.py":"2cb49c145086b889a529ba8482fce7e0f0cd92760cc254dedd51bb8688dc0742","src/gnn/visualization/AGENTS.md":"3849e56468759a205c28dbe37ede7197ea2362cd4fae47d23261ba6e0494e308","src/gnn/visualization/README.md":"bccc87c1656bef6850a62637b33b5b12cfe5ccd0a7a9bd26fb0aa87fa5e219b9","src/gnn/visualization/SKILL.md":"ddae8f0602ec7c6509ca2d943028e235f95ba3479dd2732e45b96490e65d57b1","src/gnn/visualization/SPEC.md":"803052620e2d32a4a7e6a31dbbcb7df0c52c0eeb1d5f898f56aee6b5e3981d27","src/gnn/visualization/__init__.py":"592f976e0531b3a37d9a975711b5b6cf7414e8c0e4901a55f5eb4bb9f18367b8","src/gnn/visualization/__main__.py":"2e4448fb86ececd500acb46d4b7fd350eb58cd45d48665fbeac143277a808776","src/gnn/visualization/analysis/AGENTS.md":"724aa5752e1e1b230c4d7d048b69011ae928282b936dc18cd58942d61adeff64","src/gnn/visualization/analysis/README.md":"7d1b5a83826b6946cbd66f95d02028b4f51c5da8153690beb755daef2354aad7","src/gnn/visualization/analysis/SPEC.md":"dc416c7060dd0260bbedacf653d25a6d66b996ee5e946b6324fdd285f94e06b3","src/gnn/visualization/analysis/__init__.py":"8947a3a548b915f624da158ca93532d34bab29106c6e2b9622268dd09754ac55","src/gnn/visualization/analysis/combined_analysis.py":"28e2f4cc10b7d0d1b45f0403b90ce540e7ce99bef82b85d0b588de488d080a8b","src/gnn/visualization/backends.py":"d24b0043f487c04ee96ea69fe1617b63cfeb0d8d9cb3473d0cad38a07871b47f","src/gnn/visualization/cli.py":"f723ae6c19e0557284fe19a454b73d24a1472b3dce6b1fbfc3933c17eac28410","src/gnn/visualization/combined_analysis.py":"44208aeefb977b9aa4f7c0153c7ac50853cd95fa8d995368225053437efddc5c","src/gnn/visualization/compat/AGENTS.md":"2f89e23561fc038c2a11d357ea116b1be6cbc9bfb58cfb5734d8e5db176df672","src/gnn/visualization/compat/README.md":"29e2e3cb25e85279054ea26830b3d708ca267202ae99e42ad1901f64892a00be","src/gnn/visualization/compat/SPEC.md":"4bb320757a9973a59735670067861c96763a563e343b447a49796eec7fe6bf91","src/gnn/visualization/compat/__init__.py":"6627e82f5c46256da8ad7933e6ad5171bd734f4fe46f0071dcfb226019fbee62","src/gnn/visualization/compat/viz_compat.py":"d36a6b66ca46b9d775f2e45db202d3e0378e58e75f17ce669e081e61b4e08390","src/gnn/visualization/connection_format.py":"1606467cfaee96d9630960e2efb60c8de07d2d640c66d7bc172a36b10c932ba6","src/gnn/visualization/core/AGENTS.md":"80580c40139ff9ca296c4fc10de99ef6e235929b0239371bed1543163531bc0a","src/gnn/visualization/core/README.md":"89062f828fa79907b64bea528bed9c0c7d2ee3a26bccc971dca999706f549557","src/gnn/visualization/core/SPEC.md":"557e489d05104b39182b9e5b0550911672ccba8571ed098ac7e27706f293b483","src/gnn/visualization/core/__init__.py":"23f54fab43484158a9b6fa9505ab293ff54091db115272122b773786460cd87b","src/gnn/visualization/core/parsed_model.py":"e1139db54c3742f6c1e61d6f3f8c9544d3979628156de27531b048325fa0e08b","src/gnn/visualization/core/process.py":"2832d96e56962e96fe341917508f784d2d57e99800991f532d0c9ef07731d706","src/gnn/visualization/core/sampling.py":"e3a5244a7d99f88f25c01eec4c364b8ae854f4dd5a85bf2c0f28fc58f406abf6","src/gnn/visualization/graph/AGENTS.md":"e6c464dc12912484513c20137de11f96e4cc00357a7da9482f08231ac2bc6c00","src/gnn/visualization/graph/README.md":"e5323357ad1a69fad77f8e5d852179bc313a35a030cd00fcb74e5e1669a06ea7","src/gnn/visualization/graph/SPEC.md":"7801205c8240c4e318d0d6c7049fddf362173ea0bbc323abb13d7c5b39e6c189","src/gnn/visualization/graph/__init__.py":"d41ca94ab96a6c77037a0913caa90173f0c7b539015b8843aece78eab31d5c58","src/gnn/visualization/graph/bipartite.py":"500a8c9ef4bf1644254f8a2ddf069446e96f875ccb60b23f2c256d51412d7597","src/gnn/visualization/graph/network_visualizations.py":"5ed004ff5e80552608918b155072da28f6eb1189ba42b07aada6a68036472d73","src/gnn/visualization/graph/stats.py":"5dda05cb86797ea94ca899dd03c191c727d756b7ec737260b5d3e0b4b9c2459b","src/gnn/visualization/matrix/AGENTS.md":"821683f411d9edeb8ef248c6c89076c2bbd9f7ec3822223a6a3b0459b6f431e9","src/gnn/visualization/matrix/README.md":"6b63e1168e6d13ca0873eae76737da44c70343c262c528311473d37d3f55acc7","src/gnn/visualization/matrix/SPEC.md":"f9a0c5213ee099718d22e6ce5c4e6e447c8b0fca6822100d39c576bc9a8dfc0d","src/gnn/visualization/matrix/__init__.py":"a12c038cb92d1ee75d263b5d236de713627ed6337cdfd953540f4aec6369a21f","src/gnn/visualization/matrix/compat.py":"212489625f96f6b3eb040a315e78411473b619798d08cbe63fa0585e58148f40","src/gnn/visualization/matrix/extract.py":"e4c50605feb1275bcebf0d07cc64240ae0de411825b5c8f7e0b5222129caac01","src/gnn/visualization/matrix/threejs_template.py":"1176cf466cd3daa256bca02b503edd56584a6cb8acd339b0f346ec12390de3df","src/gnn/visualization/matrix/transition_analysis.py":"67673876ac030379b68cfacc75f7daf0aacf8b3be12a904b39ab185ab6d82eec","src/gnn/visualization/matrix/visualizer.py":"7ee09f008466d4d3371a84ef80db5bbeae022cb89c1e468b31779e7793a67d53","src/gnn/visualization/matrix_compat.py":"1bf937d5babd053b3998931f723e32d7b7f37a2860bacdab3791ddcec7d70a8b","src/gnn/visualization/matrix_visualizer.py":"ca0c8d41e7b63e1f41601a8ca4b3cfe7356e1f986a7d370e9c643e819de081a6","src/gnn/visualization/mcp.py":"605b8cd4ba9a51c00debdc7d8461849098c0290b2263c729b732e2d850dfcaf0","src/gnn/visualization/network_visualizations.py":"885ce60095996324594e17b7846670b9a1a18d4ed804484949a3d01a79184e88","src/gnn/visualization/ontology/AGENTS.md":"cfd78e9801ae4557fd09e6dcb2c82b82ffa0781a29f57b157829cb50ba49f955","src/gnn/visualization/ontology/README.md":"1bb2c54af5b6791bb4451d6db842efc3ea956b38ca8ba6445d70a3eb5af756ef","src/gnn/visualization/ontology/SPEC.md":"cedc3bab2af8ff6467f627b6647facfd704ad905aab0ad3d191bae640b5ac46f","src/gnn/visualization/ontology/__init__.py":"cd3abdad866d5f21390b52167dcf8d0d4314174566bee8d7c7e859b051556dd7","src/gnn/visualization/ontology/visualizer.py":"108801405cb88d79fb504631dc932113b0e17594981a7431967cf4d985d24c44","src/gnn/visualization/ontology_visualizer.py":"5ccb488960994699af10f3e957e94b800b5c5916eea60b7f943f26a8dc7fb8e7","src/gnn/visualization/parse/AGENTS.md":"900727c9b9540a41837943450cbf8fc1354a9f2185627a9fb5a7677757672c1f","src/gnn/visualization/parse/README.md":"57fa4aff48d22151d9ab2b7df023ff07694268fd75b3216f33977339b5ed7c4b","src/gnn/visualization/parse/SPEC.md":"0fe586563e2375e5b6eca9c926c87600b753e2ee2d9a66b0766e8a26f143bafb","src/gnn/visualization/parse/__init__.py":"2f6c375def662097f518cc6051b875b69839cea6d4d9099012ec40a1450c30e9","src/gnn/visualization/parse/gnn_file_parser.py":"37db18736b8afe38ff54a450c3b19d562d80f5d40b198fcdc97359d6b18e2b0b","src/gnn/visualization/parse/markdown.py":"33cbd77ddd4574bd56d3ee5a0c5409f5ddb04c7591c63fcbdb7bf4ba7b7b759f","src/gnn/visualization/parser.py":"cce43d95c16dc94ab959db181251d8913db468a14f19ff77c81f016090c7a0db","src/gnn/visualization/plotting/AGENTS.md":"292e390a6cd3835545a583100014002bd5555f2a26d86b1c6c7776b50678217d","src/gnn/visualization/plotting/README.md":"a7120622a233c577e66314bd6e0ed78c3dce6a5a834599b3638be9cdd3436f2a","src/gnn/visualization/plotting/SPEC.md":"7aacf5224e9ae4e87f252fd0ca2882e1f4a971456f84be8d30a687f70cbf7dce","src/gnn/visualization/plotting/__init__.py":"cffb7a1c377b91e4c98fb917128c9029617f27501878a560579fb75deb0f9965","src/gnn/visualization/plotting/utils.py":"2c29adcbb46d8ba00ac056eabf104ff3edf73f92802c104c35578d2ac0ddd665","src/gnn/visualization/processor.py":"8da688be8bfd533b32cd0d44e84b919401b5cc487cdbf5af94139c55acbe59b0","src/gnn/visualization/run_visualization.py":"421da6df5794c6ba9eaaf5909ccbf20269be989f1b4f723b9051ae6d2f59e3d0","src/gnn/visualization/theme.py":"98ec013126f7585d520493919cf01aef521ea0bfd66f5cbc7cef7498d8ceeddb","src/gnn/visualization/visualizer.py":"c6a59c54bfc88d8a7b1f767f259d3e12da6449237c0b542ee09d6ce1248105fe","src/gnn/website/AGENTS.md":"a53bed770e526f09d7b90f4f6a60106e295c57fc41d6aa8db5a83bdfd9e7dddb","src/gnn/website/README.md":"e8ebdf86e055fefc23b7e29c7f8d2b4011248831163fd7e2d2d94b82037e9200","src/gnn/website/SKILL.md":"50628404e23ae7e579cdb7d8dbe9cc5d4ae39ce768d6b40dfd8bfed5d10e036a","src/gnn/website/SPEC.md":"f37b74cef8feaeda4cc1876aa16c21001884d07dd7bf26a33faf5254e1293993","src/gnn/website/__init__.py":"b81a4cc84e93f79f4527754cfeda430f0af4278f63f27c719dc499d27488e2bb","src/gnn/website/asset_transport.py":"bd7cb98a6ff2671bf1b287eb1bce6af4147bec40aaa47eaa87b2cf59fc3a01a2","src/gnn/website/collection.py":"0000a12a3a155540a52e6c8f54cafdf093cea0b5adc03c30b77d5c6cd8dc5eda","src/gnn/website/evidence.py":"9bc7f79a511234fbaef2cb2737389495e7ca5249f1841a895548dd95062bbc74","src/gnn/website/generator.py":"0f08f241d3753b7b88d17b828300004a4ccb4c1b57a2c0b0488905464df760a1","src/gnn/website/inspection.py":"14544ecfde73c14ac853fc43a716985e057ed5e58d13ffad60392e05f203adbf","src/gnn/website/mcp.py":"06535e4848833532ece158f2b3638eccd37f5ba9bd996a42876b12574d716498","src/gnn/website/model_navigation.py":"f90548a2665487d08eb2eac48c50775c8c3191656bc0b37983c660812e12e3d9","src/gnn/website/pages.py":"13d131cbf8a2a5f8332c388415ea65e53802ad7b2a88a28998d7c5ef6f77e334","src/gnn/website/processor.py":"05d1764260a5b0ce9ab829c7a3a95197efa3a9e9c06cb9d40d7976100d8bdf47","src/gnn/website/renderer.py":"360b767d66859a6415719150995ec39138081eb31aaa1c8d2fde8572cebd7736","src/gnn/website/serve.py":"6f7a99bb06f571cf7281ad6711520ddbe7d0a4b35badef1fe1a1809d2625e79f","src/gnn/website/source_collection.py":"a5fe1fbe4280564087d3ac3761a67e6f62f00a312c393777192039853bd3c9d1","src/gnn/website/steps.py":"3b6a08f261cf1f287cacacf926dcca73b66df5a43c2fdc05da6140ddcd6a3a91","src/gnn/website/templates.py":"5b6ae0e8cabec5fbc0d631616608bc8b215989fd3ab39462130fd9d92bde3bb5"},"repository":"ActiveInferenceInstitute/Generalized_Notation_Notation","schema":"gnn-importer-source/v1","verdict_modules":["gnn","gnn.importers","gnn.parsers.basic","gnn.validation.semantic_validator"]} diff --git a/.github/scripts/gate.py b/.github/scripts/gate.py index 3fcf2c0..25946d2 100755 --- a/.github/scripts/gate.py +++ b/.github/scripts/gate.py @@ -12,7 +12,7 @@ ``notebooks`` tracked notebooks are output-free JSON ``checkpoints`` no Jupyter checkpoint file is tracked ``archive`` the four archive arms over one file listing -``tests`` the gate's own unit tests +``tests`` dependency-free gate contracts and controlled scraper regressions ``gnn`` pinned GNN parser and sketch/exemplar conformance ``fast`` (default) ``archive`` + ``tests``; what CI's docs job runs ``full`` ``fast`` + ``gnn``; the whole gate @@ -58,7 +58,7 @@ "notebooks": "tracked notebooks are valid JSON with no committed outputs", "checkpoints": "no Jupyter checkpoint file is tracked", "archive": "all four archive checks over one `git ls-files` read", - "tests": "the gate's own dependency-free unit tests", + "tests": "dependency-free gate contracts and controlled scraper regressions", "gnn": "pinned GNN parser, sketch parsing, and type checking", "fast": "archive checks plus tests; the default arm and CI's docs job", "full": "the fast arm plus the pinned GNN conformance arm", @@ -136,8 +136,10 @@ def arm_tests() -> int: return 0 -def run_arm(arm: str, *, install: bool = False) -> int: - """Run one arm and return its exit status.""" +def run_arm( + arm: str, *, install: bool = False, source_root: Path | None = None +) -> int: + """Run one arm with explicit GNN source selection when requested.""" if arm in ARCHIVE_ARMS: return arm_archive((arm,), arm) if arm == "archive": @@ -145,20 +147,27 @@ def run_arm(arm: str, *, install: bool = False) -> int: if arm == "tests": return arm_tests() if arm == "gnn": - return gnn_conformance.run(ROOT, install_first=install) + return gnn_conformance.run( + ROOT, install_first=install, source_root=source_root + ) if arm == "fast": return 0 if arm_archive(ARCHIVE_ARMS, "archive") == 0 and arm_tests() == 0 else 1 if arm == "full": if arm_archive(ARCHIVE_ARMS, "archive") != 0 or arm_tests() != 0: return 1 - return gnn_conformance.run(ROOT, install_first=install) + return gnn_conformance.run( + ROOT, install_first=install, source_root=source_root + ) raise ValueError(f"unknown arm: {arm}") -def _measure(arm: str) -> float: +def _measure(arm: str, *, source_root: Path | None = None) -> float: + command = [sys.executable, str(Path(__file__).resolve()), arm] + if source_root is not None: + command.extend(("--gnn-source-root", str(source_root.resolve()))) started = time.perf_counter() result = subprocess.run( - [sys.executable, str(Path(__file__).resolve()), arm], + command, cwd=ROOT, capture_output=True, text=True, @@ -176,8 +185,13 @@ def timings_arms() -> tuple[str, ...]: return tuple(arm for arm in ARM_ORDER if arm not in {"gnn", "full", "timings"}) -def render_timings(rows: list[tuple[str, float]], gnn_seconds: float | None) -> str: - """Render the generated timings page.""" +def render_timings( + rows: list[tuple[str, float]], + gnn_seconds: float | None, + *, + source_mode: bool = False, +) -> str: + """Render timings without conflating source and installed qualification.""" implementation = platform.python_implementation() version = platform.python_version() lines = [ @@ -200,26 +214,29 @@ def render_timings(rows: list[tuple[str, float]], gnn_seconds: float | None) -> "", "## Interpreter-specific arms", "", - "`gnn` is measured separately because it installs third-party packages " - "and reads the network, so its duration depends on the package cache " - "and mirror.", + "`gnn` is measured separately because it requires independently " + "qualified parser source and runtime dependencies, and fetches the " + "pinned exemplar when no repository sketch is tracked.", ] if gnn_seconds is None: lines.append( - "It was not measured for this page: the pinned parser was not " - "importable in the measuring interpreter." + "It was not measured for this page; no GNN execution qualification " + "was recorded by this measurement." ) else: + mode = "explicit source" if source_mode else "installed" lines.append( - f"With the pinned parser already installed it took {gnn_seconds:.2f} s " - "for one conformance check, excluding the install step; the install " - "step's duration depends on pip's cache. Refresh this page from an " - "interpreter that has the parser installed to record it again." + f"With {mode} admission it took {gnn_seconds:.2f} s for one " + "conformance check, excluding installation. Explicit source mode is " + "not installed-origin proof. The install step, when requested " + "separately, depends on pip's cache and network." ) return "\n".join(lines) + "\n" -def write_timings(output: Path, *, include_gnn: bool) -> int: +def write_timings( + output: Path, *, include_gnn: bool, source_root: Path | None = None +) -> int: arms = timings_arms() # The `tests` arm asserts that this page lists every measured arm, and `fast` # runs it, so a first generation would otherwise measure itself into a @@ -232,8 +249,10 @@ def write_timings(output: Path, *, include_gnn: bool) -> int: ) try: rows = [(arm, _measure(arm)) for arm in arms] - gnn_seconds: float | None = _measure("gnn") if include_gnn else None - document = render_timings(rows, gnn_seconds) + gnn_seconds = _measure("gnn", source_root=source_root) if include_gnn else None + document = render_timings( + rows, gnn_seconds, source_mode=source_root is not None + ) except BaseException: if previous is None: output.unlink(missing_ok=True) @@ -263,6 +282,14 @@ def parsers() -> argparse.ArgumentParser: action="store_true", help="install the pinned GNN parser before the gnn or full arm", ) + parser.add_argument( + "--gnn-source-root", + type=Path, + help=( + "explicit exact-revision src/gnn package directory instead of an " + "installed distribution; incompatible with --install" + ), + ) parser.add_argument( "--output", type=Path, @@ -291,9 +318,31 @@ def main(argv: list[str] | None = None) -> int: if options.install and options.arm not in {"gnn", "full"}: print("gate.py: --install is only valid for the gnn and full arms", file=sys.stderr) return 2 + if options.gnn_source_root is not None: + if options.install: + print( + "gate.py: --gnn-source-root is incompatible with --install", + file=sys.stderr, + ) + return 2 + if options.arm not in {"gnn", "full"} and not ( + options.arm == "timings" and options.include_gnn + ): + print( + "gate.py: --gnn-source-root requires gnn, full, or " + "timings --include-gnn", + file=sys.stderr, + ) + return 2 if options.arm == "timings": - return write_timings(options.output, include_gnn=options.include_gnn) - return run_arm(options.arm, install=options.install) + return write_timings( + options.output, + include_gnn=options.include_gnn, + source_root=options.gnn_source_root, + ) + return run_arm( + options.arm, install=options.install, source_root=options.gnn_source_root + ) if __name__ == "__main__": diff --git a/.github/scripts/gnn_conformance.py b/.github/scripts/gnn_conformance.py index 322f39e..7b0835f 100755 --- a/.github/scripts/gnn_conformance.py +++ b/.github/scripts/gnn_conformance.py @@ -2,23 +2,26 @@ """Pinned Generalized Notation Notation (GNN) conformance for this archive. The repository pins one upstream parser revision in ``.github/gnn-pin.json`` -(schema ``gnn-importer-pin/v1``). This module validates that pin, installs the -pinned distribution when asked, and verifies that +(schema ``gnn-importer-pin/v1``). Before importing the parser it binds the +independently frozen bootstrap and complete source manifest, then verifies +origin and content throughout the actual parser/type-checker execution. -* the installed parser reports the pinned version, -* every ``*.gnn.md`` sketch in the repository parses, passes the syntax +* the admitted parser reports the pinned version, +* every tracked ``*.gnn.md`` sketch parses, passes the syntax validator, and passes the type checker, or -* when the repository carries no sketch, a pinned upstream exemplar does. +* when the repository tracks no sketch, a pinned upstream exemplar does. The GitHub Actions job ``gnn conformance (pinned)`` and the local gate arm ``gnn`` both call `gate.py`, which calls this module, so the job body exists -once. Fetching the parser and the exemplar needs the network; nothing here -touches the committed research artifacts. +once. ``--install`` explicitly permits installation; source mode never installs +or falls back from refused installed admission. Research artifacts are not changed. """ from __future__ import annotations +import hashlib import json +import os import re import shutil import subprocess @@ -27,10 +30,14 @@ import urllib.request from pathlib import Path +from archive_checks import tracked_files +import gnn_runtime + PIN_PATH = Path(".github") / "gnn-pin.json" PIN_SCHEMA = "gnn-importer-pin/v1" EXPECTED_REPOSITORY = "ActiveInferenceInstitute/Generalized_Notation_Notation" EXEMPLAR_PATH = "input/gnn_files/basics/static_perception.md" +EXEMPLAR_SHA256 = "1ddd0fbde8155e2083d586a368503278373f26f6aae11dd4a2b4adfdf5ea7b8c" RUNTIME_DEPENDENCIES = ("defusedxml", "psutil", "pyyaml") TAG = re.compile(r"^v(\d+\.\d+\.\d+)$") REVISION = re.compile(r"^[0-9a-f]{40}$") @@ -81,13 +88,30 @@ def install(pin: dict) -> None: def _exemplar_bytes(pin: dict) -> bytes: - """Download the pinned upstream exemplar.""" - url = ( - "https://raw.githubusercontent.com/" - f"{pin['repository']}/{pin['revision']}/{EXEMPLAR_PATH}" - ) - with urllib.request.urlopen(url, timeout=FETCH_TIMEOUT) as response: - return response.read() + """Read the same immutable exemplar from explicit preparation or HTTPS.""" + if ( + pin.get("repository") != EXPECTED_REPOSITORY + or pin.get("revision") != gnn_runtime.REVISION + ): + raise ValueError("exemplar pin has no independently frozen content digest") + prepared = os.environ.get("GNN_PREPARED_EXEMPLAR") + if prepared is not None: + if not prepared: + raise ValueError("GNN_PREPARED_EXEMPLAR must name the prepared file") + path = Path(prepared) + if path.is_symlink() or not path.is_file(): + raise ValueError("GNN_PREPARED_EXEMPLAR must be an ordinary existing file") + data = path.read_bytes() + else: + url = ( + "https://raw.githubusercontent.com/" + f"{pin['repository']}/{pin['revision']}/{EXEMPLAR_PATH}" + ) + with urllib.request.urlopen(url, timeout=FETCH_TIMEOUT) as response: + data = response.read() + if hashlib.sha256(data).hexdigest() != EXEMPLAR_SHA256: + raise ValueError("pinned exemplar content digest mismatch") + return data def _check_parses(sketch: Path) -> None: @@ -123,60 +147,77 @@ def _check_types(sketches: list[Path]) -> None: ) -def verify(root: Path, pin: dict) -> dict: - """Verify the installed parser and the checked sketches; return the receipt.""" - try: +def verify( + root: Path, + pin: dict, + *, + install_first: bool = False, + source_root: Path | None = None, +) -> dict: + """Run every parser/verdict import and call inside checked source admission.""" + with gnn_runtime.qualified_parser( + root, + pin, + source_root=source_root, + installer=install if install_first else None, + ) as qualification: from gnn import __version__ - except ImportError as exc: - raise SystemExit( - "the pinned GNN parser is not installed for this interpreter; " - "run `python .github/scripts/gate.py gnn --install`" - ) from exc - - expected_version = str(pin["tag"]).removeprefix("v") - if __version__ != expected_version: - raise SystemExit(f"installed GNN {__version__!r} does not match {pin['tag']!r}") - - sketches = sorted( - path - for path in root.rglob("*.gnn.md") - if ".git" not in path.relative_to(root).parts - ) - with tempfile.TemporaryDirectory(prefix="gnn-conformance-") as workdir: - if sketches: - checked, source = sketches, "repository" - else: - exemplar = Path(workdir) / Path(EXEMPLAR_PATH).name - exemplar.write_bytes(_exemplar_bytes(pin)) - checked, source = [exemplar], "pinned-exemplar" - for sketch in checked: - _check_parses(sketch) - _check_types(checked) - - return { - "gnn-version": __version__, - "pin-revision": pin["revision"], - "models": len(checked), - "source": source, - "result": "verified", - } - - -def run(root: Path, *, install_first: bool = False) -> int: - """Validate the pin, optionally install the parser, then verify.""" + expected_version = str(pin["tag"]).removeprefix("v") + if __version__ != expected_version: + raise SystemExit( + f"admitted GNN {__version__!r} does not match {pin['tag']!r}" + ) + + sketches = sorted( + path + for path in tracked_files(root) + if path.name.endswith(".gnn.md") + ) + + with tempfile.TemporaryDirectory(prefix="gnn-conformance-") as workdir: + if sketches: + checked, source = sketches, "repository" + else: + exemplar = Path(workdir) / Path(EXEMPLAR_PATH).name + exemplar.write_bytes(_exemplar_bytes(pin)) + checked, source = [exemplar], "pinned-exemplar" + for sketch in checked: + _check_parses(sketch) + _check_types(checked) + + # Returning exits the guard first: a final content/origin refusal cannot + # escape as a verified receipt. + return { + "gnn-version": __version__, + "pin-revision": pin["revision"], + "models": len(checked), + "source": source, + "source-qualification": qualification, + "result": "verified", + } + + +def run( + root: Path, + *, + install_first: bool = False, + source_root: Path | None = None, +) -> int: + """Validate the pin and run one explicitly installed or source-mode verdict.""" try: pin = load_pin(root) + errors = validate_pin(pin) + if errors: + print("gnn conformance: pin does not satisfy the contract:", file=sys.stderr) + for error in errors: + print(f"- {error}", file=sys.stderr) + return 1 + receipt = verify( + root, pin, install_first=install_first, source_root=source_root + ) except (OSError, ValueError) as exc: print(f"gnn conformance: {exc}", file=sys.stderr) return 1 - errors = validate_pin(pin) - if errors: - print("gnn conformance: pin does not satisfy the contract:", file=sys.stderr) - for error in errors: - print(f"- {error}", file=sys.stderr) - return 1 - if install_first: - install(pin) - print(json.dumps(verify(root, pin), sort_keys=True)) + print(json.dumps(receipt, sort_keys=True)) return 0 diff --git a/.github/scripts/gnn_runtime.py b/.github/scripts/gnn_runtime.py new file mode 100644 index 0000000..5f2653c --- /dev/null +++ b/.github/scripts/gnn_runtime.py @@ -0,0 +1,114 @@ +"""Bind independently approved GNN bytes before any target-package import. + +The vendored bootstrap and manifest are exact producer artifacts, not a local +bootstrap fork or an inventory generated from the target installation. Each +verdict needs a fresh process; installed refusal never selects source mode. +""" + +from __future__ import annotations + +import hashlib +import sys +import types +from collections.abc import Callable, Iterator +from contextlib import contextmanager +from pathlib import Path + +ARTIFACTS = Path(__file__).resolve().parents[1] / "gnn" +BOOTSTRAP_PATH = ARTIFACTS / "gnn_bootstrap.py" +MANIFEST_PATH = ARTIFACTS / "v5.1.0-source-manifest.json" +BOOTSTRAP_SHA256 = "e04e9114c860a622f26ee8d323ac44b77c6484f5a29bdc7654fb298a9b58c3b2" +MANIFEST_SHA256 = "43b33c0b2b40386afa3f306fec4cc13bc1fd7c3b570fbf11d5008bad5c8e6b51" +REPOSITORY = "ActiveInferenceInstitute/Generalized_Notation_Notation" +TAG = "v5.1.0" +REVISION = "75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf" +PIN_PATH = Path(".github") / "gnn-pin.json" +_BOOTSTRAP_NAME = "_knowledge_engineering_checked_gnn_bootstrap" +_MISSING = object() + + +@contextmanager +def checked_bootstrap() -> Iterator[tuple[types.ModuleType, bytes]]: + """Check both frozen inputs, then execute exactly the checked source bytes.""" + bootstrap_bytes = BOOTSTRAP_PATH.read_bytes() + if hashlib.sha256(bootstrap_bytes).hexdigest() != BOOTSTRAP_SHA256: + raise ValueError("bootstrap-digest-mismatch: approved GNN bootstrap required") + manifest_bytes = MANIFEST_PATH.read_bytes() + if hashlib.sha256(manifest_bytes).hexdigest() != MANIFEST_SHA256: + raise ValueError("manifest-digest-mismatch: approved v5.1.0 manifest required") + + module = types.ModuleType(_BOOTSTRAP_NAME) + module.__file__ = str(BOOTSTRAP_PATH) + module.__package__ = "" + previous = sys.modules.get(_BOOTSTRAP_NAME, _MISSING) + sys.modules[_BOOTSTRAP_NAME] = module + try: + # Do not use an import loader: it could reread the file or accept a pyc. + exec( + compile(bootstrap_bytes, str(BOOTSTRAP_PATH), "exec", dont_inherit=True), + module.__dict__, + ) + yield module, manifest_bytes + finally: + if previous is _MISSING: + sys.modules.pop(_BOOTSTRAP_NAME, None) + else: + sys.modules[_BOOTSTRAP_NAME] = previous + + +@contextmanager +def qualified_parser( + root: Path, + pin: dict, + *, + source_root: Path | None = None, + installer: Callable[[dict], None] | None = None, +) -> Iterator[dict]: + """Enclose imports, execution, and final rechecks in the producer's guard. + + An explicit source root selects the package directory (``src/gnn``), not a + distribution or an automatic fallback. Installed mode leaves resolution + alone and requires the real PEP610 origin plus complete frozen content. + """ + if source_root is not None and installer is not None: + raise ValueError("explicit source mode cannot install a distribution") + + with checked_bootstrap() as (bootstrap, manifest): + bound_pin = bootstrap.read_pin(root / PIN_PATH) + if bound_pin.raw != pin: + raise ValueError("GNN pin changed before source admission") + if ( + pin.get("repository") != REPOSITORY + or pin.get("tag") != TAG + or pin.get("revision") != REVISION + ): + raise ValueError("GNN pin has no independently approved source manifest") + if any(name == "gnn" or name.startswith("gnn.") for name in sys.modules): + raise ValueError("source-module-cached: use a fresh GNN verdict process") + if installer is not None: + # Frozen authority and pin identity precede any installation effect. + installer(pin) + + if source_root is None: + with bootstrap.qualified_source( + bound_pin, + manifest=manifest, + manifest_sha256=MANIFEST_SHA256, + origin_mode="installed", + ) as qualification: + yield qualification + else: + selected = source_root.resolve(strict=True) + previous_path = sys.path[:] + try: + sys.path.insert(0, str(selected.parent)) + with bootstrap.qualified_source( + bound_pin, + manifest=manifest, + manifest_sha256=MANIFEST_SHA256, + package_root=selected, + origin_mode="source", + ) as qualification: + yield qualification + finally: + sys.path[:] = previous_path diff --git a/.github/scripts/tests/pdf_fixtures.py b/.github/scripts/tests/pdf_fixtures.py new file mode 100644 index 0000000..fe84d81 --- /dev/null +++ b/.github/scripts/tests/pdf_fixtures.py @@ -0,0 +1,102 @@ +"""Isolated CSV/text fixtures for the historical scraper's real local modules. + +Only PDF extraction is replaced: a local module reads controlled UTF-8 text +beside the expected PDF path. These tests do not establish PDF-parser or +scientific-corpus correctness and do not require either dependency. +""" + +from __future__ import annotations + +import contextlib +import csv +import importlib +import io +import sys +import tempfile +import types +import unittest +from pathlib import Path +from unittest import mock + +ROOT = Path(__file__).resolve().parents[3] +SCRAPER = ROOT / "Literature_Analysis" / "PDF_Scrape" + + +class PdfScraperCase(unittest.TestCase): + """Restore CWD, import paths, and imported modules after every fixture.""" + + def setUp(self) -> None: + self.stack = contextlib.ExitStack() + self.addCleanup(self.stack.close) + self.root = Path(self.stack.enter_context(tempfile.TemporaryDirectory())).resolve() + self.stack.enter_context(contextlib.chdir(self.root)) + self.stack.enter_context(mock.patch.object(sys, "path", [str(SCRAPER), *sys.path])) + self.stack.enter_context(mock.patch.dict(sys.modules)) + for name in ("dataImport", "docResults", "streamingExport", "manager"): + sys.modules.pop(name, None) + self.extraction_errors: dict[str, Exception] = {} + reader = types.ModuleType("pdfReader") + reader.extractPDFtext = self.extract_text # type: ignore[attr-defined] + sys.modules["pdfReader"] = reader + + def extract_text(self, file_path: str) -> str: + path = Path(file_path) + if path.stem in self.extraction_errors: + raise self.extraction_errors[path.stem] + return path.with_suffix(".txt").read_text(encoding="utf-8") + + def load_scraper( + self, + keywords: list[str], + documents: list[tuple[str, str, str | None]], + ) -> None: + """Load real parameter CSVs; each document is (ID, abstract, text).""" + params = self.root / "resc" / "params" + params.mkdir(parents=True) + corpus = self.root / "resc" / "pdfList" + corpus.mkdir() + with (params / "keywords.csv").open("w", encoding="utf-8", newline="") as stream: + writer = csv.writer(stream) + writer.writerow(["Kw"]) + writer.writerows([[keyword] for keyword in keywords]) + with (params / "fileInfo.csv").open("w", encoding="utf-8", newline="") as stream: + writer = csv.writer(stream) + writer.writerow(["COGSEC_ID", "Title", "Abstract"]) + for file_id, abstract, text in documents: + writer.writerow([file_id, f"Controlled document {file_id}", abstract]) + if text is not None: + (corpus / f"{file_id.zfill(5)}.txt").write_text(text, encoding="utf-8") + self.data_import = importlib.import_module("dataImport") + self.doc_results = importlib.import_module("docResults") + self.export = importlib.import_module("streamingExport") + self.manager = importlib.import_module("manager") + + def read_rows(self, kind: str) -> list[list[str]]: + with (self.root / f"batch-{kind}.csv").open( + encoding="utf-8", newline="" + ) as stream: + return list(csv.reader(stream)) + + def run_batch(self, keys: list[str] | None = None): + self.export.setExportId("batch") + manager = self.manager.mrManager() + if keys is None: + manager.getKeys() + else: + manager.giveKeys(keys) + stdout, stderr = io.StringIO(), io.StringIO() + with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr): + totals = manager.run() + return totals, stdout.getvalue(), stderr.getvalue() + + def assert_totals(self, totals, expected: tuple[int, int, int, int, int]) -> None: + self.assertEqual( + ( + totals.attempted, + totals.succeeded, + totals.failed, + totals.log_failures, + totals.exit_code, + ), + expected, + ) diff --git a/.github/scripts/tests/test_gnn_conformance.py b/.github/scripts/tests/test_gnn_conformance.py index 602d8f2..6a4cb8f 100644 --- a/.github/scripts/tests/test_gnn_conformance.py +++ b/.github/scripts/tests/test_gnn_conformance.py @@ -7,9 +7,9 @@ pin down, because a truthiness test printed ``"result": "verified"`` for an invalid model set. -The pinned parser is a third-party install the ``tests`` arm deliberately does -not require, so every case here stubs ``gnn`` in ``sys.modules``. The arm's own -code — the copying, the call, the verdict, the receipt — runs unchanged. +The dependency-free verdict cases explicitly replace source admission and stub +the parser surface. They are not origin/content qualification. The separate +``test_gnn_runtime`` cases exercise the real checked bootstrap and guard. """ from __future__ import annotations @@ -51,7 +51,13 @@ def _stub_modules(verdict: object, *, version: str | None = None) -> dict[str, o parsers = types.ModuleType("gnn.parsers") basic = types.ModuleType("gnn.parsers.basic") - basic.parse_gnn_formal = lambda path: _Parsed() # type: ignore[attr-defined] + basic.parsed_paths = [] # type: ignore[attr-defined] + + def _parse(path): + basic.parsed_paths.append(Path(path)) # type: ignore[attr-defined] + return _Parsed() + + basic.parse_gnn_formal = _parse # type: ignore[attr-defined] basic.validate_gnn_syntax = lambda text, **kwargs: (True, []) # type: ignore[attr-defined] checker_module = types.ModuleType("gnn.type_checker") @@ -121,6 +127,11 @@ def test_zero_is_refused_and_named(self) -> None: self._run(0) self.assertIn("returned 0", str(raised.exception.code)) + def test_one_is_refused_and_named(self) -> None: + with self.assertRaises(SystemExit) as raised: + self._run(1) + self.assertIn("returned 1", str(raised.exception.code)) + class RunVerdictTests(unittest.TestCase): """The arm must not print a ``verified`` receipt for a refused verdict.""" @@ -132,6 +143,22 @@ def setUp(self) -> None: pin_path.parent.mkdir(parents=True) pin_path.write_text(json.dumps(PIN), encoding="utf-8") (self.root / "model.gnn.md").write_text("# sketch\n", encoding="utf-8") + admission = mock.patch.object( + gnn_conformance.gnn_runtime, + "qualified_parser", + side_effect=lambda *args, **kwargs: contextlib.nullcontext( + {"evidence": "unit-verdict-fixture"} + ), + ) + admission.start() + self.addCleanup(admission.stop) + inventory = mock.patch.object( + gnn_conformance, + "tracked_files", + return_value=[self.root / "model.gnn.md"], + ) + self.inventory = inventory.start() + self.addCleanup(inventory.stop) def tearDown(self) -> None: self._temp.cleanup() @@ -156,6 +183,82 @@ def test_verified_models_print_the_receipt(self) -> None: self.assertEqual(receipt["result"], "verified") self.assertEqual(receipt["source"], "repository") self.assertEqual(receipt["models"], 1) + self.assertEqual(receipt["gnn-version"], PIN["tag"].removeprefix("v")) + + def test_only_sorted_tracked_sketches_are_checked(self) -> None: + nested = self.root / "models" + nested.mkdir() + first = nested / "a.gnn.md" + last = self.root / "z.gnn.md" + ignored = self.root / "ignored.gnn.md" + readme = self.root / "README.md" + for path in (first, last, ignored, readme): + path.write_text("# controlled fixture\n", encoding="utf-8") + self.inventory.return_value = [last, readme, first] + stubs = _stub_modules(True) + stdout = io.StringIO() + with mock.patch.dict(sys.modules, stubs), contextlib.redirect_stdout(stdout): + code = gnn_conformance.run(self.root) + receipt = json.loads(stdout.getvalue()) + self.assertEqual(code, 0) + self.assertEqual(receipt["source"], "repository") + self.assertEqual(receipt["models"], 2) + self.assertEqual( + stubs["gnn.parsers.basic"].parsed_paths, # type: ignore[attr-defined] + [first, last], + ) + + def test_untracked_sketch_does_not_prevent_pinned_exemplar(self) -> None: + self.inventory.return_value = [] + stubs = _stub_modules(True) + stdout = io.StringIO() + with ( + mock.patch.dict(sys.modules, stubs), + mock.patch.object( + gnn_conformance, + "_exemplar_bytes", + return_value=b"# controlled upstream fixture\n", + ), + contextlib.redirect_stdout(stdout), + ): + code = gnn_conformance.run(self.root) + receipt = json.loads(stdout.getvalue()) + self.assertEqual(code, 0) + self.assertEqual(receipt["source"], "pinned-exemplar") + self.assertEqual(receipt["models"], 1) + parsed = stubs["gnn.parsers.basic"].parsed_paths # type: ignore[attr-defined] + self.assertEqual([path.name for path in parsed], [Path(gnn_conformance.EXEMPLAR_PATH).name]) + + def test_inventory_failure_cannot_emit_a_verified_receipt(self) -> None: + self.inventory.side_effect = OSError("tracked inventory unavailable") + stdout, stderr = io.StringIO(), io.StringIO() + with ( + mock.patch.dict(sys.modules, _stub_modules(True)), + mock.patch.object( + gnn_conformance, + "_exemplar_bytes", + side_effect=AssertionError("must not substitute an exemplar"), + ), + contextlib.redirect_stdout(stdout), + contextlib.redirect_stderr(stderr), + ): + code = gnn_conformance.run(self.root) + self.assertNotEqual(code, 0) + self.assertEqual(stdout.getvalue(), "") + self.assertIn("tracked inventory unavailable", stderr.getvalue()) + + def test_wrong_version_is_refused_before_parsing(self) -> None: + stubs = _stub_modules(True, version=PIN["tag"].removeprefix("v") + "-mismatch") + stdout = io.StringIO() + with ( + mock.patch.dict(sys.modules, stubs), + contextlib.redirect_stdout(stdout), + self.assertRaises(SystemExit) as raised, + ): + gnn_conformance.run(self.root) + self.assertIn("does not match", str(raised.exception.code)) + self.assertEqual(stdout.getvalue(), "") + self.assertEqual(stubs["gnn.parsers.basic"].parsed_paths, []) # type: ignore[attr-defined] if __name__ == "__main__": diff --git a/.github/scripts/tests/test_gnn_prepared_exemplar.py b/.github/scripts/tests/test_gnn_prepared_exemplar.py new file mode 100644 index 0000000..fa77a1d --- /dev/null +++ b/.github/scripts/tests/test_gnn_prepared_exemplar.py @@ -0,0 +1,92 @@ +"""Acquisition-boundary fixtures, not installed-parser or scientific proof.""" +from __future__ import annotations + +import hashlib +import io +import json +import os +import tempfile +import unittest +from pathlib import Path +from unittest import mock + +import gnn_conformance + +PIN = json.loads( + (Path(__file__).resolve().parents[2] / "gnn-pin.json").read_text(encoding="utf-8") +) + + +class PreparedExemplarTests(unittest.TestCase): + def setUp(self) -> None: + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.directory = Path(temporary.name) + self.path = self.directory / "static_perception.md" + self.data = b"controlled acquisition-boundary bytes\n" + self.path.write_bytes(self.data) + digest = mock.patch.object( + gnn_conformance, "EXEMPLAR_SHA256", hashlib.sha256(self.data).hexdigest() + ) + digest.start() + self.addCleanup(digest.stop) + environment = mock.patch.dict(os.environ, {}, clear=True) + environment.start() + self.addCleanup(environment.stop) + network = mock.patch.object(gnn_conformance.urllib.request, "urlopen") + self.network = network.start() + self.addCleanup(network.stop) + + def read_prepared(self, path: Path | str) -> bytes: + with mock.patch.dict(os.environ, {"GNN_PREPARED_EXEMPLAR": str(path)}): + return gnn_conformance._exemplar_bytes(PIN) + + def test_prepared_exact_bytes_need_no_network(self) -> None: + self.assertEqual(self.read_prepared(self.path), self.data) + self.network.assert_not_called() + + def test_changed_prepared_bytes_refuse_without_download_fallback(self) -> None: + self.path.write_bytes(self.data + b"drift") + with self.assertRaisesRegex(ValueError, "digest mismatch"): + self.read_prepared(self.path) + self.network.assert_not_called() + + def test_missing_prepared_path_refuses_without_download_fallback(self) -> None: + with self.assertRaisesRegex(ValueError, "ordinary existing file"): + self.read_prepared(self.directory / "missing.md") + self.network.assert_not_called() + + def test_empty_prepared_selector_is_not_network_selection(self) -> None: + with self.assertRaisesRegex(ValueError, "must name"): + self.read_prepared("") + self.network.assert_not_called() + + def test_prepared_symlink_is_refused(self) -> None: + link = self.directory / "linked.md" + link.symlink_to(self.path) + with self.assertRaisesRegex(ValueError, "ordinary existing file"): + self.read_prepared(link) + self.network.assert_not_called() + + def test_unapproved_revision_cannot_reuse_exemplar_authority(self) -> None: + with self.assertRaisesRegex(ValueError, "no independently frozen"): + gnn_conformance._exemplar_bytes(dict(PIN, revision="0" * 40)) + self.network.assert_not_called() + + def test_default_download_retains_exact_upstream_url_and_bytes(self) -> None: + self.network.return_value = io.BytesIO(self.data) + self.assertEqual(gnn_conformance._exemplar_bytes(PIN), self.data) + self.network.assert_called_once_with( + "https://raw.githubusercontent.com/" + f"{PIN['repository']}/{PIN['revision']}/{gnn_conformance.EXEMPLAR_PATH}", + timeout=gnn_conformance.FETCH_TIMEOUT, + ) + + def test_changed_download_is_not_a_verified_exemplar(self) -> None: + self.network.return_value = io.BytesIO(self.data + b"drift") + with self.assertRaisesRegex(ValueError, "digest mismatch"): + gnn_conformance._exemplar_bytes(PIN) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/scripts/tests/test_gnn_runtime.py b/.github/scripts/tests/test_gnn_runtime.py new file mode 100644 index 0000000..660ee8d --- /dev/null +++ b/.github/scripts/tests/test_gnn_runtime.py @@ -0,0 +1,623 @@ +"""Consumer admission regressions; no installed metadata or scientific proof. + +The real frozen bootstrap guards a deliberately tiny source fixture. Expected +file bytes are declared before materializing the target; they are not learned +from that target. Only test-local manifest authority is replaced. Installed +success must be accepted separately against real PEP610 metadata by the owner. +""" + +from __future__ import annotations + +import contextlib +import hashlib +import importlib.abc +import importlib.metadata +import importlib.util +import io +import json +import marshal +import struct +import subprocess +import sys +import tempfile +import types +import unittest +from pathlib import Path +from unittest import mock + +SCRIPTS = Path(__file__).resolve().parents[1] +ROOT = SCRIPTS.parents[1] +if str(SCRIPTS) not in sys.path: + sys.path.insert(0, str(SCRIPTS)) + +import gate +import gnn_conformance +import gnn_runtime + +PIN = json.loads((ROOT / gnn_conformance.PIN_PATH).read_text(encoding="utf-8")) + + +class CheckedBootstrapTests(unittest.TestCase): + def setUp(self) -> None: + self.stack = contextlib.ExitStack() + self.addCleanup(self.stack.close) + self.root = Path(self.stack.enter_context(tempfile.TemporaryDirectory())) + self.bootstrap = self.root / "bootstrap.py" + self.manifest = self.root / "manifest.json" + self.marker = self.root / "executed.txt" + self.checked_bytes = b"VALUE = 'checked'\n" + self.manifest_bytes = b"{}\n" + self.bootstrap.write_bytes(self.checked_bytes) + self.manifest.write_bytes(self.manifest_bytes) + self.stack.enter_context( + mock.patch.multiple( + gnn_runtime, + BOOTSTRAP_PATH=self.bootstrap, + MANIFEST_PATH=self.manifest, + BOOTSTRAP_SHA256=hashlib.sha256(self.checked_bytes).hexdigest(), + MANIFEST_SHA256=hashlib.sha256(self.manifest_bytes).hexdigest(), + ) + ) + + def _malicious_bytes(self) -> bytes: + return ( + "from pathlib import Path\n" + f"Path({str(self.marker)!r}).write_text('executed', encoding='utf-8')\n" + "VALUE = 'unchecked'\n" + ).encode("utf-8") + + def test_changed_bootstrap_cannot_execute(self) -> None: + self.bootstrap.write_bytes(self._malicious_bytes()) + with self.assertRaisesRegex(ValueError, "bootstrap-digest-mismatch"): + with gnn_runtime.checked_bootstrap(): + self.fail("changed bootstrap was admitted") + self.assertFalse(self.marker.exists()) + + def test_manifest_is_bound_before_bootstrap_execution(self) -> None: + bootstrap_bytes = self._malicious_bytes() + self.bootstrap.write_bytes(bootstrap_bytes) + self.manifest.write_bytes(self.manifest_bytes + b" ") + with mock.patch.object( + gnn_runtime, "BOOTSTRAP_SHA256", hashlib.sha256(bootstrap_bytes).hexdigest() + ): + with self.assertRaisesRegex(ValueError, "manifest-digest-mismatch"): + with gnn_runtime.checked_bootstrap(): + self.fail("changed manifest was admitted") + self.assertFalse(self.marker.exists()) + + def test_exec_uses_checked_snapshot_not_a_later_file_read(self) -> None: + original_read = Path.read_bytes + reads: list[Path] = [] + + def replace_after_read(path: Path) -> bytes: + value = original_read(path) + if path == self.bootstrap: + reads.append(path) + path.write_bytes(self._malicious_bytes()) + return value + + with mock.patch.object(Path, "read_bytes", replace_after_read): + with gnn_runtime.checked_bootstrap() as (module, manifest): + self.assertEqual(module.VALUE, "checked") + self.assertEqual(manifest, self.manifest_bytes) + self.assertEqual(reads, [self.bootstrap]) + self.assertFalse(self.marker.exists()) + + +class RepositoryIdentityTests(unittest.TestCase): + """Checked producer URL policy, not installed-origin or scientific proof.""" + + def test_supported_repository_spellings_preserve_the_pin_identity(self) -> None: + repository = PIN["repository"] + with gnn_runtime.checked_bootstrap() as (bootstrap, _): + for spelling in ( + repository, + repository + ".git", + "http://github.com/" + repository, + "https://github.com/" + repository + ".git", + "git@github.com:" + repository + ".git", + ): + with self.subTest(spelling=spelling): + self.assertEqual( + bootstrap.normalize_repository(spelling), repository + ) + + def test_untrusted_or_truncated_repository_urls_are_rejected(self) -> None: + repository = PIN["repository"] + with gnn_runtime.checked_bootstrap() as (bootstrap, _): + for spelling in ( + "https://" + repository, + "https://github.com.evil.invalid/" + repository, + "https://github.com@evil.invalid/" + repository, + "https://github.com:443/" + repository, + "https://github.com/" + repository + "/extra", + "https://github.com/" + repository + "?query=1", + "https://github.com/" + repository + "#fragment", + "https://github.com/" + repository.replace("/", "//"), + "https://github.com/" + repository.replace("/", "/%2f"), + "https://github.com/" + repository + "\\extra", + repository + "/tree/main", + ): + with self.subTest(spelling=spelling): + self.assertIsNone(bootstrap.normalize_repository(spelling)) + + +class GuardedCallerTests(unittest.TestCase): + def setUp(self) -> None: + self.stack = contextlib.ExitStack() + self.addCleanup(self.stack.close) + temporary = Path(self.stack.enter_context(tempfile.TemporaryDirectory())) + # Restore all test-owned module imports, including after a failed guard. + self.stack.enter_context(mock.patch.dict(sys.modules)) + self._clear_gnn_modules() + self.root = temporary / "consumer" + self.root.mkdir() + pin_path = self.root / gnn_conformance.PIN_PATH + pin_path.parent.mkdir() + pin_path.write_text(json.dumps(PIN), encoding="utf-8") + self.model = self.root / "model.gnn.md" + self.model.write_text("# controlled source fixture\n", encoding="utf-8") + self.package = temporary / "independent" / "src" / "gnn" + self.import_marker = temporary / "imported.txt" + self.parse_marker = temporary / "parsed.txt" + self.attack_marker = temporary / "unchecked.txt" + version = PIN["tag"].removeprefix("v") + self.expected_bytes = { + "__init__.py": ( + "from pathlib import Path\n" + f"Path({str(self.import_marker)!r}).write_text('imported', encoding='utf-8')\n" + f"__version__ = {version!r}\n" + ).encode("utf-8"), + "parsers/__init__.py": b"", + "parsers/basic.py": ( + "from pathlib import Path\n" + "from types import SimpleNamespace\n" + "def parse_gnn_formal(path):\n" + f" Path({str(self.parse_marker)!r}).write_text(Path(path).read_text(encoding='utf-8'), encoding='utf-8')\n" + " return SimpleNamespace(parse_errors=[])\n" + "def validate_gnn_syntax(text):\n" + " return True, []\n" + ).encode("utf-8"), + "type_checker.py": ( + "class GNNTypeChecker:\n" + " def validate_gnn_files(self, model_dir, output_dir):\n" + " from gnn.late import ACCEPT\n" + " return ACCEPT\n" + ).encode("utf-8"), + "late.py": b"ACCEPT = True\n", + "fixture-data.txt": b"independently declared fixture data\n", + } + manifest = { + "schema": "gnn-importer-source/v1", + "repository": PIN["repository"], + "commit": PIN["revision"], + "files": { + "src/gnn/" + name: hashlib.sha256(content).hexdigest() + for name, content in self.expected_bytes.items() + }, + "verdict_modules": ["gnn", "gnn.parsers.basic", "gnn.type_checker"], + } + self.manifest_bytes = ( + json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n" + ).encode("ascii") + for name, content in self.expected_bytes.items(): + path = self.package / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(content) + self.manifest_path = temporary / "trusted-fixture-manifest.json" + self.manifest_path.write_bytes(self.manifest_bytes) + self.manifest_sha256 = hashlib.sha256(self.manifest_bytes).hexdigest() + self.stack.enter_context( + mock.patch.multiple( + gnn_runtime, + MANIFEST_PATH=self.manifest_path, + MANIFEST_SHA256=self.manifest_sha256, + ) + ) + self.stack.enter_context(mock.patch.object(gate, "ROOT", self.root)) + self.stack.enter_context( + mock.patch.object(gnn_conformance, "tracked_files", return_value=[self.model]) + ) + + @staticmethod + def _clear_gnn_modules() -> None: + for name in tuple(sys.modules): + if name == "gnn" or name.startswith("gnn."): + sys.modules.pop(name) + + def _run(self, arguments: list[str]) -> tuple[int, str, str]: + stdout, stderr = io.StringIO(), io.StringIO() + with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr): + code = gate.main(arguments) + return code, stdout.getvalue(), stderr.getvalue() + + def _source_arguments(self, arm: str = "gnn") -> list[str]: + return [arm, "--gnn-source-root", str(self.package)] + + def _assert_qualified_receipt(self, output: str) -> None: + receipt = json.loads(output) + self.assertEqual(receipt["result"], "verified") + self.assertEqual(receipt["source"], "repository") + self.assertEqual(receipt["pin-revision"], PIN["revision"]) + qualification = receipt["source-qualification"] + self.assertTrue(qualification["ok"]) + self.assertTrue(qualification["preimport"]) + self.assertTrue(qualification["imports_verified"]) + self.assertFalse(qualification["execution_verified"]) + self.assertEqual(qualification["origin"]["kind"], "explicit-source") + self.assertFalse(qualification["origin"]["vcs_verified"]) + self.assertEqual(qualification["manifest_sha256"], self.manifest_sha256) + self.assertTrue( + {"gnn", "gnn.parsers.basic", "gnn.type_checker", "gnn.late"}.issubset( + qualification["loaded_modules"] + ) + ) + self.assertEqual(self.parse_marker.read_bytes(), self.model.read_bytes()) + + def test_source_mode_guards_actual_parse_and_delayed_type_imports(self) -> None: + previous_path = sys.path[:] + code, stdout, stderr = self._run(self._source_arguments()) + self.assertEqual(code, 0, stderr) + self._assert_qualified_receipt(stdout) + self.assertEqual(sys.path, previous_path) + + def test_full_arm_keeps_source_admission_for_its_gnn_execution(self) -> None: + with ( + mock.patch.object(gate, "arm_archive", return_value=0), + mock.patch.object(gate, "arm_tests", return_value=0), + ): + code, stdout, stderr = self._run(self._source_arguments("full")) + self.assertEqual(code, 0, stderr) + self._assert_qualified_receipt(stdout) + + def _measured_child(self, command: list[str], **kwargs) -> subprocess.CompletedProcess: + # In-process child harness preserves real argument parsing/admission. + with contextlib.chdir(kwargs["cwd"]): + code, stdout, stderr = self._run(command[2:]) + return subprocess.CompletedProcess(command, code, stdout, stderr) + + def test_timing_child_uses_explicit_source_and_labels_the_narrower_proof(self) -> None: + output = self.root / "measurement.md" + with ( + mock.patch.object(gate, "timings_arms", return_value=()), + mock.patch.object(gate.subprocess, "run", side_effect=self._measured_child), + ): + code, stdout, stderr = self._run( + ["timings", "--include-gnn", "--gnn-source-root", str(self.package), + "--output", str(output)] + ) + self.assertEqual(code, 0, stderr) + self.assertTrue(self.parse_marker.exists()) + self.assertIn("With explicit source admission", output.read_text(encoding="utf-8")) + self.assertIn("not installed-origin proof", stdout) + + def test_timing_resolves_relative_source_before_the_child_changes_cwd(self) -> None: + output = self.root / "measurement.md" + with ( + contextlib.chdir(self.package.parent), + mock.patch.object(gate, "timings_arms", return_value=()), + mock.patch.object(gate.subprocess, "run", side_effect=self._measured_child), + ): + code, stdout, stderr = self._run( + ["timings", "--include-gnn", "--gnn-source-root", "gnn", + "--output", str(output)] + ) + self.assertEqual(code, 0, stderr) + self.assertTrue(self.parse_marker.exists()) + self.assertIn("With explicit source admission", stdout) + + def test_refused_timing_preserves_previous_measurement_bytes(self) -> None: + output = self.root / "measurement.md" + previous = b"historical measured bytes\n" + output.write_bytes(previous) + (self.package / "fixture-data.txt").write_bytes(b"changed\n") + with ( + mock.patch.object(gate, "timings_arms", return_value=()), + mock.patch.object(gate.subprocess, "run", side_effect=self._measured_child), + self.assertRaises(SystemExit), + ): + self._run( + ["timings", "--include-gnn", "--gnn-source-root", str(self.package), + "--output", str(output)] + ) + self.assertEqual(output.read_bytes(), previous) + self.assertFalse(self.import_marker.exists()) + + def test_installed_mode_refuses_untrusted_recorded_urls_without_imports(self) -> None: + """Negative metadata fixtures only; never mutate a real installation.""" + repository = PIN["repository"] + for origin_url in ( + repository, + "https://" + repository, + "https://github.com/" + repository + "/extra", + "https://github.com/" + repository + "?redirect=github.com", + "https://github.com:443/" + repository, + ): + with self.subTest(origin_url=origin_url): + origin = { + "url": origin_url, + "vcs_info": { + "vcs": "git", + "commit_id": PIN["revision"], + "requested_revision": PIN["revision"], + }, + } + distribution = types.SimpleNamespace( + version=PIN["tag"].removeprefix("v"), + locate_file=lambda relative: self.package.parent / relative, + read_text=lambda name: ( + json.dumps(origin) if name == "direct_url.json" else None + ), + ) + with ( + mock.patch.object(sys, "path", [str(self.package.parent), *sys.path]), + mock.patch.object( + importlib.metadata, "distribution", return_value=distribution + ), + ): + code, stdout, stderr = self._run(["gnn"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("origin", stderr.lower()) + self.assertFalse(self.import_marker.exists()) + self.assertFalse(self.parse_marker.exists()) + + def test_installed_mode_refuses_missing_origin_without_source_fallback(self) -> None: + with ( + mock.patch.object(sys, "path", [str(self.package.parent), *sys.path]), + mock.patch.object( + importlib.metadata, + "distribution", + side_effect=importlib.metadata.PackageNotFoundError( + "generalized-notation-notation" + ), + ), + ): + code, stdout, stderr = self._run(["gnn"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("origin", stderr.lower()) + self.assertFalse(self.import_marker.exists()) + + def test_installer_success_is_not_installed_origin_admission(self) -> None: + with ( + mock.patch.object(sys, "path", [str(self.package.parent), *sys.path]), + mock.patch.object( + importlib.metadata, + "distribution", + side_effect=importlib.metadata.PackageNotFoundError( + "generalized-notation-notation" + ), + ), + mock.patch.object(gnn_conformance, "install") as installer, + ): + code, stdout, stderr = self._run(["gnn", "--install"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("origin", stderr.lower()) + installer.assert_called_once_with(PIN) + self.assertFalse(self.import_marker.exists()) + + def test_ambiguous_pin_identity_is_refused_before_installation(self) -> None: + payloads = { + "duplicate": json.dumps(PIN)[:-1] + + ',"revision":' + json.dumps(PIN["revision"]) + "}", + "disagreeing": json.dumps({**PIN, "commit": "0" * 40}), + } + with mock.patch.object(gnn_conformance, "install") as installer: + for name, payload in payloads.items(): + with self.subTest(name=name): + (self.root / gnn_conformance.PIN_PATH).write_text( + payload, encoding="utf-8" + ) + code, stdout, stderr = self._run(["gnn", "--install"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertTrue(stderr) + installer.assert_not_called() + self.assertFalse(self.import_marker.exists()) + + def test_existing_parser_digest_is_not_waived_by_complete_manifest(self) -> None: + pin = { + **PIN, + "parser_files": {"gnn/parsers/basic.py": "0" * 64}, + } + (self.root / gnn_conformance.PIN_PATH).write_text( + json.dumps(pin), encoding="utf-8" + ) + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("parser digest", stderr.lower()) + self.assertFalse(self.import_marker.exists()) + + def test_complete_frozen_manifest_is_not_rebuilt_from_the_target(self) -> None: + with mock.patch.multiple( + gnn_runtime, + MANIFEST_PATH=gnn_runtime.ARTIFACTS / "v5.1.0-source-manifest.json", + MANIFEST_SHA256="43b33c0b2b40386afa3f306fec4cc13bc1fd7c3b570fbf11d5008bad5c8e6b51", + ): + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("inventory", stderr.lower()) + self.assertFalse(self.import_marker.exists()) + + def test_missing_extra_and_changed_content_fail_before_target_import(self) -> None: + for change in ("missing", "extra", "changed"): + with self.subTest(change=change): + victim = self.package / "fixture-data.txt" + extra = self.package / "unexpected.txt" + try: + if change == "missing": + victim.unlink() + elif change == "extra": + extra.write_bytes(b"unexpected\n") + else: + victim.write_bytes(b"changed\n") + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("inventory", stderr.lower()) + self.assertFalse(self.import_marker.exists()) + finally: + victim.write_bytes(self.expected_bytes["fixture-data.txt"]) + extra.unlink(missing_ok=True) + + def test_foreign_resolution_is_refused_before_either_package_executes(self) -> None: + foreign = self.root / "foreign" / "gnn" + foreign.mkdir(parents=True) + foreign_init = foreign / "__init__.py" + foreign_init.write_text( + f"from pathlib import Path\nPath({str(self.attack_marker)!r}).write_text('foreign')\n", + encoding="utf-8", + ) + + class ForeignFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname == "gnn": + return importlib.util.spec_from_file_location( + fullname, foreign_init, submodule_search_locations=[str(foreign)] + ) + return None + + before = sys.path[:] + with mock.patch.object(sys, "meta_path", [ForeignFinder(), *sys.meta_path]): + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("different GNN package root", stderr) + self.assertFalse(self.import_marker.exists()) + self.assertFalse(self.attack_marker.exists()) + self.assertEqual(sys.path, before) + + def test_delayed_import_drift_cannot_execute_or_emit_verified(self) -> None: + original = gnn_conformance._check_types + + def replace_before_type_check(sketches: list[Path]) -> None: + (self.package / "late.py").write_text( + f"from pathlib import Path\nPath({str(self.attack_marker)!r}).write_text('unchecked')\nACCEPT = True\n", + encoding="utf-8", + ) + original(sketches) + + with mock.patch.object( + gnn_conformance, "_check_types", side_effect=replace_before_type_check + ): + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertTrue(stderr) + self.assertFalse(self.attack_marker.exists()) + + def test_final_guard_refusal_cannot_escape_as_a_verified_receipt(self) -> None: + original = gnn_conformance._check_types + + def change_after_verdict(sketches: list[Path]) -> None: + original(sketches) + (self.package / "fixture-data.txt").write_bytes(b"changed after verdict\n") + + with mock.patch.object( + gnn_conformance, "_check_types", side_effect=change_after_verdict + ): + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertTrue(self.parse_marker.exists()) + self.assertTrue(stderr) + + def test_cached_bytecode_cannot_replace_checked_package_source(self) -> None: + source = self.package / "__init__.py" + cache = Path(importlib.util.cache_from_source(str(source))) + cache.parent.mkdir() + attack = compile( + f"from pathlib import Path\nPath({str(self.attack_marker)!r}).write_text('cached')\n__version__ = '5.0.3'\n", + str(source), "exec", + ) + stat = source.stat() + cache.write_bytes( + importlib.util.MAGIC_NUMBER + + struct.pack(" None: + with mock.patch.object(gnn_conformance, "install") as installer: + self.manifest_path.write_bytes(self.manifest_bytes + b" ") + code, stdout, stderr = self._run(["gnn", "--install"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("manifest-digest-mismatch", stderr) + installer.assert_not_called() + self.manifest_path.write_bytes(self.manifest_bytes) + pin = {**PIN, "tag": "v5.1.0", "revision": "75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf"} + (self.root / gnn_conformance.PIN_PATH).write_text(json.dumps(pin), encoding="utf-8") + code, stdout, stderr = self._run(["gnn", "--install"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("no independently approved source manifest", stderr) + installer.assert_not_called() + self.assertFalse(self.import_marker.exists()) + + def test_preloaded_package_cannot_trigger_installation_or_requalification(self) -> None: + with ( + mock.patch.dict(sys.modules, {"gnn": types.ModuleType("gnn")}), + mock.patch.object(gnn_conformance, "install") as installer, + ): + code, stdout, stderr = self._run(["gnn", "--install"]) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertIn("fresh", stderr) + installer.assert_not_called() + self.assertFalse(self.import_marker.exists()) + + def test_stale_pin_argument_is_refused_before_installation(self) -> None: + changed = {**PIN, "recorded": "2026-11-13"} + (self.root / gnn_conformance.PIN_PATH).write_text(json.dumps(changed), encoding="utf-8") + with mock.patch.object(gnn_conformance, "install") as installer: + with self.assertRaisesRegex(ValueError, "pin changed"): + gnn_conformance.verify(self.root, PIN, install_first=True) + installer.assert_not_called() + self.assertFalse(self.import_marker.exists()) + + def test_missing_tracked_model_is_not_replaced_by_an_exemplar(self) -> None: + self.model.unlink() + with mock.patch.object( + gnn_conformance, + "_exemplar_bytes", + side_effect=AssertionError("must not replace a tracked model"), + ): + code, stdout, stderr = self._run(self._source_arguments()) + self.assertNotEqual(code, 0) + self.assertEqual(stdout, "") + self.assertTrue(stderr) + + def test_source_install_and_non_gnn_selections_have_no_execution_effects(self) -> None: + selections = [ + [*self._source_arguments(), "--install"], + self._source_arguments("fast"), + self._source_arguments("tests"), + self._source_arguments("timings"), + ] + with ( + mock.patch.object(gnn_conformance, "install") as installer, + mock.patch.object(gate, "arm_archive", side_effect=AssertionError("unexpected arm")), + mock.patch.object(gate, "arm_tests", side_effect=AssertionError("unexpected tests")), + ): + for arguments in selections: + with self.subTest(arguments=arguments): + code, stdout, stderr = self._run(arguments) + self.assertEqual(code, 2) + self.assertEqual(stdout, "") + self.assertTrue(stderr) + installer.assert_not_called() + self.assertFalse(self.import_marker.exists()) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/scripts/tests/test_pdf_batch.py b/.github/scripts/tests/test_pdf_batch.py new file mode 100644 index 0000000..bdbe17f --- /dev/null +++ b/.github/scripts/tests/test_pdf_batch.py @@ -0,0 +1,218 @@ +"""Real scraper batch/CLI/export behavior without a private PDF corpus.""" + +from __future__ import annotations + +import contextlib +import io +import runpy +import sys +import unittest +from pathlib import Path +from unittest import mock + +SCRIPTS = Path(__file__).resolve().parents[1] +if str(SCRIPTS) not in sys.path: + sys.path.insert(0, str(SCRIPTS)) + +from tests.pdf_fixtures import PdfScraperCase, SCRAPER + + +class BatchTests(PdfScraperCase): + def load_three_documents(self) -> None: + self.load_scraper( + ["active inference"], + [ + ("1", "active inference", "Active Inference"), + ("2", "active inference", "activeinference"), + ("3", "", "activeinference ACTIVE\nINFERENCE"), + ], + ) + + def run_cli(self): + stdout, stderr = io.StringIO(), io.StringIO() + with ( + mock.patch("builtins.input", return_value="batch"), + contextlib.redirect_stdout(stdout), + contextlib.redirect_stderr(stderr), + self.assertRaises(SystemExit) as raised, + ): + runpy.run_path(str(SCRAPER / "manager.py"), run_name="__main__") + return raised.exception.code, stdout.getvalue(), stderr.getvalue() + + def test_successful_batch_returns_totals_and_preserves_result_columns(self) -> None: + self.load_scraper( + ["active inference", "aa"], + [ + ("1", "Active Inference aa", "ACTIVE\nINFERENCE aaaa"), + ("2", "activeinference active inference", "aaaa"), + ], + ) + totals, _, stderr = self.run_batch() + self.assert_totals(totals, (2, 2, 0, 0, 0)) + self.assertEqual(stderr, "") + self.assertEqual( + self.read_rows("Results"), + [ + ["FileId", "ft_activeinference", "ft_aa", "ab_activeinference", "ab_aa", ""], + ["00001", "1", "2", "1", "1", ""], + ["00002", "0", "2", "2", "0", ""], + ], + ) + self.assertEqual(self.read_rows("Log"), []) + + def test_processing_failure_is_one_quoted_record_and_later_documents_run(self) -> None: + self.load_three_documents() + message = 'bad input, "quoted"\nnext line\rcafé Ω' + self.extraction_errors["00002"] = ValueError(message) + totals, _, stderr = self.run_batch() + self.assert_totals(totals, (3, 2, 1, 0, 1)) + self.assertEqual(stderr, "") + self.assertEqual( + self.read_rows("Results")[1:], + [["00001", "1", "1", ""], ["00003", "2", "0", ""]], + ) + self.assertEqual(self.read_rows("Log"), [["00002", "failed", message]]) + + def test_failure_log_round_trips_each_csv_separator_and_unicode(self) -> None: + self.load_scraper( + ["active inference"], + [("1", "", "unused after failure"), ("2", "", "active inference")], + ) + messages = ["comma, detail", 'a "quote"', "\r", "\n", "\r\n", "café Ω", ""] + for message in messages: + with self.subTest(message=message): + self.extraction_errors["00001"] = ValueError(message) + totals, _, _ = self.run_batch() + self.assert_totals(totals, (2, 1, 1, 0, 1)) + self.assertEqual(self.read_rows("Log"), [["00001", "failed", message]]) + self.assertEqual( + self.read_rows("Results")[1:], [["00002", "1", "0", ""]] + ) + + def test_result_export_failure_is_counted_without_stopping_later_documents(self) -> None: + self.load_three_documents() + append = self.export.appendToResultsCsv + + def fail_second_export(row): + if row.startswith("00002,"): + raise OSError("result medium unavailable") + append(row) + + with mock.patch.object(self.export, "appendToResultsCsv", side_effect=fail_second_export): + totals, _, _ = self.run_batch() + self.assert_totals(totals, (3, 2, 1, 0, 1)) + self.assertEqual( + self.read_rows("Results")[1:], + [["00001", "1", "1", ""], ["00003", "2", "0", ""]], + ) + self.assertEqual( + self.read_rows("Log"), [["00002", "failed", "result medium unavailable"]] + ) + + def test_all_missing_documents_fail_but_each_is_attempted_and_logged(self) -> None: + self.load_scraper(["active inference"], [("1", "", None), ("2", "", None)]) + totals, _, _ = self.run_batch() + self.assert_totals(totals, (2, 0, 2, 0, 1)) + self.assertEqual( + self.read_rows("Results"), [["FileId", "ft_activeinference", "ab_activeinference", ""]] + ) + records = self.read_rows("Log") + self.assertEqual([row[:2] for row in records], [["00001", "failed"], ["00002", "failed"]]) + self.assertIn("00001.txt", records[0][2]) + self.assertIn("00002.txt", records[1][2]) + + def test_failed_failure_log_is_reported_and_does_not_stop_later_documents(self) -> None: + self.load_scraper( + ["active inference"], [("1", "", None), ("2", "", "active inference")] + ) + with mock.patch.object(self.export, "appendToLogCsv", side_effect=OSError("log full")): + totals, _, stderr = self.run_batch() + self.assert_totals(totals, (2, 1, 1, 1, 1)) + self.assertEqual(self.read_rows("Results")[1:], [["00002", "1", "0", ""]]) + self.assertEqual(self.read_rows("Log"), []) + self.assertIn("log full", stderr) + self.assertIn("00001.txt", stderr) + + def test_unknown_selected_key_fails_without_preventing_a_later_known_key(self) -> None: + self.load_scraper(["active inference"], [("2", "", "active inference")]) + totals, _, _ = self.run_batch(["missing", "00002"]) + self.assert_totals(totals, (2, 1, 1, 0, 1)) + self.assertEqual(self.read_rows("Results")[1:], [["00002", "1", "0", ""]]) + self.assertEqual(self.read_rows("Log"), [["missing", "failed", "'missing'"]]) + + def test_reused_callsign_truncates_prior_results_and_failure_log(self) -> None: + self.load_three_documents() + self.extraction_errors["00002"] = ValueError("old failure") + first, _, _ = self.run_batch(["00001", "00002"]) + self.assert_totals(first, (2, 1, 1, 0, 1)) + self.assertEqual(self.read_rows("Log"), [["00002", "failed", "old failure"]]) + second, _, _ = self.run_batch(["00003"]) + self.assert_totals(second, (1, 1, 0, 0, 0)) + self.assertEqual(self.read_rows("Results")[1:], [["00003", "2", "0", ""]]) + self.assertEqual(self.read_rows("Log"), []) + + def test_empty_batch_truncates_existing_callsign_files_too(self) -> None: + self.load_three_documents() + self.extraction_errors["00002"] = ValueError("discarded failure") + self.run_batch(["00001", "00002"]) + totals, _, _ = self.run_batch([]) + self.assert_totals(totals, (0, 0, 0, 0, 0)) + self.assertEqual( + self.read_rows("Results"), [["FileId", "ft_activeinference", "ab_activeinference", ""]] + ) + self.assertEqual(self.read_rows("Log"), []) + + def test_cli_returns_nonzero_after_processing_failure_and_continues(self) -> None: + self.load_three_documents() + self.extraction_errors["00002"] = ValueError("controlled CLI failure") + code, _, _ = self.run_cli() + self.assertEqual(code, 1) + self.assertEqual( + self.read_rows("Results")[1:], + [["00001", "1", "1", ""], ["00003", "2", "0", ""]], + ) + self.assertEqual( + self.read_rows("Log"), [["00002", "failed", "controlled CLI failure"]] + ) + + def test_cli_returns_nonzero_after_result_export_failure(self) -> None: + self.load_three_documents() + append = self.export.appendToResultsCsv + + def fail_second_export(row): + if row.startswith("00002,"): + raise OSError("controlled CLI export failure") + append(row) + + with mock.patch.object(self.export, "appendToResultsCsv", side_effect=fail_second_export): + code, _, _ = self.run_cli() + self.assertEqual(code, 1) + self.assertEqual( + self.read_rows("Results")[1:], + [["00001", "1", "1", ""], ["00003", "2", "0", ""]], + ) + self.assertEqual( + self.read_rows("Log"), [["00002", "failed", "controlled CLI export failure"]] + ) + + def test_cli_success_returns_zero_and_exports_the_document(self) -> None: + self.load_scraper(["active inference"], [("1", "", "active inference")]) + code, _, stderr = self.run_cli() + self.assertEqual(code, 0) + self.assertEqual(stderr, "") + self.assertEqual(self.read_rows("Results")[1:], [["00001", "1", "0", ""]]) + self.assertEqual(self.read_rows("Log"), []) + + def test_cli_empty_csv_batch_returns_zero_with_header_only_outputs(self) -> None: + self.load_scraper(["active inference"], []) + code, _, stderr = self.run_cli() + self.assertEqual(code, 0) + self.assertEqual(stderr, "") + self.assertEqual( + self.read_rows("Results"), [["FileId", "ft_activeinference", "ab_activeinference", ""]] + ) + self.assertEqual(self.read_rows("Log"), []) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/scripts/tests/test_pdf_counts.py b/.github/scripts/tests/test_pdf_counts.py new file mode 100644 index 0000000..5c8d1b8 --- /dev/null +++ b/.github/scripts/tests/test_pdf_counts.py @@ -0,0 +1,84 @@ +"""Keyword/count/export contracts with controlled CSV and extracted-text inputs.""" + +from __future__ import annotations + +import csv +import sys +import unittest +from pathlib import Path +from unittest import mock + +SCRIPTS = Path(__file__).resolve().parents[1] +if str(SCRIPTS) not in sys.path: + sys.path.insert(0, str(SCRIPTS)) + +from tests.pdf_fixtures import PdfScraperCase + + +class KeywordCountTests(PdfScraperCase): + def result_row(self, file_id: str = "00007") -> list[str]: + result = self.doc_results.docResults(self.data_import.FileInfoList[file_id]) + return next(csv.reader([result.toCSV()])) + + def test_multiword_keywords_and_both_sources_share_normalization(self) -> None: + self.load_scraper( + ["Ac tive\nInference", "Inference"], + [ + ( + "7", + "active inference ACTIVE\nINFERENCE activeinference", + "ACTIVE INFERENCE active\ninference activeinference", + ) + ], + ) + self.assertEqual(self.result_row(), ["00007", "3", "3", "3", "3", ""]) + + def test_substrings_remain_case_insensitive_and_nonoverlapping(self) -> None: + text = "aAaAa BANANA preINFERENCEpost" + self.load_scraper(["aa", "ana", "Inference"], [("7", text, text)]) + self.assertEqual( + self.result_row(), ["00007", "2", "1", "1", "2", "1", "1", ""] + ) + + def test_tabs_punctuation_and_unicode_keep_historical_character_semantics(self) -> None: + text = "active\tinference active-inference active inference STRASSE Straße" + self.load_scraper(["Active Inference", "Straße"], [("7", text, text)]) + self.assertEqual(self.result_row(), ["00007", "1", "1", "1", "1", ""]) + + def test_empty_full_text_and_abstract_export_zero_counts(self) -> None: + self.load_scraper(["active inference", "aa"], [("7", "", "")]) + self.assertEqual(self.result_row(), ["00007", "0", "0", "0", "0", ""]) + + def test_normalized_duplicates_preserve_first_column_order_and_csv_shape(self) -> None: + self.load_scraper( + ["Beta term", "Active Inference", "BETA TERM", "aa"], + [("7", "aa Beta term", "Active Inference beta term beta term aaaa")], + ) + self.assertEqual( + next(csv.reader([self.data_import.outputFileHeader])), + [ + "FileId", + "ft_betaterm", + "ft_activeinference", + "ft_aa", + "ab_betaterm", + "ab_activeinference", + "ab_aa", + "", + ], + ) + self.assertEqual( + self.result_row(), ["00007", "2", "1", "2", "1", "0", "1", ""] + ) + + def test_import_reads_parameters_without_prompting_or_creating_exports(self) -> None: + with mock.patch("builtins.input", side_effect=AssertionError("unexpected prompt")): + self.load_scraper(["active inference"], [("7", "abstract fixture", "text")]) + self.assertEqual(self.data_import.FileInfoList["00007"].abstract, "abstract fixture") + self.assertEqual(list(self.data_import.KwList), ["activeinference"]) + self.assertEqual(list(self.root.glob("*-Results.csv")), []) + self.assertEqual(list(self.root.glob("*-Log.csv")), []) + + +if __name__ == "__main__": + unittest.main() diff --git a/AGENTS.md b/AGENTS.md index 236ef91..b6fdfc1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,11 +32,7 @@ must pass before publishing: python .github/scripts/gate.py fast ``` -`fast` runs the four archive checks over one `git ls-files` read (relative -Markdown links resolve, tracked Python compiles, notebooks are output-free JSON, -no Jupyter checkpoint is tracked) plus the gate's own tests. CI calls exactly -this command, and separately -`python .github/scripts/gate.py gnn --install` for the pinned GNN conformance. +`fast` runs archive checks over tracked inputs plus dependency-free gate contracts and controlled scraper regressions. CI calls this command and separately `python .github/scripts/gate.py gnn --install`. Plain `gnn` requires qualified installed origin/content; `--gnn-source-root /exact/checkout/src/gnn` explicitly chooses narrower source proof, never fallback. Installation requires separate authority. See the [GNN guide](.github/GNN.md). Arms, job keys, the pin, and measured wall times are in [`docs/RUN_GUIDE.md`](docs/RUN_GUIDE.md). For Python edits, also run `python -m py_compile` on changed scripts. For notebook edits, verify JSON diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d490ac9..34bfd5d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -32,10 +32,7 @@ commands: python .github/scripts/gate.py fast ``` -Add the GNN arm (`python .github/scripts/gate.py gnn --install`) when you change -`.github/gnn-pin.json` or the conformance script. Arms and their measured wall -times are in [docs/RUN_GUIDE.md](docs/RUN_GUIDE.md) and -[docs/gate-timings.md](docs/gate-timings.md). +Run the GNN arm when changing the pin or conformance source. Plain `gnn` verifies an already prepared installed runtime; `--install` explicitly permits installation. `--gnn-source-root /exact/checkout/src/gnn` chooses qualified source, never installed fallback. Each verdict needs a fresh process. See the [GNN guide](.github/GNN.md) and [run guide](docs/RUN_GUIDE.md); historical [timings](docs/gate-timings.md) are not fresh acceptance. Describe the files changed, the verification performed, and any remaining limitations. Keep data provenance clear: include source, query date, filters, and transformations for newly generated exports where known. diff --git a/Literature_Analysis/PDF_Scrape/README.md b/Literature_Analysis/PDF_Scrape/README.md index d0591ff..eb54cad 100644 --- a/Literature_Analysis/PDF_Scrape/README.md +++ b/Literature_Analysis/PDF_Scrape/README.md @@ -4,13 +4,13 @@ Exploratory Python tooling that counts configured keywords in a local PDF corpus ## Inputs -- `resc/params/keywords.csv` — 331 keyword rows under the `Kw` column. `dataImport.py` lowercases terms and removes spaces before counting. +- `resc/params/keywords.csv` — 331 keyword rows under `Kw`. `dataImport.normalizeText()` lowercases and removes literal ASCII spaces and newline characters from keywords, full text, and abstracts. Each text is normalized once per document; matching remains nonoverlapping substring counting, not token-aware search. - `resc/params/fileInfo.csv` — 257 paper records with `COGSEC_ID`, `Title`, and `Abstract` columns. IDs are zero-padded to five digits. - `resc/pdfList/` — expected PDF directory. It is not committed to this repository. ## How it works -`manager.py` loads every row from `fileInfo.csv`, prompts for an export ID through `streamingExport.py`, extracts PDF text, counts each keyword in full text and abstract, and writes `-Results.csv` plus `-Log.csv` in the current working directory. Result columns are generated as `ft_` and `ab_`. +Importing `dataImport.py`, including through `manager.py`, reads both CWD-relative parameter CSVs and constructs keyword/document mappings; the manager also imports the PDF-reader dependency. Import alone does not prompt, extract PDFs, run a batch, or create exports. Running the manager initializes callsign outputs and writes full-text columns before abstract columns. Run from this directory so the existing relative paths resolve: @@ -29,12 +29,14 @@ The scripts import a PDF reader compatible with the `pypdf` API, or PyPDF2 as a python -m pip install pypdf ``` -`manager.py` also uses only Python standard-library functionality beyond the local modules. There is no requirements file or automated test suite in this archive. +Beyond its PDF-reader dependency and local modules, the scraper uses the standard library. Controlled CSV/text regressions live in `.github/scripts/tests/`; they replace the PDF-extraction boundary and do not qualify a real PDF parser, private corpus, or scientific result. This archive has no dependency manifest or packaging configuration. ## Caveats -- `streamingExport.py` resolves the export callsign lazily: importing the module is safe, and `python manager.py` prompts once for the callsign before writing output files. -- Keyword normalization removes spaces and searches with substring counts. This can produce matches inside larger words; it is the historical behavior of the script, not a token-aware search. -- `manager.py` catches all exceptions while processing a document and records the failure (with the exception message) in the log. Inspect the source and inputs when diagnosing a failure. -- `utilCSV.py` is an empty placeholder and is not used by the current manager path. -- `resc/pdfList/` and generated `*-Results.csv`/`*-Log.csv` files are intentionally not part of the committed archive. +- Parameter CSV reads occur at import time and remain CWD-relative. Lazy export prompting does not make imports free of input I/O or dependency requirements. +- Normalized-key insertion order and the result column/trailing-field layout are retained. Substrings can match inside larger words; tabs and punctuation are not broadly stripped. +- `mrManager.run()` returns `BatchTotals(attempted, succeeded, failed, log_failures)`, with `attempted = succeeded + failed`. Processing or result-write errors fail that document while later documents continue. A failure-log error is additionally reported to stderr; either failure makes the CLI exit nonzero. +- Failure logs are CSV records containing file ID, `failed`, and exception message. Use a CSV reader so quoted commas and embedded line breaks remain one field. +- Every run truncates both callsign files before processing, including empty batches. Reusing a callsign discards its prior contents. Streaming writes are not transactional or retry/resume behavior. +- For separately approved revival, prepare a separate workspace with its own `resc/params/` and `resc/pdfList/`, invoke this script by its full path, and choose a fresh callsign. Preserve historical inputs and exports. Other workspaces are not automatically covered by this repository's ignore rules. +- `utilCSV.py` remains an unused empty placeholder. The uncommitted PDF corpus and generated scraper outputs remain outside the historical archive. diff --git a/Literature_Analysis/PDF_Scrape/dataImport.py b/Literature_Analysis/PDF_Scrape/dataImport.py index 8a81c21..6b14d95 100644 --- a/Literature_Analysis/PDF_Scrape/dataImport.py +++ b/Literature_Analysis/PDF_Scrape/dataImport.py @@ -10,6 +10,11 @@ def formatFileId(fileId): nFileId += "0" return nFileId+str(fileId) +# normalizeText preserves the historical space/newline-free substring search. +def normalizeText(text): + return text.lower().replace(" ", "").replace("\n", "") + + # genOutPutHeader creates a header for output csv file def genOutPutHeader(kwlist): @@ -28,8 +33,7 @@ def getKws(): r = reader(fileInfo) next(r) for row in r: - #kwlist[row[0]]="" - kwlist[row[0].lower().replace(" ", "")]="" #bugfix 8-1-22 + kwlist[normalizeText(row[0])] = "" return kwlist # getFileInfo pulls paper information from fileInfo.csv and returns a dict diff --git a/Literature_Analysis/PDF_Scrape/docResults.py b/Literature_Analysis/PDF_Scrape/docResults.py index bd51226..41fcd39 100644 --- a/Literature_Analysis/PDF_Scrape/docResults.py +++ b/Literature_Analysis/PDF_Scrape/docResults.py @@ -3,8 +3,7 @@ # separate body, abstract, and citations from pdfReader import extractPDFtext -from dataImport import KwList -from dataImport import FileInfoList +from dataImport import KwList, normalizeText # kwResults is a container for results of keyword search of a doc class kwResults: @@ -34,16 +33,14 @@ class docResults: def __init__(self,doc): self.doc = doc # doc class - dataImport.docImport self.kws = kwResults() # load up KwList - self.fulltext = extractPDFtext(self.doc.filePath).replace("\n", "") # extract pdf text and scrub new-lines - # Additional removal of spaces added after it was found some Pdf text extractions result in no spaces, - # this creates consistency across all Pdfs, given that the risk of word combination resulting in false positives - # on keywords is minimal relative to the risk of false negatives due to lack of spaces in text extraction - self.fulltext = self.fulltext.replace(" ", "") + # Flatten both sources once, using the same normalization as keywords. + self.fulltext = normalizeText(extractPDFtext(self.doc.filePath)) + self.abstract = normalizeText(self.doc.abstract) self.countKws() def countKws(self): for kw in KwList.keys(): - self.kws.addFullTextCount(kw,(self.fulltext.lower().count(kw))) - self.kws.addAbstractCount(kw,(self.doc.abstract.lower().count(kw))) + self.kws.addFullTextCount(kw, self.fulltext.count(kw)) + self.kws.addAbstractCount(kw, self.abstract.count(kw)) def toCSV(self): row = self.doc.fileId + "," row += self.kws.toCSV() diff --git a/Literature_Analysis/PDF_Scrape/manager.py b/Literature_Analysis/PDF_Scrape/manager.py index 4388084..6409b73 100644 --- a/Literature_Analysis/PDF_Scrape/manager.py +++ b/Literature_Analysis/PDF_Scrape/manager.py @@ -1,10 +1,25 @@ # -*- coding: utf-8 -*- +from dataclasses import dataclass +import sys + from dataImport import FileInfoList from docResults import docResults import streamingExport as export +@dataclass +class BatchTotals: + attempted: int = 0 + succeeded: int = 0 + failed: int = 0 + log_failures: int = 0 + + @property + def exit_code(self): + return 1 if self.failed or self.log_failures else 0 + + # mrManager is just a "manager" for allowing three-line implementation class mrManager: def __init__(self): @@ -17,14 +32,28 @@ def getKeys(self): self.keyring = FileInfoList.keys() def run(self): export.instantiateFiles() + totals = BatchTotals() for key in self.keyring: + totals.attempted += 1 print("---------------\n\n\nAttempting: "+key,"\n-------------\n") try: export.appendToResultsCsv(docResults(FileInfoList[key]).toCSV() + "\n") - print("---------------\n\nSucceeded: "+key,"\n-------------\n") except Exception as exc: - export.appendToLogCsv(key+", failed, "+str(exc)+"\n") + totals.failed += 1 + try: + export.appendToLogCsv([key, "failed", str(exc)]) + except Exception as log_exc: + totals.log_failures += 1 + print( + f"Unable to log failure for {key}: {log_exc}; " + f"original error: {exc}", + file=sys.stderr, + ) print("---------------\n\nFailed: "+key,"\n-------------\n") + else: + totals.succeeded += 1 + print("---------------\n\nSucceeded: "+key,"\n-------------\n") + return totals def close(self): pass @@ -34,7 +63,17 @@ def close(self): #f.close() -if __name__ == "__main__": +def main(): m = mrManager() m.getKeys() - m.run() + totals = m.run() + print( + f"Batch complete: attempted={totals.attempted} " + f"succeeded={totals.succeeded} failed={totals.failed} " + f"log_failures={totals.log_failures}" + ) + return totals.exit_code + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/Literature_Analysis/PDF_Scrape/streamingExport.py b/Literature_Analysis/PDF_Scrape/streamingExport.py index 01756ca..76b6cf2 100644 --- a/Literature_Analysis/PDF_Scrape/streamingExport.py +++ b/Literature_Analysis/PDF_Scrape/streamingExport.py @@ -1,4 +1,6 @@ # -*- coding: utf-8 -*- +from csv import writer + from dataImport import outputFileHeader # Export parameters are resolved lazily on first use so that importing this @@ -32,22 +34,21 @@ def _ensureConfigured(): # instantiatefiles instantiates log and export files def instantiateFiles(): _ensureConfigured() - f = open(ResultsExportFile, "w") - f.write(outputFileHeader) - f.close() - f = open(LogExportFile, "w") - f.close() + with open(ResultsExportFile, "w", encoding="utf-8", newline="") as f: + f.write(outputFileHeader) + with open(LogExportFile, "w", encoding="utf-8", newline=""): + pass # appendToResultsCsv appends a row to results def appendToResultsCsv(row): _ensureConfigured() - with open(ResultsExportFile, 'a') as f: + with open(ResultsExportFile, "a", encoding="utf-8", newline="") as f: f.write(row) -# appendToLogCsv appends a row top log +# appendToLogCsv appends one structured failure record to the log. def appendToLogCsv(row): _ensureConfigured() - with open(LogExportFile, 'a') as f: - f.write(row) + with open(LogExportFile, "a", encoding="utf-8", newline="") as f: + writer(f).writerow(row) diff --git a/Literature_Analysis/Pubmed_to_Coda/README.md b/Literature_Analysis/Pubmed_to_Coda/README.md index 623c635..6c6466a 100644 --- a/Literature_Analysis/Pubmed_to_Coda/README.md +++ b/Literature_Analysis/Pubmed_to_Coda/README.md @@ -18,14 +18,32 @@ The notebook imports `pandas` and `Bio.Entrez` from Biopython. Install them in a python -m pip install pandas biopython jupyter ``` -Before running requests, replace the notebook's example `Entrez.email = 'you@email.com'` values with an address for NCBI request identification. The notebook calls the public Entrez `esearch` and `efetch` endpoints and may produce different results as PubMed changes. +An NCBI contact address identifies separately approved requests; it does not resolve the extraction or cohort limitations below. -## Run +## Historical status and rerun warning -Open `Pubmed_Query.ipynb` in Jupyter and execute cells in order. The notebook writes `FEP_ActInf.csv` in this directory. It uses `ids.csv` and `PMIDS2.csv` during the join stage; keep those files in the notebook's working directory or update the paths. +This February 2022 notebook is preserved exploratory source, not a validated current extraction workflow. Keep the notebook and committed CSVs as historical artifacts. Inventory counts describe saved snapshots, not expected new query results. The following source risks do not establish that particular saved rows were affected. -The notebook is retained as a historical exploratory artifact. It contains repeated author-unpacking cells and assumes at least 13 author positions in its intermediate DataFrame. No automated tests are included. +Do not execute all cells in this checkout to reproduce the archive. The notebook makes live Entrez requests; zero-based cell 35 writes `FEP_ActInf.csv` in CWD and can overwrite the committed export. Ignore rules do not prevent that overwrite. + +### Known source limitations + +Cell numbers are zero-based. + +- **Structured/missing abstracts:** cell 4 retains only `AbstractText[0]`; later sections are not assembled. Missing `Abstract` records are skipped; empty/missing `AbstractText` is unguarded. Cells 5 and 29 retain abstract-bearing records as the left-hand join set. The scratch missing-abstract list is reused, not retained as an exclusion report. +- **Tenth author:** cell 18 selects `Authors9` but builds `A9` from `Authors3`. It repeats fourth-author data and can add that duplicate even when a record has no tenth author. +- **Truncation/narrow frames:** cells 8–22 assemble positions 0–12, thirteen positions rather than the fourteen in a comment. Later authors are omitted. Unconditional positional-column selection can fail when the cohort's widest list has fewer than thirteen positions; this is a cohort-wide frame-width assumption. +- **Derived lists/counts:** cells 22 and 24–26 use those positional frames. Duplicated or omitted authors feed both lists and `num_authors`, which need not equal complete Entrez `AuthorList` lengths. +- **Final schema:** cell 34 names exactly six data columns: `abstract`, `authors`, `num_authors`, `first_author`, `title`, `DOI`. PMID remains the exported join index. Earlier affiliation fields and cohort provenance are not separate final fields; renaming assumes exactly six joined data columns. +- **Missing matches:** cell 27 selects the first-author match with `.values[0]`; an absent PMID can stop execution. Later left joins do not reconcile coverage/cardinality. Unmatched surviving rows may contain missing metadata; right-only identifiers add no rows. +- **Live/frozen mixing:** live queries/fetches are combined with frozen `ids.csv` author inputs and `PMIDS2.csv` DOI inputs. The displayed `ids` frame does not refresh either file. A rerun is not automatically a consistent new cohort or reproduction. + +### Decisions before revival + +Warning documentation does not authorize notebook edits or data regeneration. The research owner must select the PMID cohort, query/filter/date policy, structured/missing-abstract treatment, complete author extraction or labeled limit, missing-join behavior, required fields, provenance, and a non-overwriting destination. + +Future offline acceptance must cover multi-section/missing/empty abstracts; zero/one/narrow author cohorts; fourth-author records without tenth authors; distinct fourth/tenth authors; lists longer than thirteen; missing author/first-author matches; query-only, author-input-only and DOI-input-only PMIDs; association/order/count/schema fidelity; and preservation of historical exports. ## Provenance -The checked-in CSVs are snapshots, not a live PubMed database. Record the execution date, query terms, and any changed filters when generating a replacement export. See the repository [README](../../README.md) for the citation and license. +Committed CSVs are snapshots, not a live database. Separately approved new exports must record date, exact query/filters, selected PMID cohort, input versions, extraction policies, and destination without replacing archived exports. See the repository [README](../../README.md) for citation and license. diff --git a/Literature_Analysis/README.md b/Literature_Analysis/README.md index 7e34382..d5518b3 100644 --- a/Literature_Analysis/README.md +++ b/Literature_Analysis/README.md @@ -23,9 +23,7 @@ overlaps. - `PDF_Scrape/resc/params/keywords.csv` and `Ontology_Snapshot/Ontology_TermsOnly.csv` share 314 terms verbatim; the keyword list extends the ontology terms with abstract-scope variants. -- `Pubmed_to_Coda/FEP_ActInf.csv` is the only generated dataset in the folder; - it derives from the notebook's Entrez queries plus the two committed ID/DOI - inputs. +- `Pubmed_to_Coda/FEP_ActInf.csv` is a committed historical export, not a safely reproducible current database. Live responses and frozen identifiers are mixed, with known extraction/join limitations. Read the [preservation warnings](Pubmed_to_Coda/README.md); do not overwrite it. ## Run the tooling @@ -40,9 +38,7 @@ python manager.py jupyter notebook Literature_Analysis/Pubmed_to_Coda/Pubmed_Query.ipynb ``` -The notebook run needs an `Entrez.email` value for NCBI, and its results change -over time. See [the quickstart](../docs/quickstart.md) for the full setup and -[data provenance](../docs/provenance.md) for per-file details and caveats. +The notebook command opens historical source for inspection, not execution of every cell. Its export can overwrite the committed CSV; dependencies and an NCBI email do not settle extraction/cohort limitations. Follow the [area warnings](Pubmed_to_Coda/README.md), [quickstart](../docs/quickstart.md), and [provenance guide](../docs/provenance.md). ## Preservation boundary diff --git a/README.md b/README.md index cb22140..7667c74 100644 --- a/README.md +++ b/README.md @@ -35,9 +35,9 @@ This is an archive of research inputs and exploratory analysis artifacts rather The repository has no build step. Start with the area README files above, then inspect the CSV, spreadsheet, JSON, PNG, and notebook artifacts directly. -### Run the PubMed notebook +### Inspect the historical PubMed notebook -The notebook uses `pandas` and Biopython's `Bio.Entrez` client. Open `Literature_Analysis/Pubmed_to_Coda/Pubmed_Query.ipynb` in Jupyter, replace the example `Entrez.email` value with an email address for your NCBI requests, and execute the cells in order. See the [Pubmed_to_Coda README](Literature_Analysis/Pubmed_to_Coda/README.md) for inputs and outputs. +Open the notebook only for inspection until the research owner selects a revival cohort and non-overwriting output. Its abstract/author/join limitations and relative export can affect a rerun or overwrite historical `FEP_ActInf.csv`; read the [complete preservation warnings](Literature_Analysis/Pubmed_to_Coda/README.md). ### Run PDF keyword extraction @@ -45,13 +45,13 @@ The PDF scraper expects a local PDF corpus at `Literature_Analysis/PDF_Scrape/re ### Verify the repository -One gate script, runnable arm by arm. The default `fast` arm is dependency-free. It fails when a relative Markdown link does not resolve, a tracked Python file does not compile, a notebook is invalid JSON or carries committed cell outputs, a Jupyter checkpoint file is tracked, or the gate's own tests fail: +The default `fast` arm combines archive checks, recorded Publishing-copy digest agreement, dependency-free gate contracts, and controlled scraper regressions. It checks relative Markdown targets, tracked Python syntax, output-free notebook JSON, and tracked checkpoint exclusion. This describes configured behavior, not a current full-gate or scientific-validation receipt: ```bash python .github/scripts/gate.py fast ``` -List every arm with `python .github/scripts/gate.py --list`; the network-backed `gnn` conformance arm and the measured wall time for each arm are documented in [docs/RUN_GUIDE.md](docs/RUN_GUIDE.md) and [docs/gate-timings.md](docs/gate-timings.md). +List arms with `python .github/scripts/gate.py --list`. Plain `gnn` verifies an already prepared installed parser; `--install` explicitly requests installation, while `--gnn-source-root /exact/checkout/src/gnn` deliberately selects narrower source qualification, never fallback. See the [GNN guide](.github/GNN.md), [run guide](docs/RUN_GUIDE.md), and historical [timing page](docs/gate-timings.md). ## Documentation @@ -100,7 +100,7 @@ See [`CONTRIBUTING.md`](CONTRIBUTING.md). In particular, do not commit credentia ## Audit trail -The current documentation review is recorded in [`REVIEW_LOG_2026-08-02.md`](REVIEW_LOG_2026-08-02.md), with outstanding work in [`TO-DO.md`](TO-DO.md). +The historical documentation review is recorded in [`REVIEW_LOG_2026-08-02.md`](REVIEW_LOG_2026-08-02.md); current decisions and recorded evidence are in [`TO-DO.md`](TO-DO.md). The historical review is not a current gate receipt. ## InstituteOS sidecar diff --git a/TO-DO.md b/TO-DO.md index 6706856..b1324df 100644 --- a/TO-DO.md +++ b/TO-DO.md @@ -49,7 +49,13 @@ Sections: No scoped finding from the 2026-08-02 review is still open. Everything below is either newly found or deliberately deferred; each line names what blocks it and who clears it. 1. **GNN pin moved to `v5.1.0` (2026-11-16)** — `.github/gnn-pin.json` now records tag `v5.1.0`, revision `75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf` (the commit the annotated `v5.1.0` tag resolves to), recorded `2026-11-16`; the pin tables in `.github/GNN.md`, `.github/README.md` and `docs/RUN_GUIDE.md` and the `gnn-pin.json` digest in the [Publishing digest block](docs/workflows/publishing.md) moved with it. `python .github/scripts/gate.py fast` and the `gnn` arm against an installed 5.1.0 parser (CPython 3.12) passed locally before the change was proposed. Nothing open. -2. **Hosted CI gives no verdict** — every workflow run fails before its jobs start: run `43244620261` (push to `main`, 2026-11-12) carries "The job was not started because your account is locked due to a billing issue" on both `docs and scripts` and `gnn conformance (pinned)`, and the same annotation appears on the pull-request runs for #11 and #12. Until the organisation's Actions billing is restored, a local `python .github/scripts/gate.py fast` is the only gate evidence and a merge cannot wait on a hosted check. Blocked outside this repository on ActiveInferenceInstitute GitHub billing; its owner clears it. +2. **Hosted CI has no recorded verdict after the billing lock** — run `43244620261` on 2026-11-12 recorded both named jobs as not started due to billing, with similar PR #11/#12 annotations. This is dated evidence, not a fresh account/Actions check. Local receipts do not establish hosted success or authorize bypassing required review/status policy. Owner: organisation billing owner. 3. **Rendered docs site** with a static-site generator and CI (MkDocs/Jekyll) — deferred by the decision recorded under Major; unblock when the archive gains a build step or an installable package. Owner: repository maintainer. -4. **Code modernization beyond the entrypoint fix** — the `dataImport.py`/`docResults.py` reads that resolve `resc/params/*.csv` against the working directory (deliberate for a run-from-here archive) and `formatFileId` edge cases. Unscheduled: the scrapers only run against a PDF corpus that is not committed, so there is no reproducible test input. Owner: whoever revives PDF_Scrape. (`docResults1` legacy variant was removed on 2026-11-06, PR #6, commit `9b7658e`.) +4. **Scraper revival policy** — CWD-relative input resolution and `formatFileId` edge cases remain maintainer decisions. The absent private PDF corpus blocks representative corpus acceptance, not controlled counting/batch/CSV regressions. Bounded repairs do not settle revival policy. Preserve `docResults1` removal at PR #6 / `9b7658e`. 5. **Packaging for the PDF_Scrape tool** — a `requirements.txt`/`pyproject.toml` if it is revived for active use; `git ls-files` tracks no packaging file today, which is also why the gate has no `lint` or `type` arm. Blocked on the same revival decision. Owner: whoever revives PDF_Scrape. + +## 2026-11-13 bounded qualification + +All 35 original entries and 24 historical closures are retained. Governed controlled counting/batch/GNN-admission regressions passed; real consumer helpers parsed, syntax-checked, and obtained literal-`True` type checking using the exact unchanged v5.0.3 manifested source and pinned upstream exemplar bytes. This is explicit-source proof, not an installed-runtime, complete network-backed gate, corpus/science, merge, or release claim. + +K2 notebook/cohort decisions, K5 qualified immutable Journal copy adoption, installed-origin/runtime qualification, deliberate pin migration, hosted billing, and static-site/packaging expansion remain open. Historical exports, pin/digests, review logs, and measured timing artifacts are unchanged. diff --git a/docs/README.md b/docs/README.md index 9b13d34..82c1f70 100644 --- a/docs/README.md +++ b/docs/README.md @@ -9,8 +9,7 @@ one flat index. - [RUN_GUIDE.md](RUN_GUIDE.md) — the gate entry point, its arms, the CI jobs, and the GNN pin. - [gate-timings.md](gate-timings.md) — per-arm wall times, generated by the gate. -- [quickstart.md](quickstart.md) — browse the archive, run the PubMed notebook, - and run PDF keyword extraction. +- [quickstart.md](quickstart.md) — browse the archive, inspect the historical PubMed notebook safely, and run PDF keyword extraction. - [provenance.md](provenance.md) — per-dataset inventory: formats, dates, sizes, and caveats. - [architecture.md](architecture.md) — how the literature-analysis components @@ -32,8 +31,7 @@ license, and [AGENTS.md](../AGENTS.md) for contribution and preservation rules. on pushes to `main`. Job `docs and scripts` runs the fast arm, `python .github/scripts/gate.py fast`, which checks that relative Markdown links resolve, tracked Python compiles, notebooks are output-free JSON, no -`.ipynb_checkpoints` directory is tracked, and the gate's own tests pass. It -exits 1 and lists every failure when any of those break. +`.ipynb_checkpoints` directory is tracked, and controlled gate/scraper regressions pass. These are configured contracts, not a new hosted verdict. The proof is run 41719405985, job `docs and scripts`: the log line `- docs/README.md: missing link target: does-not-exist.md` is followed by @@ -42,8 +40,4 @@ The proof is run 41719405985, job `docs and scripts`: the log line The workflow also runs the pinned GNN conformance baseline, job `gnn conformance (pinned)`, as -`python .github/scripts/gate.py gnn --install`; it verifies the parser pin and, -as this archive carries no `.gnn.md` model file, validates the pinned upstream -exemplar. [RUN_GUIDE.md](RUN_GUIDE.md) lists every arm, and `.github/GNN.md` -records what the conformance arm parses. Wall times for each arm are in the -generated [gate-timings.md](gate-timings.md). +`python .github/scripts/gate.py gnn --install`; installation is explicit, and default parser execution requires matching installed origin/full content. `--gnn-source-root /exact/checkout/src/gnn` deliberately selects narrower source qualification. With no tracked authored model, the complete arm fetches the pinned upstream exemplar. See [RUN_GUIDE.md](RUN_GUIDE.md) and the [GNN guide](../.github/GNN.md). The generated [timing page](gate-timings.md) retains historical measurements. diff --git a/docs/RUN_GUIDE.md b/docs/RUN_GUIDE.md index cf604f1..31c5a48 100644 --- a/docs/RUN_GUIDE.md +++ b/docs/RUN_GUIDE.md @@ -19,8 +19,8 @@ $ python .github/scripts/gate.py --list | `notebooks` | `python .github/scripts/gate.py notebooks` | Tracked notebooks are valid JSON with no committed cell outputs. | | `checkpoints` | `python .github/scripts/gate.py checkpoints` | No Jupyter checkpoint file is tracked. | | `archive` | `python .github/scripts/gate.py archive` | The four archive checks over one `git ls-files` read. | -| `tests` | `python .github/scripts/gate.py tests` | The gate's own dependency-free unit tests. | -| `gnn` | `python .github/scripts/gate.py gnn --install` | The pinned GNN parser, sketch parsing, and type checking. | +| `tests` | `python .github/scripts/gate.py tests` | Dependency-free gate contracts and controlled scraper regressions. | +| `gnn` | `python .github/scripts/gate.py gnn` | Qualified installed parser origin/content, sketch parsing, syntax and type checking; installation requires explicit `--install`. | | `fast` (default) | `python .github/scripts/gate.py fast` | `archive` + `tests`; CI's docs job runs exactly this. | | `full` | `python .github/scripts/gate.py full` | `fast` + `gnn`; the whole gate. | | `timings` | `python .github/scripts/gate.py timings` | Measure each offline arm once and rewrite the timings page. | @@ -28,12 +28,9 @@ $ python .github/scripts/gate.py --list `links`, `python`, `notebooks`, `checkpoints`, and `archive` share one implementation in `.github/scripts/archive_checks.py`; running `archive` reads `git ls-files` once instead of four times. `gnn` lives in -`.github/scripts/gnn_conformance.py` and is the only arm that needs the network. +`.github/scripts/gnn_conformance.py`; installation and empty-model exemplar fetching need network access. -The `links` check also invokes the byte-identical Publishing checker with -`--verify-copy` for the schema, checker module, and GNN pin recorded in the -[member contract](workflows/publishing.md). This runs through `archive`, `fast`, -and `full` too; no additional gate arm or corpus is introduced. +The `links` check invokes the recorded Publishing checker with `--verify-copy` for the schema, checker, and member-owned GNN pin in the [member contract](workflows/publishing.md). `archive`, `fast`, and `full` include it. This proves local digest agreement, not authenticated producer freshness or corpus identity coverage. ## Where the arms are measured @@ -44,13 +41,7 @@ records one local sample per offline arm on the host that ran python .github/scripts/gate.py timings --include-gnn ``` -`--include-gnn` adds the `gnn` measurement and needs the pinned parser already -importable in the measuring interpreter. `gnn` and `full` never appear in the -table, because both need the pinned parser and the network; `--include-gnn` -records `gnn` alone in the page's separate section, and `full` adds nothing a -reader cannot get by adding the fast table to that number. The `tests` arm fails -when the page stops listing every measured arm with its current command, so a -new arm cannot land without refreshing it. +`--include-gnn` adds a separate GNN measurement, requiring its actual selected parser/runtime and, for this empty-model archive, network access. Historical samples remain historical. New timings must come from the source-owned generator after inputs settle; a successful subset does not qualify a new full measurement. ## CI @@ -91,33 +82,22 @@ arm gains a locked dependency set. | Revision | `75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf` | | Recorded | `2026-11-16` | -`.github/GNN.md` records what the conformance arm parses. The arm validates the -schema and repository identity, installs -`generalized-notation-notation @ git+https://github.com/.git@` -with `--no-deps` plus the runtime dependencies `defusedxml`, `psutil`, and -`pyyaml`, then checks that the installed `gnn.__version__` equals the tag -without its `v`. Parsing then covers every `*.gnn.md` sketch in the repository -(full parse, syntax validation, type checking). The type-check verdict passes -only when `validate_gnn_files` returns the literal `True`; its `2` -(`SUCCESS_WITH_WARNINGS`, which covers invalid files and an empty model set) is -a failure, as `.github/GNN.md` records. This archive carries none, so -the arm validates the pinned upstream exemplar -`input/gnn_files/basics/static_perception.md` at the pinned revision and prints -a JSON receipt naming `"source": "pinned-exemplar"`. +The conformance arm checks independently frozen reviewed bootstrap and complete manifest bytes before importing the unchanged pinned parser. Default installed mode requires matching PEP610 Git origin and complete package content. Explicit source mode uses the same authority with a deliberately selected `src/gnn` root, without claiming installed/VCS provenance. No failed-installed-to-source fallback exists. + +Parser/version/syntax/type-check calls and delayed imports remain guarded through final content/origin rechecks. Only literal `True` from `validate_gnn_files` passes. Sorted tracked sketches are selected; inventory failures refuse. This archive has none, so the complete arm fetches the pinned upstream exemplar and labels its model source separately from parser qualification. ### Running the GNN arm locally -The pinned release declares Python `>=3.11,<3.15`; pip refuses to install it on -a newer interpreter (`3.15.2 not in '<3.15,>=3.11'`). CI uses 3.12. Use a -throwaway environment at a supported version so the arm does not modify your -default interpreter: +Use an already provisioned Python `>=3.11,<3.15` runtime (CI uses 3.12), and a fresh process per verdict: ```bash -python3.12 -m venv ~/.cache/gnn-venv -~/.cache/gnn-venv/bin/python .github/scripts/gate.py gnn --install +python .github/scripts/gate.py gnn +python .github/scripts/gate.py gnn --gnn-source-root /exact/checkout/src/gnn +python .github/scripts/gate.py full --gnn-source-root /exact/checkout/src/gnn +python .github/scripts/gate.py timings --include-gnn --gnn-source-root /exact/checkout/src/gnn ``` -Both steps need network access to PyPI and GitHub. +`--gnn-source-root` is incompatible with `--install` and unrelated arms; relative paths are resolved before timing children change CWD. `--install` is an explicitly authorized separate installation, not automatic runtime selection. Installation and the empty-selection exemplar need network authority. ## Why no lint or type arm @@ -136,5 +116,6 @@ repository's contract. If the scraper becomes an installable package, add a - `notebooks` checks JSON structure and output emptiness, not that a notebook runs; the PubMed notebook needs `pandas`, `biopython`, and network Entrez access, none of which this host or CI provides here. -- `gnn` proves parser and pin conformance. With no committed sketch it says - nothing about a model of this repository's own. +- Controlled CSV/text fixtures do not parse real PDFs or qualify the private corpus. +- Controlled GNN fixtures do not qualify an installed parser; explicit source qualification is a separate, narrower origin claim. +- With no tracked authored sketch, the upstream exemplar says nothing about an archive-specific model or scientific semantics. diff --git a/docs/architecture.md b/docs/architecture.md index 4f3ca51..09ad064 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -26,19 +26,9 @@ Knowledge-Engineering/ ### PubMed → FEP/ActInf dataset -``` -NCBI Entrez (esearch "free energy principle"[TIAB] / "active inference"[TIAB], - open-access filter) - │ - ▼ -Pubmed_Query.ipynb ──► ids.csv (258 PMIDs) - │ PMIDS2.csv (168 PMID→DOI) - │ - └──► FEP_ActInf.csv (331 records: abstract, authors, num_authors, - first_author, title, DOI) -``` +The preserved notebook fetches abstracts, authors, and titles from live Entrez query identifiers. It separately reads frozen `ids.csv` for author dictionaries and frozen `PMIDS2.csv` for DOI joins; the displayed `ids` DataFrame does not write either input. Left joins assemble metadata before a relative write to `FEP_ActInf.csv`. -The notebook's module flow: `Bio.Entrez.esearch` collects PMIDs, `efetch` (XML) retrieves abstracts, author lists, and titles, then DataFrame joins attach author counts and DOIs before the final CSV export. Inputs `ids.csv`/`PMIDS2.csv` are read relative to the notebook's working directory. +This mixes live responses and frozen cohorts and can overwrite the archived export. It is a historical flow description, not proof of reproducibility; see the [PubMed warnings](../Literature_Analysis/Pubmed_to_Coda/README.md). ### PDF corpus → keyword counts @@ -65,7 +55,7 @@ manager.py ──► dataImport.py `utilCSV.py` is an unused placeholder. -Keyword normalization: `dataImport.getKws()` lowercases each term and removes spaces, so the effective match set is the 331 normalized keys; duplicate/case-variant source rows are therefore behaviorally irrelevant (the list was deduplicated for readability on 2026-08-02). +`dataImport.normalizeText()` lowercases and removes literal spaces/newlines for keywords, full text, and abstracts. Text is normalized once per document. Counting remains nonoverlapping substring search; normalized-key insertion order determines result columns. Parameter CSV reads occur at import relative to CWD. The recorded 2026-08-02 deduplication remains historical maintenance, not a new measurement. ## Cross-references between areas diff --git a/docs/provenance.md b/docs/provenance.md index 492c5e0..ef41161 100644 --- a/docs/provenance.md +++ b/docs/provenance.md @@ -28,7 +28,7 @@ Outputs of the PubMed query notebook (authored by Bleu Knight, February 2022; co | `FEP_ActInf.csv` | merged export: abstract, authors, num_authors, first_author, title, DOI | 331 rows | | `pubmed_230101.dtd` | PubMed XML DTD snapshot | — | -Caveats: the notebook contains repeated author-unpacking cells and assumes at least 13 author positions in its intermediate DataFrame; it is a historical exploratory artifact, not a maintained library. NCBI results are time-dependent. +Caveats: preserved exploratory source has incomplete structured-abstract extraction, a fourth/tenth-author branch defect, thirteen-position truncation/narrow-frame assumptions, derived count limitations, unguarded missing first-author matches, a six-column final schema, and live/frozen mixing. Its export can overwrite the committed CSV. These risks do not prove particular historical rows were affected. See the [complete preservation warnings](../Literature_Analysis/Pubmed_to_Coda/README.md). Snapshot counts remain dated inventory. ## PDF_Scrape diff --git a/docs/quickstart.md b/docs/quickstart.md index bddea2c..5daad8e 100644 --- a/docs/quickstart.md +++ b/docs/quickstart.md @@ -11,26 +11,15 @@ git clone https://github.com/ActiveInferenceInstitute/Knowledge-Engineering.git cd Knowledge-Engineering ``` -The repository has no runtime dependencies until you run the notebook or the PDF scraper. The data files (CSV, ODS, XLSX, JSON, PNG, ZIP) can be opened directly. +Browsing committed data/Markdown needs no project Python environment. Offline gate contracts and controlled CSV/text regressions use the standard library. Importing scraper modules can read CWD-relative parameters and import the PDF dependency; a real scraper run also needs its local corpus. The notebook has separate Jupyter, pandas, Biopython, network, and research-policy prerequisites. -## 2. Run the PubMed query notebook +## 2. Inspect the historical PubMed notebook -The notebook in `Literature_Analysis/Pubmed_to_Coda/` queries NCBI Entrez for open-access papers whose title/abstract mentions `free energy principle` or `active inference`, then joins author, title, and DOI metadata and writes `FEP_ActInf.csv`. +`Literature_Analysis/Pubmed_to_Coda/Pubmed_Query.ipynb` is preserved exploratory source, not a validated current extraction workflow. Inspect it without executing all cells in this checkout: its export cell can overwrite committed `FEP_ActInf.csv`. -Requirements: Python 3, [Jupyter](https://jupyter.org/), `pandas`, and `biopython` (for `Bio.Entrez`). +Read the [preservation and revival warnings](../Literature_Analysis/Pubmed_to_Coda/README.md) before a separately approved run. Dependencies, an NCBI contact address, and saved inputs do not resolve abstract, author, join, schema, or live/frozen-cohort limitations. The saved 331-record inventory is historical, not a promised rerun result. -```bash -python -m pip install pandas biopython jupyter -jupyter notebook Literature_Analysis/Pubmed_to_Coda/Pubmed_Query.ipynb -``` - -Before running the cells: - -1. Replace every `Entrez.email = 'you@email.com'` line with an address NCBI can use to identify your requests (NCBI requires a contact address on E-utilities traffic). -2. Keep `ids.csv` and `PMIDS2.csv` in the notebook's working directory — they are consumed during the join stage. -3. Execute cells in order. The final cell writes `FEP_ActInf.csv` (331 records in the checked-in export). - -Notes: PubMed results change over time, so a fresh run will differ from the committed snapshot. Record your query date and any changed filters alongside the new export. +Revival requires research-owner decisions on cohort, missing data, complete author extraction, output schema, provenance, and a non-overwriting destination. ## 3. Run the PDF keyword extractor @@ -51,9 +40,9 @@ cd Literature_Analysis/PDF_Scrape python manager.py ``` -The script prompts for a callsign/ID, then writes `-Results.csv` and `-Log.csv` in the current directory. Importing the modules without running `manager.py` is safe — nothing executes at import time. +The script requests a callsign only when export configuration is first needed. Importing modules does not start a batch or create exports, but `dataImport.py` reads parameter CSVs during import and the manager imports its PDF-reader dependency. Prepare CWD-relative inputs deliberately. -Caveats: keyword counting is substring-based after lowercasing and removing spaces, so short terms can match inside larger words; every per-paper failure is recorded in the log with its exception message. +See the [PDF area guide](../Literature_Analysis/PDF_Scrape/README.md) for normalization, continuation, failure status, CSV logging, and callsign truncation. Controlled regressions do not establish real-corpus or scientific correctness. ## Where outputs land @@ -62,4 +51,4 @@ Caveats: keyword counting is substring-based after lowercasing and removing spac | PubMed notebook | `FEP_ActInf.csv` | `Literature_Analysis/Pubmed_to_Coda/` | | PDF keyword extractor | `-Results.csv`, `-Log.csv` | current working directory at run time | -Both output files are gitignored so they cannot be committed accidentally. +Ignore rules cover scraper `*-Results.csv`/`*-Log.csv` only under `Literature_Analysis/PDF_Scrape/`, not arbitrary workspaces. PubMed `FEP_ActInf.csv` is tracked historical data; ignore rules do not protect it from overwrite. Use a separate destination for approved new research. diff --git a/docs/workflows/publishing.md b/docs/workflows/publishing.md index d088458..64d2a71 100644 --- a/docs/workflows/publishing.md +++ b/docs/workflows/publishing.md @@ -31,9 +31,6 @@ identity.py 847328ff163fa90c869495164869caf4e83313748e8a444dbab8d4e459b11074 gnn-pin.json 4e4a455875c7afdf21312d4de1bce6d6695c48dea01d90d6132e2545b14ba276 ``` -The `links` arm invokes the canonical module's `--verify-copy` command for every -artifact above. `archive`, `fast`, and `full` include that check. Gate tests prove -that matching copies pass and changed copies fail. Checks are offline and -stdlib-only; no JSON Schema package, journal corpus, or fabricated record data is -required. These checks prove artifact agreement, not identity coverage of the -historical research exports. +The `links` arm invokes the recorded module's `--verify-copy` for every artifact above; `archive`, `fast`, and `full` include it. This offline standard-library check establishes agreement with the local digest block. It neither fetches/authenticates the producer nor establishes upstream freshness or historical-corpus identity coverage. + +Do not independently edit borrowed checker/schema bytes. Adoption of repaired upstream logic requires its qualified immutable revision, complete approved artifact roster, exact bytes, and authoritative digests; update copies and the member contract together. A dirty producer base plus new working-tree bytes is not an immutable release. This member's GNN pin remains locally owned. Do not fabricate publishing records for archived research exports. From 341919c7553419ce0c66859abaee2ea6c20e0609 Mon Sep 17 00:00:00 2001 From: Daniel Ari Friedman <6911384+docxology@users.noreply.github.com> Date: Mon, 16 Nov 2026 21:26:05 -0800 Subject: [PATCH 2/2] test: keep historical pin outside current approval - Preserve every refusal and installer-not-called assertion while using a genuinely different released identity for the current v5.1.0 guard. --- .github/scripts/tests/test_gnn_runtime.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/scripts/tests/test_gnn_runtime.py b/.github/scripts/tests/test_gnn_runtime.py index 660ee8d..52c9271 100644 --- a/.github/scripts/tests/test_gnn_runtime.py +++ b/.github/scripts/tests/test_gnn_runtime.py @@ -555,7 +555,8 @@ def test_bad_authority_and_unapproved_pin_precede_any_installation(self) -> None self.assertIn("manifest-digest-mismatch", stderr) installer.assert_not_called() self.manifest_path.write_bytes(self.manifest_bytes) - pin = {**PIN, "tag": "v5.1.0", "revision": "75c834bd8519dc7b5adc4d24f16bf393cfd1ecdf"} + # A valid historical release is not this checkout's approved pin. + pin = {**PIN, "tag": "v5.0.3", "revision": "8f293d9ba810e6eda5c09842d9c7ed9ffa5f92c1"} (self.root / gnn_conformance.PIN_PATH).write_text(json.dumps(pin), encoding="utf-8") code, stdout, stderr = self._run(["gnn", "--install"]) self.assertNotEqual(code, 0)