Law Becomes Executable

Law Becomes Executable

Receiz v106.0.0 — The Constitutional Application Platform

I did not set out to build a constitutional application platform.

I set out to solve a more fundamental problem:

How can something digital remain true outside the system that displayed it?

Not merely accessible.

Not merely retrievable from a database.

Not merely recognized because a server says it exists.

How can a digital object carry its own identity, provenance, ownership, state, history and proof—and continue to remain itself across applications, devices, networks and time?

That question became Receiz.

At first, the work was about the object.

Could the proof live with the thing itself?

Could it verify offline?

Could it preserve identity outside the database?

Could it move without losing continuity?

Could its history append without rewriting what had already been witnessed?

Could the artifact outrank the server?

By v100, that answer had become Living Proof.

The object could carry itself.

But once the object could carry itself, a new question appeared:

What kind of application should be allowed to act upon it?

If an object carries durable truth, then software cannot continue treating it like an ordinary database row.

A server response cannot simply overwrite it.

A newer snapshot cannot erase an older verified event.

An AI agent cannot fabricate a transition because the requested outcome sounds reasonable.

A marketplace cannot silently reinterpret ownership.

A migration cannot rewrite history to make the new version easier to operate.

A game cannot resurrect a retired being merely because one branch of state failed to receive the retirement event.

Once proof lives with the object, the application itself must become accountable to that proof.

That is what v106 establishes.

Receiz v106.0.0 is The Constitutional Application Platform.

The law is now executable.

⸻

The Constitution Does Not Replace Proof

The first thing that must be understood is that the constitution is not sovereign.

The proof object remains sovereign.

The registry does not become a new centralized authority.

The SDK does not become truth.

The MCP server does not become truth.

The AI does not become truth.

The database does not become truth.

The release report does not become truth.

The hierarchy remains:

Sealed artifact truth. Deterministic proof-object state. Verified local truth. Verified appends. Authenticated projections. Server, database and session state. UI representation.

Every layer exists to serve the truth carried by the object beneath it.

That distinction matters because software systems usually reverse this hierarchy.

The database is treated as reality.

The server response becomes the final word.

The interface displays whatever the latest request returned.

If a local object disagrees with the server, the local object is assumed to be stale.

Receiz begins from the opposite premise:

Verified truth is not stale merely because it is local.

Once admitted, it remains part of the object’s history.

The only valid question is not:

Should we replace this truth?

The valid question is:

Is there new truth to append?

That is the central law of v106:

First admission only. Then append forever.

Proof memory is not a cache.

It is not temporary hydration.

It is not a convenience layer waiting to be replaced by the “real” server response.

It is the verified prefix of reality already known by the application.

The application paints from that known truth immediately, then asks whether new verified additions exist beyond the known head.

It does not rediscover the past.

It does not surrender stronger truth to a weaker snapshot.

It does not allow reconciliation to become rollback.

⸻

One Digest Binds the System

In v106, the SDK, MCP server, AI Skills, migration system, threat evidence and release qualification are bound to the same constitutional registry digest.

Not approximately.

Not by matching version labels alone.

Exactly.

If one surface is operating under a different constitution, the system does not quietly continue.

It fails closed.

That means the code executing a command, the MCP tool planning an operation, the AI Skill guiding the agent and the release gate validating the result all agree on the exact law being applied.

This changes what it means to build with Receiz.

A developer is no longer only importing methods.

They are importing an operating boundary.

The system knows:

• which laws apply;
• which commands are allowed;
• which transitions are forbidden;
• which authority profile governs the object;
• which evidence is required;
• which effects may be produced;
• which mutations must never occur;
• and what must happen before the work may be called complete.

The registry itself still declares that it is not the strongest truth.

Its purpose is not to replace the object.

Its purpose is to ensure that every actor interacting with the object obeys the same deterministic constraints.

⸻

Commands Are the Only Mutation Rail

In ordinary software, state can change from almost anywhere.

A component updates a field.

A database query edits a row.

A background process repairs an inconsistency.

An administrator changes a value manually.

An agent calls a convenient tool.

A migration rewrites old records into a new shape.

The application may eventually arrive at the expected screen, but the path that produced the result becomes difficult or impossible to prove.

v106 removes that ambiguity from canonical state.

Commands are the only mutation rail.

A command carries:

• the actor requesting the action;
• the tenant or authority boundary;
• the affected aggregate;
• the expected revision;
• its causal parents;
• the exact registry digest;
• a signed capability;
• an idempotency key;
• the requested input;
• and the maximum effects the command is permitted to create.

The application does not accept the claimed outcome.

It recomputes the consequences.

It evaluates the applicable law.

It verifies the capability.

It checks the expected revision.

It confirms the causal parent.

It ensures the effects remain within the authorized ceiling.

Only then may the command be admitted.

Direct state writes fail closed.

History rewriting fails closed.

Registry-digest drift fails closed.

Stale revisions fail closed.

Authority bypass fails closed.

A model cannot make the result legitimate by explaining it persuasively.

A database cannot make the result legitimate by storing it successfully.

An interface cannot make the result legitimate by rendering it beautifully.

The action becomes legitimate only through admission.

⸻

Review Now Binds Execution

This matters even more as AI becomes capable of operating software directly.

It is not enough for an agent to describe what it plans to do.

The reviewed plan must remain the plan that is ultimately executed.

v106 introduces a constitutional plan, permit and execute path.

First, an operation is modeled under the applicable law, state machine, authority boundary and allowed-command set.

The system produces a deterministic plan digest.

That digest becomes the exact object of confirmation.

If the plan changes, the digest changes.

If the command changes, the digest changes.

If the affected object changes, the digest changes.

If the proposed effects change, the digest changes.

The previous permission no longer applies.

Execution cannot silently outrun review.

The permit is also single-use.

It cannot become an open-ended authorization that an agent replays whenever convenient.

This produces a very different relationship between humans, agents and software.

The human does not merely approve an AI in general.

The human approves a specific bounded operation under a known constitution.

The AI does not acquire sovereignty.

It receives permission to execute one admissible plan.

⸻

Delegation Can Only Narrow Authority

Receiz v106 also introduces signed capability authority.

A capability binds:

• actor;
• tenant;
• audience;
• operation;
• resource scope;
• registry digest;
• Kai validity interval;
• maximum effects;
• delegation ancestry;
• and delegation depth.

A child capability may narrow its parent.

It cannot amplify it.

It cannot cross into another tenant.

It cannot add operations the parent did not possess.

It cannot expand the resource scope.

It cannot increase the maximum permitted effects.

It cannot extend beyond the parent’s validity.

Delegation becomes attenuation, not inheritance without limit.

This is critical for AI agents.

An agent may be permitted to perform a particular operation on a particular resource under a particular tenant.

That does not mean it receives the user’s full identity.

It does not become the owner.

It does not become proof authority.

It does not gain the right to perform adjacent actions simply because they are technically available.

Permission remains explicit, scoped and reducible.

⸻

All Effects Commit Together

A command may produce more than one consequence.

It may append proof.

Advance a causal head.

Update a projection.

Record resource effects.

Produce an outbox event.

Create an audit reference.

Return an admission receipt.

In weak systems, these effects may occur independently.

The database changes, but the event fails.

The projection updates, but the receipt is missing.

The reward is issued, but the causal history does not advance.

The ownership state changes, but the audit record fails to persist.

The application then has to repair partial reality after the fact.

v106 treats the admitted outcome as one atomic unit of work.

Either the complete consequence commits, or none of it does.

The admission-store conformance contract tests:

• competing writes;
• optimistic concurrency;
• idempotent retries;
• conflicting idempotency keys;
• transaction limits;
• detached reads;
• committed outbox records;
• and injected failure before the final state swap.

A simulated crash must not expose half-committed truth.

Atomicity is not assumed because a database claims to support transactions.

The adapter must prove that it preserves the entire admission unit.

⸻

History Appends. Replay Reproduces.

Once actions are admitted, their history must remain causally coherent.

Each causal record binds:

• the event;
• the aggregate;
• the governing registry;
• the admission receipt;
• its parent records;
• its Kai position;
• and its own digest.

History may branch.

Devices may operate offline.

Events may arrive in different orders.

But replay cannot depend on whichever request happened to reach the server first.

Receiz orders causal history deterministically.

It rejects missing parents.

It rejects cycles.

It rejects modified receipts.

It rejects unverified admissions.

It recognizes contradictions that ordinary last-write-wins systems would hide.

A being retired on one branch cannot remain alive through a concurrent stale branch.

Two unrelated branches cannot assign the same object to contradictory owners and quietly allow one to win because it arrived later.

The same cause cannot generate conflicting rewards.

The same admitted history must produce the same projection, state digest and history root.

That is what replay means in v106.

Not merely rerunning code.

Reproducing consequence from admitted history.

⸻

Evidence Closes Outside the Agent

An AI agent cannot be the sole judge of whether its own work is correct.

The MCP server cannot validate itself merely by calling the same SDK function again.

The implementation under test cannot be the only implementation defining what the result should be.

v106 includes a separately invoked independent constitutional verifier.

It does not import the SDK’s command-admission, causal-history or replay implementations.

It independently reconstructs the expected history, projection, state digest, replay trace and checkpoint.

Then it compares its result against the SDK.

Divergence fails qualification.

The verifier remains beneath proof.

It does not become a new public authority.

Its job is to close the evidence boundary outside the agent that performed the work.

This is one of the most important principles of the release:

The AI’s assertion is not evidence. The MCP result is not evidence. The passing interface is not evidence. Independent reproducibility is evidence.

⸻

MCP Carries Law, Not Authority

The Receiz MCP server now injects constitutional context directly into agent operations.

It carries:

• the exact registry digest;
• applicable laws;
• the authority profile;
• the state machine;
• allowed commands;
• forbidden mutations;
• and required verification.

The agent does not need to be repeatedly reminded:

Do not let the database overwrite stronger truth.

Do not directly modify canonical state.

Do not treat a visible projection as proof.

Do not call the task complete without replay and independent verification.

Those rules now exist in the environment through which the agent acts.

MCP can inspect.

MCP can plan.

MCP can explain.

MCP can request permission.

MCP can execute through the configured SDK admission rail.

But MCP does not become authority.

Its own hierarchy explicitly places it beneath sealed proof, deterministic state, verified local truth, verified appends and authenticated SDK projections.

The machine interface carries the constitution while remaining governed by it.

⸻

Fifteen Skills Carry the Implementation Contract

The AI Skills complete the surface.

Fourteen focused constitutional skills govern:

• architecture;
• domain modeling;
• executable law;
• commands;
• authority security;
• deterministic replay;
• offline-first behavior;
• causal synchronization;
• portable artifacts;
• migration;
• performance;
• observability;
• testing;
• and release qualification.

A fifteenth skill, receiz-build-production-system, coordinates the complete production workflow.

These are not merely instructional prompt files.

Each skill carries a machine-readable manifest defining:

• required SDK and MCP versions;
• the exact registry digest;
• applicable laws;
• allowed tools;
• forbidden operations;
• required inputs;
• required evidence;
• completion criteria;
• escalation conditions;
• and the maximum authority the agent may exercise autonomously.

The production-system skill may inspect, plan, scaffold and test.

It may not quietly grant itself production authority.

It must refuse completion when evidence is absent.

It must refuse completion when the registry digest is wrong.

It must refuse completion when an authority bypass is detected.

It must refuse completion when migration is ambiguous.

It must refuse completion when independent verification is missing.

It must refuse completion when the release lock has not passed.

This is why AI inside the Receiz repository now behaves differently.

It is no longer operating from generic software assumptions.

It has been placed inside an environment where truth, authority, mutation and evidence have already been defined.

Most people personalize an AI by telling it what tone to use.

Receiz gives the AI a constitution.

⸻

v105 Moves Forward Without Rewriting History

A constitutional platform also needs a constitutional migration path.

v106 does not treat migration as permission to reinterpret the past.

The v105-to-v106 migration is:

• dry-run first;
• digest-confirmed;
• forward-only;
• resumable;
• idempotent;
• ambiguity-blocking;
• and independently verifiable.

Safe changes may be codemodded.

Ambiguous authority changes block and explain.

Existing witnessed proof history remains immutable.

Recovery rolls forward from a verified checkpoint.

It does not rewrite the old history until it resembles what the new system wishes had happened.

The past is not corrected by editing it.

New truth is appended.

⸻

The Profile Regression Proved the Law Applied to Receiz Too

During final qualification, a real regression exposed the distinction between global visibility and local admission.

A newly published proof object appeared correctly on the public Showcase.

Logged-out users could see it.

The public Live Player route could open it.

But for the logged-in owner, the accepted PBI signature disappeared and Live Player reported the object as unavailable.

The public row existed.

The local admission had been skipped.

An early return treated the existence of the canonical global row as permission to bypass the owner’s local admission path.

That allowed an older authenticated snapshot to outrank a newer verified append.

The visible symptom looked like a profile bug.

The actual defect was a violation of the primitive:

Global visibility is not local admission.

The correction now merges accepted PBI authorship into the canonical object, appends the proof to owned local authority, writes deterministic Showcase and Live Player projections and prevents the older snapshot from rolling it back.

Receiz itself had to obey the law it was shipping to developers.

That is exactly what a constitutional release should require.

⸻

Qualification Passed in Full

The final v106 qualification includes:

• 39 commits across 216 changed paths;
• 14,993 insertions and 120 deletions;
• full release-freeze passage;
• production build passage;
• 233 of 233 static pages;
• coordinated packed installation of SDK, MCP and AI Skills;
• zero workspace-protocol leakage;
• 128 of 128 profile release contracts;
• 140 of 140 continuity contracts;
• 135 of 135 local-truth contracts;
• performance qualification;
• governance qualification;
• governance-artifact signature verification;
• migration verification;
• public Showcase browser evidence;
• and direct Live Player browser evidence.

Qualification is not publication.

Publication and deployment remain separate authorized operations.

Production database state is not claimed by local tests.

Authenticated post-deployment browser state is not claimed by logged-out browser evidence.

The evidence says exactly what it proves and stops where its authority ends.

No evidence overclaim.

No authority inflation.

No replacing proof with confidence.

⸻

What v106 Actually Means

This release is not merely an SDK update.

It is not merely an MCP server.

It is not merely an AI Skill package.

It is not merely a rules engine, event system, game engine, verifier or compiler.

It is the coordination of all of them beneath one truth hierarchy.

The SDK admits lawful change.

The MCP gives machines a constrained way to request and execute that change.

The AI Skills preserve the judgment required to build without violating the primitive.

The independent verifier closes evidence outside the agent.

The migration system moves applications forward without rewriting witnessed history.

The release lock ensures the package versions, registry digest, tests, verifier, skills and evidence all agree before the system may be called releasable.

But none of those layers becomes sovereign.

The proof object remains first.

That is the central achievement of Receiz v106:

The law is executable. The action is admitted. The authority is bounded. The consequence is atomic. The history is causal. The replay is reproducible. The evidence closes independently. And proof remains sovereign.

v100 proved that truth could live inside the object.

v106 proves that entire applications—and the intelligence building them—can be made to live beneath that truth.

Receiz has now left Receiz.

Not only as reusable code.

Not only as an SDK.

Not only as tools for agents.

Its laws left with it.

And now those laws can compile into new domains, new economies, new games, new applications and new worlds—without requiring the object to surrender the truth it already carries.

Receiz v106.0.0

The Constitutional Application Platform

First admission only. Then append forever.