pgc-workloads 2.0.0__py3-none-any.whl

pgc_workloads-2.0.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,46 @@
+pgc_workloads-2.0.0.dist-info/licenses/LICENSE,sha256=wf4s-Px76q2zHB2b8Gbvuu4ULua8AMds2IY01MkBn0A,2544
+pgc_workloads-2.0.0.dist-info/licenses/NOTICE,sha256=nE4--l6r3rMCz0nVaFyFohZtY4NYADnrhcS9K2pdNr0,407
+workloads/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workloads/collatz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workloads/collatz/client/bindings/http.json,sha256=HeGvwHGcWkMsZYoAW-r0Bs3OoWV_2bIc4fHqs41AoXc,298
+workloads/collatz/implementation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workloads/collatz/implementation/capability_transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workloads/collatz/implementation/capability_transforms/atoms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workloads/collatz/implementation/capability_transforms/atoms/ct_pure_collatz_step_v0.py,sha256=8x2uQWb3Xdp1AbASzKu6eUmboI6BUR1jwWWWq8bSknE,1858
+workloads/collatz/implementation/capability_transforms/atoms/ct_pure_termination_check_v0.py,sha256=QR86MObF6gktMrk2dPziC8PjSghpzPSf64TnzMlmqK4,1593
+workloads/collatz/snapshot/compiled/behavior_logic/WF_COLLATZ_CONJECTURE_V0/WF_COLLATZ_CONJECTURE_V0.graph.json,sha256=GUmrQMOr2YA4sZFRgpt4_OTPUxdcSKQab5Sf5s1K16E,4963
+workloads/collatz/snapshot/compiled/canonical/metadata.json,sha256=fVElpklNjPRrBx9dh3D-agP7yKYxMzQ89dYz_mCFyHY,453
+workloads/collatz/snapshot/compiled/canonical/actors/workload__AC_REFERENCE_ACTOR_V0.json,sha256=r5ojMccGhAdkRfQKNlrLtT1UTYpaCw8aVgrhRPFWPVU,2095
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_COMPUTE_SEQUENCES_V0.json,sha256=JEgDJlvHN-cfOZav8uV0WO5z0hopqNmpF9RrrI4xWsU,3157
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_STORE_RESULTS_V0.json,sha256=FZS052UeFooLJQfUmJH3CaN_KpRurN6JbfpLVXEqPIs,4164
+workloads/collatz/snapshot/compiled/canonical/capability_contracts/workload__CC_VERIFY_TERMINATION_V0.json,sha256=zMRLX67ncPR3cSCqE_Ls7jJPnO28KyxQskoQLACr9Lc,4059
+workloads/collatz/snapshot/compiled/canonical/capability_side_effects/capability_side_effects__CS_MUTABLE_JSON_V0.json,sha256=dzNuLJ4eDEWtlIUnjc4KoWXz4VE9Q3WbPAgjnsfSQ5Q,13064
+workloads/collatz/snapshot/compiled/canonical/capability_transforms/workload__CT_PURE_COLLATZ_STEP_V0.json,sha256=2q0kJ-CKLePo-_cImqI1H39NjRy6TPvsl6mS_t5iOZk,3532
+workloads/collatz/snapshot/compiled/canonical/capability_transforms/workload__CT_PURE_TERMINATION_CHECK_V0.json,sha256=2CSOPIEyurKyB8xYmFfkqoFwj-RGBIGF6r0ICBkMMTA,3885
+workloads/collatz/snapshot/compiled/canonical/events/workload__EV_CONJECTURE_EVALUATED_V0.json,sha256=PfPbnKWdAn9V_SSeIsLkiopm72mTAehr_8D_9FTpvt0,1668
+workloads/collatz/snapshot/compiled/canonical/ingress_intents/workload__TI_COLLATZ_COMPUTE_V0.json,sha256=5dGQRS4ABbZDm_XdNc_TpJGAXOekOM-07CxVorOlNOY,2965
+workloads/collatz/snapshot/compiled/canonical/intents/workload__IN_COLLATZ_INPUT_VALIDATED_V0.json,sha256=So0ntYuP7OOBLB7EM8eOMS2z2cbYow3PqiBgoHI5G_4,2233
+workloads/collatz/snapshot/compiled/canonical/runtime_bindings/workload__RB_COLLATZ_V0.json,sha256=g31j0QMwK5WNym_k8PCiRCx3RwJoVo1LhCbjB5pxnHI,2024
+workloads/collatz/snapshot/compiled/canonical/structures/workload__STRUCTURE_BUILD_WORKLOAD_CONFIG_V0.json,sha256=1pH75DSKsxVCbpAWlzl2SY8ZX8ViKXcIJVtkG8jrv0g,7701
+workloads/collatz/snapshot/compiled/canonical/structures/workload__STRUCTURE_COLLATZ_STORAGE_V0.json,sha256=QzV-UuJdjKKGceJ_r_0M8v-N18ZZCzfPaPDimkdldfo,2659
+workloads/collatz/snapshot/compiled/canonical/transport/egress/workload__TE_COLLATZ_COMPUTE_V0.json,sha256=OiMYXrVFPU-Rksk3x3Bzf35BT5Y47tXqcc3A-OAc2Dc,3281
+workloads/collatz/snapshot/compiled/canonical/workflows/workload__WF_COLLATZ_CONJECTURE_V0.json,sha256=uxr4MxuKbJZOVCPQQPrVWQiGlxY7_yq3aE6nkAHdbdo,6323
+workloads/collatz/snapshot/compiled/evidence/workload/evidence.json,sha256=dP3LxWfImyp9o7dEXrcyHIARufgIhfBqbYiAOXlCMEo,7604
+workloads/collatz/snapshot/compiled/evidence/workload/evidence_graph.json,sha256=1uedWBzNz4G0ZcJMhmDO9iieZsyU79va0k_sx9dqN2c,29702
+workloads/collatz/snapshot/compiled/evidence/workload/metadata.json,sha256=KQ1Kd9CzxgmHx-eNJkgt0IsxAC3qFhvrGLWJwcoZsbY,724
+workloads/collatz/snapshot/compiled/tokenized/workload/dispatch.json,sha256=Y-VQNbgtoAGjkR4LZHq4R1qltvK_ir4pzpKtOxGjySo,3517
+workloads/collatz/snapshot/compiled/tokenized/workload/handlers.json,sha256=HgZrNFbC8q_9T7PH74Nz7n18h_MXZIvAHC-XYVdVHi8,9665
+workloads/collatz/snapshot/compiled/tokenized/workload/metadata.json,sha256=oX5vWKeexeaUh7-OfgPKJlcoLM6047n7JEKlgcLdPqc,666
+workloads/collatz/snapshot/compiled/tokenized/workload/topology.json,sha256=uGhgEQQSILwBlkumpGqgD8ffsCrY0J2AWXoOvnXw6tc,2010
+workloads/collatz/snapshot/compiled/trust/workload/structure_attestation.json,sha256=Zu8oHA1eLioQTrkW0DV7_1dtoox-UPQ9atuScQJabU4,609
+workloads/collatz/snapshot/compiled/vocabulary/workload/forward.json,sha256=LfrgmAJabXOxnIS-ausxzH0qd290IR329osu6rG1x6k,2025
+workloads/collatz/snapshot/compiled/vocabulary/workload/metadata.json,sha256=oN3FwFkHJdwY1CNcaWhvNZYZ2H5rcDrye5wJASK8UMc,559
+workloads/collatz/snapshot/compiled/vocabulary/workload/reverse.json,sha256=Qi8hYb092LSuIIHD5Q3km2etuH_2QJlWr86W8U3AanI,2025
+workloads/collatz/snapshot/determinations/STRUCTURE_BUILD_WORKLOAD_CONFIG_V0.admitted.json,sha256=utlAZpOx3sJf54WIb8LmIok51-HHbOD6Wdd3Mw4St9g,19782
+workloads/collatz/test_payloads/01_happy_path.json,sha256=I4FsN4EnD4CdXbbn3xPd1TNjfODUdvGiULUtT0FjoYU,59
+workloads/collatz/test_payloads/02_single_number.json,sha256=qWtcocMfUY2sU8nQfrIjjmq11ogypgTW-5JkRaXg-YE,22
+workloads/collatz/test_payloads/03_invalid_nack.json,sha256=oYO5JwAeqe_-djUkD1x-3lrP0lUL4LGdgUtxep606GY,29
+pgc_workloads-2.0.0.dist-info/METADATA,sha256=MT9jCqlExMtxkhh3uNOmK7yWh_CrVJ2GthcNIGCHU2o,5900
+pgc_workloads-2.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pgc_workloads-2.0.0.dist-info/top_level.txt,sha256=AebziWFXu5criTVhZfHvsLpwDAWzCFR3T1hglhpcWko,10
+pgc_workloads-2.0.0.dist-info/RECORD,,

pgc_workloads-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pgc_workloads-2.0.0.dist-info/licenses/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.dist-info/licenses/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.dist-info/top_level.txt

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

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" }
+  ]
+}

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}

workloads/collatz/implementation/capability_transforms/atoms/ct_pure_termination_check_v0.py

@@ -0,0 +1,59 @@
+"""
+CT_TERMINATION_CHECK_V0
+
+Pure Capability Transform (Atom)
+
+Purpose:
+    Verify that every Collatz sequence in the input terminates at 1.
+
+Implementation:
+    - Inspects last element of each sequence
+    - Collects any sequences that do not end at 1
+    - Returns all_terminate flag and list of non-terminating seeds
+
+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_TERMINATION_CHECK_V0.
+
+    Inputs:
+        sequences (dict): Mapping from str(n) → list of integers (Collatz sequences)
+
+    Outputs:
+        all_terminate (bool): True if every sequence ends at 1
+        non_terminating (list): Seeds whose sequences did not end at 1
+    """
+    if "sequences" not in inputs:
+        raise CTExecutionError(
+            "CT_TERMINATION_CHECK_V0: missing required input 'sequences'"
+        )
+
+    sequences = inputs["sequences"]
+
+    if not isinstance(sequences, dict):
+        raise CTExecutionError(
+            f"CT_TERMINATION_CHECK_V0: 'sequences' must be a dict, got {type(sequences).__name__}"
+        )
+
+    non_terminating: List[str] = []
+
+    for seed, seq in sequences.items():
+        if not isinstance(seq, list) or len(seq) == 0:
+            non_terminating.append(seed)
+            continue
+        if seq[-1] != 1:
+            non_terminating.append(seed)
+
+    all_terminate = len(non_terminating) == 0
+
+    return {
+        "all_terminate": all_terminate,
+        "non_terminating": non_terminating,
+    }

workloads/collatz/snapshot/compiled/behavior_logic/WF_COLLATZ_CONJECTURE_V0/WF_COLLATZ_CONJECTURE_V0.graph.json

@@ -0,0 +1,209 @@
+{
+  "wf_id": "WF_COLLATZ_CONJECTURE_V0",
+  "entry": "IN_COLLATZ_INPUT_VALIDATED_V0",
+  "nodes": [
+    {
+      "id": "CC_COMPUTE_SEQUENCES_V0",
+      "type": "CC",
+      "cc_code": "CC_COMPUTE_SEQUENCES_V0",
+      "capability": "workload::CT_PURE_COLLATZ_STEP_V0",
+      "capability_type": "CT",
+      "projection": {
+        "steps": [
+          {
+            "bindings": {
+              "numbers": "in.numbers"
+            },
+            "fqdn": "workload::CT_PURE_COLLATZ_STEP_V0",
+            "id": "CT_PURE_COLLATZ_STEP_V0",
+            "inputs": [
+              "numbers"
+            ],
+            "kind": "CT",
+            "outputs": [
+              "sequences"
+            ]
+          }
+        ]
+      },
+      "input_bindings": {
+        "type": "wf_boundary",
+        "bindings": {
+          "numbers": "IN.numbers"
+        }
+      }
+    },
+    {
+      "id": "CC_STORE_RESULTS_V0",
+      "type": "CC",
+      "cc_code": "CC_STORE_RESULTS_V0",
+      "capability": "capability_side_effects::CS_MUTABLE_JSON_V0",
+      "capability_type": "CS",
+      "projection": {
+        "steps": [
+          {
+            "fqdn": "capability_side_effects::CS_MUTABLE_JSON_V0",
+            "id": "CS_MUTABLE_JSON_V0",
+            "kind": "CS",
+            "ops": [
+              "READ",
+              "WRITE",
+              "UPDATE",
+              "DELETE",
+              "DELETE_MANY"
+            ],
+            "ops_truncated": true,
+            "outputs": [
+              "result_status"
+            ]
+          }
+        ]
+      },
+      "input_bindings": {
+        "type": "wf_boundary",
+        "bindings": {
+          "all_terminate": "CC_VERIFY_TERMINATION_V0.all_terminate",
+          "non_terminating": "CC_VERIFY_TERMINATION_V0.non_terminating",
+          "sequences": "CC_COMPUTE_SEQUENCES_V0.sequences"
+        }
+      }
+    },
+    {
+      "id": "CC_VERIFY_TERMINATION_V0",
+      "type": "CC",
+      "cc_code": "CC_VERIFY_TERMINATION_V0",
+      "capability": "workload::CT_PURE_TERMINATION_CHECK_V0",
+      "capability_type": "CT",
+      "projection": {
+        "steps": [
+          {
+            "bindings": {
+              "sequences": "in.sequences"
+            },
+            "fqdn": "workload::CT_PURE_TERMINATION_CHECK_V0",
+            "id": "CT_PURE_TERMINATION_CHECK_V0",
+            "inputs": [
+              "sequences"
+            ],
+            "kind": "CT",
+            "outputs": [
+              "all_terminate",
+              "non_terminating"
+            ]
+          }
+        ]
+      },
+      "input_bindings": {
+        "type": "wf_boundary",
+        "bindings": {
+          "sequences": "CC_COMPUTE_SEQUENCES_V0.sequences"
+        }
+      }
+    },
+    {
+      "id": "EXIT_CONJECTURE_PROVEN",
+      "type": "EXIT"
+    },
+    {
+      "id": "EXIT_CONJECTURE_VIOLATED",
+      "type": "EXIT"
+    },
+    {
+      "id": "EXIT_ERROR",
+      "type": "EXIT"
+    },
+    {
+      "id": "EXIT_REJECTED",
+      "type": "EXIT"
+    },
+    {
+      "id": "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "type": "IN"
+    }
+  ],
+  "edges": [
+    {
+      "from": "CC_COMPUTE_SEQUENCES_V0",
+      "to": "CC_VERIFY_TERMINATION_V0",
+      "condition": "SUCCESS"
+    },
+    {
+      "from": "CC_COMPUTE_SEQUENCES_V0",
+      "to": "EXIT_ERROR",
+      "condition": "VIOLATION"
+    },
+    {
+      "from": "CC_STORE_RESULTS_V0",
+      "to": "EXIT_ERROR",
+      "condition": "BACKEND_ERROR"
+    },
+    {
+      "from": "CC_STORE_RESULTS_V0",
+      "to": "EXIT_CONJECTURE_PROVEN",
+      "condition": "SUCCESS"
+    },
+    {
+      "from": "CC_STORE_RESULTS_V0",
+      "to": "EXIT_ERROR",
+      "condition": "VIOLATION"
+    },
+    {
+      "from": "CC_VERIFY_TERMINATION_V0",
+      "to": "CC_STORE_RESULTS_V0",
+      "condition": "SUCCESS"
+    },
+    {
+      "from": "CC_VERIFY_TERMINATION_V0",
+      "to": "EXIT_CONJECTURE_VIOLATED",
+      "condition": "VIOLATION"
+    },
+    {
+      "from": "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "to": "CC_COMPUTE_SEQUENCES_V0",
+      "condition": "ACK"
+    },
+    {
+      "from": "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "to": "EXIT_REJECTED",
+      "condition": "NACK"
+    }
+  ],
+  "execution_paths": [
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "CC_COMPUTE_SEQUENCES_V0",
+      "CC_VERIFY_TERMINATION_V0",
+      "CC_STORE_RESULTS_V0",
+      "EXIT_ERROR"
+    ],
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "CC_COMPUTE_SEQUENCES_V0",
+      "CC_VERIFY_TERMINATION_V0",
+      "CC_STORE_RESULTS_V0",
+      "EXIT_CONJECTURE_PROVEN"
+    ],
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "CC_COMPUTE_SEQUENCES_V0",
+      "CC_VERIFY_TERMINATION_V0",
+      "CC_STORE_RESULTS_V0",
+      "EXIT_ERROR"
+    ],
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "CC_COMPUTE_SEQUENCES_V0",
+      "CC_VERIFY_TERMINATION_V0",
+      "EXIT_CONJECTURE_VIOLATED"
+    ],
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "CC_COMPUTE_SEQUENCES_V0",
+      "EXIT_ERROR"
+    ],
+    [
+      "IN_COLLATZ_INPUT_VALIDATED_V0",
+      "EXIT_REJECTED"
+    ]
+  ]
+}

workloads/collatz/snapshot/compiled/canonical/actors/workload__AC_REFERENCE_ACTOR_V0.json

@@ -0,0 +1,33 @@
+{
+  "artifact_code": "AC_REFERENCE_ACTOR_V0",
+  "artifact_type": "AC",
+  "content": "# AC_REFERENCE_ACTOR_V0\n\n## 1. Intent\n\nActor context under which the Collatz reference workflow executes. This is the Authority concern at\nits declaration/binding stage: a named actor that the workflow binds and the runtime propagates into\nthe execution context and attributes in the trace.\n\n**Scope note:** this artifact declares an actor *identity/context* only. It does NOT implement\nauthorization or enforcement \u2014 real authority checks belong to the governance/authority model and are\nout of scope here. The reference value is the lifecycle it demonstrates:\n`declaration \u2192 workflow binding \u2192 runtime context propagation \u2192 trace attribution`.\n\n---\n\n## Machine\n\n```yaml\nfqdn: workload::AC_REFERENCE_ACTOR_V0\nartifact_kind: ACTOR\nversion: v0\ngoverned_by: actor::CONSTITUTION_ACTOR_IDENTITY_V0\nauthority: pgc.platform\nconcern: workload\ncore:\n  summary: Reference workload actor\n  description: System actor context under which the Collatz reference workload executes.\n  type: system\n  attributes:\n    role:\n      type: string\n      required: true\n      value: reference_workload_runner\n```\n",
+  "content_hash": "2623143eb6d65e774c62d5194728350b8f61f5b38c82e76659e3bbed5215f9d6",
+  "fqdn_id": "workload::AC_REFERENCE_ACTOR_V0",
+  "frontmatter": {
+    "artifact_kind": "ACTOR",
+    "authority": "pgc.platform",
+    "concern": "workload",
+    "core": {
+      "attributes": {
+        "role": {
+          "required": true,
+          "type": "string",
+          "value": "reference_workload_runner"
+        }
+      },
+      "description": "System actor context under which the Collatz reference workload executes.",
+      "summary": "Reference workload actor",
+      "type": "system"
+    },
+    "fqdn": "workload::AC_REFERENCE_ACTOR_V0",
+    "governed_by": "actor::CONSTITUTION_ACTOR_IDENTITY_V0",
+    "version": "v0"
+  },
+  "layer_code": "WORKLOAD",
+  "namespace": "workload",
+  "references": [
+    "actor::CONSTITUTION_ACTOR_IDENTITY_V0"
+  ],
+  "version": "0"
+}