pgc-runtime 5.0.0__tar.gz → 6.0.0__tar.gz

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/NOTICE

@@ -1,4 +1,4 @@
-PGS — Protocol-Governed Systems
+PGC — Protocol-Governed Computing
 Copyright 2026 Bhash Ganti aka Bachi
 
 This project introduces a protocol-first execution model in which:

{pgc_runtime-5.0.0/pgc_runtime.egg-info → pgc_runtime-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgc-runtime
-Version: 5.0.0
+Version: 6.0.0
 Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
 Author-email: Bhash Ganti <bachipeachy@gmail.com>
 License-Expression: Apache-2.0
@@ -23,7 +23,7 @@ License-File: NOTICE
 Provides-Extra: reference
 Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
 Provides-Extra: render
-Requires-Dist: pgc-inspector>=5.0.0; extra == "render"
+Requires-Dist: pgc-inspector>=6.0.0; extra == "render"
 Dynamic: license-file
 
 # protocol_runtime
@@ -85,7 +85,7 @@ the data root:
 
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
-    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V1 event per line
+    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
     <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
                         or `behavior-logic <trace>`)
 
@@ -172,7 +172,7 @@ Apache-2.0. See `LICENSE` and `NOTICE`.
 | `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
 | `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
 | `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
-| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-transformation` | `transformation_compilers` | change request → protocol artifacts |
 | `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
 | `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
 | `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
@@ -204,15 +204,16 @@ assembler and the runtime alike.
 The full sequence, with the repositories it needs, is in
 [`pgc_install`](https://github.com/protocol-governed-computing/pgc_install).
 
-**Versioning.** Two schemes, and the published version follows the second.
+**Versioning.** Two numbers name two different things.
 
-- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
-  composition rather than each repo: they release together and the governance closure forces lockstep,
-  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
-  cycle is tagged `release-<N>`. This is not published.
-- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v3`**.
+- **Published** — this distribution's `version` in `pyproject.toml`. It moves on its own. A release
+  that changes this repository bumps it, and a release that leaves the repository unchanged keeps it.
+- **Composition** — the public identity (`v6`, …) names one composition of the whole family.
+  `pgc_release` records which version of each distribution that composition holds, and `pgc_install`
+  pins exactly those versions.
 
-**The published version is the public one: `v4` is `4.0.0`.** The standard the packages implement is a
-separate artifact on its own track and is not this number.
+Each repository's `VERSION` file holds the workspace's cycle ordinal, which names the `dev/<N>`
+branch. It is development accounting, and it is never published. The standard the packages
+implement is a separate artifact on its own track, and none of these numbers is its revision.
 
 The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/README.md

@@ -57,7 +57,7 @@ the data root:
 
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
-    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V1 event per line
+    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
     <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
                         or `behavior-logic <trace>`)
 
@@ -144,7 +144,7 @@ Apache-2.0. See `LICENSE` and `NOTICE`.
 | `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
 | `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
 | `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
-| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-transformation` | `transformation_compilers` | change request → protocol artifacts |
 | `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
 | `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
 | `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
@@ -176,15 +176,16 @@ assembler and the runtime alike.
 The full sequence, with the repositories it needs, is in
 [`pgc_install`](https://github.com/protocol-governed-computing/pgc_install).
 
-**Versioning.** Two schemes, and the published version follows the second.
+**Versioning.** Two numbers name two different things.
 
-- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
-  composition rather than each repo: they release together and the governance closure forces lockstep,
-  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
-  cycle is tagged `release-<N>`. This is not published.
-- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v3`**.
+- **Published** — this distribution's `version` in `pyproject.toml`. It moves on its own. A release
+  that changes this repository bumps it, and a release that leaves the repository unchanged keeps it.
+- **Composition** — the public identity (`v6`, …) names one composition of the whole family.
+  `pgc_release` records which version of each distribution that composition holds, and `pgc_install`
+  pins exactly those versions.
 
-**The published version is the public one: `v4` is `4.0.0`.** The standard the packages implement is a
-separate artifact on its own track and is not this number.
+Each repository's `VERSION` file holds the workspace's cycle ordinal, which names the `dev/<N>`
+branch. It is development accounting, and it is never published. The standard the packages
+implement is a separate artifact on its own track, and none of these numbers is its revision.
 
 The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0/pgc_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgc-runtime
-Version: 5.0.0
+Version: 6.0.0
 Summary: PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)
 Author-email: Bhash Ganti <bachipeachy@gmail.com>
 License-Expression: Apache-2.0
@@ -23,7 +23,7 @@ License-File: NOTICE
 Provides-Extra: reference
 Requires-Dist: pgc-governance>=2.0.0; extra == "reference"
 Provides-Extra: render
-Requires-Dist: pgc-inspector>=5.0.0; extra == "render"
+Requires-Dist: pgc-inspector>=6.0.0; extra == "render"
 Dynamic: license-file
 
 # protocol_runtime
@@ -85,7 +85,7 @@ the data root:
 
 ```
 <data-root>/traces/<domain>/<WF>/<TRACE_ID>/
-    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V1 event per line
+    <TRACE_ID>.jsonl    append-only execution log, one SCHEMA_TRACE_EVENT_V0 event per line
     <TRACE_ID>.png      the path the run took, drawn only on request (`run --behavior-logic`,
                         or `behavior-logic <trace>`)
 
@@ -172,7 +172,7 @@ Apache-2.0. See `LICENSE` and `NOTICE`.
 | `pgc-assembler` | `snapshot_assembler` | projections → sealed snapshot |
 | `pgc-runtime` | `protocol_runtime` | snapshot → governed execution |
 | `pgc-inspector` | `snapshot_inspector` | snapshot → read-only inspection |
-| `pgc-transformation` | `transformation` | change request → protocol artifacts |
+| `pgc-transformation` | `transformation_compilers` | change request → protocol artifacts |
 | `pgc-governance` | `software_governance` | the governance surface and its capability implementations |
 | `pgc-workloads` | `conformance_workloads` | the workloads that make conformance observable |
 | `pgc-domains` | `business_domains` | the business domain implementations the composed snapshot binds |
@@ -204,15 +204,16 @@ assembler and the runtime alike.
 The full sequence, with the repositories it needs, is in
 [`pgc_install`](https://github.com/protocol-governed-computing/pgc_install).
 
-**Versioning.** Two schemes, and the published version follows the second.
+**Versioning.** Two numbers name two different things.
 
-- **Internal** — each repository's `VERSION` file, a monotonic composition ordinal. PGC versions the
-  composition rather than each repo: they release together and the governance closure forces lockstep,
-  so the ordinal names which composition a repo belongs to. Development happens on `dev/<N>` and each
-  cycle is tagged `release-<N>`. This is not published.
-- **Public** — `PUBLIC_VERSION`, tagged on every component repository. The platform is at **`v3`**.
+- **Published** — this distribution's `version` in `pyproject.toml`. It moves on its own. A release
+  that changes this repository bumps it, and a release that leaves the repository unchanged keeps it.
+- **Composition** — the public identity (`v6`, …) names one composition of the whole family.
+  `pgc_release` records which version of each distribution that composition holds, and `pgc_install`
+  pins exactly those versions.
 
-**The published version is the public one: `v4` is `4.0.0`.** The standard the packages implement is a
-separate artifact on its own track and is not this number.
+Each repository's `VERSION` file holds the workspace's cycle ordinal, which names the `dev/<N>`
+branch. It is development accounting, and it is never published. The standard the packages
+implement is a separate artifact on its own track, and none of these numbers is its revision.
 
 The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/pgc_runtime.egg-info/requires.txt

@@ -3,4 +3,4 @@
 pgc-governance>=2.0.0
 
 [render]
-pgc-inspector>=5.0.0
+pgc-inspector>=6.0.0

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pgc-runtime"
-version = "5.0.0"
+version = "6.0.0"
 description = "PGC protocol runtime — executes a sealed snapshot as governed DAG traversal and emits traces (import package: runtime)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,7 +34,7 @@ dependencies = []
 reference = ["pgc-governance>=2.0.0"]
 # The PNG projection (`--behavior-logic`, `behavior-logic`) draws the inspector's explanation of a
 # run. Execution never imports the inspector; only `runtime.trace_viz` does.
-render = ["pgc-inspector>=5.0.0"]
+render = ["pgc-inspector>=6.0.0"]
 
 [project.scripts]
 protocol_runtime = "runtime.cli:main"

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/runtime/api.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from typing import Any
 
 from runtime.boot import BootedSnapshot, boot, default_snapshot_root
-from runtime.evidence import TraceWriter, make_trace_id
+from runtime.evidence import RecordedRefusal, TraceWriter, make_trace_id
 from runtime.scheduler import run_wf
 
 
@@ -71,6 +71,9 @@ def run_workflow(
     try:
         status, surface = run_wf(wf_fqdn=wf_fqdn, payload=payload, pkg=pkg,
                                  writer=writer, data_root=str(data_root))
+    except RecordedRefusal:
+        # Recorded where it was determined; recording it again here would count it twice.
+        raise
     except Exception as exc:
         writer.error(str(exc))
         raise

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/runtime/boot.py

@@ -91,9 +91,9 @@ def boot(snapshot_root: str | Path | None = None) -> BootedSnapshot:
 
     # 2. ACCEPTANCE — all four conditions of `3b` §7, established from content.
     #
-    # The runtime does not carry its own weaker copy of this. It previously recomputed the composite
-    # over the manifest's RECORDED per-domain hashes, which detects a tampered manifest and not a
-    # tampered constituent — and a snapshot with an edited projection booted and reported healthy.
+    # The runtime does not carry its own weaker copy of this. A composite over the manifest's RECORDED
+    # per-domain hashes detects a tampered manifest and not a tampered constituent: a snapshot with an
+    # edited projection would boot and report healthy.
     # `assembler.core.verify_snapshot` recomputes every constituent from its bytes; there is one
     # acceptance determination and both the assembler and the runtime reach it.
     #

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/runtime/conformance.py

@@ -6,7 +6,7 @@ the composition sealed it. This runs every case of one build and reports every t
 supplies as **proven** (every case ran and passed), **unproven** (no vector tests it) or **refused** (a
 case failed). It never reports success over nothing: a build with no vector is reported, by name, as
 unproven. The build is a domain's, or the platform's for the transforms the platform supplies.
-Governed by `conformance::CONSTITUTION_TEST_DATA_V2`.
+Governed by `conformance::CONSTITUTION_TEST_DATA_V0`.
 
 What a build supplies and what it only carries is read from the capabilities its attestation records
 as imported, never from a transform's name: a carried copy is byte-identical to its supplier's, and the
@@ -27,7 +27,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from runtime.ct_executor import CTArtifactNotFound, CTExecutor, CTExecutionError
+from runtime.ct_executor import CTArtifactNotFound, CTExecutor, CTExecutionError, CTFault
 
 NONDETERMINISTIC_PURITY = "ct_impure"
 # Where a build's result is written, beside its compiled projections, so the assembler carries it into
@@ -201,6 +201,31 @@ def _resolve_outputs(ct_ir: dict[str, Any], vars_result: dict[str, Any]) -> dict
     return actual
 
 
+def _undeclared_result(ct_ir: dict[str, Any], vars_result: dict[str, Any]) -> str | None:
+    """Say how a completed run's result differs from the outputs the transform declares, if it does.
+
+    A result read field by field carries exactly the outputs read from it: a key no output names is an
+    answer nothing declared, and a declared output it lacks is one the case could only compare against
+    the whole result. A result read as one output's value is that value, whatever it holds.
+    """
+    groups: dict[str, set[str]] = {}
+    for output_key, output_spec in (ct_ir.get("outputs") or {}).items():
+        groups.setdefault(output_spec.get("from"), set()).add(output_key)
+    for from_var, keys in sorted(groups.items(), key=lambda g: str(g[0])):
+        if from_var not in vars_result:
+            return f"no step produced {from_var!r}, which outputs {sorted(keys)} are read from"
+        source = vars_result[from_var]
+        if not isinstance(source, dict) or not keys & set(source):
+            if len(keys) == 1:
+                continue
+            return f"{from_var!r} carries none of the declared outputs {sorted(keys)}"
+        if set(source) != keys:
+            missing, extra = sorted(keys - set(source)), sorted(set(source) - keys)
+            return (f"{from_var!r} differs from the declared outputs"
+                    f"{f' — lacks {missing}' if missing else ''}{f' — undeclared {extra}' if extra else ''}")
+    return None
+
+
 def _canonical(compiled: Path, kind_dir: str) -> list[dict[str, Any]]:
     folder = compiled / "canonical" / kind_dir
     return [json.loads(p.read_text()) for p in sorted(folder.glob("*.json"))] if folder.is_dir() else []
@@ -251,6 +276,10 @@ def _run_case(executor: CTExecutor, case: dict[str, Any]) -> CaseResult:
         # VIOLATION case by accident. A transform whose implementation is absent is refused and named,
         # which is a result; escaping as a crash names nothing and stops the other cases.
         return CaseResult(fqdn, False, f"implementation not present: {e}")
+    except CTFault as e:
+        # A fault is not the transform's judgement: it fails the case whatever the case expected,
+        # so a VIOLATION case is never passed by a transform that broke rather than refused.
+        return CaseResult(fqdn, False, f"fault, not a refusal: {e}")
     except CTExecutionError as e:
         # A refusal the case expected passes — unless it was the runner refusing a missing record,
         # which is a defect in the case, not the transform's judgement.
@@ -268,6 +297,9 @@ def _run_case(executor: CTExecutor, case: dict[str, Any]) -> CaseResult:
         if unused:
             return CaseResult(fqdn, False, f"recorded results no step used: {unused}")
 
+    undeclared = _undeclared_result(ct_ir, vars_result)
+    if undeclared:
+        return CaseResult(fqdn, False, f"result differs from the declared outputs: {undeclared}")
     actual = _resolve_outputs(ct_ir, vars_result)
     assertion_error = _assert_structural(actual, assertions) if assertions else None
     if assertion_error:

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/runtime/coordinator.py

@@ -1,6 +1,6 @@
 """A coordinating party that runs several runtimes.
 
-`CONSTITUTION_EXECUTION_PLACEMENT_V1` authorizes `LOCAL_MULTI_WORKER`: more than one worker process
+`CONSTITUTION_EXECUTION_PLACEMENT_V0` authorizes `LOCAL_MULTI_WORKER`: more than one worker process
 on one host, each drawing work from a coordinating party and executing a governed topology in its
 own process. This is that party.
 

{pgc_runtime-5.0.0 → pgc_runtime-6.0.0}/runtime/ct_execute.py

@@ -6,8 +6,7 @@ Adapter between the dispatcher and CTExecutor.
 
 from typing import Any
 
-from runtime.ct_errors import StructuredError
-from runtime.ct_executor import CTExecutor
+from runtime.ct_executor import CTExecutor, CTFault
 
 # Module-level executor singleton — avoids re-creating per call,
 # preserves federated IR directory cache and atom loading.
@@ -48,11 +47,7 @@ def execute_ct(ct_ir: dict[str, Any], inputs: dict[str, Any], observer=None, rec
     # ---- Output adaptation ----
     outputs = ct_ir.get("outputs")
     if not outputs:
-        raise StructuredError(
-            error_code="CT_EXECUTION_FAILED",
-            node_category="CT",
-            message="CT must declare at least one output",
-        )
+        raise CTFault("CT must declare at least one output")
 
     # Build CT outputs by mapping from symbol table
     ct_outputs = {}
@@ -60,11 +55,7 @@ def execute_ct(ct_ir: dict[str, Any], inputs: dict[str, Any], observer=None, rec
         from_symbol = spec["from"]
 
         if from_symbol not in symbol_table:
-            raise StructuredError(
-                error_code="CT_EXECUTION_FAILED",
-                node_category="CT",
-                message=f"CT output symbol '{from_symbol}' was not produced by CT execution",
-            )
+            raise CTFault(f"CT output symbol '{from_symbol}' was not produced by CT execution")
 
         symbol_value = symbol_table[from_symbol]