tablassert 10.0.0__tar.gz → 11.0.0__tar.gz

{tablassert-10.0.0 → tablassert-11.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tablassert
-Version: 10.0.0
+Version: 11.0.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
@@ -99,15 +99,31 @@ template:
     - { annotation: supporting_study_size, method: column, encoding: D }
 ```
 
-Wrap it in a graph config (`graph.yaml`) pointing at your fullmap entity-resolution database:
+Wrap it in a graph config (`graph.yaml`) pointing at your fullmap entity-resolution database
+and carrying the required `rig:` metadata for the generated Resource Ingest Guide:
 
 ```yaml
 name: MY_KG
 version: 1.0.0
-description: Gene–disease associations extracted from tabular sources.
 tables:
   - ./table.yaml
 fullmap: /path/to/fullmap
+rig:
+  source_info:
+    infores_id: infores:my-kg
+    terms_of_use_info:
+      terms_of_use_url: https://example.org/terms
+    data_access_locations:
+      - My source downloads - https://example.org/downloads
+    source_status: maintained_regular_updates
+  ingest_info:
+    utility: Gene-disease associations support Translator disease-mechanism queries.
+    scope: Gene-disease associations extracted from tabular sources.
+  provenance_info:
+    contributions:
+      - "Author Name - code author, data modeling"
+  artifact_base_url: https://example.org/my-kg
+  artifact_base_path: ./published/my-kg
 ```
 
 Build the knowledge graph:

{tablassert-10.0.0 → tablassert-11.0.0}/README.md

@@ -44,15 +44,31 @@ template:
     - { annotation: supporting_study_size, method: column, encoding: D }
 ```
 
-Wrap it in a graph config (`graph.yaml`) pointing at your fullmap entity-resolution database:
+Wrap it in a graph config (`graph.yaml`) pointing at your fullmap entity-resolution database
+and carrying the required `rig:` metadata for the generated Resource Ingest Guide:
 
 ```yaml
 name: MY_KG
 version: 1.0.0
-description: Gene–disease associations extracted from tabular sources.
 tables:
   - ./table.yaml
 fullmap: /path/to/fullmap
+rig:
+  source_info:
+    infores_id: infores:my-kg
+    terms_of_use_info:
+      terms_of_use_url: https://example.org/terms
+    data_access_locations:
+      - My source downloads - https://example.org/downloads
+    source_status: maintained_regular_updates
+  ingest_info:
+    utility: Gene-disease associations support Translator disease-mechanism queries.
+    scope: Gene-disease associations extracted from tabular sources.
+  provenance_info:
+    contributions:
+      - "Author Name - code author, data modeling"
+  artifact_base_url: https://example.org/my-kg
+  artifact_base_path: ./published/my-kg
 ```
 
 Build the knowledge graph:

{tablassert-10.0.0 → tablassert-11.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tablassert"
-version = "10.0.0"
+version = "11.0.0"
 description = "Extract knowledge assertions from tabular data into NCATS Translator-compliant KGX NDJSON — declaratively, with entity resolution and quality control built in."
 authors = [
     { name = "Skye Lane Goetz", email = "sgoetz@isbscience.org" }
@@ -96,17 +96,35 @@ optimize = [
 ]
 
 [dependency-groups]
-dev = [
-    "mkdocs>=1.6.1",
-    "mkdocs-material>=9.6.0",
+test = [
     "maturin>=1.10,<2.0",
-    "pre-commit>=4.5.1",
-    "pyright>=1.1.411",
     "pytest>=9.0.2",
     "pytest-cov>=7.1.0",
-    "ruff>=0.15.6",
     "pytest-xdist>=3.8.0",
 ]
+typecheck = [
+    "pyright>=1.1.411",
+]
+docs = [
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.6.0",
+]
+# The EXACT set both CI Python jobs install. Keeping `python-type` and `python-test` on one
+# identical sync is deliberate: `astral-sh/setup-uv` keys its cache on the lockfile, so jobs
+# with different dependency sets race to save a cache the others then restore and miss on.
+# One shared set means one genuinely warm cache. Excludes docs/pre-commit/ruff, which no CI
+# job that syncs needs (lint runs ruff standalone; docs uses `--group docs`).
+ci = [
+    { include-group = "test" },
+    { include-group = "typecheck" },
+]
+# Superset for local development, so `make setup` still installs everything.
+dev = [
+    { include-group = "ci" },
+    { include-group = "docs" },
+    "pre-commit>=4.5.1",
+    "ruff>=0.15.6",
+]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/agent.py

@@ -1313,12 +1313,34 @@ def build_and_audit(
         table_cfg: dict[str, object] = data if ("template" in data or "sections" in data) else {"template": data}
 
         (root / "table.yaml").write_text(yaml.safe_dump(table_cfg, sort_keys=False))
+        # The measurement build still emits a RIG (every build does), so it carries an
+        # honest minimal rig block: the agent only mines PMC open-access tables, and the
+        # artifacts live in this throwaway workdir (file:// base = unpublished).
+        resolved_root: str = str(root.resolve())
         graph_cfg: dict[str, object] = {
             "name": name,
             "version": version,
-            "description": f"Agent-built graph for {name}",
             "tables": ["table.yaml"],  # relative to workdir (the pipelines chdir there)
             "fullmap": str(fullmap),
+            "rig": {
+                "source_info": {
+                    "infores_id": f"infores:{name.lower().replace('_', '-')}",
+                    "name": f"Agent-built measurement graph {name}",
+                    "terms_of_use_info": {
+                        "terms_of_use_url": "https://pmc.ncbi.nlm.nih.gov/about/copyright/",
+                        "terms_of_use_description": "PubMed Central open-access supplementary table; individual article licenses apply.",
+                    },
+                    "data_access_locations": ["PubMed Central - https://pmc.ncbi.nlm.nih.gov/"],
+                    "source_status": "unknown",
+                },
+                "ingest_info": {
+                    "utility": f"Transient measurement graph used to score agent-derived table configs for {name}.",
+                    "scope": "Associations mined from one PMC supplementary table config under audit.",
+                },
+                "provenance_info": {"contributions": ["Tablassert agent: automated config derivation and measurement build"]},
+                "artifact_base_url": f"file://{resolved_root}",
+                "artifact_base_path": resolved_root,
+            },
         }
         (root / "graph.yaml").write_text(yaml.safe_dump(graph_cfg, sort_keys=False))
 
@@ -2153,9 +2175,12 @@ section choose column-letter encodings for entity columns and literal CURIEs for
 pick a predicate the subject/object pair actually permits (see BIOLINK MODELING below); add
 statistical annotations (p_value / effect_size / effect_type) when that table has them —
 method: column for table-provided columns, method: value for a fixed valid value (e.g.
-effect_type: spearmans_rho when every row is a Spearman correlation). Emit effect_type ONLY
-alongside an effect_size annotation: the pipeline nulls an effect_type without a numeric
-effect_size. A single-table article is still ONE config with ONE section.
+effect_type: spearmans_rho when every row is a Spearman correlation). effect_size and effect_type
+are MANDATORY AS A PAIR: either one without the other is a hard validation error that bounces your
+final answer, so a table with an effect-size column also needs its effect_type (method: value when
+every row shares one statistic). Alias spellings count — `odds ratio` and the legacy
+`relationship_strength` both coerce to effect_size. A single-table article is still ONE config with
+ONE section.
 
 # BIOLINK MODELING (the pipeline enforces these SILENTLY — violating them costs you score)
 The build derives each edge's association CLASS from the (subject category, object category)

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/cli.py

@@ -121,13 +121,15 @@ def build_pipeline(
     """Build a knowledge graph from a YAML configuration file.
 
     Runs the six-stage build pipeline: load tables → extract sections → build
-    Tcodes → collect instructions → build subgraphs → compile graph.
+    Tcodes → collect instructions → build subgraphs → compile graph. With ``qc``
+    enabled a seventh stage studies the final NDJSON files.
 
     Args:
         configuration_file: Path to the graph YAML file.
         progress: Pipeline progress reporter.
         release: When ``True``, emit release-mode artifacts.
-        qc: When ``True``, run quality-control audits on each section.
+        qc: When ``True``, run quality-control audits on each section and assert
+            over the final NDJSON files (failing the build on any violation).
         log: When ``True``, enable per-section verbose logging.
         head: When ``True``, preview a random sample of up to 5 rows per section (fast schema/shape check).
 
@@ -166,6 +168,12 @@ def build_pipeline(
             advance()
     sections: list[dict[str, Any]] = list(chain.from_iterable(temp))
     n: int = len(sections)
+    # Per-section source descriptors for the generated RIG's relevant-file cross-check:
+    # each entry records the section's local file name and its validated source URLs.
+    section_sources: list[dict[str, Any]] = []
+    for s in sections:
+        src: dict[str, Any] = s.get("source") or {}
+        section_sources.append({"local": str(src.get("local") or ""), "urls": [str(u) for u in src.get("url") or []]})
 
     # Stage 3/6: build Tcode.
     progress.stage("Building TCode")
@@ -179,7 +187,16 @@ def build_pipeline(
         try:
             tcode.append(
                 Tcode.model_validate(
-                    {**s, "store": store, "log": log, "qc": qc, "release": release, "head": head, "name": g.name, "infores": g.infores}
+                    {
+                        **s,
+                        "store": store,
+                        "log": log,
+                        "qc": qc,
+                        "release": release,
+                        "head": head,
+                        "name": g.name,
+                        "infores": g.rig.source_info.infores_id,
+                    }
                 )
             )
         except pydantic.ValidationError as e:
@@ -214,13 +231,39 @@ def build_pipeline(
     start(f"{g.name} · v{g.version}")
     # on_phase drives the phase tag (scan → normalize → write-nodes → write-edges → dedup → rig);
     # on_subgraph ticks the bar once per subgraph, so the total is len(subgraphs).
-    compile_graph(
-        subgraphs, g.name, g.version, g.description, g.contributions, g.ui_explanation, g.tables, g.infores, on_phase=sub_step, on_subgraph=advance
-    )
+    compile_graph(subgraphs, g.name, g.version, g.rig, section_sources, on_phase=sub_step, on_subgraph=advance)
+
+    # Stage 7/7 (only with --qc): assert over the final NDJSON files.
+    if qc:
+        progress.stage("Studying Graph")
+        study_final_ndjson(g.name, g.version, Path(g.rig.artifact_base_path))
 
     logger.info("Built graph {name} v{version}: {n} sections", name=g.name, version=g.version, n=n)
 
 
+def study_final_ndjson(name: str, version: str, out_dir: Path) -> None:
+    """Run study assertions over a build's final NDJSON files (the ``--qc`` stage 7).
+
+    Args:
+        name: Graph name, used to locate ``<name>_<version>.nodes.ndjson``.
+        version: Graph version, used to locate ``<name>_<version>.edges.ndjson``.
+        out_dir: Artifact directory the build wrote into
+            (``rig.artifact_base_path``).
+
+    Raises:
+        SystemExit: With status 1 when any study assertion is violated.
+    """
+    from tablassert.study import format_violations, study_kgx
+
+    violations = study_kgx(out_dir / f"{name}_{version}.nodes.ndjson", out_dir / f"{name}_{version}.edges.ndjson")
+    if violations:
+        summary: str = format_violations(violations)
+        print(summary, file=sys.stderr)
+        logger.warning("study assertions failed on final NDJSON:\n{summary}", summary=summary)
+        raise SystemExit(1)
+    logger.info("study assertions passed on final NDJSON")
+
+
 def validate_pipeline(table_configuration_file: Path, progress: PipelineProgress) -> None:
     """Validate section syntax from a YAML configuration file.
 
@@ -599,11 +642,14 @@ def build_kg(
 
     ``--qc`` requires the ``[qc]`` extra (``pip install "tablassert[qc]"``); it is
     checked before the build starts, because the audit stage runs LAST and a missing
-    extra would otherwise surface only after entity resolution has finished.
+    extra would otherwise surface only after entity resolution has finished. It also
+    runs a final study stage that asserts over the emitted NDJSON -- no duplicate node
+    ids, no undeclared or isolated nodes, no malformed lines or stray whitespace --
+    and fails the build (non-zero exit) when any assertion is violated.
     """
     if qc:
         extras.require("qc", required_by="--qc")
-    run(6, build_pipeline, graph_configuration_file, release=release, qc=qc, log=log, head=head)
+    run(7 if qc else 6, build_pipeline, graph_configuration_file, release=release, qc=qc, log=log, head=head)
 
 
 @APP.command(name="validate")
@@ -950,7 +996,7 @@ def _prebuilt_fullmap_urls(babel_version: str) -> tuple[str, str]:
 
     RENCI publishes a prebuilt ``fullmap.tar.zst`` (and a ``sha256sum.txt``) under
     ``{BABEL_BASE}/{babel_version}/fullmap/{tablassert_version}/``, where the version
-    directory is the INSTALLED Tablassert package version (e.g. ``10.0.0``) — resolved from
+    directory is the INSTALLED Tablassert package version (e.g. ``10.1.0``) — resolved from
     installed-package metadata, never hardcoded, so a new release looks itself up.
 
     Args:

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/coerce.py

@@ -523,6 +523,26 @@ def effect_size_target(name: str) -> str | None:
     return None
 
 
+def coerced_target(name: str) -> str:
+    """Map a column/annotation name to the canonical name the clean phase renames it to.
+
+    Args:
+        name: Raw source column or annotation name.
+
+    Returns:
+        The canonical slot name a ``coerce_*_columns`` op would rename ``name``
+        to, or ``name`` unchanged when no coercion claims it.
+
+    Notes:
+        Classifier order mirrors the op order in ``Tcode._source_ops``:
+        ``coerce_pvalue_columns`` runs first, so a p/q-value alias is claimed
+        before the study-size and effect classifiers ever see it. Config-time
+        validators judge this target rather than the raw name so they see a
+        name exactly as the build will.
+    """
+    return pvalue_target(name) or study_size_target(name) or effect_size_target(name) or effect_type_target(name) or name
+
+
 def coerce_effect_size_columns(lf: pl.LazyFrame) -> pl.LazyFrame:
     """Rename effect-size-like columns to Biolink KGX-compliant ``effect_size`` (Biolink PR #1774).
 

tablassert-11.0.0/src/tablassert/enums.py

@@ -0,0 +1,131 @@
+"""Tablassert configuration enums (non-Biolink).
+
+These enums describe Tablassert's own configuration vocabulary (source kinds,
+comparison operators, encoding/fill methods, contribution labels, and so on).
+
+The Biolink Model vocabulary -- ``Categories``, ``Predicates``, ``Qualifiers``,
+``KnowledgeLevels``, ``AgentTypes``, ``EdgeCategories``, and
+``ALLOWED_EDGE_FIELDS`` -- is derived from the ``biolink-model`` package and lives
+in :mod:`tablassert.biolink`. Import those from there.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Tokens(str, Enum):
+    AUTO = "auto"
+    VALUES = "values"
+
+
+class Repositories(str, Enum):
+    PUBMED_CENTRAL = "PMC"
+    PUBMED = "PMID"
+
+
+class InformationResources(str, Enum):
+    PUBMED = "infores:pubmed"
+    PUBMED_CENTRAL = "infores:pubmed-central"
+
+
+class Contributions(str, Enum):
+    CURATION = "curation"
+    VALIDATION = "validation"
+    TOOL = "tool"
+
+
+class Comparisons(str, Enum):
+    GT = "gt"
+    GE = "ge"
+    LT = "lt"
+    LE = "le"
+    EQ = "eq"
+    NE = "ne"
+
+
+class Functions(str, Enum):
+    COPYSIGN = "copysign"
+    POW = "pow"
+
+
+class Files(str, Enum):
+    TEXT = "text"
+    EXCEL = "excel"
+
+
+class EncodingMethods(str, Enum):
+    VALUE = "value"
+    COLUMN = "column"
+
+
+class FillMethods(str, Enum):
+    FORWARD = "forward"
+    BACKWARD = "backward"
+    MIN = "min"
+    MAX = "max"
+    MEAN = "mean"
+    ZERO = "zero"
+    ONE = "one"
+
+
+# --- Resource Ingest Guide vocabularies ------------------------------------ #
+# These mirror the enums declared by the released RIG schema
+# (biolink/resource-ingest-guide-schema), so a generated `.RIG.yaml` can only
+# carry values the upstream validator accepts.
+
+
+class SourceStatuses(str, Enum):
+    MAINTAINED_REGULAR_UPDATES = "maintained_regular_updates"
+    MAINTAINED_AS_NEEDED_UPDATES = "maintained_as_needed_updates"
+    NOT_MAINTAINED = "not_maintained"
+    UNKNOWN = "unknown"
+
+
+class ProvisionMechanisms(str, Enum):
+    FILE_DOWNLOAD = "file_download"
+    API_ENDPOINT = "api_endpoint"
+    DATABASE_DUMP = "database_dump"
+    OTHER = "other"
+
+
+class DataFormats(str, Enum):
+    TSV = "tsv"
+    XML = "xml"
+    CSV = "csv"
+    JSON = "json"
+    YAML = "yaml"
+    OBO = "obo"
+    PROTOBUFF = "protobuff"
+    KGX = "kgx"
+    MYSQL = "mysql"
+    POSTGRESQL = "postgresql"
+    SQLITE = "sqlite"
+    OTHER = "other"
+
+
+class IngestCategories(str, Enum):
+    PRIMARY_KNOWLEDGE_PROVIDER = "primary_knowledge_provider"
+    AGGREGATION_PROVIDER = "aggregation_provider"
+    AGGREGATION_INTERPRETER = "aggregation_interpreter"
+    SUPPORTING_DATA_PROVIDER = "supporting_data_provider"
+    TRANSLATOR_KNOWLEDGE_CREATOR = "translator_knowledge_creator"
+    ONTOLOGY_PROVIDER = "ontology_provider"
+    NODE_PROPERTY_ONLY_PROVIDER = "node_property_only_provider"
+    OTHER = "other"
+
+
+class ContentCategories(str, Enum):
+    EDGE_CONTENT = "edge_content"
+    NODE_PROPERTY_CONTENT = "node_property_content"
+    EDGE_PROPERTY_CONTENT = "edge_property_content"
+    OTHER = "other"
+
+
+class ModelingCategories(str, Enum):
+    SPOQ_PATTERN = "spoq_pattern"
+    PREDICATES = "predicates"
+    QUALIFIERS = "qualifiers"
+    EDGE_PROPERTIES = "edge_properties"
+    NODE_PROPERTIES = "node_properties"
+    OTHER = "other"

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/errors.py

@@ -12,6 +12,7 @@ TablassertErrorCodes = Literal[
     "graph-validation-failed",
     "section-validation-failed",
     "babel-download-failed",
+    "resolve-bad-specs",
     "config-rows-and-row-slice-conflict",
     "comparison-bad-comparator-type",
     "comparison-nonnumeric-comparator",
@@ -28,10 +29,19 @@ TablassertErrorCodes = Literal[
     "encoding-list-method-removed",
     "annotation-split-by-requires-column",
     "annotation-split-by-empty",
+    "annotation-effect-size-without-type",
+    "annotation-effect-type-without-size",
     "qualifier-auto-derived",
     "qualifier-bad-value",
     "qualifier-unsatisfiable",
     "qualifier-nullable-literal",
+    "qualifier-duplicated",
+    "rig-bad-infores",
+    "rig-bad-artifact-url",
+    "rig-bad-access-location",
+    "rig-terms-empty",
+    "rig-legacy-keys",
+    "rig-validation-failed",
 ]
 
 

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/fullmap.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any, NamedTuple, cast
 from tablassert import rs
 from tablassert._lazy import LazyModule
 from tablassert.biolink import Categories
+from tablassert.errors import TablassertError
 from tablassert.log import cat
 
 logger = cat("FULLMAP")
@@ -575,12 +576,46 @@ def resolve_batch(
 
     Returns:
         LazyFrame with resolved columns added.
+
+    Raises:
+        TablassertError: ``resolve-bad-specs`` when two specs share a column, or a
+            spec's column or its ``<col> + tag`` normalization column is absent from
+            the input schema. Checked schema-only (no ``collect``) before any term
+            extraction or redb access, so bad specs never surface mid-build as a raw
+            polars ``ColumnNotFoundError``.
     """
     # Each column still gets its own taxon/prioritize/avoid filtering and its own join back into lf;
     # only the redb round trip itself (rs.lookup_fullmap_terms) is pooled across columns.
     if not specs:
         return lf
 
+    # Fail loudly on malformed specs BEFORE term collection or any redb access. A duplicated
+    # spec would otherwise die mid-build in its second join_matches pass (the first pass drops
+    # <col> + tag, so the second spec's level-two join hits a raw polars ColumnNotFoundError),
+    # and a spec whose normalization columns were never produced would crash distinct().
+    seen: set[str] = set()
+    duplicates: list[str] = []
+    for spec in specs:
+        if spec.col in seen and spec.col not in duplicates:
+            duplicates.append(spec.col)
+        seen.add(spec.col)
+    if duplicates:
+        raise TablassertError(
+            f"resolve_batch received more than one ResolveSpec for column(s) {', '.join(repr(col) for col in duplicates)}; "
+            "each node column may be resolved at most once per batch.",
+            code="resolve-bad-specs",
+        )
+
+    schema: pl.Schema = lf.collect_schema()
+    missing: list[tuple[str, str]] = [(name, spec.col) for spec in specs for name in (spec.col, spec.col + tag) if name not in schema]
+    if missing:
+        detail: str = ", ".join(f"{name!r} (needed by the spec for {col!r})" for name, col in missing)
+        raise TablassertError(
+            f"resolve_batch specs reference column(s) absent from the input schema: {detail}. This usually means a node "
+            "encoding was declared twice or against the wrong column, so its normalization columns were never produced.",
+            code="resolve-bad-specs",
+        )
+
     terms_by_col: dict[str, pl.LazyFrame] = {spec.col: distinct(lf, spec.col, spec.col + tag) for spec in specs}
     collected_terms: dict[str, pl.DataFrame] = {col: terms.collect() for col, terms in terms_by_col.items()}
 

{tablassert-10.0.0 → tablassert-11.0.0}/src/tablassert/graph_registry.py

@@ -36,11 +36,42 @@ TMP_NAME: str = f"{GRAPH_YAML}.tmp"
 CORRUPT_PREFIX: str = f"{GRAPH_YAML}.corrupt-"
 GRAPH_NAME: str = "tablassert-agent"
 GRAPH_VERSION: str = "1"
-GRAPH_DESCRIPTION: str = "Aggregate graph of agent-built PMC table configs"
 #: Record statuses whose best config self-registers (both are SUCCESSFUL builds).
 REGISTERED_STATUSES: frozenset[str] = frozenset({"MAPPED", "BUILT_UNMEASURED"})
 
 
+def _registry_rig(state_dir: Path) -> dict[str, Any]:
+    """The honest ``rig:`` block for the aggregate agent registry graph.
+
+    Every fact here is mechanical: the agent only mines PubMed Central
+    open-access supplementary tables, so source terms/access describe PMC, and
+    the artifact bases point at the state directory itself (a ``file://`` base
+    is a valid unpublished URI; swap it for a public https base before sending
+    the generated RIG anywhere).
+    """
+    resolved: str = str(state_dir.resolve())
+    return {
+        "source_info": {
+            "infores_id": "infores:tablassert-agent",
+            "name": "PubMed Central open-access supplementary tables",
+            "description": "Aggregate of tabular associations mined from PubMed Central open-access supplementary files by the Tablassert agent.",
+            "terms_of_use_info": {
+                "terms_of_use_url": "https://pmc.ncbi.nlm.nih.gov/about/copyright/",
+                "terms_of_use_description": "PubMed Central open-access subset; individual article licenses apply.",
+            },
+            "data_access_locations": ["PubMed Central - https://pmc.ncbi.nlm.nih.gov/"],
+            "source_status": "unknown",
+        },
+        "ingest_info": {
+            "utility": "Aggregates agent-derived tabular knowledge assertions for Translator-style querying.",
+            "scope": "All agent-built table configs registered under this state directory.",
+        },
+        "provenance_info": {"contributions": ["Tablassert agent: automated config derivation and build"]},
+        "artifact_base_url": f"file://{resolved}",
+        "artifact_base_path": resolved,
+    }
+
+
 @contextlib.contextmanager
 def _registry_lock(state_dir: Path) -> Iterator[None]:
     """Hold an EXCLUSIVE ``flock`` on ``<state_dir>/graph.yaml.lock`` (created if missing).
@@ -58,9 +89,9 @@ def _registry_lock(state_dir: Path) -> Iterator[None]:
             fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
 
 
-def _fresh_doc() -> dict[str, Any]:
+def _fresh_doc(state_dir: Path) -> dict[str, Any]:
     """A brand-new registry document (``_apply_fullmap`` fills the first-wins ``fullmap``)."""
-    return {"name": GRAPH_NAME, "version": GRAPH_VERSION, "description": GRAPH_DESCRIPTION, "tables": []}
+    return {"name": GRAPH_NAME, "version": GRAPH_VERSION, "tables": [], "rig": _registry_rig(state_dir)}
 
 
 def _quarantine(state_dir: Path, reason: str) -> Path:
@@ -85,20 +116,20 @@ def _load_registry(state_dir: Path) -> dict[str, Any]:
     """
     path: Path = state_dir / GRAPH_YAML
     if not path.is_file():
-        return _fresh_doc()
+        return _fresh_doc(state_dir)
     try:
         data: object = yaml.safe_load(path.read_text(encoding="utf-8"))
     except yaml.YAMLError as exc:
         _quarantine(state_dir, f"YAML parse error: {exc}")
-        return _fresh_doc()
+        return _fresh_doc(state_dir)
     if not isinstance(data, dict):
         _quarantine(state_dir, f"top level is not a mapping (got {type(data).__name__})")
-        return _fresh_doc()
+        return _fresh_doc(state_dir)
     try:
         Graph.model_validate(data)
     except pydantic.ValidationError as exc:
         _quarantine(state_dir, f"fails Graph.model_validate ({len(exc.errors())} error(s))")
-        return _fresh_doc()
+        return _fresh_doc(state_dir)
     return data