Exploration in Plantangenet

Exploration is the proof domain between Music and Rally Driving.

Where Pong asks: can a deterministic world host interchangeable agency? And Music asks: can an agent become aware of its participation in a structured field? And Rally Driving asks: can an agent maintain coherent action while navigating multiple overlapping, partially reliable runway projections under constraint?

Exploration asks:

Can an agent build a usable model of a field through situated, bounded observation?

This document explains what exploration means inside the Plantangenet architecture and why Discovery, Observation, Progression, and the Explorer matter as modeling choices, not just gameplay mechanics.

The Short Version

Inside Plantangenet, exploration is a field-learning activity.

It demonstrates that:

an agent can encounter a world partially rather than all at once
first observation is different from continued presence
local discoveries can aggregate into area and region progress
surface conditions can be attached to discovered places
memory, novelty, and progress can be kept separate from world infrastructure

The architectural question is:

What does this agent know about the field because it has actually encountered it?

Exploration is not yet Rally Driving. It does not require the agent to choose between conflicting future projections under irreversible constraint.

But it is also not Music. The agent is no longer only participating in a pre-encoded shared artifact. It is learning the shape of a field by moving through it.

That makes Exploration the epistemic bridge: it teaches an agent how a world becomes known.

From Participation to Field Learning

In Pong:

one ball defines one future
the paddle learns temporal coherence in a small deterministic field

In Music:

Pop and Jazz define a structured shared field
the Musician learns participation inside an encoded artifact

In Exploration:

the world is encountered through local observation
the Explorer learns which places have been seen, how they relate to larger regions, and what conditions were present when they were discovered

In Rally:

the Driver must choose between visible road, pace notes, car state, surface inference, and memory
the field is no longer merely discovered; it is interpreted under pressure

Exploration therefore sits between Music and Rally because it introduces earned familiarity.

The agent does not yet need to decide which future to trust. First it must learn what it has actually seen.

What Discovery Is

Discovery is the first transition from unknown to known.

A discovery event is not the same as location. It is not the same as presence. It is not the same as occupancy.

A location exists whether or not an agent has seen it.

A hob may be present at a location for many ticks.

Discovery occurs when an activity recognizes that this hob has newly encountered this location in this exploration context.

That distinction matters because a creature cannot build a meaningful self-model if the system conflates:

where the world is
where the body is
what the agent has newly learned
what the agent already knew

Exploration keeps those seams explicit.

A discovery event records the encounter:

hob identity
location identity
coordinate space
parent scope
segment index
offset
deformation pressure
optional region
optional area
tick

The event is small, but it is epistemically dense. It says: this agent, at this time, encountered this part of the field under these local conditions.

That is the first stable contract for field knowledge.

What Observation Is

Observation is the activity of sampling the local field.

In the current exploration runtime, observation can occur at the hob's current activity location or across a radius of nearby segments.

The radius form is especially important. It is the baby version of visible-road scanning.

The agent is not only asking:

Where am I?

It is beginning to ask:

What can I currently see around me?

The observation payload records:

hob id
tick
center segment
observed entries
new discovery count

Each entry carries:

location id
segment index
deformation pressure

This means observation is not just a boolean visibility check. It is a structured perception surface.

It gives the later creature layer a place to distinguish:

what was visible
what was newly discovered
what was already known
what local conditions were attached to the observation

That is the first step toward perception with memory.

What the Registry Is

The registry remembers what has already been discovered.

Its most important behavior is duplicate suppression: repeated observation of the same location by the same hob does not emit the same discovery event again.

That makes the registry an anti-noise device.

Without it, every tick would look like discovery. The creature would drown in false novelty. Every frame would scream "new world" even when the agent was merely standing still.

With it, the system can distinguish:

first encounter
continued presence
revisitation
progression

This distinction is small in code and large in architecture.

It is the difference between sensation and memory.

What Progression Is

Progression lifts local discovery into larger field knowledge.

A single discovered segment is local. But agents do not only need local facts. They need larger orientation surfaces:

How much of this area have I encountered?
How much of this region has become familiar?
Where is exploration complete, partial, or absent?

The progression ledger aggregates discovery events into area and region progress.

Progression signals are published under canonical paths, such as:

region::exploration/progression/area/...
region::exploration/progression/region/...

This makes exploration legible to the wider Plantangenet system without forcing the world infrastructure to own exploration policy.

That is the correct separation.

The world defines what exists.

The activity defines what has been discovered.

The progression ledger defines how local discoveries become navigable knowledge.

What Deformation Adds

Exploration does not only record geometry. It also records deformation pressure.

That is the seed of surface awareness.

A discovered place is not simply a coordinate. It is a coordinate under conditions.

This matters because later domains, especially Rally Driving, cannot treat the field as static geometry. The same segment under different surface conditions may imply different actions, different risks, and different trust in prior knowledge.

A creature that only remembers "I have been here" is weaker than a creature that remembers:

I have been here, and when I observed it, the surface was under this kind of pressure.

Exploration is where that habit begins.

It does not yet require the agent to act on deformation. It only requires the architecture to preserve deformation as part of the encounter record.

That is enough for the next layer to learn from it.

The Explorer

The Explorer is the site of field learning.

Like the paddle, the Musician, and the Driver, the Explorer may be driven in several ways:

Algorithmically driven -- follows a coverage or search policy
Replay-driven -- repeats a known exploration path
Creature-driven -- develops curiosity, novelty preference, caution, fatigue, and memory
Human-driven -- receives external direction through an adapter or control surface

The architecture does not change. Only the source of the next action changes.

The Explorer is not the world. It is not the registry. It is not the progression ledger.

The Explorer is the participant whose movement produces encounters, whose encounters become discovery events, and whose accumulated discoveries can eventually become self-knowledge.

Dissonance in Exploration

Exploration introduces dissonance domains that are softer than Rally but sharper than Music.

1. Novelty Dissonance

The agent expects to discover something new but keeps revisiting known space.

This may produce curiosity pressure, boredom, or a need to change strategy.

2. Coverage Dissonance

The agent has partially explored an area but lacks enough coverage to treat it as familiar.

This creates pressure to complete, abandon, or reprioritize the region.

3. Surface Dissonance

The agent remembers a location under one deformation state but observes it later under another.

The map is not wrong, but it is stale.

4. Orientation Dissonance

The agent has local observations but cannot yet assemble them into a coherent regional model.

It has seen pieces but does not know the shape.

5. Confidence Dissonance

The agent has technically discovered a place but does not trust that its understanding is sufficient for future action.

This is the earliest form of trust modeling.

Unlike music, where dissonance can be aesthetic, exploration dissonance is epistemic.

It concerns what the agent knows, what it thinks it knows, and whether its knowledge is still useful.

The Role of the Self-Model

A creature Explorer must eventually develop:

Discovery Model

which locations have been encountered
which areas and regions are familiar
which discoveries were recent or stale

Coverage Model

where gaps remain
which regions have been partially explored
which paths tend to reveal new space

Surface Model

what deformation or pressure conditions were present during observation
where conditions tend to change
where prior observations may no longer be reliable

Curiosity Model

what kinds of novelty the creature seeks
how long it tolerates revisiting known space
when it prefers safety over discovery

Confidence Model

how strongly the creature trusts its own map
when it treats an area as known enough
when it must re-observe before acting

This is not about discovering more quickly.

It is about:

learning how knowledge of a field is earned, maintained, revised, and trusted.

Why Exploration Belongs Between Music and Rally

Music gives the agent a shared form. The Musician learns to participate in something already structured.

Rally gives the agent conflicting futures. The Driver must decide what to trust under time pressure and consequence.

Exploration gives the agent a field it does not yet know.

That makes it the missing rung.

Before an agent can decide whether to trust a pace note against visible road, it needs a general mechanism for learned familiarity:

I have seen this before
I saw it under these conditions
I have not seen what lies beyond it
my old observation may be stale
this region is partially known
this map is useful but incomplete

Exploration creates the vocabulary that Rally later makes dangerous.

The Runway Model Extended

Across the domains:

Pong: one clean runway
Music: structured shared runway
Exploration: discovered runway fragments
Rally: multiple conflicting runways

Exploration changes the runway model from "what future is emitted?" to:

Which parts of the field has this agent earned the right to project from?

In Pong, the ball emits a readable future.

In Music, Pop and Jazz emit structured futures.

In Exploration, the agent builds its own partial runway map through encounter.

In Rally, that map becomes one projection among several: visible road, pace notes, car state, surface inference, and memory.

The important step is that memory is no longer assumed. It is produced.

What Is Already Working

The current exploration runtime already contains the core pieces of this domain:

ExplorationGame owns gameplay policy and progression state
location and deformation are consumed from plant_runner::ExecutionContext
DiscoveryContext records the observation context
DiscoveryEvent provides a canonical schema id: exploration.discovery.v1
ExplorationRegistry suppresses duplicate discovery events
ObservationConfig, ObservationEntry, and ObservationPayload support radius-based observation
DiscoveryProgressionLedger aggregates discovery into area and region progress
lifecycle conformance tests verify tick, reset, and remove behavior

This is already enough to prove the activity boundary.

Exploration is not world infrastructure. It is not a physics primitive. It is an activity runtime that interprets world exposure as discovery and progress.

That is exactly where it should live.

What Comes Next

The next step is to make exploration more explicitly testable as a bridge domain.

First: Trace Schema

Define ExplorerTraceRow before adding creature behavior.

It should capture:

hob id
tick
center segment
observed segment ids
new discovery count
area id
region id
deformation pressure summary
known-before / known-after state
selected movement action
rejected alternatives
novelty pressure
coverage pressure
confidence estimate

This schema is not scaffolding. It is the metric vocabulary the creature layer will eventually internalize.

Second: Named Explorers

Before building a creature Explorer, build named exploration profiles:

Scout -- favors new segments and high coverage expansion
Cartographer -- favors systematic area completion
Forager -- favors deformation or resource-rich observations
Homer -- favors safe return to known regions

Run them against the same exploration field.

Verify that the same observation and progression surfaces produce measurably different behavior.

If named explorers do not diverge, the architecture is not yet carrying meaningful exploration policy.

Third: External Metrics

Implement metrics as external library functions first:

novelty yield: how often movement produces new discoveries
coverage efficiency: how quickly area or region progress increases
revisit ratio: how often known space is re-entered
surface awareness: how consistently deformation pressure affects exploration choices
map confidence alignment: how often confidence matches actual known coverage

These metrics should be computable from trace slices, independent of any creature implementation.

The creature should later internalize the same vocabulary as dissonance and self-knowledge.

Fourth: Ablation

Ablation proves architecture.

Remove radius observation. Novelty yield and coverage efficiency should change.

Remove deformation pressure. Surface awareness should degrade.

Remove area and region aggregation. Map confidence should become less coherent.

If removing a layer does not change behavior or metrics, that layer is not load-bearing.

Fifth: Creature Layer

Only after the trace, named explorers, metrics, and ablations pass should the creature layer be added.

The creature Explorer should develop:

curiosity drives
caution drives
coverage dissonance
stale-map dissonance
confidence resolution
willful choice between new, known, risky, and safe regions

The goal is not a better explorer.

The goal is an explorer that knows how its own field knowledge was produced.

What Comes After That

Rally Driving.

Exploration should feed Rally in two ways.

First, it provides the memory substrate for learned roads. A Driver should be able to distinguish between:

visible road
pace note projection
current car state
inferred surface
remembered segment experience

Exploration is where remembered segment experience becomes legitimate.

Second, it provides the trust substrate for stale or contradicted knowledge.

A Driver that has previously observed a segment under dry conditions should not trust that memory equally when current deformation or grip signals disagree.

That is the bridge from map to judgment.

Beyond Rally, Exploration also supports multi-agent discovery:

scouts publishing partial maps
agents disagreeing about what has been seen
shared progress ledgers
stale observations being refreshed by other participants
trust emerging from who observed what, when, and under which conditions

At that point, exploration becomes contract-relevant.

A future commitment made against a field depends on which parts of that field were actually known, who knew them, and whether the knowledge was still valid.