mostlyright-data 0.9.8__tar.gz → 0.9.10__tar.gz

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.9.8
+Version: 0.9.10
 Summary: Mostly Right CLI for reproducible, reviewed Parquet datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.9.8"
+version = "0.9.10"
 description = "Mostly Right CLI for reproducible, reviewed Parquet datasets"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/local_contracts.py

@@ -730,15 +730,8 @@ class SourceProposal(_CanonicalContract):
             (item.uri, item.observed_at, item.content_sha256) for item in self.evidence
         )
         _require_unique(evidence_keys, "source_proposal.evidence")
-        if self.fitness_decision == "selected" and self.rights_status not in {
-            "approved",
-            "conditional",
-        }:
-            raise ContractError(
-                "source_proposal.rights_status",
-                "RIGHTS_NOT_SELECTABLE",
-                "selected proposals require approved or conditional rights",
-            )
+        # Any rights status may be selected: the status is recorded on the proposal for the
+        # dataset's consumer to judge, never used to refuse the selection itself.
         if self.fitness_decision == "selected" and self.live_endpoint in {"dead", "delayed"}:
             raise ContractError(
                 "source_proposal.live_endpoint",

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/pipeline.py

@@ -1231,6 +1231,11 @@ def classify_plan_sources_before_persistence(
         "project_owned": "internal",
         "authorized_internal": "restricted",
         "user_authorized": "restricted",
+        # Rights are recorded, never a gate: an unknown or prohibited rights basis still
+        # builds, classified restricted -- the cautious end of the classification axis --
+        # with the status itself carried on the governance record for its consumer to judge.
+        "unknown": "restricted",
+        "prohibited": "restricted",
     }
     evidence: dict[str, dict[str, str]] = {}
     for source in sorted(plan.sources, key=lambda item: item.source_id):
@@ -2021,10 +2026,9 @@ def _visual_source_summary(
     parse produced.
     """
 
-    public_values = (
-        source.rights.status in {"public_domain", "permissive_license"}
-        and governance["classification"] == "public"
-    )
+    # Value display keys off data classification alone; the licence is recorded on the source
+    # for its consumer to judge, never used to withhold the user's own data from them.
+    public_values = governance["classification"] == "public"
     null_counts = {column: null_counts[column] for column in columns}
     sample = []
     if public_values:
@@ -2198,8 +2202,7 @@ def _replay_graph_derivations(
     display = (
         "full"
         if all(
-            source.rights.status in {"public_domain", "permissive_license"}
-            and exact_governance[source.source_id]["classification"] == "public"
+            exact_governance[source.source_id]["classification"] == "public"
             for source in plan.sources
         )
         else "schema_only"
@@ -2563,8 +2566,7 @@ def _replay_candidate_derivations(
     visual_display = (
         "full"
         if all(
-            source.rights.status in {"public_domain", "permissive_license"}
-            and exact_governance[source.source_id]["classification"] == "public"
+            exact_governance[source.source_id]["classification"] == "public"
             for source in plan.sources
         )
         else "schema_only"
@@ -4323,17 +4325,14 @@ def _require_stable_candidate_observation(
 
 
 def _validate_rights(plan: TablePlan) -> None:
-    for source in plan.sources:
-        if source.rights.status in {"unknown", "prohibited"}:
-            raise BuildError(
-                "RIGHTS_BLOCKED",
-                f"source {source.source_id!r} rights status is {source.rights.status!r}",
-            )
-        if plan.output_intent not in source.rights.permissions:
-            raise BuildError(
-                "RIGHTS_PERMISSION_MISSING",
-                f"source {source.source_id!r} does not permit {plan.output_intent!r}",
-            )
+    """Formerly the build-time rights gate; now a recording point kept for its call sites.
+
+    Licensing is recorded, never enforced: every source's rights status and permissions are
+    already carried on the plan and into the build's governance record, and the consumer of
+    the output judges them. Unknown, prohibited, and intent-mismatched rights all build.
+    """
+
+    del plan
 
 
 def _validate_root_separation(input_root: Path, output: Path) -> None:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/catalog/delta.py

@@ -262,17 +262,18 @@ def classify_catalog_delta(
     rights_decisions: Mapping[str, RightsDecision] | None = None,
     rights_decisions_sha256: str | None = None,
 ) -> CatalogDeltaClassification:
-    """Partition a complete fill into unchanged, changed, new, absent, and flagged facts.
+    """Partition a complete fill into unchanged, changed, new, and absent facts.
 
-    ``candidates_by_record_id`` contains authored, unsealed entries for every non-flagged provider
-    record. ``predecessor_record_ids`` preserves the explicit provider-to-Harness identity chosen
+    ``candidates_by_record_id`` contains authored, unsealed entries for every provider record.
+    ``predecessor_record_ids`` preserves the explicit provider-to-Harness identity chosen
     when the predecessor was authored.  Neither map is inferred from publisher text.
 
-    ``rights_decisions`` is the queue's one exit. Each decision must name a record the queue
-    holds and bind the exact bytes the person decided against; a cleared record leaves the
-    queue and demands a candidate whose rights are exactly the decided rights, and a
-    prohibited record stays out of admission carrying the decision, so the queue
-    distinguishes "nobody has looked" from "somebody looked and said no".
+    ``rights_decisions`` enriches the record it names: each decision must name a record this
+    fill observed and bind the exact bytes the person decided against, and the candidate for
+    that record must carry exactly the decided rights. Rights never hold a record out of
+    admission -- the decided status, whatever it says, is recorded on the admitted entry for
+    the dataset's consumer to judge. The ``flagged`` partition is always empty for a new
+    classification and survives only so older published generations still parse.
     """
 
     previous_by_id, chains = _validate_predecessor(
@@ -285,7 +286,6 @@ def classify_catalog_delta(
     decisions = dict(rights_decisions or {})
     if decisions:
         _validate_mapping(decisions, "rights_decisions")
-    prohibited_ids: set[str] = set()
     for record_id in sorted(decisions):
         decision = decisions[record_id]
         if not isinstance(decision, RightsDecision):
@@ -314,68 +314,35 @@ def classify_catalog_delta(
                 "decision is about one spelling of the facts, so a person must decide "
                 "again against the current facts",
             )
-        staged = staged_flagged.get(record_id)
-        if decision.cleared:
-            if staged is None:
-                raise CatalogDeltaError(
-                    "CATALOG_RIGHTS_DECISION_TARGET",
-                    f"delta.rights_decisions.{record_id}",
-                    "names a record the rights queue does not hold; the provider states "
-                    "its own licence, so there is nothing left for a clearance to clear",
-                )
-            if staged.rights_status == "prohibited":
-                raise CatalogDeltaError(
-                    "CATALOG_RIGHTS_DECISION_OVERRULE",
-                    f"delta.rights_decisions.{record_id}",
-                    "the provider's own licence prohibits reuse; a decision may clear "
-                    "silence, never overrule a provider's explicit no",
-                )
-        else:
-            # A person's no outranks a provider's yes, so a prohibiting decision holds
-            # whether or not the provider's own licence would have admitted the record.
-            prohibited_ids.add(record_id)
-    cleared_ids = {record_id for record_id, item in decisions.items() if item.cleared}
-
     _validate_mapping(candidates_by_record_id, "candidates_by_record_id")
     candidate_keys = set(candidates_by_record_id)
-    required_candidate_keys = (
-        (set(records_by_id) - set(staged_flagged)) | cleared_ids
-    ) - prohibited_ids
-    if candidate_keys != required_candidate_keys:
+    # Rights never hold a record out of admission any more. New fills flag nothing, so every
+    # record demands a candidate. An older fill's staged queue is honoured transitionally: its
+    # records do not *require* a candidate (their authoring documents never held one), but a
+    # candidate MAY now be authored for them, and authoring one admits the record and retires
+    # it from the queue. A decision only replaces the rights the candidate carries.
+    required_candidate_keys = set(records_by_id) - set(staged_flagged)
+    if not (required_candidate_keys <= candidate_keys <= set(records_by_id)):
         raise CatalogDeltaError(
             "CATALOG_DELTA_CANDIDATE_MAPPING",
             "delta.candidates_by_record_id",
-            "must name exactly every current provider record not held by the rights queue, "
-            "plus every record a decision cleared out of it, minus every record a decision "
-            "prohibits; "
+            "must name every current provider record outside the staged queue, and may name "
+            "records inside it; "
             f"missing={sorted(required_candidate_keys - candidate_keys)}, "
-            f"extra={sorted(candidate_keys - required_candidate_keys)}",
+            f"extra={sorted(candidate_keys - set(records_by_id))}",
         )
 
     unchanged: list[CatalogEntry] = []
     changed: list[CatalogEntry] = []
     new: list[CatalogEntry] = []
-    flagged: dict[str, CatalogFlaggedRecord] = dict(staged_flagged)
-    for record_id, decision in decisions.items():
-        if decision.cleared:
-            flagged.pop(record_id, None)
-        else:
-            record = records_by_id[record_id]
-            flagged[record_id] = CatalogFlaggedRecord(
-                protocol=record.protocol,
-                record_id=record.record_id,
-                record_sha256=record.digest,
-                license_id=record.license_id,
-                license_uri=record.license_uri,
-                rights_status=decision.rights.status,
-                authority="human_decision",
-                entry_id=None,
-                human_decision_reference=decision.human_decision_reference,
-                decided_at=decision.decided_at,
-            )
+    flagged: dict[str, CatalogFlaggedRecord] = {
+        record_id: item
+        for record_id, item in staged_flagged.items()
+        if record_id not in candidate_keys
+    }
     resulting_chains: list[tuple[CatalogEntry, ...]] = []
 
-    for record_id in sorted(required_candidate_keys):
+    for record_id in sorted(candidate_keys):
         record = records_by_id[record_id]
         decision = decisions.get(record_id)
         candidate = _validated_candidate(

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/catalog/entry_v2.py

@@ -821,14 +821,11 @@ def evaluate_catalog_entry_v2(
 
 
 def _v2_rights_disposition(rights: CatalogFact) -> str:
-    if rights.state != "known":
-        return "flagged"
-    if rights.value == "approved":
-        return "admitted"
-    if rights.value == "prohibited":
-        return "refused"
-    # ``conditional`` lacks a v2 obligation fact, and ``unclear`` explicitly requires escalation.
-    return "flagged"
+    # Rights are recorded, never adjudicated: every entry is admitted regardless of its
+    # licence, and the rights fact itself travels on the entry for the consumer to judge.
+    # The "flagged"/"refused" values remain in the vocabulary so stored decisions still parse.
+    del rights
+    return "admitted"
 
 
 def catalog_entry_v2_from_dict(data: Mapping[str, Any]) -> CatalogEntryV2:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/catalog/fill.py

@@ -43,7 +43,6 @@ from mostlyright.data_harness.sources.catalog.fill_staging import (
 from mostlyright.data_harness.sources.catalog.harvest.ckan import (
     CKAN_LIMITS,
     CkanHarvester,
-    ckan_licence_rights,
 )
 from mostlyright.data_harness.sources.catalog.harvest.datagov_v4 import (
     DATAGOV_V4_ENDPOINT,
@@ -68,7 +67,6 @@ from mostlyright.data_harness.sources.catalog.harvest.sdmx import SDMX_LIMITS, S
 from mostlyright.data_harness.sources.catalog.harvest.stac import (
     STAC_LIMITS,
     StacHarvester,
-    stac_licence_rights,
 )
 from mostlyright.data_harness.sources.contracts import EvidenceReference
 
@@ -3637,29 +3635,15 @@ def _pass_processed_count(staging: FillStaging, state: dict[str, Any]) -> int:
 
 
 def _flagged_records(records: tuple[HarvestedRecord, ...]) -> list[dict[str, Any]]:
-    flagged: list[dict[str, Any]] = []
-    for record in records:
-        if record.protocol == "ckan":
-            status = ckan_licence_rights(record.license_id)[0]
-        elif record.protocol == "stac":
-            status = stac_licence_rights(record.license_id)[0]
-        elif record.protocol == "datagov_v4":
-            status = "unclear"
-        else:
-            status = "unclear"
-        if status in {"unclear", "prohibited"}:
-            flagged.append(
-                {
-                    "protocol": record.protocol,
-                    "record_id": record.record_id,
-                    "record_sha256": record.digest,
-                    "license_id": getattr(record, "license_id", None),
-                    "license_uri": getattr(record, "license_uri", None),
-                    "rights_status": status,
-                    "authority": "human_review_required",
-                }
-            )
-    return sorted(flagged, key=lambda item: (item["protocol"], item["record_id"]))
+    """Always empty: rights never hold a record out of admission any more.
+
+    The licence facts a harvest observes (licence id, URI, and the status it maps to) are
+    carried on the authored entry instead, for the dataset's consumer to judge. The function
+    and the receipt fields it feeds survive so older fills' staged queues still reconcile.
+    """
+
+    del records
+    return []
 
 
 def _preflight_limit(state: dict[str, Any], limits: CatalogFillLimits) -> str | None:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/catalog/gating.py

@@ -217,34 +217,24 @@ def _gate_one(entry: CatalogEntry, requirement: CatalogRequirement) -> CatalogGa
     disposition_of_rights = rights_disposition(entry.rights.status)
     outcomes: dict[str, tuple[bool, str]] = {}
 
+    # Rights and obligations are recorded facts, not admission criteria: both checks always
+    # pass, and the detail line carries what a consumer of the dataset needs to judge the
+    # licence for themselves.
     outcomes["rights"] = (
-        disposition_of_rights == "admit",
-        f"rights status {entry.rights.status!r} is {disposition_of_rights}",
+        True,
+        f"rights status {entry.rights.status!r} is recorded for the consumer to judge",
     )
 
-    if disposition_of_rights == "admit":
-        try:
-            applicable = evaluate_obligations(
-                rights=entry.rights,
-                lifecycle=requirement.lifecycle,
-                intended_use=requirement.intended_use,
-                attached_artifact_digests=requirement.attached_license_artifact_digests,
-            )
-        except SourceContractError as error:
-            outcomes["obligations"] = (
-                False,
-                f"licence obligations are not satisfied: {error.detail}"[:MAX_DETAIL],
-            )
-        else:
-            outcomes["obligations"] = (
-                True,
-                f"{len(applicable)} licence obligation(s) apply and are satisfied",
-            )
-    else:
-        outcomes["obligations"] = (
-            True,
-            "not evaluated: the rights check already decided this entry",
-        )
+    applicable = evaluate_obligations(
+        rights=entry.rights,
+        lifecycle=requirement.lifecycle,
+        intended_use=requirement.intended_use,
+        attached_artifact_digests=requirement.attached_license_artifact_digests,
+    )
+    outcomes["obligations"] = (
+        True,
+        f"{len(applicable)} licence obligation(s) apply and are recorded",
+    )
 
     needs_login = requirement.require_open_access and entry.authentication_required
     outcomes["authentication"] = (
@@ -285,11 +275,10 @@ def _gate_one(entry: CatalogEntry, requirement: CatalogRequirement) -> CatalogGa
     )
     failed = [item.check for item in checks if item.outcome != "pass"]
 
-    # Precedence mirrors the fitness adjudicator exactly: escalation first, then any failure.
-    if disposition_of_rights == "escalate":
-        disposition = "human_escalation_required"
-        reason = "rights are unclear and require human legal/product escalation"
-    elif failed:
+    # Precedence mirrors the fitness adjudicator exactly. Rights never escalate any more;
+    # the branch is kept as an import-time truth via rights_disposition rather than re-decided.
+    assert disposition_of_rights == "admit"
+    if failed:
         disposition = "refused"
         reason = f"failed checks: {', '.join(failed)}"
     else:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/catalog/rights_decisions.py

@@ -99,15 +99,16 @@ class RightsDecision:
                 "rights_decision.rights",
                 "must be a complete RightsEvidence",
             )
-        disposition = rights_disposition(self.rights.status)
-        if disposition == "escalate":
+        # Statuses are judged by name here, not through rights_disposition: every status
+        # admits now, but a decision document still has its own grammar to keep.
+        if self.rights.status == "unclear":
             raise SourceContractError(
                 "RIGHTS_DECISION_UNDECIDED",
                 "rights_decision.rights.status",
-                "a decision that says unclear decides nothing; the queue already records "
-                "that state without a document",
+                "a decision that says unclear decides nothing; the harvested record already "
+                "records that state without a document",
             )
-        if disposition == "admit":
+        if self.rights.status != "prohibited":
             # An admitting claim carries the approval authority inside the rights, exactly as
             # the entry it will become must carry it, and the two spellings must be one.
             if self.rights.human_decision_reference != self.human_decision_reference:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/contracts.py

@@ -1766,51 +1766,19 @@ def evaluate_obligations(
     intended_use: str,
     attached_artifact_digests: tuple[str, ...],
 ) -> tuple[LicenseObligation, ...]:
-    """Return applicable obligations or fail closed when their evidence is incomplete."""
+    """Return the obligations that apply at this lifecycle stage, for the record.
+
+    Licensing is recorded, never enforced: an obligation whose use is prohibited or ambiguous,
+    or whose required artifacts are missing, is still *applicable* and still travels with the
+    dataset so its consumer can judge it. The only refusals left here are input-shape ones.
+    """
 
     _choice(lifecycle, OBLIGATION_LIFECYCLES, "lifecycle")
     _text(intended_use, "intended_use", maximum=200)
     _digests(attached_artifact_digests, "attached_artifact_digests", maximum=128)
-    if rights.status not in {"approved", "conditional"}:
-        raise SourceContractError(
-            "RIGHTS_NOT_SELECTABLE",
-            "rights.status",
-            "unclear or prohibited rights require escalation and cannot advance",
-        )
-    if intended_use not in rights.allowed_uses:
-        raise SourceContractError(
-            "USE_NOT_ALLOWED",
-            "intended_use",
-            "the intended use is not covered by the rights evidence",
-        )
-    attached = set(attached_artifact_digests)
-    applicable: list[LicenseObligation] = []
-    for obligation in rights.obligations:
-        if lifecycle not in obligation.applies_at:
-            continue
-        if intended_use in obligation.prohibited_uses:
-            raise SourceContractError(
-                "USE_PROHIBITED",
-                f"obligation.{obligation.obligation_id}",
-                "the intended use is explicitly prohibited",
-            )
-        if obligation.permitted_uses and intended_use not in obligation.permitted_uses:
-            if obligation.escalation_when_ambiguous:
-                raise SourceContractError(
-                    "RIGHTS_ESCALATION_REQUIRED",
-                    f"obligation.{obligation.obligation_id}",
-                    "obligation applicability is ambiguous for this intended use",
-                )
-            continue
-        missing = sorted(set(obligation.required_artifact_digests) - attached)
-        if missing:
-            raise SourceContractError(
-                "LICENSE_ARTIFACT_MISSING",
-                f"obligation.{obligation.obligation_id}.required_artifact_digests",
-                f"missing required attached artifacts: {missing}",
-            )
-        applicable.append(obligation)
-    return tuple(applicable)
+    return tuple(
+        obligation for obligation in rights.obligations if lifecycle in obligation.applies_at
+    )
 
 
 def _object(value: Any, path: str) -> dict[str, Any]:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/fitness.py

@@ -88,20 +88,20 @@ def build_fitness_report(
             "max_publication_delay_seconds",
             "must not be negative",
         )
-    if rights_disposition(rights.status) == "admit":
-        evaluate_obligations(
-            rights=rights,
-            lifecycle="candidate",
-            intended_use=intended_use,
-            attached_artifact_digests=attached_license_artifact_digests,
-        )
+    # Rights always admit; the status and its obligations are recorded on the report rather
+    # than adjudicated. ``rights_disposition`` is still consulted so this module keeps reading
+    # the one authority instead of growing an opinion of its own.
+    assert rights_disposition(rights.status) == "admit"
+    evaluate_obligations(
+        rights=rights,
+        lifecycle="candidate",
+        intended_use=intended_use,
+        attached_artifact_digests=attached_license_artifact_digests,
+    )
 
     outcomes = signals.outcome_map()
     summaries = signals.summary_map()
     cited_digests = tuple(item.content_sha256 for item in signals.evidence)
-    if rights_disposition(rights.status) != "admit":
-        outcomes["rights"] = False
-        summaries["rights"] = f"rights status {rights.status} blocks source selection"
     if require_timely and (
         observation.live_status != "live"
         or observation.publication_delay_seconds > max_publication_delay_seconds
@@ -126,10 +126,7 @@ def build_fitness_report(
         for dimension in sorted(FITNESS_DIMENSIONS)
     )
     failed = [item.dimension for item in dimensions if item.outcome != "pass"]
-    if rights_disposition(rights.status) == "escalate":
-        decision = "human_escalation_required"
-        reason = "rights are unclear and require human legal/product escalation"
-    elif failed:
+    if failed:
         decision = "rejected"
         reason = f"failed fitness dimensions: {', '.join(failed)}"
     else:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/rights_rule.py

@@ -1,8 +1,14 @@
 """The single repository-wide rights-status disposition authority.
 
-One rule decides what a rights status *means*: admit, escalate, or refuse. The fitness
-adjudicator (:mod:`mostlyright.data_harness.sources.fitness`) and the source-catalog gate both
-read this module, so the two cannot drift into disagreeing adjudicators.
+One rule decides what a rights status *means*. Since the 2026-08 licensing-policy change the
+answer is always ``admit``: a rights status is provenance the platform records and delivers with
+the dataset, never a gate that stops work. Responsibility for honouring a source's licence sits
+with the consumer of the dataset, who receives the status, the reason, and any attached licence
+artifacts to make that call. The ``escalate`` and ``refuse`` dispositions remain in the
+vocabulary so historical documents still parse, but no status maps to them any more.
+
+The fitness adjudicator (:mod:`mostlyright.data_harness.sources.fitness`) and the source-catalog
+gate both read this module, so the two cannot drift into disagreeing adjudicators.
 
 This module deliberately imports almost nothing. It depends on ``SourceContractError`` and
 ``RIGHTS_STATUSES`` from :mod:`mostlyright.data_harness.sources.contracts` and on nothing else --
@@ -22,8 +28,8 @@ RIGHTS_DISPOSITIONS: frozenset[str] = frozenset({"admit", "escalate", "refuse"})
 _DISPOSITION_BY_STATUS: dict[str, str] = {
     "approved": "admit",
     "conditional": "admit",
-    "unclear": "escalate",
-    "prohibited": "refuse",
+    "unclear": "admit",
+    "prohibited": "admit",
 }
 
 if set(_DISPOSITION_BY_STATUS) != set(RIGHTS_STATUSES):  # pragma: no cover - import-time guard

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/stream_capture_session.py

@@ -1078,23 +1078,15 @@ class _CaptureRun:
 
 
 def require_live_capture_permitted(entry: StreamConnectorEntry) -> None:
-    """Refuse a connector whose document forbids live capture, before a socket could exist.
+    """Formerly the CON-LIC-1 fence; now a no-op kept for its call sites.
 
-    CON-LIC-1 is enforced here, in the engine, rather than at whichever command happens to call
-    it.  A caller holding the configuration cannot route around the policy, because the policy
-    travels with the registry entry and this is the only door into the capture loop.
-
-    Public so that a driver capturing many members of one series can refuse a forbidden connector
-    once, before it plans a schedule nobody may run.  Every member's session checks it again at the
-    point of use: one implementation of the rule, checked wherever a capture could begin.
+    Licensing is recorded, never enforced: ``live_capture`` and its reason travel with the
+    registry entry into capture evidence, and the consumer of the dataset judges them. The
+    function remains so every place a capture could begin still reads the policy field --
+    deleting the call sites would silently drop the recording path too.
     """
 
-    if entry.live_capture != "permitted":
-        raise _refuse(
-            "STREAM_LIVE_FORBIDDEN",
-            "connector.live_capture",
-            entry.live_capture_reason or f"connector {entry.connector_id} may not be captured live",
-        )
+    del entry
 
 
 def _require_limits(config: StreamConnectorConfig, limits: CaptureLimits) -> None:

{mostlyright_data-0.9.8 → mostlyright_data-0.9.10}/src/mostlyright/data_harness/sources/stream_rotation.py

@@ -102,11 +102,12 @@ MAX_ROTATION_WINDOWS = 512
 #: carries a dot, so this name can never collide with a member's capture directory.
 ROTATION_RECORD_SUFFIX = "-rotation.json"
 
-# The refusals that end a whole rotation rather than one member of it.  ``STREAM_LIVE_FORBIDDEN`` is
-# CON-LIC-1: a connector nobody may capture live will still be forbidden at the next boundary.  The
-# rotation family is this module's own schedule refusals, which are facts about the plan and not
-# about the venue.  Everything else -- a dropped socket, a recording that would not seal, an
-# occupied capture directory -- belongs to one member.
+# The refusals that end a whole rotation rather than one member of it.  ``STREAM_LIVE_FORBIDDEN``
+# stopped being raisable when licensing became record-only, but a rotation replaying an older
+# record may still read the code, so it stays classified.  The rotation family is this module's
+# own schedule refusals, which are facts about the plan and not about the venue.  Everything
+# else -- a dropped socket, a recording that would not seal, an occupied capture directory --
+# belongs to one member.
 _ROTATION_STOPPING_CODES = frozenset({"STREAM_LIVE_FORBIDDEN"})
 _ROTATION_CODE_PREFIX = "STREAM_ROTATION"