Semantic reuse created two authorities

Ordivon Game adopted the Host workload contract before it adopted one production authority. The P0–P2 adapters proved that Game's single-Agent and Team lifecycles could map into TaskDescriptor, Dispatch, Observation, VerificationReceipt, and TaskOutcome. They also left Game reconstructing the same generic truth through local tables and adapters.

The next decision was not whether Host semantics were useful. It was whether Game should call the same Python implementation through a sidecar or embed one authority that implemented the same contract inside its existing TypeScript process.

Reusing one implementation is not automatically cheaper than reusing one contract.

The sidecar worked

A minimal Python JSONL sidecar completed one real World Tick, including recovery after a World commit with a lost response. It did not require HTTP, MCP, Python-to-Node callbacks, or a cross-database transaction. It was not rejected because it was broken.

It lost because the in-process Game workload did not need the process boundary it introduced.

MetricPython sidecarEmbedded authorityDifferenceDecision pressure
Startup196.120 ms36.896 ms5.3× slowersidecar
Lifecycle p50259.260 ms96.567 ms2.7× slowersidecar
Lifecycle p95286.873 ms111.843 ms2.6× slowersidecar
Production lines879212667 moresidecar
Extra processyesnosplit deploymentsidecar

The sidecar also divided startup, transport, packaging, evidence lookup, and recovery across two processes. None of those costs supplied a capability required by the three-specialist Scenario.

One authority replaced reconstruction

The final boundary is:

Agent cognition or Team coordination
→ EmbeddedHostAuthority
→ TaskDescriptor
→ Dispatch
→ Observation
→ VerificationReceipt
→ TaskOutcome

GameWorldExecutor
→ authoritative World Command / Event / Snapshot

The generic Host lifecycle is stored only in immutable host_artifacts and one hash-chained host_journal. Game retains domain state that is not a second generic Host: cognition sessions, actor leases, profiles, Messages, authority decisions, Rounds, actor-visible Context references, Proposals, and TickPlans.

Thirteen duplicate truth tables left

PathDeleted generic tablesDeleted adaptersRetained authorityOutcome
Single Actor6SingleActorHostContractAdapterHost journal + Game cognitionexact
Team7TeamHostContractAdapterHost joint lifecycle + Team domain stateexact

The migration removed:

  • 13 generic duplicate truth tables;
  • two reconstruction adapters;
  • the duplicate execution store;
  • the temporary Python sidecar;
  • 641 net implementation and test lines relative to the P0–P2 baseline.

Deleting tables mattered more than deleting lines. The system no longer had to decide which copy of Goal, Task, Effect, Dispatch, Observation, or Verification truth would win after interruption.

World results did not move

The deterministic single-Agent workload preserved ten admitted Decisions, 25 primitive World Effects, 25 Host lifecycles, final revision 25, and the exact terminal digest. The Team workload preserved 18 Rounds, 54 actor Contexts, 54 Proposals, 18 joint Effects, 54 per-Actor result items, zero duplicate Ticks, final revision 18, and the exact terminal digest.

A live Codex single-Agent Run also reached victory with verified replay after the cutover. The authority migration changed ownership and recovery, not the World rules or accepted outcome.

What Game still owns

Unique authority does not mean flattening every domain object into Host. Game still owns the structures whose meaning is genuinely local:

cognition sessionsactor leasesprofilesmessagesauthority grantsroundsproposalstick plans

Host owns the generic work lifecycle. World owns physical Game state and replay. Mission Control derives a product projection from both. It does not become another authority store.

The general lesson

There are at least three different kinds of reuse:

  • contract reuse — common identities, stages, invariants, and evidence;
  • library reuse — shared code within a compatible process and language boundary;
  • service reuse — one deployed process serving multiple consumers.

Contract reuse was mandatory. Service reuse was not. Forcing every consumer through one process would have treated deployment topology as the architecture, even when the workload already shared a database, process, recovery boundary, and release unit.

The correct test is not “can this be centralized?” It is:

Which authority must be unique, and what is the cheapest implementation that preserves that uniqueness for this workload?

What this does not generalize

The result does not imply that sidecars or services are generally wrong. A separate process can be correct when consumers use different trust zones, machines, release cadences, languages, resource controls, or operational ownership. Historical databases containing removed tables were not migrated. Game-specific Actions and Ticks were not promoted into the shared protocol.

The experiment establishes a local decision: in-process Game execution gained no capability from deploying Python Host as a sidecar, while it paid measurable transport, startup, code, and split-recovery cost.

The architecture became more shared by deleting the shared-looking implementation path and preserving one semantic authority.

Evidence

Authority cutover record

  1. Full report. Host authority cutover P3–P6.
  2. Second workload context. Contracts across a second workload.