pgc-transformation 2.0.0__py3-none-any.whl

pgc_transformation-2.0.0.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: pgc-transformation
+Version: 2.0.0
+Summary: PGC transformation compiler — the governed change request to authoring mandate pipeline (P0-P8), and the construction compiler that renders artifacts from an approved design (command: tc)
+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/transformation
+Project-URL: Standard, https://doi.org/10.5281/zenodo.22150616
+Keywords: protocol-governed-computing,pgc,transformation,change-request,evolution
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: pgc-inspector>=2.0.0
+Requires-Dist: pgc-runtime>=2.0.0
+Requires-Dist: click
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# transformation
+
+**The governed Change Request → Protocol Artifact pipeline**, and it holds **two compilers**.
+
+| Compiler | Transforms | Code | Registry |
+|---|---|---|---|
+| **Design** | problem → design | `transformation/design/` | `registry/design/` |
+| **Construction** | design → protocol artifacts | `transformation/build/` | `registry/build/` |
+
+They are two because they fail differently. A *design* failure is a mandate that is incomplete or
+contradictory, and a phase's rule set catches it. A *construction* failure is a mandate that was
+valid and did not uniquely determine an artifact — only the thing that renders can expose that, and
+the repair amends the design language rather than one register. Merging them would blur two failure
+classes that different layers repair.
+
+The repository is named for the lifecycle, not for either compiler. **`transformation` is not a
+third compiler.** A functional rehost of RI-0's `pgs_change_mgmt`, extended well past where RI-0
+stopped.
+
+A change begins as a plain-language problem statement and is driven through gated phases into an
+**Authoring Mandate** — a complete, reviewable dossier — *before* any protocol artifact is written.
+Only after the mandate is approved are artifacts authored, and the protocol compiler then governs
+their admissibility.
+
+```
+problem statement → P0 → Gate 0 → seed → dossier P1..P7 → Gate 1 → P8 → Gate 2
+     → construction → authored artifacts
+     → protocol_compiler S1..S9 → snapshot_assembler → conformance → runtime → trace
+```
+
+This pipeline is measured in **phases (P0–P8)**; `protocol_compiler` is measured in **stages
+(S1–S9)**. RI-0 numbered both S1–S7/S1–S9, which made every piece of evidence ambiguous about which
+pipeline produced it. A dossier has phases, a compilation has stages, and nothing uses one word for
+the other.
+
+## Install
+
+```bash
+pip install pgc-transformation
+```
+
+Once installed:
+
+```bash
+tc --help
+```
+
+## Build-time tool
+
+`transformation` is **CLI only** — no TI/TE boundary contract, no Operation Identity, not
+reachable over transport. A boundary contract governs a runtime surface served from a sealed
+snapshot; this tool runs *before* a snapshot exists, its output is authored artifacts a human
+gates, and its only reader is the person driving the change.
+
+```bash
+tc phase list                              # phases this build governs
+tc phase check --phase p0 <seed.md>        # structural oracle — ADMISSIBLE / INADMISSIBLE
+tc phase check --phase p1 <register.md>
+tc phase check --phase p2 <register.md> --snapshot <root>   # grounds against the composition
+tc phase template --phase p1               # the required section structure
+tc phase rules --phase p1                  # the declared rule set
+tc phase project <prior.md> --phase p1 --out <doc.md>       # phases that decide nothing
+
+tc phase meta                              # do the rule sets themselves hold?
+tc phase emit --check                      # are the sealed workflows current?
+
+tc baseline show --snapshot <root>                 # the composition present, as a pin
+tc baseline verify <pin.json> --snapshot <root>
+tc baseline approve <pin.json> --phase p2 --by <who>
+
+tc construction check <dossier> --snapshot <root>   # does the design determine its artifacts?
+tc construction emit  <dossier> --root <domain>     # render them, at 100% or not at all
+```
+
+Two of these judge the pipeline rather than a dossier. `tc phase meta` asserts that every declared
+rule can run and every implemented mechanism is declared — if that correspondence breaks, a verdict
+over a document is meaningless, because a rule that cannot run reports green over a subject it never
+evaluated. `tc phase emit --check` asserts the sealed copy of a rule set still agrees with the
+generator that produces it; a rule added after a workflow was emitted once left 52 rules sealed
+against 55 declared, and every run reported confidently on the smaller set. Both belong in a build.
+
+`tc construction check` measures **determinacy** before anything is written: the fraction of the
+facts the artifacts require that the design determines. Below 100% nothing is emitted, because a
+generator choosing a value it was not given is a generator inventing one.
+
+## The two loops
+
+`$W` is the workspace root holding the sibling repos.
+
+**After editing a dossier's P7 or P8** — skipping a step leaves the snapshot describing a design that
+no longer exists:
+
+```bash
+D=$W/business_domains/book_library_mgmt/cr_dossiers/cr_01_catalog
+
+tc construction check $D --snapshot $W/snapshot
+tc construction emit  $D --root $W/business_domains/book_library_mgmt
+
+python $W/transformation/scripts/testbed/construction_acceptance.py
+$W/protocol_compiler/compile_domain.sh $W/business_domains/book_library_mgmt
+PGC_SNAPSHOT_PROFILE=REFERENCE_PLATFORM_PROFILE_V1 $W/snapshot_assembler/assemble.sh
+```
+
+`--snapshot` on the check is not optional in practice. Completeness never looks at what already
+exists, so an artifact inventoried `EXTEND` is rendered whole and replaces its predecessor — a design
+stating only the delta deletes the rest, at 100% completeness. The flag is what runs the narrowing
+check; without it that check does not run, and says so.
+
+Construction writes into `data/`, never into the domain. **Promotion is a separate, deliberate act.**
+A `tc construction build` CLI existed once and was removed, because it duplicated a governed path
+with an ungoverned one.
+
+A new capability transform is a protocol artifact *and* a Python implementation. Construction renders
+the first; the second is hand-authored at
+`business_domains/<domain>/implementation/capability_transforms/atoms/<code_lower>.py` with a
+callable `execute(inputs, context)` raising `CTExecutionError`. A CT whose module is missing returns
+nothing and its contract yields `VIOLATION` — while every check above still passes.
+
+**After changing a phase's rule set** — the rules are declared in
+`transformation/design/<phase>/rules.py` and *sealed* into that phase's workflow artifact. Editing
+the declaration alone leaves `tc phase check` and the governed workflow evaluating different rule
+sets:
+
+```bash
+tc phase emit --check                                  # names the drifted phase
+python $W/transformation/scripts/emit_rule_sets.py     # re-seal
+$W/protocol_compiler/compile_domain.sh $W/transformation
+PGC_SNAPSHOT_PROFILE=REFERENCE_PLATFORM_PROFILE_V1 $W/snapshot_assembler/assemble.sh
+python $W/transformation/scripts/testbed/build_fixtures.py
+python $W/transformation/scripts/testbed/build_payloads.py
+```
+
+Fixtures and payloads are **derived from the live dossier** — never hand-edit one; change the dossier
+or the mutator in `build_fixtures.py`. A derived fixture cannot go stale silently, because the
+derivation raises rather than producing a wrong one.
+
+The fast inner loop is `python scripts/testbed/differential.py`, which drives the capability
+transforms directly. It proves the rule sets and the check logic and nothing about workflow wiring;
+`scripts/testbed/e2e_phases_test.py` boots the assembled snapshot and proves the wiring. Neither
+substitutes for the other — a workflow that bound `$.capability_result.header` across nodes passed
+the differential and failed immediately under the runtime.
+
+From P2 a phase also needs its **priors**, or the handoff between phases goes unchecked:
+P1←p0 · P2←p1 · P3←p2 · P4←p3 · **P5←p0** · P6←p5 · P7←p5+p6 · P8←p7. P5 reads the seed, not P4: the
+subdomain purpose is authored once at P0, has no register to travel in through P1–P4, and reappears
+at P5.
+
+## Why "transformation", not "change management"
+
+**PGC evolution is never greenfield.** Every change is a transformation of an existing composition:
+a new domain still compiles against the platform's normative closure and composes into a snapshot
+that already exists. The name states what the tool does; `change_mgmt` named the process around it.
+
+That property is also what makes the tool testable. Its distinguishing logic — REUSE / EXTEND
+decisions, placement, ownership, semantic preservation, roundtrip equivalence — is meaningful only
+against a baseline. A greenfield run exercises none of it.
+
+## Relationship to the rest of the toolchain
+
+```
+protocol_compiler       source      → compiled projections
+snapshot_assembler      projections → assembled snapshot
+protocol_runtime        snapshot    → execution
+snapshot_inspector      snapshot    → inspection
+transformation           problem     → change request → authoring mandate   (this repo)
+```
+
+Every snapshot fact this pipeline needs arrives through
+`inspector.api.query(operation, params, snapshot_root)`. It imports nothing from `compiler.*`.
+RI-0's pipeline reached directly into `pgs_compiler.compiler.projections` to build indexes itself;
+removing that coupling is why `snapshot_inspector` was completed first, and building this repo
+without it is that work's acceptance test.
+
+## Validation is pinned
+
+Runs are validated against a **named, frozen snapshot**, never "the current snapshot" — every
+register a snapshot-reading phase emits encodes facts about one specific composition. A run that
+observes a different `snapshot_id` fails before any phase executes.
+
+Rebaselining is deliberate and has two halves. `tc baseline verify` proves the composition is the
+one named; `tc baseline approve` records that someone re-read the registers asserting facts about
+it. Which registers a phase owes is derived from its rule set — a register rests on a snapshot fact
+exactly when a rule governing it consults an observation. The approval lives in the pin, so re-pinning
+drops it: an approval is against one composition and survives no other.
+
+## Documents
+
+- `doc/THE_SHAPE_OF_A_CHANGE_V0.md` — when a subject is a new change request and when it is the
+  same one re-authored, and which artifacts a governance change may amend.
+- `doc/TRANSFORMATION_COMPILER_PLAN_V1_ADDENDUM_A.md` — the `book_library_mgmt` domain, its
+  decomposition, and the change request sequence it is worked through.
+- `doc/TRANSFORMATION_COMPILER_PLAN_V1_ADDENDUM_B.md` — self-hosting: why the pipeline's first
+  governed change is itself, and what that settles. Plan V1 itself has been removed; the addenda are
+  what survives, and a settled ruling is restated where it is needed rather than by restoring the
+  plan.
+- `doc/REGISTER_COVERAGE_VERIFICATION.md` — whether a design can state, for an artifact it amends,
+  every fact that artifact carries. Four observed instances of one pattern: a fact the authoring
+  path never had to state because authoring supplies it, and the amending path must state and
+  cannot.
+- `templates/` — the phase templates. **These are the authority**: registers, columns, controlled
+  vocabularies and optionality are read from them, and rule sets are derived. A shape declared
+  anywhere else is not a template.
+
+---
+
+## 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_transformation-2.0.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+pgc_transformation-2.0.0.dist-info/licenses/LICENSE,sha256=wf4s-Px76q2zHB2b8Gbvuu4ULua8AMds2IY01MkBn0A,2544
+pgc_transformation-2.0.0.dist-info/licenses/NOTICE,sha256=nE4--l6r3rMCz0nVaFyFohZtY4NYADnrhcS9K2pdNr0,407
+transformation/__init__.py,sha256=q8c7McgKNFK9xjFfCt_Mj8RVT8K2tcuNu543bR5i25k,169
+transformation/__main__.py,sha256=V3J6qfRbm9UDicBQ2qtxy88V_OK5RWdocqfA5wMsSJw,75
+transformation/baseline.py,sha256=_On_kaBv1-bdzGu-K42GQtdXIkEI4d_xX3pTeyfxdDw,6055
+transformation/cli.py,sha256=bgBMIwJIQqeX-lSm5kse_ixkJT3ASNP7xZiCj34nEcU,43012
+transformation/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/build/completeness.py,sha256=rkjW6XKzBSoBoX4L69Ti1DB8hgabxZgF3aoZ2poRVjw,8430
+transformation/build/generators.py,sha256=gjLa3QuWyHJjV1EMHOJHMHG72ifW9_Qs7nHAnz54LSU,7364
+transformation/build/render.py,sha256=E5uHs_-L99CoLe9XXRnLVYC6Q2UDDil0LolrFp9HSac,61850
+transformation/design/__init__.py,sha256=Z4Ot73N2NxnrxuTJRhflZpb0S3mv7CKaFCIZAqrbsNk,263
+transformation/design/catalog.py,sha256=g5fH6hDsfFYcQqN2o9mI2h74LMgHLExhT108aruaMP8,6410
+transformation/design/checks.py,sha256=TQXSRoSUOqXzFtRrkte74ZXf8OUG12-P_cBehCWTchw,142297
+transformation/design/derive.py,sha256=EHTZsMBisSrEY3GoD0cLRRTV-8u5egD9_os7S7yTCGI,8516
+transformation/design/emit.py,sha256=upSsupjgQCN1HzmSj93uXfyPi3v5nyb2DAZ7zvfOrHU,18410
+transformation/design/evaluate.py,sha256=oLybHDfuyJGKO2Xp7W1w-5gGreqDtjJF4ciOOmk-IW0,6699
+transformation/design/families.py,sha256=2Ld01Jln1C5531c9imWHZ_GBBEt7HqdZad5aVF2VV9M,4706
+transformation/design/merit.py,sha256=Hoh28UInXM8lvwPSX0WQLVosE-YEBp0XcA-1EhpUcGo,6284
+transformation/design/meta.py,sha256=q6mXaWTo0jYmJQAy4oA-ls2M2crNet5vfrkEpp6Ex8M,14846
+transformation/design/oracle.py,sha256=sjzNpKcAQZAdvi3lzPatgF2y6TQitOaeA-e9YX1CAUc,3205
+transformation/design/project.py,sha256=f_Y4LkozktHUyDV3X_6xlCKmaO71C4_MVag72g2QLKA,8571
+transformation/design/read.py,sha256=KIFnJNw2PxNjEsmCjoSntLRfbUGdizgITYUhO0brqYw,5962
+transformation/design/rules.py,sha256=m19X2LzwlIkfNEQY-h3r826gkxI6v3A1hg1vxaQQGCs,8325
+transformation/design/sealed.py,sha256=Te9e7d4eU18GyY_m0dDKwmj3u-ZsLz_wfckH76dO_lU,2426
+transformation/design/template_reader.py,sha256=K1n9It1Ul8mJXXn30g9Po4nzhLAUM2h_V2v7sstdqTA,11472
+transformation/design/p0_change_seed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/design/p0_change_seed/rules.py,sha256=fe-8CDeW8kCh6RZgPlLl5szsLZlf2AUOEYVRUQZiUBI,3238
+transformation/design/p1_change_request/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/design/p1_change_request/rules.py,sha256=Nv20v2FxaeqssQ2ifeK71KtvltX52rNSDa30wLRCwww,6675
+transformation/design/p2_domain_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/design/p2_domain_model/rules.py,sha256=46giEAJDPTMEETJGfZcdGFdm0GpLBfxpNWClC9DUJD4,5097
+transformation/design/p3_analysis_loop/__init__.py,sha256=3CUAaevgUNKto8C0b-pdZt0pMXYmCSxDVRDwj0ea3T4,37
+transformation/design/p3_analysis_loop/rules.py,sha256=X9_aJxCecHGzHJv_BJ7YS9GAL_bqu_PaUT7fPTpMyOs,8219
+transformation/design/p4_business_model/__init__.py,sha256=YEZvDAW8VpfP1hgISWaKb5AOsz2tSW1yaaSSMGKFBqw,38
+transformation/design/p4_business_model/rules.py,sha256=WOcNIpC08a08ckSKnydHGyipTJQnWInX0JvhboMGWJg,6553
+transformation/design/p5_business_intent/__init__.py,sha256=POiYdGnOzH4Z7V8kQ8MiBGMjz2Ye-7P6sd6dmd7rPeo,39
+transformation/design/p5_business_intent/rules.py,sha256=5p4qh1GIbUO5TSaT6d6uiZH7mYu-ec23gr-j9aAxb-Q,9965
+transformation/design/p6_governance_intent/__init__.py,sha256=_BjJlUEWn87iVw4kyHfNghkDrbKojdMtXePLVA_a6CQ,41
+transformation/design/p6_governance_intent/rules.py,sha256=kMusRRbEJ-CX0Xe4-auIBvPm9awTUKlt6H6RwATU_j4,9533
+transformation/design/p7_design_intent/__init__.py,sha256=G6VHVTeSbQ9Ah2DiTno1eOx_ViKZDcXbZ5P6RLDS8kQ,37
+transformation/design/p7_design_intent/rules.py,sha256=JtcO2HYQMHx-HIArgqajB_Ay6q0PiXFsA4n0w0hemCo,51633
+transformation/design/p8_authoring_mandate/__init__.py,sha256=wl3GTBgc0s0K7OJHpDtWYkNxm_6l_CzX2MCjvnjgBZs,41
+transformation/design/p8_authoring_mandate/rules.py,sha256=rgUq_n2QDVZKEK2ECnbicbdt0-4BIlWOafVfI1O_mSA,9878
+transformation/implementation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/implementation/capability_transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/implementation/capability_transforms/atoms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+transformation/implementation/capability_transforms/atoms/ct_pure_attribute_provenance_v0.py,sha256=VYKVp52DcBNHX9cBNdUoeGcMfSas1oeWgybPWJFLtPI,3154
+transformation/implementation/capability_transforms/atoms/ct_pure_evaluate_rules_v0.py,sha256=WMz_rgX0IID6JkC0pV_XNMKvgYRof0WY2E8psYAsJXw,3333
+transformation/implementation/capability_transforms/atoms/ct_pure_measure_completeness_v0.py,sha256=TfdoHZSvZQoslashdPem8bV6Olcj24IEhqB1QsP_TuQ,2665
+transformation/implementation/capability_transforms/atoms/ct_pure_parse_prior_phases_v0.py,sha256=wvovHnkCb4UTMyBcqf4gof2fXAxP1FmXsgEHMNXzon8,1994
+transformation/implementation/capability_transforms/atoms/ct_pure_parse_registers_v0.py,sha256=jbGig1hH581UhVxTr9jtTWglunfZszjZd0k6xx9Mk1Y,1648
+transformation/implementation/capability_transforms/atoms/ct_pure_render_artifacts_v0.py,sha256=jFpLEP5Csb9b4fYVFWkJuEH2H8BAWnXkC7Wc2qQxBC0,2682
+transformation/templates/p0_change_seed_template_v0.md,sha256=VtlPW8dA3Rwxh-A_Y62VEPyLdo3DkxAl-U6j9dmnjBE,11434
+transformation/templates/p1_change_request_template_v0.md,sha256=Tgn69x8ZY093VGl_hBzYZgR3rKJ1Wl7X3gDLHKXQoTw,15290
+transformation/templates/p2_domain_model_template_v0.md,sha256=3egSiCoHPzEaXv6uzBWlILqOurWQ7B2yS4G5h1RwoDY,13500
+transformation/templates/p3_analysis_loop_template_v0.md,sha256=IZX7z9EF992hwEwZ4Zn8SiwvZTA04cZMDDKvobsvvWY,9891
+transformation/templates/p4_business_model_template_v0.md,sha256=4T8laAI4Vkr1QA-SgElcz9oVvSQWxFenKfZttilGS2c,10369
+transformation/templates/p5_business_intent_template_v0.md,sha256=H7yCGxcfh5zGJcLAChRGcD74njvD1ah45BeJvv1icqs,10504
+transformation/templates/p6_governance_intent_template_v0.md,sha256=1dvERIKIPoVfc-VIRnjVq8lshWeyAYllT0JwNhzccGE,10200
+transformation/templates/p7_design_intent_template_v0.md,sha256=u6gmjRkmhv1hnbDiNE63BE7ReCeqx20FiToPib181j0,31283
+transformation/templates/p8_authoring_mandate_template_v0.md,sha256=O3QZuZwhzaAqmWxHNKutsyQd49YDYOIcNwWI3agzIPU,7618
+pgc_transformation-2.0.0.dist-info/METADATA,sha256=TsKMFlol8EoPyPasKvwn_oczX5LgZ9PQf_tSdfH2uKg,14612
+pgc_transformation-2.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pgc_transformation-2.0.0.dist-info/entry_points.txt,sha256=wn_EBvI4GGai_YPTGWYS5KgQ-5vlNbP2naBcZHC9q_s,47
+pgc_transformation-2.0.0.dist-info/top_level.txt,sha256=7lCYYweNL_Fj0SN_bJzAWQqbhEtoIoHaoX0osPwQB1E,15
+pgc_transformation-2.0.0.dist-info/RECORD,,

pgc_transformation-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_transformation-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tc = transformation.cli:main

pgc_transformation-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_transformation-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_transformation-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+transformation

transformation/__init__.py

@@ -0,0 +1,5 @@
+"""PGC Transformation Compiler.
+
+Build-time tool: problem statement -> governed dossier -> authoring mandate.
+CLI only. No transport surface, no Operation Identity.
+"""

transformation/__main__.py

@@ -0,0 +1,4 @@
+from transformation.cli import main
+
+if __name__ == "__main__":
+    main()

transformation/baseline.py

@@ -0,0 +1,134 @@
+"""The pinned baseline.
+
+Validation runs against a named, frozen snapshot — never "the current snapshot". Every register a
+snapshot-reading phase emits encodes facts about one specific composition: which artifacts exist,
+what the normative closure contains, what a REUSE decision found. Against a moving snapshot those
+fixtures fail for reasons that have nothing to do with the transformation compiler, and a
+regression becomes indistinguishable from a rebuild.
+
+So: a run that observes a different snapshot_id fails before any phase executes. Rebaselining is a
+deliberate, reviewed act — re-pin the id, re-approve the affected registers.
+
+**Re-approval is the half the pin could not previously record.** Verifying the id proves the
+composition is the one named; it proves nothing about whether anyone re-read the registers that
+encode facts about it. A register asserting `impacted_count 58` goes false without anyone editing
+it, and after a re-pin there was no way to tell "re-grounded against this snapshot" from "never
+re-checked since the id changed". `approved_registers` records the second half, and because it
+lives in the file the id lives in, re-pinning drops it: an approval is against one composition and
+survives no other.
+
+**Which registers need approving is derived, not declared.** A register rests on a snapshot fact
+exactly when a rule governing it consults an observation, which the rule set already says. A
+hand-kept list would be a second declaration that drifts from the rules the moment either changes.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Iterable
+
+from inspector import api
+
+
+class BaselineMismatch(RuntimeError):
+    """The snapshot on disk is not the one this CR was validated against."""
+
+
+@dataclass(frozen=True)
+class Baseline:
+    snapshot_id: str
+    artifact_count: int
+    domains: tuple[str, ...]
+    # phase -> register -> who re-grounded it against this snapshot_id. Absent on a freshly
+    # observed pin, because observing a composition approves nothing about it.
+    approved_registers: dict[str, dict[str, str]] = field(default_factory=dict)
+
+    @staticmethod
+    def load(path: Path) -> "Baseline":
+        if not path.is_file():
+            raise FileNotFoundError(f"baseline pin not found: {path}")
+        data = json.loads(path.read_text(encoding="utf-8"))
+        for key in ("snapshot_id", "artifact_count", "domains"):
+            if key not in data:
+                raise KeyError(f"baseline pin {path} is missing {key!r}")
+        return Baseline(
+            snapshot_id=data["snapshot_id"],
+            artifact_count=int(data["artifact_count"]),
+            domains=tuple(data["domains"]),
+            approved_registers={
+                phase: dict(registers)
+                for phase, registers in (data.get("approved_registers") or {}).items()
+            },
+        )
+
+    def as_dict(self) -> dict:
+        """The pin as it is written. `approved_registers` is omitted when nothing is approved, so
+        a freshly observed pin is byte-identical to what `tc baseline show` has always emitted."""
+        out: dict = {
+            "snapshot_id": self.snapshot_id,
+            "artifact_count": self.artifact_count,
+            "domains": list(self.domains),
+        }
+        if self.approved_registers:
+            out["approved_registers"] = {
+                phase: dict(sorted(registers.items()))
+                for phase, registers in sorted(self.approved_registers.items())
+            }
+        return out
+
+    def approve(self, phase: str, registers: Iterable[str], by: str) -> "Baseline":
+        """Record that someone re-grounded these registers against this composition."""
+        merged = {p: dict(r) for p, r in self.approved_registers.items()}
+        merged.setdefault(phase, {}).update({register: by for register in registers})
+        return replace(self, approved_registers=merged)
+
+
+def grounded_registers(phase: str) -> tuple[str, ...]:
+    """The registers of a phase that rest on a snapshot fact, read from its own rule set.
+
+    A rule consulting an observation is the definition: it is the only way a register comes to
+    assert something the composition could later contradict. Registers governed only by structural
+    or cross-phase rules say nothing about the snapshot and need no re-approval.
+    """
+    from transformation.design.meta import RULE_MODULES
+
+    module = RULE_MODULES.get(phase)
+    if module is None:
+        return ()
+    return tuple(sorted({
+        rule.register for rule in module.rule_set()
+        if rule.register and any(key.endswith("observation") for key in rule.params)
+    }))
+
+
+def pending(pin: Baseline, phase: str) -> tuple[str, ...]:
+    """Grounded registers of a phase that nobody has approved against this pin."""
+    approved = pin.approved_registers.get(phase, {})
+    return tuple(r for r in grounded_registers(phase) if r not in approved)
+
+
+def observe(snapshot_root: Path) -> Baseline:
+    """Read the composition actually present at `snapshot_root`."""
+    status, summary = api.query("si.snapshot.summary", {}, str(snapshot_root))
+    if status != "SUCCESS":
+        raise RuntimeError(f"si.snapshot.summary failed on {snapshot_root}: {status}")
+    return Baseline(
+        snapshot_id=summary["snapshot_id"],
+        artifact_count=int(summary["artifact_count"]),
+        domains=tuple(d["domain"] for d in summary.get("domains", [])),
+    )
+
+
+def verify(pin: Baseline, snapshot_root: Path) -> Baseline:
+    """Assert the snapshot on disk is the pinned one. Fail hard on any drift."""
+    actual = observe(snapshot_root)
+    if actual.snapshot_id != pin.snapshot_id:
+        raise BaselineMismatch(
+            "snapshot does not match the pinned baseline — no phase may run.\n"
+            f"  pinned:   {pin.snapshot_id}\n"
+            f"  observed: {actual.snapshot_id}\n"
+            "Rebaselining is deliberate: re-pin the id and re-approve the affected registers."
+        )
+    return actual