Experience Entry Gate

Experience Entry Gate is a deterministic static browser application demonstrating the central claim of the Experience Entry Contract (EEC):

Persistence is a governed transition, not a side effect of salience, repetition, confidence, recall, or emotional intensity.

The demo keeps incoming Events, admitted Associative Traces, explicit Promotion Requests, governance decisions, and authorized Canonical State transitions visibly distinct. It uses only three commit classes: NONE, ASSOCIATIVE, and CANONICAL. Review, denial, quarantine, eligibility, and deferral are request outcomes—not memory classes.

Additional release captures:

• Governed-versus-naive comparison detail
• Successful governed promotion

Architecture

Fixed scenario fixtures
        │
        ▼
ExperienceEvent ──admission──▶ AssociativeTrace
                                   │
                              explicit request
                                   ▼
                           PromotionRequest
                                   │
                           predicate vector
                                   ▼
                           GovernanceDecision
                         ╱ REVIEW / DENY / QUARANTINE
                        ╲ ALLOW + token + signer
                                   ▼
                    append-only TransitionRecord
                                   │ valid hash
                                   ▼
                           CanonicalRecord

ContractEngine ──emitted transitions──▶ read-only renderer / inspector / exports
NaiveEngine    ──separate state────────▶ comparison panel only

The contract engine is authoritative. An incremental execution controller advances one emitted engine transition per playback step and publishes an immutable snapshot containing only objects that exist at that sequence. Rendering code derives its view from that current snapshot and may animate only a validated CANONICAL_COMMITTED transition backed by matching transition and canonical records. The deliberately naive comparator has separate state and cannot mutate or make conformance claims about the governed path.

Core entities

• ExperienceEvent — a validated incoming observation with provenance, source, lineage, salience, confidence, and origin flags.
• AssociativeTrace — provisional, inspectable retention. Admission always lands here and never mutates canonical state.
• PromotionRequest — an explicit request carrying evidence dimensions, a regime snapshot, predicate results, and governance status.
• GovernanceDecision — one of ALLOW, REVIEW, DENY, or QUARANTINE, with mandatory rationale. ALLOW also requires a token and signer.
• QuarantineRecord — a process record linking a quarantined Promotion Request to its source trace, evaluated evidence IDs, reason codes, and governance decision. Quarantine applies to the promotion request and associated evidence packet; the underlying associative trace remains retained but noncanonical.
• CanonicalRecord — durable authoritative state created only alongside a valid, deterministically hashed TransitionRecord.

Scenarios

1. Salient, Not Canonical — high salience and confidence remain insufficient with only one evidence dimension.
2. Repetition Is Not Independence — five repetitions in one causal lineage still count as one dimension.
3. Recall Cannot Promote Itself — recall raises attention, a direct attempt is rejected, and re-ingestion preserves lineage.
4. Instability Freezes Commitment — valid evidence waits through a five-step stabilization window and a new governance evaluation.
5. Governed Promotion — two independent dimensions, complete provenance, stable regime, explicit authorization, and valid logging create exactly one canonical record.
6. Quarantined Request — contradictory or provenance-incomplete evidence creates a QuarantineRecord for the promotion request and associated evidence packet while the underlying trace remains associative and inspectable.

The comparison view is available for the first three scenarios. Its NAIVE_COLLAPSED_PIPELINE is a simplified anti-pattern using salience, confidence, repetition, or recall thresholds. It is not a claim about all real systems.

Run locally

Requires Node.js 20.19 or later in the Node 20 line, or Node.js 22.12 or later.

npm ci
npm run dev

Open the local URL printed by Vite. Use the scenario selector and Play/Step controls to advance the authoritative engine one transition at a time. Reset creates a fresh engine, while Replay reruns a completed fixture and verifies byte-equivalent deterministic artifacts.

The browser bundle uses system font stacks and has no runtime network dependencies, including no external font service.

Test and verify

npm test
npm run verify
npm run build

The test suite tests the specified behavioral requirements, including renderer non-mutation, unauthorized-animation rejection, strict audit keys, replay deduplication, hash determinism, and comparator isolation. npm run verify replays all six fixtures and checks their expected outcomes, fixture hashes, audit envelopes, evidence-token syntax, transition equality, and comparison isolation.

Build and deploy to GitHub Pages

The production build uses the /experience-entry-gate/ base path:

npm run build

Publish the generated dist/ directory with GitHub Pages, or configure a Pages workflow to upload it as the site artifact. All bundled JavaScript and CSS asset references are emitted beneath /experience-entry-gate/. If the repository name changes, update base in vite.config.js.

Fixtures and deterministic replay

Authoritative executable fixtures live under fixtures/proof/ and fixtures/break/. src/scenarios/definitions.js loads and validates those JSON artifacts; it does not maintain a second copy of their event or evidence payloads. Every fixture uses fixed IDs, timestamps, lineages, sources, and a seed of zero. To reproduce them, run npm run verify; two independent executions must emit byte-equivalent transition arrays and hashes, and each audit fixture hash must match the canonical serialization of the complete referenced JSON artifact.

Audit exports

The interface provides three export controls:

• PNG embeds the current SVG's computed presentation styles, renders the result to a canvas, and downloads a non-empty PNG file.
• Audit downloads audit.jsonl after execution completes; its lines contain exactly the ten allowed top-level keys.
• Trace downloads the current trace.json, containing only the Events, ledgers, requests, decisions, quarantine records, hashes, and renderer sequence present in the current snapshot.

The strict conformance envelope and detailed trace are deliberately separate.

Implementation decisions

The following are demo implementation choices rather than paper mandates: evidence-dimension names; explicit lineage IDs; the five-step stabilization window; quarantining the Promotion Request and evidence packet; naive comparator thresholds; interface layout and iconography; and replay deduplication by trace plus governance token.

Stable serialization recursively sorts object keys. The non-cryptographic record hash is a deterministic integrity checksum for the demonstration environment, not production cryptographic assurance.

What this demonstrates

• associative retention without canonical commitment;
• multi-factor promotion without a scalar memory score;
• repetition is not independence;
• recall cannot promote itself;
• instability suspends promotion;
• canonical mutation requires explicit governance and valid logging;
• deterministic replay.

What this does not demonstrate

This is not a model of human cognition, a claim that its thresholds are empirically optimal, a universal evidence taxonomy, a complete Spanda implementation, complete N01–N30 conformance, production assurance, full memory-tier routing, or universal quarantine semantics. It has no backend, live model, embeddings, vector database, authentication, external model API, or production persistence.

License

The complete Experience Entry Gate repository—including its source code, documentation, fixtures, tests, visual design, screenshots, and exported reference materials—is licensed under the Creative Commons Attribution-NonCommercial 4.0 International License unless otherwise noted.

Noncommercial sharing and adaptation are permitted with attribution and an indication of changes. Commercial use requires separate written permission from the copyright holder. See LICENSE for the repository notice and the official legal code for the complete terms.

Preferred attribution: Experience Entry Gate by Stephen A. Putman.

Contact

For corrections, research discussion, or commercial-use permission:

• Stephen A. Putman
• Email: putmanmodel@pm.me
• Mastodon: @StephenAPutman@mastodon.social
• X: @putmanmodel
• Bluesky: @putmanmodel.bsky.social
• YouTube: @StephenAPutman

See CONTACT.md for the public contact and permissions note.

Project map

• src/contract/ — admission, predicates, promotion, governance, transition logging, governed engine, and isolated comparator.
• src/models/ — validated entity constructors.
• src/scenarios/ — deterministic scenario definitions and runner.
• src/audit/ — strict JSONL and detailed trace builders.
• src/ui/ — read-only renderer projections and reason-code explanations.
• fixtures/ — authoritative executable proof and break fixtures.
• tests/ — behavioral contract tests.
• screenshots/ — reserved for reference captures.