pgc-workloads 2.0.0__tar.gz

pgc_workloads-2.0.0/LICENSE

@@ -0,0 +1,67 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+Copyright 2026 Bhash Ganti aka Bachi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+------------------------
+FULL LICENSE TEXT BELOW
+------------------------
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+   "Licensor" shall mean the copyright owner.
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control.
+   "You" shall mean an individual or Legal Entity exercising permissions.
+   "Source" form shall mean the preferred form for making modifications.
+   "Object" form shall mean any form resulting from mechanical transformation.
+   "Work" shall mean the work of authorship.
+   "Derivative Works" shall mean any work based on the Work.
+   "Contribution" shall mean any work intentionally submitted.
+   "Contributor" shall mean Licensor and any individual submitting Contributions.
+
+2. Grant of Copyright License.
+   Each Contributor grants You a perpetual, worldwide, non-exclusive,
+   no-charge, royalty-free copyright license.
+
+3. Grant of Patent License.
+   Each Contributor grants a patent license to make, use, sell, etc.
+
+4. Redistribution.
+   You may reproduce and distribute copies provided that:
+   - You include a copy of this License
+   - You retain notices
+   - You state modifications
+   - You include NOTICE file if present
+
+5. Submission of Contributions.
+   Contributions are under this License unless stated otherwise.
+
+6. Trademarks.
+   This License does not grant trademark rights.
+
+7. Disclaimer of Warranty.
+   Provided "AS IS", without warranties.
+
+8. Limitation of Liability.
+   No liability for damages.
+
+9. Accepting Warranty or Additional Liability.
+   You may offer support/warranty on your own behalf only.

pgc_workloads-2.0.0/NOTICE

@@ -0,0 +1,11 @@
+PGS — Protocol-Governed Systems
+Copyright 2026 Bhash Ganti aka Bachi
+
+This project introduces a protocol-first execution model in which:
+
+- Behavior is declared in protocol artifacts
+- Execution is performed by a deterministic runtime
+- Capability implementations are bound at compile time
+- Governance is enforced through invariants and assertions
+
+Extensibility is achieved by declaration, not refactor.

pgc_workloads-2.0.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: pgc-workloads
+Version: 2.0.0
+Summary: PGC conformance workloads — the capability implementations a sealed snapshot binds to make conformance observable
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing/conformance_workloads
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,conformance,workload,collatz
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: pgc-runtime>=2.0.0
+Dynamic: license-file
+
+# conformance_workloads
+
+**The workloads that prove a Profiled Normative Platform conforms.**
+
+A *platform* is not a repository — it is a composition. A **Profiled Normative Platform (PNP)** is
+what you get when a selected governance surface (`software_governance`), a selected set of workloads
+(this repo), and optionally a business domain (`business_domains`) are compiled and assembled
+together. There are as many PNPs as there are conformance profiles.
+
+This repo holds the workloads side of that composition: independently-authored domains that exercise
+the governed execution path end to end and make conformance claims observable.
+
+## Install
+
+```bash
+pip install pgc-workloads
+```
+
+This package carries declarations and the implementation modules a sealed
+snapshot binds at execution. It provides no command of its own — the toolchain
+packages read it.
+
+## Layout
+
+```
+conformance_workloads/
+  workloads/
+    __init__.py          import root — `workloads.<name>.implementation.*`
+    collatz/
+      registry/          the workload's own governance artifacts (WF/IN/CC/CT/EV/AC/RB/…)
+      transport/         TI/TE governed boundary contracts
+      implementation/    CT atom implementations (pure functions)
+      client/            web client + HTTP binding + composition launcher
+      test_payloads/     canonical request payloads
+      snapshot/          compiled output (generated)
+```
+
+## Self-describing domains
+
+A workload is compiled **against** an already-compiled governance surface; the governance surface is
+never edited to admit a workload. Each workload carries its own build manifest
+(`registry/structures/STRUCTURE_BUILD_*_CONFIG_V*.md`) declaring its layers via `domain_subpath` —
+resolved under this repo, not under the governance repo.
+
+## Build
+
+```bash
+cd ../protocol_compiler
+./compile.sh STRUCTURE_BUILD_PLATFORM_CONFIG_V1           # governance surface first
+./compile_domain.sh ../conformance_workloads/workloads/collatz
+cd ../snapshot_assembler && PGC_SNAPSHOT_PROFILE=REFERENCE_PLATFORM_PROFILE_V1 ./assemble.sh   # compose the PNP
+cd ../protocol_runtime && ./run.sh
+```
+
+## Environment provisioning
+
+This repo is **deliberately not installed** into the workspace venv. Its import root is
+env-provisioned from the repo root — `protocol_runtime/run.sh` puts it on `PYTHONPATH` by default,
+so CT handler refs resolve as `workloads.collatz.implementation.…`. Override with `PGC_IMPL_ROOTS`.
+
+## Serve the client
+
+```bash
+./workloads/collatz/client/serve.sh        # http://127.0.0.1:8000
+```
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `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-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 |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **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 **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_workloads-2.0.0/README.md

@@ -0,0 +1,109 @@
+# conformance_workloads
+
+**The workloads that prove a Profiled Normative Platform conforms.**
+
+A *platform* is not a repository — it is a composition. A **Profiled Normative Platform (PNP)** is
+what you get when a selected governance surface (`software_governance`), a selected set of workloads
+(this repo), and optionally a business domain (`business_domains`) are compiled and assembled
+together. There are as many PNPs as there are conformance profiles.
+
+This repo holds the workloads side of that composition: independently-authored domains that exercise
+the governed execution path end to end and make conformance claims observable.
+
+## Install
+
+```bash
+pip install pgc-workloads
+```
+
+This package carries declarations and the implementation modules a sealed
+snapshot binds at execution. It provides no command of its own — the toolchain
+packages read it.
+
+## Layout
+
+```
+conformance_workloads/
+  workloads/
+    __init__.py          import root — `workloads.<name>.implementation.*`
+    collatz/
+      registry/          the workload's own governance artifacts (WF/IN/CC/CT/EV/AC/RB/…)
+      transport/         TI/TE governed boundary contracts
+      implementation/    CT atom implementations (pure functions)
+      client/            web client + HTTP binding + composition launcher
+      test_payloads/     canonical request payloads
+      snapshot/          compiled output (generated)
+```
+
+## Self-describing domains
+
+A workload is compiled **against** an already-compiled governance surface; the governance surface is
+never edited to admit a workload. Each workload carries its own build manifest
+(`registry/structures/STRUCTURE_BUILD_*_CONFIG_V*.md`) declaring its layers via `domain_subpath` —
+resolved under this repo, not under the governance repo.
+
+## Build
+
+```bash
+cd ../protocol_compiler
+./compile.sh STRUCTURE_BUILD_PLATFORM_CONFIG_V1           # governance surface first
+./compile_domain.sh ../conformance_workloads/workloads/collatz
+cd ../snapshot_assembler && PGC_SNAPSHOT_PROFILE=REFERENCE_PLATFORM_PROFILE_V1 ./assemble.sh   # compose the PNP
+cd ../protocol_runtime && ./run.sh
+```
+
+## Environment provisioning
+
+This repo is **deliberately not installed** into the workspace venv. Its import root is
+env-provisioned from the repo root — `protocol_runtime/run.sh` puts it on `PYTHONPATH` by default,
+so CT handler refs resolve as `workloads.collatz.implementation.…`. Override with `PGC_IMPL_ROOTS`.
+
+## Serve the client
+
+```bash
+./workloads/collatz/client/serve.sh        # http://127.0.0.1:8000
+```
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `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-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 |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **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 **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_workloads-2.0.0/pgc_workloads.egg-info/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: pgc-workloads
+Version: 2.0.0
+Summary: PGC conformance workloads — the capability implementations a sealed snapshot binds to make conformance observable
+Author-email: Bhash Ganti <bachipeachy@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://omnibachi.org/
+Project-URL: Repository, https://github.com/protocol-governed-computing/conformance_workloads
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,conformance,workload,collatz
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: pgc-runtime>=2.0.0
+Dynamic: license-file
+
+# conformance_workloads
+
+**The workloads that prove a Profiled Normative Platform conforms.**
+
+A *platform* is not a repository — it is a composition. A **Profiled Normative Platform (PNP)** is
+what you get when a selected governance surface (`software_governance`), a selected set of workloads
+(this repo), and optionally a business domain (`business_domains`) are compiled and assembled
+together. There are as many PNPs as there are conformance profiles.
+
+This repo holds the workloads side of that composition: independently-authored domains that exercise
+the governed execution path end to end and make conformance claims observable.
+
+## Install
+
+```bash
+pip install pgc-workloads
+```
+
+This package carries declarations and the implementation modules a sealed
+snapshot binds at execution. It provides no command of its own — the toolchain
+packages read it.
+
+## Layout
+
+```
+conformance_workloads/
+  workloads/
+    __init__.py          import root — `workloads.<name>.implementation.*`
+    collatz/
+      registry/          the workload's own governance artifacts (WF/IN/CC/CT/EV/AC/RB/…)
+      transport/         TI/TE governed boundary contracts
+      implementation/    CT atom implementations (pure functions)
+      client/            web client + HTTP binding + composition launcher
+      test_payloads/     canonical request payloads
+      snapshot/          compiled output (generated)
+```
+
+## Self-describing domains
+
+A workload is compiled **against** an already-compiled governance surface; the governance surface is
+never edited to admit a workload. Each workload carries its own build manifest
+(`registry/structures/STRUCTURE_BUILD_*_CONFIG_V*.md`) declaring its layers via `domain_subpath` —
+resolved under this repo, not under the governance repo.
+
+## Build
+
+```bash
+cd ../protocol_compiler
+./compile.sh STRUCTURE_BUILD_PLATFORM_CONFIG_V1           # governance surface first
+./compile_domain.sh ../conformance_workloads/workloads/collatz
+cd ../snapshot_assembler && PGC_SNAPSHOT_PROFILE=REFERENCE_PLATFORM_PROFILE_V1 ./assemble.sh   # compose the PNP
+cd ../protocol_runtime && ./run.sh
+```
+
+## Environment provisioning
+
+This repo is **deliberately not installed** into the workspace venv. Its import root is
+env-provisioned from the repo root — `protocol_runtime/run.sh` puts it on `PYTHONPATH` by default,
+so CT handler refs resolve as `workloads.collatz.implementation.…`. Override with `PGC_IMPL_ROOTS`.
+
+## Serve the client
+
+```bash
+./workloads/collatz/client/serve.sh        # http://127.0.0.1:8000
+```
+
+---
+
+## The package family
+
+| Package | Repository | Role |
+|---|---|---|
+| `pgc-compiler` | `protocol_compiler` | declarations → compiled projections |
+| `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-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 |
+
+`pip install pgc` brings in the whole family.
+
+**Installing the toolchain is one of two steps.** The compiler resolves the governance surface from
+`PGC_PLATFORM_ROOT` — fail-hard, cwd-independent, zero inference — so the *declarations* come from a
+repository you point at, never from a wheel. A registry inside a package would be a second governance
+surface competing with the repository's, and a build could then be governed by a stale copy.
+
+```bash
+git clone https://github.com/protocol-governed-computing/software_governance
+export PGC_PLATFORM_ROOT=$PWD/software_governance
+pgc            # reports what is installed and whether the anchor resolves
+```
+
+`PGC_BUILD_ROOT` (compiled output, keeping the governance repo read-only) and `PGC_DOMAIN_ROOTS`
+(additional domains contributing their own `registry/structures`) are optional.
+
+**Versioning.** Two schemes, and the published version follows the second.
+
+- **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 **`v2`**.
+
+**The published version is the public one: `v2` is `2.0.0`.** The standard the packages implement is a
+separate artifact on its own track and is not this number.
+
+The standard these packages implement is published separately: https://doi.org/10.5281/zenodo.22150616

pgc_workloads-2.0.0/pgc_workloads.egg-info/SOURCES.txt

@@ -0,0 +1,49 @@
+LICENSE
+NOTICE
+README.md
+pyproject.toml
+pgc_workloads.egg-info/PKG-INFO
+pgc_workloads.egg-info/SOURCES.txt
+pgc_workloads.egg-info/dependency_links.txt
+pgc_workloads.egg-info/requires.txt
+pgc_workloads.egg-info/top_level.txt
+workloads/__init__.py
+workloads/collatz/__init__.py
+workloads/collatz/client/bindings/http.json
+workloads/collatz/implementation/__init__.py
+workloads/collatz/implementation/capability_transforms/__init__.py
+workloads/collatz/implementation/capability_transforms/atoms/__init__.py
+workloads/collatz/implementation/capability_transforms/atoms/ct_pure_collatz_step_v0.py
+workloads/collatz/implementation/capability_transforms/atoms/ct_pure_termination_check_v0.py
+workloads/collatz/snapshot/compiled/behavior_logic/WF_COLLATZ_CONJECTURE_V0/WF_COLLATZ_CONJECTURE_V0.graph.json
+workloads/collatz/snapshot/compiled/canonical/metadata.json
+workloads/collatz/snapshot/compiled/canonical/actors/workload__AC_REFERENCE_ACTOR_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_COMPUTE_SEQUENCES_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_STORE_RESULTS_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_VERIFY_TERMINATION_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_side_effects/capability_side_effects__CS_MUTABLE_JSON_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_transforms/workload__CT_PURE_COLLATZ_STEP_V0.json
+workloads/collatz/snapshot/compiled/canonical/capability_transforms/workload__CT_PURE_TERMINATION_CHECK_V0.json
+workloads/collatz/snapshot/compiled/canonical/events/workload__EV_CONJECTURE_EVALUATED_V0.json
+workloads/collatz/snapshot/compiled/canonical/ingress_intents/workload__TI_COLLATZ_COMPUTE_V0.json
+workloads/collatz/snapshot/compiled/canonical/intents/workload__IN_COLLATZ_INPUT_VALIDATED_V0.json
+workloads/collatz/snapshot/compiled/canonical/runtime_bindings/workload__RB_COLLATZ_V0.json
+workloads/collatz/snapshot/compiled/canonical/structures/workload__STRUCTURE_BUILD_WORKLOAD_CONFIG_V0.json
+workloads/collatz/snapshot/compiled/canonical/structures/workload__STRUCTURE_COLLATZ_STORAGE_V0.json
+workloads/collatz/snapshot/compiled/canonical/transport/egress/workload__TE_COLLATZ_COMPUTE_V0.json
+workloads/collatz/snapshot/compiled/canonical/workflows/workload__WF_COLLATZ_CONJECTURE_V0.json
+workloads/collatz/snapshot/compiled/evidence/workload/evidence.json
+workloads/collatz/snapshot/compiled/evidence/workload/evidence_graph.json
+workloads/collatz/snapshot/compiled/evidence/workload/metadata.json
+workloads/collatz/snapshot/compiled/tokenized/workload/dispatch.json
+workloads/collatz/snapshot/compiled/tokenized/workload/handlers.json
+workloads/collatz/snapshot/compiled/tokenized/workload/metadata.json
+workloads/collatz/snapshot/compiled/tokenized/workload/topology.json
+workloads/collatz/snapshot/compiled/trust/workload/structure_attestation.json
+workloads/collatz/snapshot/compiled/vocabulary/workload/forward.json
+workloads/collatz/snapshot/compiled/vocabulary/workload/metadata.json
+workloads/collatz/snapshot/compiled/vocabulary/workload/reverse.json
+workloads/collatz/snapshot/determinations/STRUCTURE_BUILD_WORKLOAD_CONFIG_V0.admitted.json
+workloads/collatz/test_payloads/01_happy_path.json
+workloads/collatz/test_payloads/02_single_number.json
+workloads/collatz/test_payloads/03_invalid_nack.json

pgc_workloads-2.0.0/pgc_workloads.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pgc_workloads-2.0.0/pgc_workloads.egg-info/requires.txt

@@ -0,0 +1 @@
+pgc-runtime>=2.0.0

pgc_workloads-2.0.0/pgc_workloads.egg-info/top_level.txt

@@ -0,0 +1 @@
+workloads

pgc_workloads-2.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pgc-workloads"
+version = "2.0.0"
+description = "PGC conformance workloads — the capability implementations a sealed snapshot binds to make conformance observable"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+authors = [{ name = "Bhash Ganti", email = "bachipeachy@gmail.com" }]
+
+keywords = ["protocol-governed-computing", "pgc", "conformance", "workload", "collatz"]
+
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Testing",
+]
+
+# The collatz atoms import `runtime.ct_executor` for CTExecutionError — the
+# capability-transform contract lives in the runtime package.
+dependencies = ["pgc-runtime>=2.0.0"]
+
+[project.urls]
+Homepage = "https://omnibachi.org/"
+Repository = "https://github.com/protocol-governed-computing/conformance_workloads"
+Standard = "https://doi.org/10.5281/zenodo.22150616"
+
+# Only the importable implementation ships. A sealed snapshot binds these by
+# fully qualified module path — `workloads.collatz.implementation.
+# capability_transforms.atoms.ct_pure_collatz_step_v0` — so the top-level name
+# is fixed by snapshots already sealed and cannot be nested under a prefix.
+#
+# The declarations (registry/, test_payloads/, snapshot/determinations/) are not
+# packaged. The compiler resolves the governance surface from PGC_PLATFORM_ROOT
+# and PGC_DOMAIN_ROOTS by design — "fail-hard, cwd-independent, zero inference" —
+# so a registry inside a wheel would be a second governance surface competing
+# with the repository's.
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["workloads*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.json"]

pgc_workloads-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pgc_workloads-2.0.0/workloads/collatz/client/bindings/http.json

@@ -0,0 +1,6 @@
+{
+  "_note": "HTTP External Protocol Binding (Patch 2) — adapter-owned config, promotable to an XB_ artifact. Maps HTTP {method, path} to a stable Operation Identity (never a Workflow Identity).",
+  "bindings": [
+    { "method": "POST", "path": "/collatz", "operation": "collatz.compute" }
+  ]
+}

pgc_workloads-2.0.0/workloads/collatz/implementation/capability_transforms/atoms/ct_pure_collatz_step_v0.py

@@ -0,0 +1,67 @@
+"""
+CT_PURE_COLLATZ_STEP_V0
+
+Pure Capability Transform (Atom)
+
+Purpose:
+    Compute the full Collatz sequence for each number in the input list.
+
+Implementation:
+    - Pure iteration: n → n/2 (even), 3n+1 (odd), until reaching 1
+    - Entire sequence is captured per number
+    - No side effects, no external state
+
+Purity Class: ct_pure
+"""
+
+from typing import Dict, Any, List
+
+from runtime.ct_executor import CTExecutionError
+
+
+def execute(inputs: Dict[str, Any], context: Any = None) -> Dict[str, Any]:
+    """
+    Execute CT_PURE_COLLATZ_STEP_V0.
+
+    Inputs:
+        numbers (list[int]): List of positive integers for which to compute sequences
+
+    Outputs:
+        sequences (dict): Mapping from str(n) → list of integers (full Collatz sequence)
+    """
+    if "numbers" not in inputs:
+        raise CTExecutionError(
+            "CT_PURE_COLLATZ_STEP_V0: missing required input 'numbers'"
+        )
+
+    numbers = inputs["numbers"]
+
+    if not isinstance(numbers, list):
+        raise CTExecutionError(
+            f"CT_PURE_COLLATZ_STEP_V0: 'numbers' must be a list, got {type(numbers).__name__}"
+        )
+
+    sequences: Dict[str, List[int]] = {}
+
+    for n in numbers:
+        if not isinstance(n, int) or isinstance(n, bool):
+            raise CTExecutionError(
+                f"CT_PURE_COLLATZ_STEP_V0: each number must be a positive integer, got {type(n).__name__}"
+            )
+        if n < 1:
+            raise CTExecutionError(
+                f"CT_PURE_COLLATZ_STEP_V0: each number must be >= 1, got {n}"
+            )
+
+        seq: List[int] = [n]
+        current = n
+        while current != 1:
+            if current % 2 == 0:
+                current = current // 2
+            else:
+                current = 3 * current + 1
+            seq.append(current)
+
+        sequences[str(n)] = seq
+
+    return {"sequences": sequences}