MeridiansMeridians

The pentad — five independent forces, observed couplings, and a pipeline that can be reordered

From the Meridians Wiki · Public · Maintained · human-contract

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, 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 contract, the flags ontology, or the World concept. 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:

MediumWhat the sign readsWhat it must not claim
Domainthe five-force configuration of each recorded Scene and how it moved from the previous onean essence stored apart from the record
Scenariothe different sign trajectories produced when attributable Will commits at a forkwhich branch a participant ought to choose
Experiencea prepared visual and editorial rhythm—recurrence, release, stillness, and consequence—across Episodesthat presentation authored a force or changed canon while read
Worldthe present sign derived as the World is wandered, with movement traced back to actions and informationa 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 contractNew frameWhat 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 recordTheme 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 lineageThe most invisible force: what can lead to what, expressed as flagsNew. The canonical three-layer definition and current shipped status live in the app integration specification §2.3.
Will — "not a stored force; attributable authority over the lens and the move"UnchangedWill is still outside the circle. A Will collapses a question into a flag; the engine never does.
Acting — "first-class context engineering"; Entity Interpretation GraphsAn 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 projectionAn 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 existsA scene-first coverage lens now; eventually a synthesis over all five forcesThe 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

                    ┌──────────── 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.

ForceAnswersWhere it lives todayHow visibleWhy
Worldwhat existscharacters, units, locations, artifacts, worldDeltasmostA thing is named in the text; extraction names it back.
Systemwhat governs itSystem graph, systemDeltas, invoked concepts, Frame/ControlhighRules are stated or invoked; they are legible where they act.
Fatewhat remains open and consequentialThreads with outcomes, priors, horizon; thread logmediumA question is visible; its weight — what hangs on it — is not until it closes.
Themewhat recurring meaning emergesTheme tree, scene signals, arc analysis, purple attributionlowAppears only across events. No single scene contains a theme.
Causalitywhat can lead to whatnowhere named: implicit in deltas, attribution edges, MergeResolution, branch lineageleastAppears 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:

ForceEvidenceUnit
Worldbreadth × depth over entity slotsratio
Systembreadth × depth over topic slotsratio
Themebreadth × depth over valid leaf-Theme slotsratio
FateΣ entropy moved / available entropyratio
CausalityΣ Flag information / expected Flag information for the intervalratio

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.

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:

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:

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:

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:

ElementBelongs toVisible?
The question and its candidatesFateyes
Its prior and horizonFateyes
Which value it collapsed toCausality (the Flag)only after the fact
Which earlier flags the collapse depended onCausality (the edge)only across branches
Which later questions the collapse opened or foreclosedCausality (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 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 chosenthe value the question collapsed to
vantage — cursor + seatthe vantage of the collapse
nature: divergenta collapse that immediately determines which other questions can still collapse
nature: conditionala partial collapse — certainty accumulating toward a question that has not flagged yet
nature: personala collapse whose only dependents are the same character's later flags
verb: guessa bet on how a question will collapse, made before it does — a Fate act, not yet a Causality one
stakeconviction 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:

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:

CandidateReadsProperty
Collapse count per sceneflags emitted at the entrycheap; conflates trivial and load-bearing collapses
Signed collapse: open Fate mass movemententering volume and the signed entropy drop from the previous to closure beliefattention-weighted, option-set-sensitive flow measure; spreading closures remain negative
Dependency depthlongest dependsOn chain ending at this flagmeasures how much history a collapse needed
Foreclosure breadthThreads a flag closed without resolvingmeasures what a collapse cost the future

The shipped grade uses native Flag informationstakes 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

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

StageInputOutputExists todayStatus
Extract World/System/Fatecorpus chunksExtractionChunkResultassembleDomainextraction-runner.ts phase 1 → assemblyshipped
Extract Themescene signalsTheme tree, arc analyses, purple attributionreconciliation + deriveThemeAnalysisFromSignalsshipped
Re-extract Fate / Systemassembled Domainre-priced thread log; invoked rulesreextractFateWithLifecycle, reextractSystemInvocationsshipped
Extract Causality (flags)assembled Domain + branch sequenceFlag set + dependency edgesbuild
Interpret: Actingentity + branch + as-ofEntityInterpretationGraph, bindingMDL assessActingGrowth/maintainActingGrowth at arc/world/futures/game/program-merge generation seams; post-hoc bindings are attributable and revisable, Will bindings are heldshipped (#234)
Interpret: spatiallocations, topology, boardsbuildWorldMapContext, map layoutsshipped; maintained by maintainSpatialGrowthshipped
Synthesise questionsscene structure; eventually all five forces at a vantagescene coverage lens; eventually ranked open questionsscene question-bank op ships; no all-force synthesisshipped / build
Generate planquestions + scene briefBeatPlancomposed pipeline uses generateScenePlan; standalone recovery can use reverseEngineerScenePlanshipped
Generate prosequestions + plan + scene briefhighest-density tellinggenerateSceneProse, rewriteSceneProseshipped
Generate scriptquestions + plan + prose + briefcompressed ScriptContent (sanitised)generateSceneScriptshipped
Deliver Episodescript + assetsstaged catch-up EpisodeStageplay incubatorincubation
Deliver ExperienceEpisodes + forksthe readable, choosable novelbuild (VN spec)
Will re-entryreader/seat commitmenttyped delta → new flagScenario reducer pathshipped substrate; flag view is build

The derived macro classifier dials sit on top of the canonical record:

ReadingFormulaStatus
ShapeLegendre energy over the smoothed activity curveshipped; bands are dials
Scalefloor(log(n / n₀) / log r)shipped; bands are dials
Densityβ = ln(World + System slots) / ln nshipped; bands are dials
Pacingτ = mean|aᵢ₊₁ − aᵢ| / σ(a)shipped; bands are dials
Depthδ = L_max / ln nshipped; bands are dials
ConcentrationGini 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
Constitutioncount of readable unconstrained lagged couplings fitted from this recordshipped; bands are evidence bands
Registermean normalised Theme attention entropyshipped; 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?

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

ElementStatus
World, System, Fate extraction, storage, measureshipped
Theme extraction, attribution, derived gradeshipped
Theme reclassified as an invisible, non-writing force in the contract docsthis spec; docs change only
Acting, spatial map as interpretations of Systemshipped; reclassified in docs only
Flag as a world-grain record or projectionshipped (derived; ForceSnapshot unchanged)
Flag extraction phasebuild
Dependency edges with cited evidencebuild
Branch diff over flagsbuild
Causality measure in ForceSnapshot / scorecardshipped as native Flag information against the prose-length density expectation; signed collapse and dependency reach remain diagnostics — app-integration §2
Fate-as-weight (H_open), Theme recurrence (Θ) measuresshipped (derived diagnostics beside the grade; ForceSnapshot unchanged) — app-integration §2
unconstrained force flow at lag 1/2, Flag-grounded E, descriptive trace modesshipped in Pulse
ForceConstitution / fitted per-record coupling projectionshipped in Pulse
deterministic Patterns ledger with grounded scenes and Flag carriersshipped in Pulse
Pulse chat context over pattern ids, scenes, and Flag carriersshipped in Pulse
record-derived coupling awareness for turning-point contextshipped in extraction
Post-hoc settings block and Maintain surfacebuild — app-integration §4
Causality on the canvasopen; shown at Threads/entries, fifth token proposed — app-integration §3
Question synthesis stagebuild
Pipeline configuration recordbuild
Episode delivery, VN Experienceincubation / build (owned by Stageplay and VN specs)
Populated Worlds, MMO scaledirection; 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 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.

  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.