962 lines
56 KiB
Markdown
962 lines
56 KiB
Markdown
# Eve Migration Roadmap
|
|
|
|
Date: 2026-07-08
|
|
|
|
The great Eve migration is the move from a useful pile of renderer proofs,
|
|
fixtures, provider demos, and platform experiments into a kernel-shaped system:
|
|
Eve core owns contracts, plugins own semantics, runtime repos own native
|
|
projection, and provider repos own live truth.
|
|
|
|
This is not a repo cleanup campaign. It is an authority migration. The split is
|
|
complete only when the old in-repo convenience paths can no longer decide
|
|
provider truth, plugin semantics, or runtime behavior by accident.
|
|
|
|
## Objective
|
|
|
|
Make Eve the stable interactive language for CultMesh surfaces without turning
|
|
`E:\Projects\Eve` into a permanent warehouse.
|
|
|
|
The target shape:
|
|
|
|
- Eve core: surface contracts, CultUI DSL, command/binding descriptors,
|
|
provider/plugin advertisement specs, browser reference, and conformance
|
|
harness incubation.
|
|
- EvePlugins: first-party reusable semantic plugins while young.
|
|
- Owner repos: Sai owns VN/Ink, Norn owns graph semantics, providers such as
|
|
Aetheria own live state and authored product surfaces.
|
|
- Runtime repos: EveUnity, EveFlutter, EveAndroid, EveIOS, EveGodot, EveElectron,
|
|
Fensalir/Direct2D, and future bodies own projection, build glue, plugin
|
|
projection adapters, capture, and runtime tests.
|
|
- EveConformance: fixture corpus, parity runner, capability matrix,
|
|
screenshot/report artifacts, plugin packs, and CI once the harness is stable
|
|
enough to leave Eve core.
|
|
|
|
## Current Authority Map
|
|
|
|
Owner:
|
|
|
|
- Eve owns `gamecult.eve.surface.v1`, `gamecult.eve.command.v1`, CultUI,
|
|
provider/plugin advertisement contracts, plugin ABI shape, browser reference
|
|
behavior, and parity/conformance policy.
|
|
|
|
Inputs:
|
|
|
|
- Local fixtures under `web/fixtures`.
|
|
- Incubating plugin manifests under `plugins/incubating`.
|
|
- Runtime claims in `tools/parity/parity-manifest.json`.
|
|
- Provider advertisements such as Repixelizer's local fixture.
|
|
- Hermodr/Odin/CultMesh live provider surfaces when available.
|
|
|
|
Outputs:
|
|
|
|
- Browser reference lowering.
|
|
- Runtime capability reports.
|
|
- Plugin capability gaps.
|
|
- Parity reports under `artifacts/parity`.
|
|
- Split targets and graduation triggers in the parity manifest.
|
|
|
|
Derived state:
|
|
|
|
- Local provider lists are fixture advertisements, not discovery truth.
|
|
- Runtime capability status is diagnostic, not provider authority.
|
|
- Screenshot/golden artifacts are evidence, not portable state.
|
|
- In-repo runtime/plugin bodies are incubation, not permanent ownership.
|
|
|
|
Forbidden writers:
|
|
|
|
- Runtime lowerers must not import provider internals to recover missing
|
|
semantics.
|
|
- Plugins must not mutate provider truth or accept provider commands.
|
|
- Product demos must not become Eve core fixtures once they carry product state,
|
|
assets, receipts, or deployment assumptions.
|
|
- Compatibility HTTP routes and browser tabs must not replace provider
|
|
advertisements.
|
|
- Passing parity tests must not preserve a body that cannot name its owner,
|
|
inputs, outputs, and split trigger.
|
|
|
|
Shared paths:
|
|
|
|
- Every runtime claim flows through `tools/parity/parity-manifest.json`.
|
|
- Every fixture belongs to a conformance pack: `core`, `plugin`, `provider`, or
|
|
`runtime`.
|
|
- Every plugin claim names owner repo, split target, capabilities, required
|
|
fixtures, and graduation trigger.
|
|
- Every runtime claim names owner repo, repo role, split target, supported
|
|
features, plugin support, and graduation trigger.
|
|
|
|
Deletion line:
|
|
|
|
- Cut hardcoded provider tabs before adding new live providers.
|
|
- Cut renderer-specific product knowledge before claiming generic Eve support.
|
|
- Cut in-repo runtime/plugin bodies once their contract and release lifecycle
|
|
stop changing.
|
|
|
|
## Phase 0: Ledger And Contract Grounding
|
|
|
|
Status: underway.
|
|
|
|
Purpose: make ownership visible before moving code.
|
|
|
|
Work:
|
|
|
|
- Keep `docs/repo-strategy.md` as the repo boundary doctrine.
|
|
- Keep this roadmap as the migration sequence.
|
|
- Keep `tools/parity/parity-manifest.json` as the machine-readable ownership
|
|
ledger.
|
|
- Keep `docs/surface-contract-v1.md`,
|
|
`docs/provider-advertisement-contract.md`, and
|
|
`docs/plugin-architecture.md` as the contract source of truth.
|
|
- Keep browser reference and parity harness green after every migration cut.
|
|
|
|
Exit criteria:
|
|
|
|
- All fixtures declare a conformance pack.
|
|
- All incubating plugins declare owner, split target, capabilities, and required
|
|
fixtures.
|
|
- All runtimes declare owner, repo role, supported features, plugin claims, and
|
|
graduation trigger.
|
|
- Harness reports missing ownership metadata and plugin gaps explicitly.
|
|
|
|
Current proof:
|
|
|
|
- `node --test web\eve-dsl.test.mjs`
|
|
- `powershell -ExecutionPolicy Bypass -File .\scripts\run-parity-harness.ps1`
|
|
|
|
## Phase 1: Stabilize Core Surface Contract
|
|
|
|
Purpose: make the surface contract boring enough that runtimes and providers can
|
|
leave the repo without dragging hidden behavior with them.
|
|
|
|
Work:
|
|
|
|
- Normalize `surface.root`, `surface.styles.tokens`, `stateBindings`,
|
|
`embeddedDocuments`, command templates, and operation invocation descriptors.
|
|
- Keep compatibility fields such as `nodes`, `selectedNodeId`, raw `command`,
|
|
and string payloads as projections only.
|
|
- Add explicit authority/staleness witness UI in the browser reference for
|
|
stale, missing, predicted, denied, accepted, and reconciled values.
|
|
- Add provider advertisement fixture checks for local and live discovery paths.
|
|
First cut is in place for Repixelizer and Aetheria provider advertisements.
|
|
- Add plugin advertisement fixture checks before adding more plugin semantics.
|
|
|
|
Exit criteria:
|
|
|
|
- Browser reference can open all local fixtures through advertisement-shaped
|
|
provider entries.
|
|
- New renderer APIs construct commands from CultMesh operation descriptors, not
|
|
raw strings.
|
|
- New binding APIs carry CultMesh state binding descriptors, not renderer-local
|
|
stores.
|
|
- Parity harness fails if embedded slots, required bindings, command descriptors,
|
|
or provider advertisement fields disappear.
|
|
|
|
## Phase 2: Split Conformance Shape From Runtime Bodies
|
|
|
|
Purpose: make the evidence path portable before runtime repos leave.
|
|
|
|
Work:
|
|
|
|
- Promote `tools/parity` from a local script into a conformance pack layout:
|
|
fixture metadata, expected capability matrix, runtime adapters, plugin packs,
|
|
and report schema.
|
|
- Separate core fixtures from plugin/provider/runtime fixtures.
|
|
- Add screenshot comparison metrics for structure, token colors, bounding boxes,
|
|
text presence, and capability-gap overlays without pretending byte-identical
|
|
pixels are the goal.
|
|
- Keep generated reports under `artifacts/parity` as evidence only.
|
|
|
|
Exit criteria:
|
|
|
|
- A runtime repo can run conformance against Eve fixtures without importing Eve
|
|
source internals.
|
|
- Plugin conformance packs can be added without editing core harness logic.
|
|
- `EveConformance` has a clean split plan, or stays incubating only because the
|
|
report schema is still changing.
|
|
|
|
## Phase 3: Graduate Plugins
|
|
|
|
Purpose: move semantic ownership out of Eve core.
|
|
|
|
Work:
|
|
|
|
- Keep `plugins/incubating/sai-vn.plugin.json`,
|
|
`plugins/incubating/norn-graph.plugin.json`, and
|
|
`plugins/incubating/tex-math.plugin.json` as temporary manifests.
|
|
- Define `gamecult.eve.plugin.v1` and
|
|
`gamecult.eve.plugin_advertisement.v1` as explicit schemas. First-cut JSON
|
|
schemas live under `schemas/` and the parity harness validates incubating
|
|
plugin manifests and advertisements against them.
|
|
- Add plugin ABI fixtures for `describe`, `validate`, `project`, `apply`,
|
|
`lower`, and `measure` where relevant.
|
|
- Move `sai.vn` to Sai when VN/Ink story state, visual manifest, story commands,
|
|
and projection fixtures are stable.
|
|
- Move `norn.graph` to Norn when graph layout, interaction, fallback, and
|
|
conformance fixtures are stable.
|
|
- Move `tex.math` to EvePlugins when TeX source, macro, baseline, cached render,
|
|
and fallback fixtures are stable.
|
|
- Treat nested plugin placement as composition, not custody. A Sai surface may
|
|
deploy with nested Norn or TeX surfaces when those plugin sidecars are
|
|
available, but Norn and TeX remain independent plugin owners with their own
|
|
ABI manifests, capability claims, and conformance packs.
|
|
|
|
Exit criteria:
|
|
|
|
- Eve core knows plugin manifests and capability gaps, not plugin internals.
|
|
- Providers invoke plugins through the ABI object model.
|
|
- Runtimes declare plugin support through capability manifests.
|
|
- Unsupported required plugin capabilities appear as visible gaps.
|
|
- Optional nested plugin gaps degrade the nested surface; they do not transfer
|
|
graph, math, or renderer semantics into the parent plugin.
|
|
|
|
## Phase 4: Graduate Runtime Bodies
|
|
|
|
Purpose: let runtime repos own native projection without losing conformance.
|
|
|
|
Work:
|
|
|
|
- EveFlutter: provider picker, command transport, plugin projection adapters,
|
|
Android/iOS/desktop build flow, native capture, and parity reports.
|
|
- EveUnity: UPM package release, plugin projection adapter behavior,
|
|
resolver-backed embedded documents, Unity test/capture lifecycle, and Aetheria
|
|
consumption.
|
|
- EveAndroid: Kotlin device edge, generic surface traversal, sensor publishing,
|
|
Android-specific CI, and explicit discovery input.
|
|
- EveIOS: UIKit renderer, sensor edge release flow, fixed-device and simulator
|
|
capture, and generic surface lowering.
|
|
- Fensalir/Direct2D: Eve-to-`AquariumUiDocument` adapter, DirectWrite/Direct2D
|
|
token lowering, embedded slot preservation, and frame capture.
|
|
- EveWeb: stays in Eve while it is the behavior oracle; splits only if it becomes
|
|
an independently deployed runtime product.
|
|
|
|
Exit criteria:
|
|
|
|
- Runtime can build, test, capture, and report conformance without sharing Eve's
|
|
dirty worktree.
|
|
- Runtime consumes surface documents, plugin manifests, and provider
|
|
advertisements through contracts.
|
|
- Runtime has no provider-specific renderer brain unless it is explicitly a
|
|
provider-owned app.
|
|
|
|
## Phase 5: Move Product Fixtures To Provider Repos
|
|
|
|
Purpose: prevent demos from becoming quiet product authority inside Eve.
|
|
|
|
Work:
|
|
|
|
- Repixelizer owns job/session/artifact/operator fixtures once they carry real
|
|
product state or receipts.
|
|
- Aetheria owns RTS/ARPG world surfaces, assets, generated level state, command
|
|
receipts, and scenario conformance.
|
|
- Huginn owns `.cc` and Persona-state inspection fixture packs when they depend
|
|
on runtime stewardship details.
|
|
- Mimir owns sensor/media/control surfaces that depend on live stream timing or
|
|
room state.
|
|
|
|
Exit criteria:
|
|
|
|
- Provider repo publishes provider advertisements and fixture/conformance packs.
|
|
- Eve core keeps only minimal generic fixtures and references provider packs by
|
|
contract.
|
|
- Product assets and receipts are not stored as Eve core truth.
|
|
|
|
## Phase 6: Cut Compatibility Paths
|
|
|
|
Purpose: make old routes unable to reassert authority.
|
|
|
|
Work:
|
|
|
|
- Remove hardcoded browser provider tabs once live/local advertisements cover
|
|
the same flows.
|
|
- Remove direct Mimir deck probing from generic Eve paths.
|
|
- Remove renderer-private style shortcuts once token lowering is complete.
|
|
- Remove raw command construction APIs from new public runtime paths.
|
|
- Remove provider-specific renderer fallbacks from generic lowerers.
|
|
|
|
Exit criteria:
|
|
|
|
- The only normal path is provider advertisement -> surface document -> runtime
|
|
lowering -> command intent -> provider receipt -> republished state.
|
|
- Compatibility routes exist only as named lowerings or debug probes.
|
|
- Parity and runtime diagnostics report the same layer of reality the user sees.
|
|
|
|
## Active Work Queue
|
|
|
|
1. Move EveUnity toward split readiness with runtime-owned UPM release and
|
|
Unity capture/test lifecycle evidence.
|
|
|
|
Recently cut:
|
|
|
|
- The web reference now has a schema-backed layout probe for the
|
|
`embedded-surface` and `sai-vn` fixtures.
|
|
`scripts/run-web-reference-layout-probe-smoke.ps1` builds the browser lowerer,
|
|
runs Chrome headless through
|
|
`tools/web-reference/run-layout-probe.mjs`, writes
|
|
`gamecult.eve.web_layout_probe.v1` evidence under
|
|
`artifacts/web-reference-layout-probe/latest/`, and parity consumes those
|
|
artifacts so `web:embedded-surface:bounding-boxes` and
|
|
`web:sai-vn:bounding-boxes` are measured runtime evidence instead of
|
|
`pending-runtime-probe`. This proves the browser oracle can measure both core
|
|
embedded slots and a Sai surface that optionally composes independent Norn
|
|
and TeX plugin surfaces without taking custody of their semantics.
|
|
- The conformance export now carries `screenshotComparisonMetrics[]` records.
|
|
Runtime owners get structure, color-token, bounding-box, and text-presence
|
|
metrics per runtime/fixture pair without relying on byte-identical screenshots
|
|
or Eve-local prose. Structure and token metrics are surface-contract evidence;
|
|
text presence is authored text evidence; bounding boxes stay
|
|
`pending-runtime-probe` or `pending-capture` until a runtime-owned capture or
|
|
layout probe attaches real visual evidence.
|
|
- Runtime capability manifests now declare world-surface lowering targets.
|
|
`web/eve-runtime-capability.json` claims `web-reference`, and
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
claims `unity-uitoolkit`, each with supported world surface kinds,
|
|
projection kinds, support level, evidence paths, and the rule that runtimes
|
|
lower provider-owned world state without owning it. Parity compares those
|
|
claims against the ledger, exports them through runtime records and
|
|
`packs/runtime.json`, the runtime-owner smoke asserts them, and the generic
|
|
conformance smoke now treats `unity-scene`, `electron-shell`, and `tui` as
|
|
narrow runtime-owned command-surface claims while capture and release remain
|
|
split blockers.
|
|
- Missing provider-advertised world-surface lowering targets are still assigned
|
|
to their pending runtime owner when one exists. Eve only owns a world-lowering
|
|
gap when no runtime target has been declared.
|
|
- The conformance export now carries `worldSurfaceLoweringGaps[]` as typed
|
|
data in addition to the generic `capabilityGaps[]` ledger. Runtime owners can
|
|
consume provider id, surface id, target id, owner repo, runtime id, split
|
|
target, and runtime status without scraping prose or gap strings.
|
|
- The conformance export also carries `worldSurfaceLoweringCoverage[]`, a full
|
|
provider-surface-to-target ledger that marks each advertised lowering target
|
|
as `claimed`, `missing-claim`, or `missing-runtime`. The generic conformance
|
|
consumer now asserts Aetheria's claimed web, UI Toolkit, Unity scene graph,
|
|
Electron shell, and TUI terminal-grid targets from the same typed surface.
|
|
- The conformance export carries `commandBoundaryCoverage[]`, joining each
|
|
provider-owned interactive world surface target to its runtime owner,
|
|
provider command boundary, receipt schema, and runtime command envelope. Web,
|
|
Unity UI Toolkit, Unity scene, Electron shell, and TUI are `covered` because
|
|
they advertise `gamecult.eve.command.v1`.
|
|
- The browser reference lowerer now carries the active provider surface's
|
|
advertised `worldInteraction.commandBoundary` and
|
|
`worldInteraction.receiptSchema` into each `gamecult.eve.command.v1` intent.
|
|
It can use component action metadata as a fallback, but the provider
|
|
advertisement is the authority when present.
|
|
- The browser lowerer command intent path now passes the active surface id
|
|
explicitly and tests that a provider with multiple world surfaces uses the
|
|
active surface advertisement instead of the provider's first advertised
|
|
surface. This keeps Aetheria game/editor command boundaries from collapsing
|
|
inside the generic web reference.
|
|
- Unity scene now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-unity-scene`. The skeleton consumes an advertised
|
|
`worldInteraction` boundary, creates `gamecult.eve.command.v1` requests with
|
|
command boundary and receipt schema fields, builds a provider-agnostic Unity
|
|
scene graph DTO from the surface tree, and claims only the `unity-scene`
|
|
graph command-surface target. It still does not own provider simulation,
|
|
plugin projection adapters, release, or capture evidence.
|
|
- EveElectron now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-electron`. The shell selects advertised provider
|
|
surfaces, emits `gamecult.eve.command.v1` intents with provider command
|
|
boundary and receipt schema fields, and has a runnable Node smoke without
|
|
claiming embedded document rendering, packaged Electron lifecycle, or capture.
|
|
- EveTui now has a provider-shell contract skeleton under
|
|
`runtimes/incubating/eve-tui`. The shell selects advertised provider
|
|
surfaces, emits `gamecult.eve.command.v1` intents with provider command
|
|
boundary and receipt schema fields, lowers Eve surface trees into an
|
|
explicitly lossy `gamecult.eve.tui_grid.v1` terminal grid, and claims the
|
|
`tui` command-surface target without owning provider truth or transcript
|
|
capture.
|
|
- The conformance export carries `splitHandoffMoveCoverage[]`, joining runtime
|
|
split handoff move sets to source path status. EveElectron now exposes the
|
|
existing Aetheria `Aetheria.Rts.Web/Electron` and command transport paths as
|
|
`observed-provider` sources that must be replaced by a provider-agnostic
|
|
shell; Unity scene now exposes current incubation paths for its generic scene
|
|
graph body, world-surface lowering claim, and command transport, while scene
|
|
capture remains replacement-required.
|
|
- The conformance export schema and consumer smoke now require minimum typed
|
|
item shapes for plugins, providers, runtimes, and split targets. Owner repos
|
|
can rely on exported ids, owners, statuses, split targets, manifest or
|
|
advertisement paths, feature/plugin arrays, and blocker/proof arrays instead
|
|
of treating those sections as untyped bags.
|
|
- Plugin ABI fixture operations are now exported as
|
|
`plugins[].abiOperationContracts`. Sai and Norn can consume operation-level
|
|
`input` and `expect` contracts for `describe`, `validate`, `project`,
|
|
`lower`, `measure`, and `apply` without reading Eve-local fixture files.
|
|
- Plugin ABI operation coverage is now exported as root
|
|
`pluginAbiOperationCoverage[]` records. The plugin-owner smoke asserts Sai
|
|
and Norn `describe`, `lower`, and `apply` operations as `contracted`, so plugin
|
|
owners can consume the coverage ledger without walking Eve's nested plugin
|
|
records.
|
|
- Provider/plugin requirement coverage is now exported as root
|
|
`providerPluginRequirementCoverage[]` records with availability. The
|
|
plugin-owner smoke asserts `sai.vn` as the required VN plugin and
|
|
`norn.graph` / `tex.math` as `optional-satisfied` nested plugins owned by
|
|
Norn and EvePlugins. A Sai surface can embed Norn or TeX when those plugins
|
|
are available, but Sai does not own their graph or math semantics.
|
|
- Runtime/plugin projection claims are now exported as root
|
|
`runtimePluginProjectionCoverage[]` records. Runtime-owner smokes assert
|
|
Unity UI Toolkit support for `sai.vn`, `norn.graph`, and `tex.math`, Unity
|
|
scene support for the same three plugin capabilities, and Electron shell
|
|
and TUI support for the same sidecar plugin projection shells without
|
|
importing plugin semantics.
|
|
- Provider/runtime/plugin projection coverage is now exported as
|
|
`providerRuntimePluginProjectionCoverage[]`. The runtime-owner smoke proves
|
|
the Sai VN provider surface lowers fully in web, lowers in Unity UI Toolkit
|
|
and Android Flutter with optional independent Norn and TeX nested plugin
|
|
projection when those plugins are available, and does not let UIKit's generic
|
|
embedded-document path impersonate required Sai VN, optional Norn graph, or
|
|
optional TeX math projection.
|
|
- Runtime/plugin projection gaps are now exported as
|
|
`runtimePluginProjectionGaps[]`. Device-edge runtimes no longer consume the
|
|
Sai fixture as failed projection clients; missing Sai, Norn, or TeX support is
|
|
recorded only on runtimes that actually claim plugin projection work, so plugin
|
|
semantics do not drift into Eve core or Aetheria product code.
|
|
- Split target blockers are now exported as `splitTargetBlockers[]` and as
|
|
per-target `blockerRecords[]` with blocker kind, subject, owner, and source
|
|
text. The split-target consumer smoke asserts Unity scene status/plugin
|
|
blockers, Electron feature blockers, and TUI command-transport blockers
|
|
without scraping the human `blockers[]` strings.
|
|
- EveUnity now has a pending Unity scene handoff at
|
|
`runtimes/incubating/eve-unity-scene/eveunity-scene-split-handoff.json`.
|
|
The active `unity-uitoolkit` runtime remains a semantic UI surface lowerer;
|
|
it is not treated as full scene/world projection. The pending `unity-scene`
|
|
runtime now names current scene graph and command-transport source paths,
|
|
while release, capture, non-Aetheria provider proof, and runtime graduation
|
|
remain EveUnity blockers.
|
|
- Unity scene now has a pending runtime capability manifest at
|
|
`runtimes/incubating/eve-unity-scene/eve-runtime-capability.json` and a
|
|
lifecycle smoke at `scripts/run-eveunity-scene-lifecycle-smoke.ps1`. The
|
|
manifest claims a provider-agnostic scene graph command surface for
|
|
`unity-scene`, types the package release, provider-advertisement scene smoke,
|
|
command boundary, and scene capture contracts. The release contract now uses
|
|
the Unity scene package manifest as version source and reuses the shared
|
|
EveUnity release request builder through
|
|
`scripts/run-eveunity-scene-release-contract-smoke.ps1`. It also reuses the
|
|
shared EveUnity capture request builder through
|
|
`scripts/run-eveunity-scene-capture-contract-smoke.ps1`, while the actual
|
|
Unity scene PNG/frame artifact remains pending. The scene graph now preserves
|
|
embedded document slot identity for resolver-backed child surfaces without
|
|
owning the nested plugin semantics. Sai, Norn, and TeX scene projection
|
|
adapters now exist as runtime-owned shells; TeX parsing, typesetting,
|
|
baseline metrics, and render-cache semantics remain plugin-owned.
|
|
- Unity scene now has a direct split handoff smoke at
|
|
`scripts/run-eveunity-scene-split-handoff-smoke.ps1`. The smoke verifies the
|
|
scene runtime's current source paths for runtime body, scene graph lowering,
|
|
Sai/Norn/TeX plugin projection, and command transport, does not treat
|
|
Aetheria product paths, Sai story state, Norn implementation state, or TeX
|
|
implementation state as generic runtime source, names the required Eve
|
|
contracts, and keeps capture as an external proof until EveUnity owns it.
|
|
- Runtime split handoff documents now have a catalog-backed schema,
|
|
`gamecult.eve.runtime_split_handoff.v1`. EveConformance exports that schema
|
|
so runtime owner repos can consume split target, move set, contract input,
|
|
forbidden import, and external proof shape without trusting only ad hoc smoke
|
|
script checks.
|
|
- Plugin, provider, and conformance handoff documents are now schema-backed as
|
|
`gamecult.eve.plugin_handoff.v1`, `gamecult.eve.provider_handoff.v1`, and
|
|
`gamecult.eve.conformance_handoff.v1`. The parity runner validates the
|
|
documents, exports the schema catalog entries, and owner-consumer smokes now
|
|
demand those contracts explicitly, so Sai, Norn, EvePlugins, Aetheria, and
|
|
EveConformance can consume handoff shape without depending on Eve's local
|
|
smoke script folklore.
|
|
- Runtime lifecycle shape is now schema-backed as
|
|
`gamecult.eve.runtime_lifecycle.v1`. Flutter's standalone
|
|
`eveflutter-lifecycle.json` validates against that contract, embedded
|
|
release/test/capture lifecycle blocks in runtime capability manifests are
|
|
wrapped and validated through the same schema, and the conformance export
|
|
carries `lifecycleManifestPath` plus `lifecycleErrors` so runtime owners can
|
|
consume lifecycle status without guessing from prose.
|
|
- Electron and TUI provider-shell outputs are now schema-backed as
|
|
`gamecult.eve.electron_shell_projection.v1` and
|
|
`gamecult.eve.tui_grid.v1`. Their runtime tests load the schema documents and
|
|
validate actual lowered projection objects, so Electron and TUI cannot claim
|
|
generic provider-shell lowering by string constant alone.
|
|
- EveElectron now has a pending split target and handoff at
|
|
`runtimes/incubating/eve-electron/eveelectron-split-handoff.json`. It does
|
|
claim a provider-agnostic Electron shell surface-tree projection and command
|
|
surface with Sai, Norn, and TeX sidecar plugin projection shells, but not
|
|
packaged rendering or captured window artifacts. The handoff draws the line
|
|
between the generic shell and Aetheria's Starbridge RTS product client, and
|
|
the split-target consumer smoke keeps release, packaged rendering, and
|
|
capture artifact proofs visible as blockers.
|
|
- EveElectron now has a direct split handoff smoke at
|
|
`scripts/run-eveelectron-split-handoff-smoke.ps1`. The smoke verifies the
|
|
current generic shell, command, and world-surface lowering paths, the observed
|
|
Aetheria Electron/client paths that must be replaced, the required Eve
|
|
contract inputs, and the pending external proofs without treating Aetheria's
|
|
product client as the generic Electron runtime.
|
|
- EveElectron now has a pending runtime capability manifest at
|
|
`runtimes/incubating/eve-electron/eve-runtime-capability.json` and a
|
|
lifecycle smoke at `scripts/run-eveelectron-lifecycle-smoke.ps1`. The
|
|
manifest declares provider advertisement consumption, command transport, and
|
|
surface-tree/plugin projection, claims `electron-shell` world/editor
|
|
lowering, and now carries executable release and capture request contracts.
|
|
Release uses
|
|
`tools/eveelectron/eveelectron-release-contract.mjs` and
|
|
`scripts/run-eveelectron-release-contract-smoke.ps1`; capture uses
|
|
`tools/eveelectron/eveelectron-capture-contract.mjs` and
|
|
`scripts/run-eveelectron-capture-contract-smoke.ps1`. The packaged Electron
|
|
app, packaged window rendering, and actual Electron window capture artifacts
|
|
remain pending EveElectron work.
|
|
- Electron pending lifecycle details and TUI active-incubation lifecycle details
|
|
now live in their runtime capability manifests rather than being duplicated in
|
|
`tools/parity/parity-manifest.json`. The parity ledger points at the
|
|
capability documents; the conformance export reads command/lifecycle contracts
|
|
from those documents for runtime targets.
|
|
- EveTui now has an active incubating runtime target and a split handoff at
|
|
`runtimes/incubating/eve-tui/evetui-split-handoff.json`. It claims the
|
|
advertised `tui` world-surface lowering target as a lossy terminal-grid
|
|
command surface and carries compact Sai, Norn, and TeX sidecar plugin
|
|
fallback shells. The handoff draws the line between the provider-agnostic
|
|
terminal/grid lowerer, plugin-owned semantics, and provider-owned TUI
|
|
surfaces, while the split-target consumer smoke keeps package release and
|
|
owner-repo capture production visible as blockers.
|
|
- EveTui now has a direct split handoff smoke at
|
|
`scripts/run-evetui-split-handoff-smoke.ps1`, an active runtime capability
|
|
manifest at `runtimes/incubating/eve-tui/eve-runtime-capability.json`, and a
|
|
lifecycle smoke at `scripts/run-evetui-lifecycle-smoke.ps1`. The manifest
|
|
declares provider advertisement consumption, command transport, terminal-grid
|
|
summary, terminal-grid lowering, sidecar plugin fallback projection, and the
|
|
`tui` world/editor lowering claim; it now carries an executable terminal
|
|
capture request contract through
|
|
`tools/evetui/evetui-capture-contract.mjs` and
|
|
`scripts/run-evetui-capture-contract-smoke.ps1`, plus a deterministic
|
|
`gamecult.eve.tui_grid.v1` JSON capture artifact through
|
|
`tools/evetui/evetui-capture-artifact.mjs` and
|
|
`scripts/run-evetui-capture-smoke.ps1`. Terminal package release and
|
|
owner-repo production of the capture path remain pending.
|
|
- EveTui release lifecycle now carries a structured pending release request
|
|
contract. The runtime capability manifest reads version truth from
|
|
`runtimes/incubating/eve-tui/package.json`, names the
|
|
`gamecult.eve.runtime_release_request.v1` request schema, and proves the
|
|
`evetui-v{version}` tag plus terminal runtime artifact path through
|
|
`tools/evetui/evetui-release-contract.mjs` and
|
|
`scripts/run-evetui-release-contract-smoke.ps1`. This proves the request
|
|
shape without pretending the EveTui package has been published.
|
|
- Aetheria interactive world surfaces now carry a structured provider-owned
|
|
`worldInteraction` contract. The provider advertisement names projection
|
|
kind, provider state schemas, daemon command boundary, receipt schema,
|
|
lowering targets, and ownership rules for `aetheria.daemon.game` and
|
|
`aetheria.daemon.editor`. The provider scenario requires the daemon game
|
|
world-surface contract, parity validates it against the advertisement, and the
|
|
conformance export carries both provider `surfaceContracts` and root
|
|
`interactiveWorldSurfaces[]` records. The Aetheria consumer smoke asserts the
|
|
advertised web, Unity UI Toolkit, and Unity scene lowering targets without
|
|
importing Aetheria or Eve internals.
|
|
- EveUnity test lifecycle now carries a structured Unity EditMode runner
|
|
contract. `packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
names the runner script, consumer Unity project, default Unity editor path,
|
|
package name, test assembly, platform, result artifacts, and temporary
|
|
`testables` manifest mutation. The lifecycle smoke validates the runner
|
|
script and Aetheria project, parity compares the contract against the ledger,
|
|
and the runtime-owner consumer smoke asserts exported test fields. This is
|
|
Unity package consumption proof for CultLib-produced assemblies; CultLib
|
|
remains the owner of the .NET/NuGet dependency story.
|
|
- EveUnity release lifecycle now carries a structured UPM release contract.
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
names the package root, version source, tag pattern, artifact kind, and
|
|
owner-side publish proof for `org.gamecult.eve.unity-uitoolkit`.
|
|
`tools/eveunity/eveunity-release-contract.mjs` now builds a
|
|
`gamecult.eve.runtime_release_request.v1` request from the runtime capability
|
|
manifest and UPM package manifest, deriving the `eveunity-uitoolkit-v{version}`
|
|
tag, package dependency set, and UPM artifact path. The lifecycle smoke
|
|
validates that contract against the package manifest, parity compares it
|
|
against the ledger, and the runtime-owner consumer smoke asserts the exported
|
|
release fields without pretending the tagged EveUnity release already exists.
|
|
- EveUnity capture lifecycle now carries a structured pending capture contract.
|
|
`captureContract` names the Unity UI Toolkit runtime, capture kind, PNG
|
|
artifact pattern, conformance attachment point, required Aetheria provider
|
|
surface, request schema, request builder, advertisement input, and authority
|
|
rule. `tools/eveunity/eveunity-capture-contract.mjs` now builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`scripts/run-eveunity-capture-contract-smoke.ps1` proves that request path
|
|
without pretending a Unity PNG has been captured. The actual capture artifact
|
|
remains a split blocker for EveUnity.
|
|
- EveElectron capture lifecycle now carries the same kind of structured pending
|
|
capture contract. `captureContract` names the Electron shell runtime, capture
|
|
kind, PNG artifact pattern, conformance attachment point, required Aetheria
|
|
provider surface, request schema, request builder, advertisement input, and
|
|
authority rule. `tools/eveelectron/eveelectron-capture-contract.mjs` builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`scripts/run-eveelectron-capture-contract-smoke.ps1` proves that request path
|
|
without pretending an Electron window PNG has been captured. The actual
|
|
capture artifact remains a split blocker for EveElectron.
|
|
- EveTui capture lifecycle now attaches a typed terminal-grid artifact instead
|
|
of stopping at a request contract. `tools/evetui/evetui-capture-artifact.mjs`
|
|
lowers `web/fixtures/aetheria-world-surface.json` through `EveTuiShell`,
|
|
writes `artifacts/evetui-capture/latest/tui-grid.json`, and stores the paired
|
|
capture request beside it. Parity validates the artifact schema, provider,
|
|
surface, and linked request path, then exports it as `runtime.captureArtifacts[]`.
|
|
The split blocker is no longer "no artifact"; it is "EveTui must own this
|
|
capture path outside Eve incubation."
|
|
- EveElectron release lifecycle now carries a structured pending release
|
|
request contract. `releaseContract` names
|
|
`gamecult.eve.runtime_release_request.v1`, the
|
|
`tools/eveelectron/eveelectron-release-contract.mjs` request builder,
|
|
`runtimes/incubating/eve-electron/package.json` as the version source, and
|
|
the `eveelectron-v{version}` tag/artifact pattern.
|
|
`scripts/run-eveelectron-release-contract-smoke.ps1` proves the request
|
|
without pretending a packaged Electron app has been published.
|
|
- Unity scene capture now uses that same request-contract shape. The
|
|
`unity-scene` runtime capability manifest names
|
|
`gamecult.eve.runtime_capture_request.v1`, the shared
|
|
`tools/eveunity/eveunity-capture-contract.mjs` request builder, the Aetheria
|
|
provider advertisement input, and the scene PNG artifact pattern.
|
|
`scripts/run-eveunity-scene-capture-contract-smoke.ps1` proves the request
|
|
without pretending a Unity scene frame has been captured. The actual frame or
|
|
screenshot artifact remains a split blocker for EveUnity.
|
|
- Unity scene release now uses the same UPM release request contract shape as
|
|
Unity UI Toolkit. The `unity-scene` runtime capability manifest names
|
|
`gamecult.eve.runtime_release_request.v1`, the shared
|
|
`tools/eveunity/eveunity-release-contract.mjs` request builder,
|
|
`runtimes/incubating/eve-unity-scene/package.json` as the version source, and
|
|
the `eveunity-scene-v{version}` tag/artifact pattern.
|
|
`scripts/run-eveunity-scene-release-contract-smoke.ps1` proves the request
|
|
without pretending the tagged UPM package has been published.
|
|
- EveTui capture lifecycle now carries a structured terminal cell-grid capture
|
|
contract and typed artifact. `captureContract` names the TUI runtime,
|
|
`terminal-cell-grid` capture kind, `json-grid` artifact kind, conformance
|
|
attachment point, required Aetheria provider surface, request schema, request
|
|
builder, advertisement input, and authority rule.
|
|
`tools/evetui/evetui-capture-contract.mjs` builds a
|
|
`gamecult.eve.runtime_capture_request.v1` request from the runtime capability
|
|
manifest and provider advertisement, and
|
|
`tools/evetui/evetui-capture-artifact.mjs` writes
|
|
`gamecult.eve.tui_grid.v1` evidence. The remaining blocker is owner-repo
|
|
production of the same capture path, not absence of a cell-grid artifact.
|
|
- Runtime-owner conformance consumption now asserts EveUnity lifecycle stage
|
|
evidence directly. The generic consumer supports
|
|
`--expect-runtime-lifecycle-status` and
|
|
`--expect-runtime-lifecycle-pending`; the runtime-owner smoke verifies the
|
|
Unity UI Toolkit release/test/capture statuses plus the tagged UPM release,
|
|
batchmode runner, and capture artifact pending proofs from the exported
|
|
runtime record.
|
|
- Plugin manifests and advertisements now carry a typed runtime-independent
|
|
sidecar ABI boundary. Sai, Norn, and TeX declare `invocationModel:
|
|
executable-sidecar`, `gamecult.eve.plugin_abi.v1`, CultMesh/stdio transports,
|
|
renderer independence, no provider-state mutation, provider-owned command
|
|
acceptance, and `runtime.sidecar` fields for process kind, protocol,
|
|
request/response schemas, operations, command envelope, receipt schema, and
|
|
state authority. The parity harness validates manifest/advertisement
|
|
agreement, checks sidecar operations against ABI fixture operations, exports
|
|
the runtime boundary, and the plugin-owner consumer smoke asserts the Sai and
|
|
Norn sidecar contracts from the conformance pack.
|
|
- Conformance export now carries first-class `capabilityGaps[]` records derived
|
|
from plugin errors, provider advertisement/scenario errors, runtime missing
|
|
evidence, declared unsupported plugin projection, capture gaps, and split
|
|
blockers. The generic consumer can assert named gaps with
|
|
`--expect-capability-gap`; the default smoke now proves Direct2D capture and
|
|
EveUnity release ownership remain visible blockers instead of hiding in
|
|
Markdown prose.
|
|
- Conformance export now carries a first-class
|
|
`gamecult.eve.capability_matrix.v1` projection. The matrix summarizes pack
|
|
health, plugin ABI/capability claims, provider surfaces/commands/receipts,
|
|
runtime feature/capture/command coverage, split readiness, and handoff counts
|
|
from the exported evidence. The generic consumer smoke asserts it with
|
|
`--expect-capability-matrix`, so owner repos do not need to scrape the
|
|
Markdown report or rebuild Eve's summary logic to understand coverage.
|
|
- The capability matrix projection now has a catalog-backed schema document at
|
|
`schemas/gamecult.eve.capability_matrix.v1.schema.json`, and the generic
|
|
conformance consumer asserts that schema from the exported pack.
|
|
- Conformance export now copies handoff documents into `handoffs/*.json` rather
|
|
than exporting Eve-local source paths only. The export carries handoff export
|
|
paths for EveConformance, Sai/Norn plugins, Aetheria, and EveUnity; the
|
|
generic consumer verifies those copied documents for conformance, plugin,
|
|
provider, and runtime handoff assertions. Owner repos can inspect the
|
|
boundary map from the exported pack itself.
|
|
- EveConformance now has a machine-readable handoff at
|
|
`tools/conformance/eveconformance-handoff.json` and a verifier at
|
|
`scripts/run-eveconformance-handoff-smoke.ps1`. The handoff names the
|
|
conformance runner, schemas, consumer smokes, fixture corpus, contract inputs,
|
|
forbidden imports, and external proofs that leave Eve when the harness
|
|
graduates. The conformance export carries `conformanceHandoffPath`, and the
|
|
generic consumer smoke asserts it so EveConformance split readiness is not
|
|
trapped in Eve's parity manifest.
|
|
- Sai and Norn now have plugin handoff manifests at
|
|
`plugins/incubating/sai-vn.plugin-handoff.json` and
|
|
`plugins/incubating/norn-graph.plugin-handoff.json`, plus a shared verifier
|
|
at `scripts/run-plugin-handoff-smoke.ps1`. The handoffs name the manifest,
|
|
advertisement, ABI fixture, move sets, contract inputs, forbidden imports,
|
|
and external proofs that must move to the owner repos. The conformance export
|
|
carries plugin `handoffPath`, and the plugin-owner smoke asserts it so Sai
|
|
and Norn can consume the plugin boundary without reading Eve's parity
|
|
manifest.
|
|
- Aetheria now has a provider handoff manifest at
|
|
`web/fixtures/aetheria-provider-handoff.json` and a verifier at
|
|
`scripts/run-aetheria-provider-handoff-smoke.ps1`. The handoff names the
|
|
advertisement, interactive world fixture, provider scenario, contract inputs,
|
|
forbidden imports, and external proofs that must move to Aetheria. The
|
|
conformance export carries the handoff path, and the Aetheria consumer smoke
|
|
asserts it so provider ownership does not depend on Eve's parity manifest.
|
|
- EveUnity now has a machine-readable split handoff at
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eveunity-split-handoff.json` and
|
|
a verifier at `scripts/run-eveunity-split-handoff-smoke.ps1`. The handoff
|
|
names the UPM package body, Unity test lifecycle, Unity capture lifecycle,
|
|
contract inputs, forbidden imports, and required external proofs that must
|
|
move to EveUnity. It is wired into the runtime capability manifest and
|
|
lifecycle smoke, so the remaining split blockers are release/test/capture
|
|
ownership rather than an undocumented migration shape.
|
|
- Split-target conformance consumption now verifies graduation state instead of
|
|
only split-target presence. The generic consumer supports
|
|
`--expect-split-target-status`, `--expect-split-target-blocker`, and
|
|
`--expect-split-target-proof`; the parity harness runs
|
|
`scripts/run-split-target-conformance-consumer-smoke.ps1`; and EveFlutter /
|
|
EveUnity consumers can now prove that the targets remain incubating for named
|
|
blockers while their current split-readiness proofs stay passed.
|
|
- Runtime owner conformance consumption now verifies runtime target health
|
|
instead of only runtime presence. The generic consumer supports
|
|
`--expect-runtime-status`, `--expect-runtime-feature`,
|
|
`--expect-runtime-command-schema`, and `--expect-runtime-capture-status`; the
|
|
export carries top-level `captureStatus`; and the parity harness runs a
|
|
runtime-owner smoke that proves active Flutter/Unity/web targets while keeping
|
|
Fensalir Direct2D explicitly demoted as `external-adapter-spike` with missing
|
|
capture.
|
|
- Provider owner conformance consumption now verifies the interactive-world
|
|
contract instead of only provider presence. The generic conformance consumer
|
|
supports `--expect-provider-surface`, `--expect-provider-surface-kind`,
|
|
`--expect-provider-command`, and `--expect-provider-receipt-state`; the
|
|
export now carries provider receipt states and surface-kind claims; and
|
|
Aetheria's consumer smoke asserts the daemon game/editor surfaces,
|
|
interactive world surface roles, daemon command boundary, and
|
|
accepted/reconciled receipts from the exported provider pack.
|
|
- Plugin owner conformance consumption now has a smoke runner at
|
|
`scripts/run-plugin-owner-conformance-consumer-smoke.ps1`. The generic
|
|
conformance consumer can assert plugin ABI operations and capabilities with
|
|
`--expect-plugin-operation` and `--expect-plugin-capability`, and the export
|
|
now carries plugin manifest paths, advertisement paths, split targets,
|
|
graduation triggers, and optional nested composition claims. Sai and Norn can
|
|
prove the plugin contract from the conformance export without reading Eve's
|
|
parity manifest.
|
|
- EveUnity now has a split lifecycle smoke at
|
|
`scripts/run-eveunity-lifecycle-smoke.ps1`. It validates the existing
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`
|
|
lifecycle claims directly instead of duplicating them, checks evidence paths,
|
|
and runs the Aetheria Unity package consumer-build smoke. `-RunUnityEditMode`
|
|
is available for the heavier Unity batchmode path. EveUnity remains
|
|
incubating until tagged UPM release, batchmode runner ownership, and capture
|
|
artifacts live under the `EveUnity` repo.
|
|
- EveFlutter now has explicit lifecycle incubation evidence at
|
|
`flutter/eve_parity/eveflutter-lifecycle.json` and a smoke runner at
|
|
`scripts/run-eveflutter-lifecycle-smoke.ps1`. The smoke validates the
|
|
lifecycle document, checks release/test/capture evidence paths, runs Dart
|
|
analysis from the bundled SDK, and consumes the exported conformance pack from
|
|
inside `flutter/eve_parity`. The split-readiness blocker is now narrower:
|
|
tagged release, test runner ownership, and capture runner ownership must move
|
|
to `EveFlutter`, rather than pretending the lifecycle shape is still unknown.
|
|
- EveFlutter now has a provider-catalog picker primitive. `EveProviderCatalog`
|
|
parses conformance-export provider entries, including separate Sai, Norn, and
|
|
TeX plugin requirements, and `EveProviderPicker` selects those provider ids without
|
|
reading web fixture paths. The Flutter smoke test proves provider selection
|
|
from an export-shaped provider list, so the split-readiness report records the
|
|
provider-picker proof as passed while leaving release/capture lifecycle
|
|
ownership as the remaining EveFlutter blocker.
|
|
- EveFlutter now has a conformance consumer smoke at
|
|
`scripts/run-eveflutter-conformance-consumer-smoke.ps1`. It runs from
|
|
`flutter/eve_parity`, consumes the exported conformance pack, and asserts the
|
|
runtime pack, Sai provider fixture, Flutter runtimes, and `EveFlutter` split
|
|
target without reading Eve's parity manifest. The split-readiness report now
|
|
records that as a passed proof instead of leaving it as a permanent pending
|
|
blocker.
|
|
- Fensalir now has a recorded runtime-pack
|
|
`gamecult.eve.surface.v1` adapter fixture at
|
|
`web/fixtures/fensalir-direct2d-surface.json`. The browser local catalog uses
|
|
that contract-shaped surface instead of the older dashboard-state sketch, and
|
|
the parity harness validates embedded-slot preservation, command descriptors,
|
|
runtime authority witnesses, and style tokens. Direct2D capture and
|
|
runtime-owned command smoke remain the activation blockers.
|
|
- UIKit and Kotlin device-edge runtimes no longer consume the Sai plugin fixture
|
|
as projection acceptance targets. They remain generic embedded-document and
|
|
device-edge proofs; plugin projection authority belongs to EveFlutter,
|
|
EveUnity, EveElectron, EveTui, or future runtime-specific adapters when those
|
|
bodies earn the claim.
|
|
- The web reference no longer hardcodes the local provider list in
|
|
`web/surface.js`. It loads `web/local-provider-catalog.json`, then opens
|
|
advertisement-backed entries for Aetheria, Repixelizer, and Sai through the
|
|
same `loadProviderAdvertisement` path used by the provider picker. Fixture-only
|
|
surfaces remain explicit local catalog entries until they gain provider
|
|
advertisements or move into their owner packs.
|
|
- Provider advertisements can now name sidecar plugin requirements per surface
|
|
with `surfaces[].requiresPlugins[]`. The parity harness validates those
|
|
requirements against known plugin manifests, exports them in the conformance
|
|
provider list, and reports missing plugins or capabilities as provider
|
|
capability gaps. The Sai VN fixture now has an advertisement-shaped provider
|
|
entry for `gamecult.home.vn`, so Sai, Norn, and TeX requirements sit at
|
|
separate provider/plugin boundaries instead of hiding only in fixture
|
|
metadata.
|
|
- The conformance runtime pack now exports `runtimeTargets` in
|
|
`artifacts/conformance/latest/packs/runtime.json`. Runtime repos can consume
|
|
runtime status, feature/plugin claims, command schema, lifecycle, capture
|
|
status, capability manifest path, and missing evidence without depending on
|
|
Eve's parity manifest layout.
|
|
- Sai, Norn, and TeX plugin ABI fixtures now cover `lower` and `measure` in
|
|
addition to `describe`, `validate`, `project`, and `apply`. Eve validates the
|
|
operation shape, preserved component kinds, measurement outputs, and provider
|
|
authority flag without importing plugin internals or deciding plugin
|
|
semantics.
|
|
- The web reference now publishes a runtime capability manifest at
|
|
`web/eve-runtime-capability.json`, and the parity harness validates it through
|
|
the same runtime capability path as Unity. Web remains Eve's behavior oracle,
|
|
not an EveWeb split target, unless it gains independent deployment lifecycle.
|
|
Its manifest explicitly claims provider advertisement consumption,
|
|
embedded-document lowering, state bindings, style tokens, authority witnesses,
|
|
plugin projection support, command intent emission, and Chrome headless
|
|
capture evidence.
|
|
- Unity UI Toolkit now declares runtime lifecycle evidence in
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`. The
|
|
parity harness validates release, test, and capture lifecycle claims against
|
|
`tools/parity/parity-manifest.json`, checks declared evidence paths, and
|
|
exports lifecycle status through the conformance index. Current proof covers
|
|
incubating UPM package identity, package EditMode tests, Aetheria
|
|
consumer-build smoke, and an Eve-owned batchmode EditMode run through the
|
|
Aetheria Unity project; tagged EveUnity release, moving the batchmode runner
|
|
into EveUnity, and editor or batchmode capture remain explicit split
|
|
blockers.
|
|
- Aetheria now has repeatable Unity EditMode evidence for the Eve UI Toolkit
|
|
runtime. `scripts/run-aetheria-unity-editmode-tests.ps1` temporarily adds
|
|
`org.gamecult.eve.unity-uitoolkit` to Aetheria's Unity `testables`, runs
|
|
`GameCult.Eve.UnityUIToolkit.Tests` in Unity batchmode, writes XML and log
|
|
artifacts under `artifacts/aetheria-unity-editmode`, and restores
|
|
`Packages/manifest.json` before returning. The Brokkr/CultMesh DLL references
|
|
in the Unity test asmdef are Unity package assembly plumbing: CultLib already
|
|
owns the .NET/NuGet dependency story. EveUnity's split blocker is proving how
|
|
the Unity package resolves those assemblies after it leaves Eve incubation,
|
|
not inventing a dependency system for CultLib. This proves the incubating test
|
|
lifecycle; it does not make Eve own Unity's final runtime lifecycle.
|
|
- Aetheria now has repeatable Unity package consumer-build evidence for the
|
|
Eve UI Toolkit runtime. `scripts/run-aetheria-unity-package-smoke.ps1`
|
|
verifies Aetheria's Unity `Packages/manifest.json` consumes Eve's surface and
|
|
UI Toolkit packages by file reference, checks the generated
|
|
`GameCult.Eve.UnityUIToolkit.csproj` includes all current runtime files, and
|
|
builds the package through Aetheria's Unity-generated project.
|
|
- Unity UI Toolkit now has a first-party `norn.graph` projection-adapter proof
|
|
for `embed.norn`. `NornGraphUiToolkitProjectionAdapter` owns the native
|
|
embedded graph shell and graph command emission path, while the Norn sidecar
|
|
plugin keeps graph layout and graph semantics. UI Toolkit split-readiness is now
|
|
blocked on runtime-owned release, test, and capture lifecycle evidence rather
|
|
than missing required Sai VN or optional Norn graph projection support.
|
|
- Unity scene now has the same kind of bounded `norn.graph` projection proof
|
|
for `embed.norn`. `NornGraphUnitySceneProjectionAdapter` emits a
|
|
scene-projection shell with the sidecar ABI, command boundary, document id,
|
|
and Norn semantic owner preserved; it does not calculate graph layout or make
|
|
graph-state decisions.
|
|
- Unity UI Toolkit now has a first-party `sai.vn` projection-adapter proof. The
|
|
runtime owns `IEveUiToolkitPluginProjectionAdapter`, registers
|
|
`SaiVisualNovelUiToolkitProjectionAdapter` through
|
|
`EveUiToolkitSurfaceOptions`, and declares support for `vn.stage`,
|
|
`story.choose`, `story.continue`, and `story.jump` in its runtime capability
|
|
manifest. Sai still owns story state and command semantics; Unity only lowers
|
|
the visual stage/dialogue/action surface and emits Eve command requests.
|
|
- Unity UI Toolkit now publishes a runtime-owned capability manifest at
|
|
`packages/org.gamecult.eve.unity-uitoolkit/eve-runtime-capability.json`. The
|
|
parity harness validates that manifest against
|
|
`gamecult.eve.runtime_capability.v1`, cross-checks supported features,
|
|
supported Sai, Norn, and TeX plugin projection declarations, command transport
|
|
schema, and incubation metadata, then exports the manifest path and validation
|
|
errors through the conformance report. Unity owns source-fallback projection
|
|
shells only; TeX parsing, typesetting, baseline metrics, and cached render
|
|
semantics remain EvePlugins-owned.
|
|
- Aetheria now consumes the exported conformance pack from its own working
|
|
directory through `scripts/run-aetheria-conformance-consumer-smoke.ps1`. The
|
|
smoke asserts the provider pack, `aetheria-world` fixture, `aetheria`
|
|
provider entry, and `aetheria-world-command-replay` scenario without reading
|
|
Eve's parity manifest or dirtying the Aetheria worktree.
|
|
- The Aetheria consumer smoke now also asserts frontend extraction boundaries:
|
|
web, Unity UI Toolkit, Unity scene, and Electron shell are covered generic
|
|
lowerings, while the observed Aetheria Electron shell/client paths remain
|
|
split-handoff evidence to replace with a provider-agnostic EveElectron body.
|
|
- The parity harness now runs a conformance consumer smoke against a copied
|
|
`artifacts/conformance/latest` layout, proving the export can be consumed
|
|
through `index.json` and `packs/*.json` without reading Eve's parity manifest.
|
|
- The parity harness now emits an `EveConformance`-shaped export under
|
|
`artifacts/conformance/latest`, with a top-level index and per-pack JSON
|
|
files for core, plugin, provider, and runtime consumers.
|
|
- Unity, Electron, and TUI plugin projection capability gaps are now explicitly
|
|
demoted. UI Toolkit, Unity scene, Electron, and compact TUI runtimes own
|
|
generic projection and command requests, while Sai, Norn, and TeX semantics
|
|
remain sidecar-plugin responsibilities. Runtimes only add projection shells or
|
|
lossy terminal fallbacks for capabilities a plugin advertises through Eve.
|
|
- Flutter and Unity now have runtime command-transport smoke evidence in the
|
|
parity report. Flutter emits `gamecult.eve.command.v1` intents from lowered
|
|
controls, and Unity command requests now carry the same command schema.
|
|
- Aetheria now has a provider scenario replay fixture advertised through its
|
|
provider advertisement. The parity harness validates advertised surfaces,
|
|
command boundary consumption, command intents, and provider-owned receipt
|
|
states without importing Aetheria internals into Eve.
|
|
- Aetheria's provider scenario now covers both `aetheria.daemon.game` and
|
|
`aetheria.daemon.editor` as provider-owned interactive world surfaces. The
|
|
Aetheria consumer smoke asserts editor ownership and the claimed TUI
|
|
terminal-grid lowering target instead of letting editor support hide behind
|
|
the game-surface scenario.
|
|
- The surface contract now states nested Norn and TeX placement as optional
|
|
composition, not Sai custody. The plugin-owner consumer can assert
|
|
provider-plugin requirement availability, so `sai.vn` remains required while
|
|
`norn.graph` and `tex.math` stay optional nested sidecar plugins.
|
|
- Sai, Norn, and TeX now have plugin ABI fixtures for describe, validate,
|
|
project, lower, measure, and apply behavior. The parity harness validates
|
|
those fixtures against plugin manifests, so Eve proves the ABI shape without
|
|
owning plugin semantics.
|
|
- Plugin sidecar request/response schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.plugin_abi.request.v1` and
|
|
`gamecult.eve.plugin_abi.response.v1` live under `schemas/`; Sai, Norn, and
|
|
TeX ABI fixtures must name those same schemas, and parity fails if a sidecar
|
|
advertises a request/response schema that is missing from the contract
|
|
catalog.
|
|
- Plugin sidecar receipt schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.command_receipt.v1` is the generic command receipt
|
|
envelope for provider-owned acceptance/reconciliation, while
|
|
`gamecult.eve.plugin_receipt.v1` is the plugin-runtime diagnostic/proposed
|
|
state receipt envelope. Plugin ABI fixtures must match the sidecar-advertised
|
|
receipt schema, and parity fails if that schema is missing from the contract
|
|
catalog.
|
|
- Runtime release/capture request schema names are now backed by Eve contract
|
|
documents. `gamecult.eve.runtime_release_request.v1` and
|
|
`gamecult.eve.runtime_capture_request.v1` live under `schemas/`; runtime
|
|
lifecycle manifests must name catalog-backed request schemas, so release and
|
|
capture status cannot hide a missing wire contract.
|
|
- Conformance export now carries a root `schemaCatalog` and copies schema
|
|
documents under `schemas/` in the export. Plugin owners can assert
|
|
`gamecult.eve.plugin_abi.request.v1` and
|
|
`gamecult.eve.plugin_abi.response.v1` from the exported pack instead of
|
|
reading Eve's parity manifest to discover contract paths.
|
|
- EveConformance handoff now treats the exported schema catalog as part of the
|
|
split boundary. The handoff schema move set includes plugin, provider,
|
|
runtime, conformance, and ABI wire schemas, and the handoff smoke verifies the
|
|
latest conformance export copied those schema documents.
|
|
- Split-readiness reporting now exists for `EveFlutter` and `EveUnity`. The
|
|
parity report lists member runtime health, required plugin capability claims,
|
|
pending proofs, and blockers before either repo can graduate out of Eve
|
|
incubation.
|
|
- Direct2D is now recorded as an external Fensalir adapter spike, not an active
|
|
Eve runtime. Activation requires recorded `gamecult.eve.surface.v1` fixture
|
|
replay, command emission through the advertised boundary, and Direct2D frame
|
|
capture evidence from Fensalir.
|
|
- Fixture conformance metadata now lives beside each fixture and is validated by
|
|
the parity harness, so the corpus can move toward `EveConformance` without
|
|
relying only on Eve's local manifest layout.
|
|
- The browser reference now has an authority/staleness witness fixture. The
|
|
parity report verifies visible `fresh`, `accepted`, `stale`, `missing`,
|
|
`pending`, `denied`, `predicted`, and `reconciled` states, with provider and
|
|
renderer ownership kept separate.
|
|
- Command descriptor validation now runs for strict fixtures. Sai proves
|
|
`story.*`/`style.patch`; Aetheria proves the daemon command boundary; the web
|
|
lowerer resolves authored `action.command` through the shared Eve command
|
|
intent path.
|
|
- Provider advertisement validation now runs in the parity harness.
|
|
- Repixelizer and Aetheria provider advertisements are checked against
|
|
`gamecult.eve.provider_advertisement.v1`.
|
|
- Aetheria has a minimal provider-owned interactive world fixture in Eve so the
|
|
browser oracle can prove the surface path without owning Aetheria truth.
|
|
|
|
## Stop Conditions
|
|
|
|
Stop adding features and update the map when:
|
|
|
|
- a runtime needs product knowledge to render a generic surface;
|
|
- a plugin fixture needs provider state to prove plugin behavior;
|
|
- a provider fixture becomes necessary for core Eve tests;
|
|
- a compatibility route becomes easier to use than a provider advertisement;
|
|
- a generated report says "active" while listing missing source symbols,
|
|
features, metadata, or plugin support;
|
|
- a split target exists but the owner, inputs, outputs, and release lifecycle
|
|
are still awkward to explain.
|
|
|
|
If the sentence "X owns Y so that Z remains true" cannot be written cleanly, the
|
|
migration step is not ready. The machine may still be useful. It is not yet
|
|
coherent.
|