Acting and Entity Interpretation — evidence-grounded actor context

# Acting and Entity Interpretation — evidence-grounded actor context

Status: **Shipped.** Acting is the first-class context-engineering practice; the Entity Interpretation Graph is its evidence-grounded artifact; Production → Actors is its single authoring home. The record stores immutable generated graphs and effective-dated bindings, and entity chat, Scenario play, Stream suggestions, and Perspectives consume Evidence, Interpretation, or Both independently for State and Dynamics at the active branch coordinate. What ships: four-kind as-of evidence assembly, tracked strict-JSON generation, storage, evidence validation, strict reason order, cyclic and acyclic topology, independent branch-aware State/Dynamics selection, all three context mixer modes, graph visualisation, explicit return to evidence, and shared entity performance context downstream. The Behaviour Reading (§9) and its evaluation programme (§10) are a described extension, not scheduled work and not a gate on anything that ships.

Search aliases: **Latent Model**, **Latent Behaviour Graph**, and **LBG** are retired names for this
contract. Questions about how entities learn and change latent models across visual-novel branches route
here; the maintained product term is Entity Interpretation.

Behaviour Reading is an unbuilt extension term for a described, unscheduled activation seam.

This specification owns one question: **how Meridians may act on an entity's behalf by compressing
accumulated evidence into an inspectable, revisable performance context.** Entity continuity is the
evidence record, not a single fixed characterization. The same record may support several defensible
interpretations, and one continuing entity may carry discrete interpretations at different branch
moments without any of them becoming canonical psychology. The name is deliberate: in the craft sense, an
actor is a person who studies the available evidence, makes a strong read of the situation, and compresses
that read into playable choices. Production → Actors applies that craft to every performable entity type.
The artifact is the **Entity Interpretation
Graph (EIG)**. It is entity-scoped, authored or generated from bounded evidence, and used to produce a
field of plausible responses—not a diagnosis, personality score, or inevitable action.
Use this contract when asking how characters, units, locations, or artifacts change or express themselves differently across
visual-novel branches: immutable graph snapshots are reinterpreted from new evidence and selected through
branch-and-moment bindings without rewriting entity continuity.

The closest existing paradigm is the graph family already used by Causal Reasoning Graphs, Phase graphs,
and Coordination Plans:

- **CRG contributes the grammar:** typed nodes and edges, stable semantic ids, explicit inference handles,
  as-of graph provenance, reference validation, and a shared graph renderer.
- **Phase contributes the lifecycle:** immutable snapshots, optional regeneration from a prior graph, one
  current selection, staleness rather than silent refresh, and downstream consumers that inherit the
  selected model uniformly.
- **Coordination Plan contributes extension without fragmentation:** one common graph shape gains a narrow
  ontology for its altitude rather than becoming an unrelated graph system.

An EIG therefore belongs to the same **graph family**, but it does not reuse CRG node meanings. A CRG is a
scoped causal argument; a Phase graph is a working model of world machinery; a Coordination Plan is an
authored trajectory; an EIG is a provisional interpretation of one entity's behavioural formation.

Authority remains unchanged:

```text
canonical evidence describes what is recorded
the Entity Interpretation Graph describes one derived explanation
an attributable binding selects which context a consumer receives
the Behaviour Reading activates that explanation in a situation
Will supplies the attributable authorship, selection, or action
```

Read first: [proxy principle](../../knowledge/foundations/ALIGNMENT.md#the-proxy-principle),
[behaviour-model direction](../../knowledge/architecture/WORLD_ENGINE.md#acting-gives-entity-behaviour-a-selected-interpretation-context),
[Substrate vocabulary](../../knowledge/vocabulary/substrate.md), and
[Reasoning vocabulary](../../knowledge/vocabulary/reasoning.md).

Founder direction: [Acting as first-class interpretation](../../sources/founder/2026-09-07-acting-first-class-founder-clarification.md) ·
[Acting reads and manual cadence](../../sources/founder/2026-09-07-acting-reads-founder-clarification.md) ·
[Entity Interpretation graph cycles](../../sources/founder/2026-09-07-entity-interpretation-cycles-founder-clarification.md) ·
[Entity Interpretation correction](../../sources/founder/2026-09-07-2026-09-07-entity-interpretation-founder-direction.md) ·
[Entity Interpretation UI direction](../../sources/founder/2026-09-07-2026-09-07-entity-interpretation-ui-direction.md) ·
[Production and Acting direction](../../sources/founder/2026-09-07-2026-09-07-production-acting-founder-direction.md) ·
[Acting graph complexity correction](../../sources/founder/2026-09-07-2026-09-07-acting-graph-complexity-correction.md) ·
[Latent behavioural graph](../../sources/founder/2026-09-02-latent-behaviour-graph-founder-note.md) ·
[branch-specific learning and Factory roadmap](../../sources/founder/2026-09-02-2026-09-02-world-factory-roadmap-founder-note.md).

---

## 1. Two representations, one evidence boundary

The model begins by keeping two representations distinct.

### Evidence profile — historical proxy

An **Entity Evidence Profile** is a deterministic, as-of projection of what the record can support about
one entity. It may draw from:

- entity continuity nodes and authored facts;
- relevant outline entries, Scenes, actions, dialogue, expressions, and consequences;
- knowledge available to the declared perspective;
- outgoing Frames owned by the entity and incoming Frames clearly marked as other people's readings;
- relationships, obligations, capabilities, possessions, and constraints;
- formative history: culture, education, institutions, practice, loss, reinforcement, and attachment.

Outline context is useful compression, but it is not self-authenticating evidence. Every profile atom
retains a stable reference to the underlying Scene, world node, Frame, or other canonical record. A prose
summary with no recoverable source may orient generation; it cannot alone ground a latent claim.

```ts
type EvidenceRef = {
  kind: "scene" | "world-node" | "frame" | "control" | "thread-log" | "world-build" | "source";
  id: string;
  entryId?: string;            // branch position where the evidence was available
  perspectiveId?: string;      // who could observe or assert it, when bounded
};
```

### Entity Interpretation Graph — explanatory proxy

The EIG compresses that profile into one of two related graphical hypotheses. **State** interprets durable
formation and behavioural tendency from continuity and relevant Scenes. **Dynamics** interprets how the
current directed Frame and Control picture shapes the entity's response. They keep independent snapshot
and binding histories: Dynamics consumes the canonical topology but never becomes a parallel Frame or
Control model. Their nodes do not become entity `trait` nodes, canonical facts, or private truth. Each
graph records **what the model inferred from the evidence available at a declared vantage**.

```text
Entity Evidence Profile at t
→ Entity Interpretation Graph at t
→ situation + seat-projected knowledge + current state
→ Behaviour Reading: competing pulls, inhibitions, and available tendencies
→ human or agent Will
→ accepted consequence at t+1
→ new evidence profile and, when refreshed, a new graph snapshot
```

Each graph snapshot is a directed interpretation model, not necessarily a causal DAG. It may be acyclic,
or it may contain reciprocal, reinforcing, and inhibiting feedback when those relations make the acting
read more faithful. Feedback also happens **across time**: consequence becomes new evidence for the next
snapshot. A cycle must explain a real dependency in the interpretation rather than decorate the graph;
stable node indices keep downstream context serialization readable without pretending topology is linear.

### Post-hoc growth (MDL)

- SWITCH to interpretation when a graph describes the record more cheaply than the record describes itself,
  within the horizon the world already declares — AND the narrative keeps returning to the entity (focus).
- GROWTH (re-interpretation) when the accumulated surprisal of evidence the graph does not explain exceeds
  the graph's own length: it is cheaper to rewrite the graph than to keep listing exceptions.
- The successor graph is generated FROM the prior (`prior:` arg already exists) so it is the prior revised,
  not replaced. The effective-dated chain of graphs is the growth arc.

---

## 2. What psychometrics contributes—and what it does not

Psychometrics contributes the distinction between **observable indicators** and **latent dimensions**.
Repeated measurements can support an inference about an underlying capability or disposition that no
single measurement directly reveals.

Meridians adapts that shape semantically:

- repeated choices, statements, relationships, emotions, and consequences are indicators;
- an LLM proposes domain-native latent dimensions and connections from sufficiently rich evidence;
- held-out behaviour and later evidence test whether the graph was useful;
- contradictions revise the model rather than being explained away.

This is not a standardized psychological test. LLM-generated dimensions do not inherit clinical validity,
population norms, cross-person comparability, or numerical precision merely because the graph resembles a
psychometric model. Universal inventories are rejected by default: the ontology fixes **causal roles**,
while labels and content remain native to the character and world.

---

## 3. Node ontology

The ontology separates evidence anchors, latent mechanisms, and behavioural outputs. Type names describe
what a node does in the model, not the subject matter it mentions.

| Tier | Type | Meaning |
|---|---|---|
| Evidence | `indicator` | An observed or authored manifestation: choice, statement, gesture, emotion, habit, outcome, or repeated pattern. Must reference evidence. |
| Evidence | `formation` | A historical shaping influence: upbringing, culture, education, institution, practice, reinforcement, loss, or relationship history. Must reference evidence. |
| Latent | `disposition` | A dynamic tendency that recurs across contexts without determining action. The graph-native term for a latent trait, avoiding collision with the entity graph's `trait` node type. |
| Latent | `schema` | A learned interpretive expectation: how the entity tends to explain, anticipate, or categorize situations. |
| Latent | `value` | A comparatively durable standard or outcome the entity protects, pursues, or refuses to trade. |
| Latent | `sensitivity` | A class of cues to which attention or affect is unusually responsive. Carries the conditions that activate it. |
| Latent | `inhibition` | An internalized brake: fear, shame, norm, loyalty, anticipated cost, taboo, or learned suppression. |
| Latent | `capacity` | A developed ability, knowledge structure, or practiced competence that makes some responses available. It is not the entity's current information state. |
| Appraisal | `motive` | A desired or avoided outcome activated in a class of situations. More situational than a value; more explanatory than a stated goal. |
| Output | `tendency` | A conditional pull toward an action or expression. Several tendencies may be active together; none is an action commitment. |

The initial ontology deliberately excludes diagnoses, moral types, demographic essences, and universal
personality-factor names. A world may label a disposition “protect the sect before the self”; it may not
invent a new node type called `sect-loyalty`.

### Common node shape

All nodes share the graph family's readable base:

```ts
type LatentNodeSnapshot = {
  id: string;                  // semantic type-prefixed slug
  index: number;               // stable presentation order, not a score
  order?: number;              // LLM emission order
  type: LatentNodeType;
  label: string;
  detail?: string;
  considered?: string;         // rival explanations rejected, and why
  breaks?: string;             // evidence that would invalidate this node
  opens?: string;              // behaviour or counterfactuals this predicts
  evidenceRefs: EvidenceRef[];
  trajectory?: "emerging" | "stable" | "strengthening" | "weakening" | "volatile";
  status: "tentative" | "supported" | "contested";
};
```

`considered`, `breaks`, and `opens` reuse the Reasoning Graph's universal inference shape. They are
required on every latent, appraisal, and output node. Evidence nodes are substrate and may omit them.

Status describes evidence support, not strength of personality. Trajectory describes change in the
model's reading, not a permanent property of the person.

---

## 4. Edge ontology

Edges have one direction: source influences or bears on target. The ontology distinguishes epistemic
support from causal influence so “we observed X” is never confused with “X caused Y.”

| Family | Type | Direction and meaning |
|---|---|---|
| Evidence | `supports` | `indicator/formation → inferred node`: increases the plausibility of the hypothesis. |
| Evidence | `contradicts` | `indicator/formation → inferred node`: evidence the hypothesis does not explain. Contradiction remains visible. |
| Development | `shapes` | `formation → latent/appraisal node`: historical influence helped form the mechanism. |
| Activation | `activates` | `latent node → appraisal/output node`: makes the target salient under the edge's condition. |
| Activation | `amplifies` | `latent/appraisal node → latent/appraisal/output node`: increases another mechanism's pull. |
| Activation | `inhibits` | `inhibition/value/schema → appraisal/output node`: suppresses or raises the cost of the target. |
| Ability | `enables` | `capacity → tendency`: makes the response available without making it chosen. |
| Behaviour | `motivates` | `value/disposition/motive → tendency`: supplies a reason or desired outcome for the response. |
| Behaviour | `expresses` | `disposition/schema/sensitivity → tendency`: the tendency is one conditional manifestation of the mechanism. |

```ts
type LatentEdgeSnapshot = {
  id: string;
  from: string;
  to: string;
  type: LatentEdgeType;
  label?: string;
  condition?: string;          // when this influence is expected to operate
  evidenceRefs?: EvidenceRef[];
};
```

The first version carries no numeric trait scores or edge weights. LLM-assigned numbers would create false
precision before the model has prediction and calibration evidence. If later evaluation supports weights,
strength and confidence must remain separate, and weights must be learned or calibrated from repeated
prediction—not asserted during extraction.

---

## 5. Graph shape and invariants

An EIG should normally contain 8–24 nodes. Evidence density, not a quota, sizes it. A sparse character may
legitimately have no graph.

Hard invariants:

1. **Evidence stays authoritative.** The graph never writes entity continuity, Frames, knowledge, or state.
2. **As-of, never hindsight by accident.** Every graph declares branch, cursor, evidence cutoff, and observer perspective.
3. **Every inferred node is grounded.** It carries a valid evidence reference and is reachable from an evidence anchor. `supported` requires at least two independent evidence clusters; one cluster can only sustain `tentative`. Ungrounded latent nodes are rejected, not merely detached.
4. **One scene is not a personality.** A single-context manifestation may create a tentative hypothesis, never a supported disposition.
5. **Contradiction remains in the graph.** New evidence may contest a node; the generator may not preserve coherence by hiding the counterexample.
6. **Topology follows the interpretation.** A graph may be acyclic or cyclic. Reciprocal, reinforcing, and inhibiting feedback is legitimate when evidence grounds every participating node and the loop adds explanatory force. Self-edges remain invalid because they express no relation between distinct reasons.
7. **No latent-to-action edge exists.** The terminal node is a `tendency`, not a tool call, Scene delta, or decision.
8. **Perspective boundaries survive.** An analyst may use authorial evidence to model the entity, but a seat's Behaviour Reading receives only knowledge and affordances available to that seat.
9. **Domain-native, not diagnostic.** Labels describe this world and trajectory; they do not diagnose a person or infer protected characteristics.
10. **Several explanations remain possible.** The graph exposes considered alternatives and falsifiers rather than collapsing ambiguity into one fluent story.

A useful graph is not the densest one. It is the smallest graph that explains repeated variation and
changes its action field under meaningful counterfactuals.

---

## 6. Evidence sufficiency

“Enough evidence” is a coverage decision, not a raw item count. Before generation, a pure coverage pass
assesses:

- **temporal coverage:** evidence spans more than one moment;
- **situational diversity:** the entity appears under different pressures or relationships;
- **independence:** several evidence clusters are not paraphrases of the same event;
- **formation coverage:** at least some history explains how tendencies may have developed;
- **counterevidence:** exceptions, reversals, or failures are available where the record contains them;
- **perspective integrity:** each item declares who could observe or authoritatively assert it.

The generator may return `insufficient_evidence` with the missing coverage dimensions. It must not fill a
sparse profile with genre convention, stereotypes, or the model's general knowledge of “people like this.”

No universal numeric threshold is settled here. The first implementation should reject a profile confined
to one Scene or one repeated claim and should test threshold choices against held-out character histories.

---

## 7. Generation, validation, and lifecycle

The intended pipeline roughly duplicates the existing graph family:

```text
assembleEntityEvidenceProfile (pure, deterministic, as-of)
→ evidenceCoverage (pure gate)
→ generateEntityInterpretation via the existing `plan` model lane
→ parse strict JSON
→ validate ontology, endpoints, evidence refs, and perspective
→ store immutable snapshot through one reducer action
→ select current graph for this entity/branch
→ surface staleness when the evidence signature changes
```

### Snapshot shape

```ts
type LatentBehaviourGraph = {
  id: string;
  entityId: string;
  kind: "state" | "dynamics";
  branchId: string;
  asOfEntryId?: string;
  perspectiveId?: string;      // absent = declared authorial/analyst vantage
  summary: string;
  nodes: LatentNodeSnapshot[];
  edges: LatentEdgeSnapshot[];
  evidenceSignature: string;
  basedOn?: string;
  guidance?: string;
  createdAt: number;
};
```

Like Phase, stored graphs are immutable. Refresh creates a new graph with `basedOn`; it does not overwrite
the old explanation. An effective binding may select the graph used for future Behaviour Readings, while
Scenes or generated artifacts pin the exact graph they used. New evidence marks the graph stale; it does
not silently spend money or replace the Director's selected model.

Acting reads should recur as evidence accumulates, the situation changes, or a prior interpretation no
longer explains the performance well. That is an editorial and rehearsal cadence, not an autonomous
Program lane. For now a person manually initiates Suggest, Draft, review, and binding. The system may
surface staleness or evidence change, but it must not schedule a generation, choose a replacement, or
rebind downstream context on its own.

The graph snapshot is canonical only as a record that **this inference was generated from this evidence at
this vantage**. Its psychological claims remain derived.

### Active interpretation is branch-and-moment scoped

A single mutable “current graph for this entity” is insufficient once the same entity continues through
several branches. Selection must be effective-dated inside branch lineage:

```ts
type LatentModelBinding = {
  entityId: string;
  branchId: string;
  kind: "state" | "dynamics";
  contextMode: "evidence" | "interpretation" | "both";
  graphId: string | null;
  effectiveFromEntryId: string;
  selectedBy: string;          // Director or governed operation provenance
  reason?: string;
};
```

Resolving an active graph at a coordinate follows branch ancestry and the latest binding at or before the
cursor. A child branch inherits its parent's binding until it explicitly selects another evidence-grounded
snapshot. Past Scenes, prepared Experiences, and deployed Worlds pin the exact `graphId`; a later refresh
cannot rewrite how an earlier character was interpreted or performed.

This supports two legitimate kinds of divergence:

- **evidence divergence:** different consequences create different evidence profiles and therefore
  different refreshed graphs;
- **interpretive divergence:** two supported graphs explain the available evidence differently, and a
  Director explicitly binds a different reading for a branch. Whether a prepared production may carry an
  interpretation-only override remains open.

Interpretive divergence is a declared modelling choice, not a newly discovered character fact. A binding
may alter Behaviour Readings and the expression coverage requested from Factory, but it cannot write entity
state, invent post-cursor evidence, or make the action. The same entity id and identity lineage continue
through every branch.

### Stricter than CRG reference recovery

CRG validation can clear a hallucinated substrate id and retain useful free-standing reasoning. An EIG
cannot: provenance is its authority boundary. Invalid evidence roots remove dependent hypotheses; if the
remaining graph fails coverage, the generation fails. Dangling or self-referential edges, unknown types,
and duplicate semantic ids are rejected deterministically. Cycles between distinct, grounded reasons are
valid topology rather than a validation failure.

---

## 8. Production, Actors, and inspection contract

**Acting is a first-class Production capability:** a person forms a strong, evidence-validated,
time-specific performance context on an entity's behalf from material that may admit more than one
reading. AI may assist with guidance and graph drafting; it does not own the read or its cadence.
**Production → Actors**
is its single authoring and management home. The Actors and Perspectives workspaces share one
Production interaction grammar: the same header rhythm, searchable rail, collapsible entity-kind groups,
kind-specific avatars, selection treatment, coordinate/status metadata, and focused working canvas. The
rail always distinguishes **Character, Unit, Location, and Artifact** rather than treating actor as a
synonym for character.

The Actors workspace's State/Dynamics lens,
context mixer, interpretation history, optional guidance, AI drafting, review, and ordered graph remain in
one full Stage field; no modal or inspector sub-workflow duplicates them. The Dynamics lens also carries
the focused canonical Frame/Control topology and its editors. Production can later gain other craft
workspaces without making Acting authoring part of an entity inspector.

State begins with
attributed World nodes plus recoverable outline and Scene context; Dynamics begins with canonical Frame
and Control evidence. Every reasoning node cites the exact evidence that grounds it, and directed edges
carry that evidence-backed interpretation through a graph that may branch, converge, and loop. Explicit node
order defines stable context serialization; it does not force a linear topology. The graph's own node
detail provides evidence, alternatives, falsifiers, and conditional openings in the same inspection
grammar as other Meridians graphs. A character performs through speech and choice; a unit through
coordinated behaviour; a location through affordances and pressures; and an artifact through use, custody,
meaning, and consequence. The ordinary entity inspector continues to inspect canonical continuity,
relationships, and attribution rather than becoming another Acting editor.

For each lane, the Director explicitly chooses the downstream context source:

- **Evidence** — consume the canonical evidence projection directly;
- **Interpretation** — consume the selected ordered reasons graph in place of the raw projection;
- **Both** — supply the canonical evidence and selected graph together.

AI generation is manual and reviewable. The guide prompt is optional; an empty guide requests the smallest
evidence-proportionate interpretation. **Suggest** uses the same complete as-of evidence profile to propose a concise guide,
but only fills the editable field—it does not draft, store, or select a graph. A draft does not write or select
itself. Applying stores the immutable graph and records
an attributable selection effective from the current Scene. Selecting another graph or mixer mode writes
a new binding at that coordinate, so earlier Scenes retain their prior performance context.

## 9. Activation into behaviour

*Extension, not shipped.* Mode resolution below is live; the Behaviour Reading that follows it is a described seam that no runtime step currently produces.

State and Dynamics resolve independently. In Evidence mode, the consumer receives raw continuity or the
canonical Frame/Control projection. In Interpretation mode, the respective projection is replaced by its
selected ordered graph. Both supplies the two representations together. Canonical continuity, Frames, and
Control always remain stored and recoverable; replacement is contextual, never destructive. A later pure
or inspectable activation step can compose the resolved context with the situation:

```text
current EIG
+ what the entity can perceive and know
+ current relationships, state, capabilities, constraints, and available tools
→ Behaviour Reading
```

A `BehaviourReading` contains:

- activated tendencies and the paths that produced them;
- active motives and inhibitions;
- tensions among several plausible responses;
- missing information and uncertainty;
- expressions or micro-movements that would be coherent with each response.

It returns an **action field**, never a ranked command that quietly becomes Will. A human-controlled seat
may use it as insight; an agent-controlled seat may use it as deliberative context; Experience production
may use it for dialogue and performance continuity. Only the existing governed action path records a move.

For Experience and World, activation resolves the binding **as of the passage or moment**, not the entity's
latest graph. Its expression suggestions are semantic requests—guarded, relieved, dissociated, newly
formal—not asset ids. The directional [Factory](../visual-novel/production.md#12-factory--the-production-control-surface)
maps those requests onto approved sprites, appearance sets, voice, and motion coverage. Missing coverage is
a production gap, never permission to change the latent model to fit the available art.

### Learning is reinterpretation across snapshots

Characters “learn” in this model when accepted consequences alter their knowledge, relationships,
capacities, formation, or repeated evidence and a later refresh produces a materially different action
field. The change may be continuous or a step change: a long-stable inhibition can become contested after
one decisive event, or a newly learned schema can reorganize several tendencies at once.

The lifecycle stays explicit:

```text
accepted consequence → new canonical evidence → stale signal
→ coverage gate → refreshed EIG based on the prior snapshot
→ comparison and explicit binding → new Behaviour Reading
```

Conversation, traversal, or an LLM's persuasive reinterpretation does not itself count as learning. The
record must first contain the event or evidence, and the old graph remains available so the changed
explanation can be inspected rather than backfilled as if it had always been true.

---

## 10. Evaluation, if activation is built

The model earns runtime authority through behavioural adequacy, not how psychologically persuasive its
prose sounds.

| Test | What it should establish |
|---|---|
| Held-out continuation | A graph built only from history up to `t` includes the observed `t+1` behaviour within its plausible action field without requiring exact prediction. |
| Counterfactual sensitivity | Changing knowledge, relationship, pressure, or constraint changes the action field while unrelated facets remain stable. |
| Contradiction update | Strong counterevidence weakens, contests, or replaces dependent nodes instead of being rationalized as confirmation. |
| Evidence ablation | Removing a formative or indicator cluster removes or destabilizes the hypotheses it grounded. |
| Distinctiveness | Different characters under the same pressure produce meaningfully different fields for evidence-backed reasons. |
| Context variation | One character under different conditions can express the same disposition differently. |
| As-of integrity | The graph and Behaviour Reading contain no evidence or knowledge from after their cursor or outside their declared perspective. |
| Run stability | Repeated extraction preserves the major supported structure while allowing honest alternatives at tentative edges. |

Failure on these tests means the graph is an attractive explanation, not yet a useful behavioural model.

---

## 10a. What this buys the three forms

The graph is an instrument for **characters worth being with**, and that is its role in the product — one role
in each form, all from the same artifact and none of them diagnostic:

- **Experience.** A second seat is only a second book if the character at the hearing behaves as the same
  person from Mara's side and the guildmaster's. Branch-and-moment-scoped interpretation pinned into
  preparation (§7) is what makes the second seat worth buying.
- **Populated World.** A cast that stays coherent under many wills is what keeps a shared world from
  coming apart the first time two players push the same character in different directions. Reinterpretation
  across snapshots (§9) is how the world's people change *because of* what happened rather than at random.
- **Consequential test worlds.** Evidence-grounded, versioned, inspectable behaviour is what makes a
  world's characters a fixed instrument a policy can be run against and compared over
  ([13](../../knowledge/product/strategy/13-consequential-test-worlds.md)). A pinned EIG is part of the
  pinned world.

The boundary does not move for any of the three: the graph explains *fictional* entities from *declared*
evidence. It has no clinical validity, infers no protected characteristic, and is never turned on a real
player. The graph is for the people they meet there.

### 10b. The player's record is a different instrument, under the same boundary

What a player does across a journey is read by a **Rasch** scale over forks, not by this graph
([12](../../knowledge/product/strategy/12-the-practice-monopoly.md#the-measure--rasch),
[training worlds §5a](../training-worlds/README.md#5a-the-measure--rasch)). §2 applies to it exactly:
domain-native trait names the person chose, `θ̂` always with its SE, no population norms, no cross-person
ranking, no protected-characteristic inference, nothing disclosed to a third party. The two instruments
share the evidence discipline and nothing else — a character's disposition edge and a player's θ are never
the same object. The player's record, its reading, and how it steers generation are the
[latent-traits spec](../latent-traits/README.md).

## 11. Reuse map

The implementation should extend the existing strategy rather than create a fourth graph stack.

| Existing seam | Reuse for EIG | Deliberate difference |
|---|---|---|
| Graph node base (`id/index/order/type/label/detail`) | Same readable snapshot shape | `index` is stable presentation order across causal layers, not narrative chronology. |
| `considered / breaks / opens` | Same inference handles | Applied to latent hypotheses and tendencies. |
| Typed edge and palette dictionaries | Same closed-set pattern and directed rendering | New behavioural edge ontology; do not overload CRG edge meanings. |
| Strict JSON generation through `modelFor("plan")` | Same tracked model lane and reasoning budget | Input is an entity evidence profile, not full-domain planning context. |
| Reference validation | Same deterministic guard seam | Missing evidence is fatal to dependent latent claims rather than merely cleared. |
| `Phase` collection + selection | Same immutable, versioned, based-on lifecycle | Selection is entity-, branch-, and effective-coordinate-scoped rather than one global current pointer. |
| Phase staleness | Same pure “model has drifted from evidence” signal | Signature is derived from the evidence profile, not the active Phase id. |
| `ReasoningGraphView` + dagre layout | Reuse through a shared graph adapter | EIG needs its own palette, inspector vocabulary, and no implication that node numbers are trait scores. |
| One-writer reducer path | Same add/select/rename/delete actions | No LLM call or component writes the collection directly. |

The likely implementation folders are siblings, not copies:

```text
src/types/domain/entity-interpretation.ts
src/lib/core/graph/entity-interpretation.ts  pure validation, ordering, lineage selection
src/lib/engine/prompts/chat/personas.ts      selected-context substitution
src/lib/engine/ai/entity-interpretation.ts   future tracked generation boundary
src/shell/stage/views/production/ActingView.tsx       Production → Actors authoring and management field
src/shell/stage/views/production/ProductionEntityUI.tsx shared Actors/Perspectives workspace grammar
src/shell/inspector/kit/EntityUnderstandingPanel.tsx shared Acting workbench + graph inspection primitives
```

These paths follow the repository's core/engine/client boundaries; Actors remains a caller of the single
canonical mutation path and the Inspector remains a read-focused support surface.

---

## 12. Deliberately open

- Whether one entity may hold several competing current graphs from different observer perspectives.
- The refresh threshold, whether arc boundaries are the default opportunity, and what magnitude earns a
  visible “step change” marker.
- Whether qualitative status is sufficient or calibrated edge weights eventually earn inclusion.
- How graph identity follows an entity across promotion between Unit and Character resolution.
- How much of an interpretation graph a reader, player, or in-character agent may inspect.
- Whether interpretive divergence may be selected per prepared production or must always be recorded on the
  underlying branch.
- Additional restrictions for graphs derived from real people rather than authored fictional characters.
- Whether repeated evaluation supports a smaller ontology before implementation.

The remaining open items above are design questions for the Behaviour Reading extension. None of them blocks prepared Experience or World work: preparation pins the selected graph and binding as of the passage or moment directly, and Factory expression coverage is requested from that selection. If activation is ever built, §10 is the bar it must clear before it earns runtime authority; until then the selected graph, not a reading derived from it, is the entity's performance context.

Raw Markdown source