Protocol-Governed Computing — snapshot_assembler v6

Component of the Protocol-Governed Computing composition v6.

Protocol-Governed Computing — snapshot_assembler v5

Component of the Protocol-Governed Computing composition v5.

snapshot_assembler v4

Component of the Protocol-Governed Computing composition v4.

Protocol-Governed Computing v3

release 15 — a crash is not a refusal

This cycle changes nothing about what the platform determines. Every domain graph address in the
sealed composition is byte-identical to the one the preceding cycle produced; only the composition
ordinal differs, and it differs because the ordinal is carried in a constituent and constituents
enter the identity. Seven domains, 410 protocol artifacts, 595 constituents, composition conformance
PASSED over five rules.

Release 14 prepared eight repositories to become pgc-* distributions and recorded why an editable
install could not have told us whether they worked. This cycle performed the upload. Doing so put the
platform in front of someone holding only what PyPI serves, and that vantage point reported four
defects that every prior session had been unable to see — all of them at the one boundary where this
platform executes code it does not own.

What was actually done

Eight distributions published. pgc-governance, pgc-compiler, pgc-assembler, pgc-runtime,
pgc-inspector, pgc-transformation, pgc-workloads, pgc-domains, each with a wheel and an
sdist under the public identity v2. Three carry a patch bump to 2.0.1 for the repairs below. A ninth,
protocol-governed-computing, pins all eight to one composition: PyPI prohibits the short name
pgc, so the composition carries the full project name and installs the command pgc.

The assembler declared no dependencies and imported one. assembler/core.py parses the claimed
profile's YAML block, on the path verify_snapshot → verify_profile → _profile_declaration. The
distribution declared dependencies = []. In this workspace and under pgc the import resolved
from elsewhere; installed alone, the verify subcommand raised ModuleNotFoundError instead of
answering. The defect was invisible to every install shape except the one an outside party would use.

The runtime crashed where it was supposed to refuse. CT and CS handler references are sealed at
compile time and loaded by importlib at execution. Neither import site was guarded. A handler
module the snapshot names but the environment lacks, or a domain's optional dependency that is not
installed, escaped as a bare ModuleNotFoundError — past the trace, past routing, to the caller.
Both sites now refuse, and the refusals use codes SCHEMA_TRACE_EVENT_V0 already admits:
CT_ARTIFACT_NOT_FOUND where the snapshot names something absent, CT_EXECUTION_FAILED and
CS_EXECUTION_FAILED where the named thing is present and cannot run. No vocabulary was invented to
describe a failure the schema had no word for; the schema had the words.

A refusal that reached the caller carried nothing. _execute_ct_step ended
except Exception: return "VIOLATION", {}. Every CT refusal — including the ones this cycle added —
was converted to a status with no cause, leaving an operator a result and no account of it. Both
branches now render a structured refusal into the step result through one payload builder, which is
the channel the reach refusal has always used.

Domain cryptography became an extra. pgc-domains required pycryptodome unconditionally, so
installing the composition pulled cryptography for everyone. Exactly one capability transform needs it, and
the workspace has said since RI-0 that domain crypto is optional and never on the core compile path.
The declaration now matches the policy: pip install "pgc-domains[blockchain]".

Why this is not bookkeeping

Three of the four are the same defect. A guard existed a line away from where it was needed —
execute_fn was wrapped and import_module was not; the CS constructor and its execute call were
wrapped nowhere; the CT branch caught its exception and threw away what it caught. Nothing was
missing that anyone had failed to think of. The thinking was done and applied unevenly, and no test
could report it because no test asked the environment to be incomplete.

That is the shape release 12 recorded about demonstrations and release 14 recorded about editable
installs, arriving from a third direction. A procedure that cannot fail is not evidence, and a
platform that fails in an undeclared way has not failed in a governed one. This project's own
doctrine is that behaviour absent from the sealed state is refused rather than improvised. A
ModuleNotFoundError reaching a caller is improvisation by omission: the runtime met a condition its
governance had no word for, and said so in Python's words instead of its own.

The fix that matters least is the assembler's missing dependency. The fix that matters most is that
the runtime now answers, in its own declared vocabulary, when the environment cannot supply what a
sealed snapshot names.

What this release is for

Release 13 made the composition citable. Release 14 made it buildable as an artifact. This one makes
it installable by a stranger, and reports what that stranger's vantage point found. The platform
determines exactly what it determined before; what changed is that its failures at the boundary are
now declared outcomes rather than exceptions, and that the family can be obtained by name.

Protocol-Governed Computing — v2

release 13 — a publication nobody outside can name is not available for use

This cycle changes nothing about what the platform does. It changes whether the platform can be
named by someone who was not part of building it, which is the precondition for every instrument the
project has left.

Cycle 12 ran the programme this project had been building toward: independent parties authoring
against the standard alone, building a system from it, driving that system from what it sealed, and
evolving it through its own transformation semantics. That result is recorded in release-12.md,
and it is the substance this cycle publishes. Cycle 12 was cut and not published; the composition
ordinal advanced and the public identity did not. This cycle issues v2 and carries cycle 12's work
under it.

What was actually done

Every repository declares its own deposit metadata. Ten .zenodo.json files — the nine
composition repositories that carry executable surface, and standards, which is outside the release
cycle and carries its own revision identity. Each declares title, description, author with ORCID,
licence and keywords.

.github deliberately has none. It carries the release process and the assembly contract, not a
component of the reference implementation, and a citable identity for it would name a thing nobody
should cite.

The standard became citable first. standards was archived at revision v0 and carries a
version DOI, 10.5281/zenodo.22150616, distinct from the concept DOI that resolves to whatever the
family later becomes. A claim names the revision it was made against, so it names the version. The
concept DOI reaches the standard; it does not name one.

Its CITATION.cff was missing an ORCID. The author was identified by name, alias and email, none
of which is a resolvable identity. Added.

Why this is not bookkeeping

v1 was archivable and not citable. Anyone could have archived it, and the archive would have been
attributed by inference — a repository name, a platform username, a licence guessed from a file. An
identity assembled by inference is the thing this family objects to everywhere else, and it is no
more acceptable when the subject is the publication itself than when it is a governed artifact.

The distinction the project keeps making about its own artifacts now holds for the artifacts
themselves: declared, not inferred.

What this release is for

The last cycle closed the last thing the project could do to itself. What remains requires someone
who was not part of building it — and someone who was not part of building it has to be able to name
what they examined, at the revision they examined it, without asking the people who built it.

That is the whole of this cycle. It is the smallest change in the project's history and the one that
makes the previous cycle's result usable by anyone else.