The pentad — five independent forces, observed couplings, and a pipeline that can be reordered
Source path: knowledge-base/specs/pentad/README.md
# The pentad — five independent forces, observed couplings, and a pipeline that can be reordered
Status: **direction; a concept contract and roadmap, not an implementation contract.** Nothing here ships
until scheduled. Where a row below says *shipped*, it names reachable runtime; everything else is proposal.
This specification owns three things:
1. the **five forces** — World, System, Causality, Fate, Theme — as five peer channels measured independently,
with the **order of visibility** kept as the account of how each force is *read* from a record;
2. **Causality as a fully formed force**, expressed through **flags**: Fate questions collapsed to a certain
value on one branch;
3. the **content pipeline** that follows extraction — interpretations, questions, prose, plans, scripts,
Episodes — as reconfigurable typed stages over a canon branch.
Its companion, [The pentad in the app](app-integration.md), owns the **measurement programme** (activity
versus composite forces; Fate-as-weight, Theme information, recurrence, and Causality), the
**surfaces** each force lives on, the **post-hoc actions** that keep the interpretations of System current,
flag detection inside extraction and generation, and the **six-step roadmap** with falsifiers.
It does not replace the [positioning](../../knowledge/product/positioning/index.md) contract, the
[flags ontology](../visual-novel/flags.md), or the [World concept](../world/README.md). It reconciles them
with the new frame and says what changes. Grounding for every "shipped" claim is in the code cited inline.
### Pentad sign
The runtime pentad sign reads all five forces as high or low. The inclusive high threshold is `0.25`,
yielding 32 signs. Fate, World, and System place a sign in one of eight stored-force **families**; Theme
supplies its register (`Resonant` or `Literal`) and Causality its bearing (`Fated` or `Open`). A family is
only a compact projection for comparison and sparse-data smoothing. The sign is the ontology and the
state of scene cadence.
The five forces are peer channels, and the glyph beside each is its sign notation. 五行 is the symbolic frame:
the element names and glyphs, the pentad mark, the pentagon layout, and stable display order. It does not
supply a scene-to-scene mechanism. Meridians measures lagged pairwise couplings independently for each
record; a record may show couplings at either lag, or may read as independent. The five are the model, not
the ground: underneath them Meridians holds **two magics** — the heart that commits (Will, injected from
outside) and the mind that builds what remembers and computes what follows (the record; technology is the
mind made manifest) — and reads the five in order to comprehend the two.
Scene cadence is therefore a first-order Markov walk over the 32 signs. The next sign depends on the current
configuration: an active phase tends to raise the phase it generates and lower the phase it controls;
continuity damps gratuitous five-force jumps, while every transition retains non-zero probability. A matrix
learned from a work uses observed sign-to-sign transitions, with the eight families only as a smoothing
backoff when a particular sign is sparse. The Markov property is deliberately local—it describes rhythm,
not destiny. Domain state, Will, and the generated scene still decide what actually happens.
### The sign as a fate-reading instrument
The sign gives the same world four scales of inspection without becoming a new source of truth:
| Medium | What the sign reads | What it must not claim |
|---|---|---|
| **Domain** | the five-force configuration of each recorded Scene and how it moved from the previous one | an essence stored apart from the record |
| **Scenario** | the different sign trajectories produced when attributable Will commits at a fork | which branch a participant ought to choose |
| **Experience** | a prepared visual and editorial rhythm—recurrence, release, stillness, and consequence—across Episodes | that presentation authored a force or changed canon while read |
| **World** | the present sign derived as the World is wandered, with movement traced back to actions and information | a universal horoscope or an unrecorded spiritual fact |
The Base-stage **Pulse (脉)** view exposes one deterministic instrument: the Forces timeline and its
derived FlowMatrix, Patterns ledger, and consequence pressure. Its companion **Pulse chat context**
interprets those same grounded rows without becoming a second source of truth. The model receives the
complete selected record prefix as a scene outline plus the force instrument; its output is a reading over
derived evidence: present movement, recurring passages, conditional tendencies, possible divergences, and a
reflective question. Each guided observation must name an exact scene, pattern, or Flag in the visible
record. The model writes no state and makes no choice; sparse samples must be named as sparse, and an
absent transition is not declared impossible.
This is where the spiritual register belongs: in sustained attention to relation, recurrence, agency, and
consequence. A sign names the present pattern; its movement shows what entered and receded; its recurrence
shows the knot a world returns to; a branch comparison shows what one commitment changed. The instrument
can feel like deep astrology because it rewards symbolic and longitudinal reading, but its authority stays
bounded by the declared world and its record. It offers contemplation, not supernatural certainty.
---
## 1. Reconciling the identities
The trinity is not discarded. It is the **visible** part of a larger pattern.
| Previous contract | New frame | What actually changes |
|---|---|---|
| **System · World · Fate** — "a trinity of atomic forces" | The three **stored** forces: what a record *contains* (§2.4 — storage, not rank) | Nothing in code. The three stored forces, their extraction, and their measures stand. |
| **Theme** — "an evidence-derived auxiliary instrument over the trinity"; "not a causal axis" | An **invisible force**: what recurs *across* the record | Theme is promoted from auxiliary to force. It remains **non-writing** — it never changes state — but it is no longer described as subordinate. See §2 on why "invisible" is the right word and "auxiliary" was not. |
| **Causality** — implicit: typed deltas, attribution edges, merge resolutions, branch lineage | The **most invisible force**: what can lead to what, expressed as **flags** | New. The canonical three-layer definition and current shipped status live in [the app integration specification §2.3](app-integration.md#23-causality-as-entropy-flow-and-reach). |
| **Will** — "not a stored force; attributable authority over the lens and the move" | Unchanged | Will is still outside the circle. A Will collapses a question into a flag; the engine never does. |
| **Acting** — "first-class context engineering"; Entity Interpretation Graphs | An **interpretation of System** (post hoc) | Unchanged in code. Reclassified: a lens over the rules that bind an entity, not content and not a force. |
| **Spatial world view** — derived location projection | An **interpretation of System** (post hoc) | Unchanged in code. Reclassified the same way: a reading of System's topology, never a store. |
| **Questions** — Threads carry them; a scene question-bank operation exists | A scene-first **coverage lens** now; eventually a synthesis over all five forces | The composed content pipeline generates per-scene questions first. All-force re-derivation remains unbuilt. |
The one sentence that must change everywhere it appears: *"neither Theme nor Acting is another causal
force."* It becomes: **Theme is an invisible force that reads and never writes; Acting is an interpretation
of System.** The protection the old sentence gave — that nothing interpretive may mutate canon — is kept in
§2.3 as the non-writing rule.
---
## 2. The five forces and the order of visibility
```text
┌──────────── visible ────────────┐ ┌──────── invisible ────────┐
WORLD → SYSTEM → FATE → THEME → CAUSALITY
what what what what what can
exists governs remains recurring lead to
it open meaning what
and emerges
consequential
```
**Visibility** is how directly a force appears in a record. It is an ordering of *epistemic access*, not of
importance and not of causation.
| Force | Answers | Where it lives today | How visible | Why |
|---|---|---|---|---|
| **World** | what exists | characters, units, locations, artifacts, `worldDeltas` | most | A thing is named in the text; extraction names it back. |
| **System** | what governs it | System graph, `systemDeltas`, invoked concepts, Frame/Control | high | Rules are stated or invoked; they are legible where they act. |
| **Fate** | what remains open and consequential | Threads with outcomes, priors, horizon; thread log | medium | A question is visible; its weight — what hangs on it — is not until it closes. |
| **Theme** | what recurring meaning emerges | Theme tree, scene signals, arc analysis, purple attribution | low | Appears only *across* events. No single scene contains a theme. |
| **Causality** | what can lead to what | *nowhere named*: implicit in deltas, attribution edges, `MergeResolution`, branch lineage | least | Appears only *between* states, and only once a question has collapsed. Its trace is the flag. |
Three consequences of the order:
**2.1 The triad is stored; the dyad is derived.** World, System, and Fate have rows in the Domain. Theme
and Causality are projections over how those rows changed. This is already true for Theme
(`deriveThemeAnalysisFromSignals` reads scene signals; it stores nothing a scene did not carry). It is the
design rule for Causality: a flag is derived from a collapse the record already made, and a Causality
measure is a function over flags — never a fifth column a model fills in.
**2.2 Extraction goes with the grain of visibility.** The extraction runner already runs structure
(World, System, Fate) → Theme reconciliation → Fate/System re-extraction. Causality extraction sits last,
because it needs every question and every state change already in place before it can ask *which question
did this scene collapse, and on what did the collapse depend?*
**2.3 Invisible forces never write.** Theme and Causality are read from the record; they are not inputs to
the reducer. Nothing Theme "produces" changes state. A flag records that a collapse *happened*; the
collapse itself was a typed delta made by a Will through the single-writer reducer. This is the old
non-causal protection, kept, and stated as a property of visibility rather than of rank.
A force appearing across events is still a projection, not a mutation: what a world's record keeps
showing may inform what its Director or Reading authors next, but it is never an engine write.
### 2.4 Display order and symbolic frame
`PENTAD_ORDER` is the stable display order `World → System → Causality → Fate → Theme` for the five
forces. It carries no causal succession. The pentad mark, element names, glyphs, and pentagon geometry are
symbolic framing only; no fixed generating or controlling relation is asserted between scenes. Force
relationships are measured from each record instead.
### 2.5 The realisation grade
Grading gives every force an equal share and reads no generation-target table. Structure forces use the
slots each scene landed on; Fate uses belief entropy movement; Causality uses native Flag information:
| Force | Evidence | Unit |
|---|---|---|
| World | breadth × depth over entity slots | ratio |
| System | breadth × depth over topic slots | ratio |
| Theme | breadth × depth over valid leaf-Theme slots | ratio |
| Fate | Σ entropy moved / available entropy | ratio |
| Causality | Σ Flag information / expected Flag information for the interval | ratio |
For a structure force, breadth is the Shannon entropy of slot shares divided by the log of the declared
space (using the observed distinct slots when larger), depth is the slot-frequency-weighted
`ln(1 + scenes containing the slot) / ln(1 + total scenes)`, and the realisation ratio is their geometric
mean. Fate availability is entropy open before the first selected scene plus entropy raised across the
series. Causality availability is the prose-length density expectation multiplied by the reference
information of a turning Flag; each realised Flag contributes `stakes weight · ln(1 + alternatives)`.
p_f = ρ_f World, System, Theme, Fate (ρ ≤ 1 by construction)
p_C = ρ_C / (1 + ρ_C) Causality (ρ_C = realised / expected, unbounded)
grade_f = 20 · σ( 1.5 · (logit p_f − logit p̂_f) + logit 0.875 )
Grade = Σ_f grade_f
The anchor p̂_f is a declared premiere-grade realisation — 0.6 of declared structure, 0.4 of open Fate,
1.5× expected Flag information — at which a force reads 17.5 of its 20.
The slope 1.5 and the anchors are dials, not fitted targets; they are read against the same records the
ratios come from. No ratio is clamped: a record that realises three times the expected Flag information
reads above one that realises once. The grade is bounded; no force can earn more than its own 20-point
share to reimburse another. The additive total can still hide which share is weak, so it is read beside
the five force grades and archetype. An empty record earns zero with no floor. Per-scene landing
information remains a diagnostic series, and Theme recurrence remains a separate diagnostic rather than
a second grade.
What is chosen: the equal shares, anchors, slope, Causality density prior, and reference Flag information. Theme
slots use valid leaf definitions. Causality's signed attention-weighted `collapse = ln(1 + volume) · drop`
remains the open-mass ledger's diagnostic unit and is not the grade's currency. What is not included in
the grade: Causality's dependency reach.
`FORCE_REFERENCE_MEANS` and `FORCE_BANDS` remain generation targets — what prompts and pacing aim at — and
the grade never reads them. The archetype is a reading, not a preset: no target table pretends that Theme
or Causality can be written through the three stored-force controls.
The Domain archetype thresholds each share independently at `17/20`, producing 32 exact formed/latent
profiles. Each receives one work-form name, from **Fragment** through **Paper**, **Chronicle**, and the
other weaves to **Opus**. It shares the Sign's five-bit coordinate but not its vocabulary or measurement:
the Sign names Scene movement, while the archetype names whole-work composition. Bitwise inversion gives
the profile's counterform. The complete semantic table is maintained in
[Pentad archetypes](../../knowledge/conventions/narrative/04-narrative-archetypes.md).
### 2.6 Record health
Record health uses the same declared horizon as Acting growth; recurrence remains a separate diagnostic
from the graded Theme information.
For an item \(x\) of force \(f\), over the resolved sequence at cursor `currentIndex`:
```text
d_x = scenes since x was last heard (touched / signalled / moved) (∞ if never)
r_x = Σ_i exp(−d_i / H) · 1[x heard in scene i], H = context horizon
dormancy_x = exp(−r_x) ∈ (0,1]; 1 = never heard
dormant ⇔ d_x > H
```
Health is a diagnostic projection, not a second record. Rules carry no predictions today, so strain is a proxy — a rule that bounds a thread which then reversed. True contradiction needs rules to state what they forbid; until then health proposes, the author decides.
### 2.7 Force flow as unconstrained record evidence
Each scene carries a force vector `r_t ∈ ℝ⁵`. Force flow is the family of unconstrained lagged couplings:
```text
A⁽ᵏ⁾_XY = corr( r^X_{t−k}, r^Y_t ) k = 1, 2
```
Every ordered pair is measured independently at lag 1 and lag 2. A readable edge requires at least six
pairs and a test statistic with `|t| ≥ 2`; otherwise it is unread. Readable edges are sorted by evidence,
not by a presumed pentad path. Positive and negative signs are both valid evidence, and no edge is itself a
claim of mechanism.
The grounded flow `E` distributes closure pressure over force pairs using the force snapshots at the
carrier scenes. It reports which observed couplings carried consequence in this record; it does not assign
feed or bound gains and does not steer generation. `traceFlow` and `counterfactualFlow` remain descriptive
instruments over grounded cells.
#### Constitution (五行体质)
`ForceConstitution` is a projection fitted from the record, never authored canonical state:
```text
couplings: (from, to, lag, corr, pairs, t)[]
source: fitted | unread
```
Every ordered pair is measured independently at both lag 1 and lag 2. A coupling is readable only when
`pairs >= 6` and `|t| >= 2`; readable edges are strongest `|t|` first, then deterministic by `from`, `to`,
and `lag`. An empty unread constitution means the record is too short for evidence; an empty fitted result
means the five forces have moved independently so far. Constitution bands count readable couplings:
Independent (0), Coupled (1–2), Linked (3–5), Meshed (6–10), and Entangled (11+). The Pulse Forces lens
shows which pairs couple and at what lag.
Generation and prompts may report this evidence as awareness, but never steer a scene toward a coupling.
Independence is a valid reading. Will remains outside the forces and is never selected by the engine.
> **Tested 2026-09-19 — the cycles are not in the data.** The generating ring (lag 1) and controlling star (lag 2) were fitted as unconstrained 5×5 lag matrices on the nine hosted records with ≥ 20 scenes (Ecclesiastes 240, Sorcerer's Stone 111, Reverend Insanity 87, Chamber of Secrets 84, After Nihilism 58, Meridians 53, Jai KB 51, Spider-Man 21, Odyssey 21), on rank-Gaussianised levels, first differences, and raw information. Cycle fidelity (ring+star energy ÷ total) was at or below the 0.20 chance share in all nine (0.04–0.20; scene-order shuffle p 0.46–0.99); the mean ring correlation was negative in seven of nine; the best-fitting ring differed in every record. Pooled across records only one classical edge read (System→Causality lag 1, r ≈ +0.09, 4/9 sign agreement) and one read against (System⊣Fate, r ≈ +0.09, 8/9). What did recur: System persists (self r 0.39 at lag 1, 9/9) and grows along a record (trend r 0.36, 9/9) while World decays (−0.16, 8/9); cumulative World predicts System (r 0.24, 9/9); System and Fate co-fire and feed each other at lags 1–2 (0.18–0.21, 8–9/9); Fate autocorrelates at lags 1, 2, 4; System depresses World at lags 2–4 (−0.13 to −0.15, 7/9). These are empirical tendencies of extracted records at scene grain, not laws; the ring and star leave the code as mechanics and remain as the five-element symbol.
### 2.8 Pulse: two layers
Pulse has two layers: a deterministic instrument (inspector) and a Pulse chat context. The instrument is
the Forces lens, FlowMatrix, Patterns ledger, and consequence pressure: every pattern is a computed sentence
with exact scenes and Flag carriers, and fewer than six aligned pairs are reported as “too short to tell.”
Pulse chat is a causality consultation as of the cursor scene: its legend explains the five forces and their
relations in plain language, its present sign shows how the current state was reached, and its budgeted force
rows and patterns keep the horizon explicit. It receives those same rows as evidence, may cite only their
scene numbers, pattern ids, and Flag ids, and never invents links. The same Present/Summative scope applies
to both layers.
---
## 3. Causality as a force: flags
### 3.1 Definition
> **A Flag is a turning point — a moment that signals Causality into action.**
When a Flag also settles a Fate Thread, its derived closure projection is a **Thread closure**. The
canonical Flag remains on the Scene; the Thread closure is rebuilt from the Fate thread log.
- A **question** is a Thread (or a reader-grain fork that a Thread underwrites): named, with candidate
outcomes and a prior, open.
- A **collapse** is the moment the record settles it: a merge resolution closes a stream against the Thread,
a scene delta moves it to a terminal phase, or a reader's commitment at a fork selects one continuation.
- The **value** is the outcome selected.
- The **vantage** is `(branchId, entryId)` plus the seat or authority that collapsed it.
Because a branch is a preserved line of history, **a branch is an assignment of values to questions**, and
two parallel worlds — same rules, same cast, different history — differ exactly in their flags. This is what
the pivot's premise ("because everything is recorded, everything can be replayed") gives when Causality is
named: a replay is the same question set collapsed differently.
### 3.2 What Causality adds beyond Fate
Fate is the question while it is open. Causality is the collapse *and its dependencies*:
| Element | Belongs to | Visible? |
|---|---|---|
| The question and its candidates | Fate | yes |
| Its prior and horizon | Fate | yes |
| Which value it collapsed to | Causality (the Flag) | only after the fact |
| Which earlier flags the collapse depended on | Causality (the edge) | only across branches |
| Which later questions the collapse opened or foreclosed | Causality (the edge) | only across time |
"What can lead to what" is the dependency graph over flags. It is readable from one branch (what followed
what) and provable only across branches (what would not have followed without). The instrument for the
second is a **branch diff over flags** — the same question set, two assignments — which does not exist
today and is the one comparison this force needs.
### 3.3 Relationship to the reader-grain flag ontology
The [flags spec](../visual-novel/flags.md) defines a flag at reader grain:
`nature · verb · vantage · stake · content`. This spec does not change that record. It says what the record
*is* at world grain: **a question collapsed by a Will**, so the two are one object at two scales.
| Reader-grain (flags spec) | World-grain (this spec) |
|---|---|
| `content` — the continuation chosen | the **value** the question collapsed to |
| `vantage` — cursor + seat | the **vantage** of the collapse |
| `nature: divergent` | a collapse that immediately determines which other questions can still collapse |
| `nature: conditional` | a **partial** collapse — certainty accumulating toward a question that has not flagged yet |
| `nature: personal` | a collapse whose only dependents are the same character's later flags |
| `verb: guess` | a bet on how a question will collapse, made before it does — a Fate act, not yet a Causality one |
| `stake` | conviction behind the collapse, priced by Scenario |
Consequence: the "accumulation shows before it forks" rule from the flags work is a Causality property —
a `conditional` flag is a visible partial collapse, so the reader sees certainty growing before the
divergent one lands.
### 3.4 Extraction of flags from canonical text
The intent is to take **canon branches** — extracted Domains and the branches Scenario and Readings have
preserved — and expand Causality's expression from implicit edges to explicit, understood flags.
The extraction contract, as a proposed phase after Fate/System re-extraction:
```text
input assembled Domain (Threads with outcomes; scenes with typed deltas; thread log)
one branch's entry sequence
for each scene, in order
ask which open Threads does this scene collapse, and to which candidate outcome?
which prior flags did the collapse depend on (cite entries)?
which Threads does the collapse open or foreclose?
what nature does the collapse carry (divergent / conditional / personal)?
emit Flag { threadId, outcomeId, vantage: (branchId, entryId), authority,
nature[], dependsOn: flagId[], opens: threadId[], forecloses: threadId[],
evidence: entryRefs[], rationale }
verify every id resolves; the collapse agrees with the thread log's phase at that entry;
dependsOn only references flags earlier in the sequence; no delta is introduced
```
Two design choices to make explicit:
- **Flags are recognised, not invented.** The thread log already records phase transitions and closure
(`thread-log.ts`). Where the log says a Thread closed at an entry, the flag is a *typed view* of that
closure with nature and dependencies added. Where the text collapses a question the log has not yet
recorded, extraction proposes the delta through the ordinary reducer path first; the flag follows the
write, never precedes it.
- **Dependencies are hypotheses with evidence.** `dependsOn` is a model's proposal with cited entries,
validated for order and existence, and *graded* — not asserted. Whether a dependency is real is what the
branch diff tests.
Whether the Flag is a **new record** or a **projection over the thread log plus attribution edges** is
open (§7). The recommendation is a projection first — derive flags from what the log and edges already
hold, measure how much a model-proposed phase adds, and persist a record only if the derivation falls
short.
### 3.5 Measuring Causality
Today `ForceSnapshot` carries all five forces, native Flags provide Scene-local Causality information,
and dependency reach plus signed collapse remain derived diagnostics. The candidate history explains the
separation:
| Candidate | Reads | Property |
|---|---|---|
| Collapse count per scene | flags emitted at the entry | cheap; conflates trivial and load-bearing collapses |
| Signed collapse: open Fate mass movement | entering volume and the signed entropy drop from the previous to closure belief | attention-weighted, option-set-sensitive flow measure; spreading closures remain negative |
| Dependency depth | longest `dependsOn` chain ending at this flag | measures how much history a collapse needed |
| Foreclosure breadth | Threads a flag closed without resolving | measures what a collapse cost the future |
The shipped grade uses **native Flag information**—`stakes weight · ln(1 + alternatives)`—against the
prose-length density expectation for the selected interval. The signed attention-weighted **collapse** is
the open-mass ledger's diagnostic unit, and dependency reach is a retrospective diagnostic. Neither is
silently substituted for the Flag-information grade.
Representation follows the Theme pattern: **attributed to the visible triad**, not a fifth cohort on the
canvas. A flag is shown *at* the Thread it collapsed and *on* the entry where it happened; its dependencies
are edges. Whether Causality earns its own colour beside purple is a design question for the canvas, not
this spec.
---
## 4. The content pipeline — reconfigurable typed stages
### 4.1 The shape
```text
CANON BRANCH ────────────────────────────────────────────────────────────────────────────────┐
│
EXTRACT World → System → Fate → Theme → Causality (flags) forces, stored │
│ │
INTERPRET Acting (State / Dynamics graphs) · spatial map lenses over System│
│ │
SYNTHESISE questions — first coverage lens for each scene Fate, re-derived │
│ │
COMPOSE per scene: questions → plan → prose → script presentation │
scenes advance independently in parallel viewable artifacts│
│ │
DELIVER Episodes → the visual-novel Experience the artifact │
│ │
WILL a reader / seat / Director / agent collapses a question a new flag ──────┘
```
Every stage is a **typed operation** with a declared input record and output record. That is what
"reorderable and reconfigurable" means here: not that prose can precede extraction, but that a stage can
be run, re-run, skipped, or substituted wherever its input exists, and that a pipeline is a *configuration*
of stages rather than one function. Within a scene, generation is deliberately compounding: each viewable
artifact becomes additional context for the next operation. Across scenes, those independent generative
cycles advance in parallel. The loop closes only through Will: nothing below the extraction line writes a
force.
### 4.2 Stage contracts and what exists
| Stage | Input | Output | Exists today | Status |
|---|---|---|---|---|
| Extract World/System/Fate | corpus chunks | `ExtractionChunkResult` → `assembleDomain` | `extraction-runner.ts` phase 1 → assembly | shipped |
| Extract Theme | scene signals | Theme tree, arc analyses, purple attribution | reconciliation + `deriveThemeAnalysisFromSignals` | shipped |
| Re-extract Fate / System | assembled Domain | re-priced thread log; invoked rules | `reextractFateWithLifecycle`, `reextractSystemInvocations` | shipped |
| **Extract Causality (flags)** | assembled Domain + branch sequence | Flag set + dependency edges | — | **build** |
| Interpret: Acting | entity + branch + as-of | `EntityInterpretationGraph`, binding | MDL `assessActingGrowth`/`maintainActingGrowth` at arc/world/futures/game/program-merge generation seams; post-hoc bindings are attributable and revisable, Will bindings are held | shipped (#234) |
| Interpret: spatial | locations, topology, boards | `buildWorldMapContext`, map layouts | shipped; maintained by `maintainSpatialGrowth` | shipped |
| **Synthesise questions** | scene structure; eventually all five forces at a vantage | scene coverage lens; eventually ranked open questions | scene question-bank op ships; no all-force synthesis | shipped / **build** |
| Generate plan | questions + scene brief | `BeatPlan` | composed pipeline uses `generateScenePlan`; standalone recovery can use `reverseEngineerScenePlan` | shipped |
| Generate prose | questions + plan + scene brief | highest-density telling | `generateSceneProse`, `rewriteSceneProse` | shipped |
| Generate script | questions + plan + prose + brief | compressed `ScriptContent` (sanitised) | `generateSceneScript` | shipped |
| Deliver Episode | script + assets | staged catch-up Episode | Stageplay incubator | incubation |
| Deliver Experience | Episodes + forks | the readable, choosable novel | — | build (VN spec) |
| Will re-entry | reader/seat commitment | typed delta → new flag | Scenario reducer path | shipped substrate; flag view is build |
The derived macro classifier dials sit on top of the canonical record:
| Reading | Formula | Status |
|---|---|---|
| Shape | Legendre energy over the smoothed activity curve | shipped; bands are dials |
| Scale | `floor(log(n / n₀) / log r)` | shipped; bands are dials |
| Density | `β = ln(World + System slots) / ln n` | shipped; bands are dials |
| Pacing | `τ = mean\|aᵢ₊₁ − aᵢ\| / σ(a)` | shipped; bands are dials |
| Depth | `δ = L_max / ln n` | shipped; bands are dials |
| Concentration | Gini coefficient of carrying causal scene weights (`n₊`) | shipped; Gini is standard; bands are dials |
| Openness | `ω = H_open(cursor) / maxₜ H_open(t)` | shipped; bands are dials |
| Constitution | count of readable unconstrained lagged couplings fitted from this record | shipped; bands are evidence bands |
| Register | mean normalised Theme attention entropy | shipped; entropy is standard; bands are dials |
### 4.3 Reconfiguration
Three configurations the same stages should support, to show the pipeline is a configuration and not a
sequence:
- **Ingest a source.** extract → interpret → synthesise → (nothing generated). The maintained-expert
posture: a Domain kept current, questions kept live, no Episode.
- **Prepare a novel.** extract → interpret → questions → plans → prose → scripts → Episodes, for every
fork on a chosen branch, ahead of any reader. The VN production posture: generate once, serve.
- **Answer a Will.** a collapse arrives → re-extract Causality for the touched Threads → re-synthesise
questions at the new vantage → generate only the next scene. The Scenario posture.
What makes these one pipeline rather than three is that the stage records are the same types. The composed
scene runner advances each scene sequentially through Questions → Plan → Prose → Script while running all
ready scenes in parallel. The operation catalog also exposes stages individually. The missing pieces are
Causality extraction, all-force question synthesis, and a durable **pipeline configuration** record that
names which stages run over which branch and vantage.
### 4.4 Questions as synthesis
Today a scene question bank is generated first from that scene's structure and then enriches its Plan. It
can be regenerated after Prose when a denser telling exists. The future all-force synthesis stage asks a different thing:
*given everything the five forces show at this vantage, what is genuinely open, and what hangs on it?*
```text
input World (who and what is here), System (what binds them), Fate (open Threads),
Theme (what this world keeps testing), Causality (what has already collapsed, and on what)
ask which open Threads are load-bearing now — many dependents, high prior mass, thematically live?
which have quietly been foreclosed by flags and should close?
which new questions do the flags imply that no scene has named?
emit ranked open questions with candidates, each citing the forces that make it open
```
This is the stage that turns forces into something a fork can be cut from, and it is why the Reading's
priced fan of futures belongs *after* it: a Reading prices continuations of a question the synthesis
surfaced. It is **build**; the scene question-bank operation is the nearest existing seam.
---
## 5. What this frame is for
The pentad is not a re-labelling. It names the thing the product was already trying to make visible and
could not: **why a door closed.** A reader who can see World, System, and Fate can see the room, the rules,
and the stakes. Only Theme tells them what this world keeps doing to people like them; only Causality tells
them which of their own choices — collapsed when, depending on what — made this scene the one they are in.
The grounded claim of the paper — *make a consequential choice, discover what it changed, return through
another perspective* — is a claim about Causality being legible. This spec is the plan to make it so.
*Different worlds, same laws, infinite stories* is the pentad's own line for the pivot's premise: laws are
System; stories are flag assignments; worlds are branches. A world is not closed because its questions can
always be collapsed another way.
### 5.1 Independent forces and observed couplings
The five forces are a symbolic macro frame, not a micro theory of scene-to-scene succession. Pulse measures
what this record actually shows: arbitrary pairwise couplings at lag 1 or lag 2, with sign and evidence.
Different works may expose different couplings, and a record with no readable edge is independently moving
so far. The application reports these observations without grading a world against a fixed force structure.
Will remains external and attributable. A reader, Director, seat, or agent may commit at a fork; the record
then computes and preserves consequences. No force relation chooses on a participant's behalf.
## 6. Status ledger
| Element | Status |
|---|---|
| World, System, Fate extraction, storage, measure | shipped |
| Theme extraction, attribution, derived grade | shipped |
| Theme reclassified as an invisible, non-writing force in the contract docs | this spec; docs change only |
| Acting, spatial map as interpretations of System | shipped; reclassified in docs only |
| Flag as a world-grain record or projection | shipped (derived; `ForceSnapshot` unchanged) |
| Flag extraction phase | build |
| Dependency edges with cited evidence | build |
| Branch diff over flags | build |
| Causality measure in `ForceSnapshot` / scorecard | shipped as native Flag information against the prose-length density expectation; signed collapse and dependency reach remain diagnostics — [app-integration §2](app-integration.md) |
| Fate-as-weight (`H_open`), Theme recurrence (`Θ`) measures | shipped (derived diagnostics beside the grade; `ForceSnapshot` unchanged) — [app-integration §2](app-integration.md) |
| unconstrained force flow at lag 1/2, Flag-grounded E, descriptive trace modes | shipped in Pulse |
| ForceConstitution / fitted per-record coupling projection | shipped in Pulse |
| deterministic Patterns ledger with grounded scenes and Flag carriers | shipped in Pulse |
| Pulse chat context over pattern ids, scenes, and Flag carriers | shipped in Pulse |
| record-derived coupling awareness for turning-point context | shipped in extraction |
| Post-hoc settings block and Maintain surface | build — [app-integration §4](app-integration.md) |
| Causality on the canvas | open; shown at Threads/entries, fifth token proposed — [app-integration §3](app-integration.md) |
| Question synthesis stage | build |
| Pipeline configuration record | build |
| Episode delivery, VN Experience | incubation / build (owned by Stageplay and VN specs) |
| Populated Worlds, MMO scale | direction; unaffected by this spec |
---
## 7. Open
1. **Record or projection.** Is a Flag persisted, or derived on read from thread-log closures plus
attribution edges? Recommend projection first (§3.4).
2. **Who may collapse.** A Will collapses. Does extraction — reading a source's own collapses — count as
Will (the author's) or as record (the corpus is already canon)? Recommend: the source's collapses are
record with `authority: source`; the distinction matters for provenance, not for the flag.
3. **Measure.** Native Flag information against the prose-length density expectation is shipped as the
Causality realisation; signed collapse remains the open-mass flow diagnostic, and dependency reach is
a separate retrospective reading.
Activity and Signature now carry all five rank-normalised channels. Theme's breadth × depth grade
remains beside recurrence.
4. **Canvas.** A fifth colour, or flags shown at their Threads only?
5. **`guess` across the boundary.** A guess is a Fate act that becomes evidence about Causality when the
question collapses. Where is the calibration read stored — on the flag, or on the seat? The
[latent-traits spec](../latent-traits/README.md) proposes: the item's difficulty on the fork, the
person's reading on their own record, never on the flag.
6. **Future force readings.** If a future design adds another force-derived measure, it must remain a
per-record projection and must not become a general law or a generation steering prior.
7. **The grove.** With branches, a Domain is one causal tree developed by MWS — 木, the
growing force. A multi-timeline authoring surface (prune · graft · train · keep, each a typed,
attributable act of Will) is directional and unbuilt; the frame is
[The grove](../../knowledge/foundations/GROVE.md).
8. **Grain.** Every measure in this spec is macro: a delta between scenes (slots landed, entropy moved,
Flags set), and the classifiers — shape, scale, density, pacing — are functions of those deltas. The
forces do not read inside a scene. The stated direction is **micro sonic analysis of prose**: a scene
as a heard composition, with a western music ontology (metre, cadence, motif, dissonance, resolution)
as the bridge from delta extraction to guidance on elegance. Whether this is a sixth reading beside the
five forces or a finer grain of the same five is open; nothing of it is built.
## Non-goals
No runtime is built by this document. The VNMMO delivery spec is paused and is not referenced as a
dependency. No pricing, retention, or production-cost figures are stated. World remains static
exploration; nothing here advances a populated World.
Open on GitHubRaw Markdown source