The data structure that represents a single character — the atomic unit of the simulation. Every person in the world is a node. This schema defines what a node knows about itself: identity, family membership, house affiliation, age, health, current role, its elemental temperament, and the hooks that other systems (bonds, drives, events) attach to. Elemental temperament is stored as six independent magnitudes (Salt, Yeast, Desert, Lake, Stars, Moon), each carrying a natal value (set at birth, immutable — the "born a Cancer" fact) and an expressed value (the live, operative number the drive evaluator reads). Six independent magnitudes, not three signed axes: one signed number per axis cannot tell the chasm-straddler (high on both poles) from the indifferent (zero), and the cosmology says those are different people. The schema also carries a node tier — a full graph node versus a lightweight combatant node spawned for a battle and culled afterward — and admits non-person node classes: faction pseudo-nodes, and idea-nodes (totemic / Jinn-class targets that carry a signature rather than a definition).

• A character can be instantiated with a unique identity, family name, house affiliation, age, sex, and role.
• The schema supports at minimum: lay characters, saints (with expanded eusebia channels), and the player-character (head of house).
• Characters can be flagged as alive, dead, exiled, or imprisoned without breaking other systems.
• The schema distinguishes node tiers: full nodes carried in the relationship graph, and lightweight combatant/scratch nodes spawned for a battle and culled when it ends — with a defined (if deferred) path to promote a scratch node into a full node.
• Non-person node classes are supported: faction pseudo-nodes, and idea-nodes that hold a signature (a borrowed drive-stack plus bond-disposition) and can be the target of drives and bonds like any other node.
• Elemental temperament is stored as six independent magnitudes, each a (natal, expressed) pair: natal is written once at instantiation and never mutated; expressed is the value other systems read and update. The representation can express a straddler (both poles of an axis high at once) and distinguish it from indifference (both low).
• The data model can be serialised and loaded without data loss.

The directed graph that connects character nodes. Each edge holds one of four bond types (eusebia, agape, philos, eros), a signed score, a floor, and a ceiling. A pair of characters may hold multiple edge types simultaneously. Saints hold four distinct eusebia edges (superior, inducer, lineage, family) scored independently.

• Edges can be created, read, updated, and removed between any two character nodes.
• Each edge stores: type (one of four), current score on a signed 8-bit scale (−128…127), floor and ceiling as their own independent fields (not folded into the type), and last-modified turn.
• Score cannot move below floor or above ceiling without an explicit system call that also updates the floor or ceiling.
• Score is stored narrow (integer) but promoted to floating point for any decay or diffusion calculation, with the result written back — integer-only decay produces chunky, untrue curves.
• Saint eusebia channels are stored as four distinct edges to four distinct target nodes, not as a single aggregated value.
• The graph can be serialised and loaded without data loss.

The container that holds everything outside individual characters: noble houses (with their member rosters, reputations, and titles), holdings (land, Jinn relationship state, productivity, security), faction records (orders and secular groups as graph participants), and the calendar that advances the simulation turn by turn.

• A house record holds: name, member list, titles held, treasury value, and reputation (stored as a text descriptor, not a score — e.g. "well-regarded in the north").
• A holding record holds: name, controlling house, material productivity value, Jinn relationship state (text descriptor), security state, and trade connection list.
• The calendar advances on a sub-weekly internal tick but surfaces to the player on a weekly briefing cycle; stretches in which nothing worth reporting occurs are auto-compressed rather than stepped through one tick at a time. It tracks the current tick, the current week, and the year (a year being no fewer than its number of weeks); no specific historical calendar is locked.
• Time compression is a first-class mechanic, not a convenience: generational play spans thousands of weeks (≈60 years ≈ 3,000 weeks), and the auto-skip of quiet stretches is what keeps a dynasty playable. It is built in from the start, not retrofitted.
• Faction records exist as pseudo-nodes in the graph — capable of holding bond edges to and from character nodes.
• Full world state can be serialised and loaded.

Each character holds a ranked list of drives, and each drive is a predicate over a target node: Ambition(Throne), Loyalty(Father), Fear(Father). A character can hold several drives at one target, and they need not agree — Loyalty(Father) and Fear(Father) on the same man is the ordinary engine of inner conflict. Drives are the engine of autonomous behaviour: given a situation, a character's drive-stack resolves to a weighted distribution over actions. The player issues no orders to other characters; they create conditions, and the drive system draws the conclusion. One predicate, Embody, takes an archetypal target — a person, a Jinn, or an idea-node — and resolves by running that target's signature stack against the present situation: an action "fits" to the degree the embodied thing would have chosen it here.

• Each character is assigned a ranked drive list at generation, each drive expressed as predicate(target-node), with at least one primary and one secondary drive.
• A character may hold multiple drives toward the same target; conflicting drives at one target (e.g. Loyalty and Fear toward a parent) resolve through the stack rather than cancelling.
• Given an identical situation, two characters with different drive-stacks produce observably different decisions.
• Drive behaviour is deterministic given the same seeded inputs — testable and reproducible.
• A drive's target is a node, so its resolution reads that node's edges: the same drive pointed at a node the character has soured on (negative edge) produces visibly different behaviour from one pointed at a node held in high agape. ("Resentment" lives here — it is a drive disagreeing with its edge, not a separate drive.)
• Embody resolves by borrowing the target's signature stack and scoring the candidate action against the distribution that stack would produce in the current situation; the same embodied target yields different verdicts in different situations (the trickster's prank fits the funeral and not the war council). For person and Jinn targets the stack is the target's own drives; for idea-node targets the signature is supplied by D-04a.
• The predicate set is closed and authored (Ambition, Loyalty, Fear, Embody, …); the target vocabulary is open and never defined — targets are nodes, including idea-nodes, whose meaning is positional, not stipulated.
• The evaluator takes the actor's expressed elements as part of its input (temperament tilts resolution), and its output is not just the chosen action but the resolved contest: the winning drive (its predicate and object — this is the actor's intent) and the weighted contender stack. D-04b consumes all three to select the deed and split its stamp.

An idea-node is a target with no body — Justice, the Return, Coyote, a memetic persona — that other characters can Embody. It carries no definition; it carries a signature: a drive-stack plus a bond-disposition, the same shape a character's own drives take. Embody(idea-node) resolves by running that signature against the present situation (see D-04), so the engine never stores what Coyote means — only how he moves, computed fresh at the moment of judgment. A signature comes from one of two sources on a single dial. Authored: hand it a stack the way you hand a character one — a Form, charged before anyone wears it. Emergent: its stack is the running aggregate of every node currently holding Embody toward it — the god is what his worshippers do. A crystallize/decay slider sits between the two: a hard Form holds its stack against its adherents; a soft one drifts toward them. This is the same current that runs the Empress question — authored Word versus crystallized longing — so the system holds both ends and the slide between them rather than choosing.

• An idea-node holds a signature (drive-stack + bond-disposition) and can be the target of Embody; resolution runs the signature through the drive evaluator (D-04) against the current situation, and fit is read off the resulting distribution.
• The verdict is computed live every time, never cached — the same idea-node fits an action in one situation and opposes it in another (the prank at the funeral, not the war council).
• Authored signatures are supported: an idea-node can be hand-given a stack at authoring time, independent of any adherents.
• A signature must ground in concrete nodes — real characters, faction/Throne pseudo-nodes, or a graph-topology delta. A signature spelled purely from other idea-nodes is rejected; every reference chain must terminate in concrete ground.
• Emergent signatures are derivable: the system can compute an idea-node's stack as the aggregate of all nodes currently holding Embody toward it. An idea with no adherents has an inert signature and steers no one.
• The crystallize/decay position is a per-idea-node parameter governing how far an authored signature drifts toward its emergent aggregate over time — settable at both extremes (pure Form, pure cluster) and between.

The layer that makes elements operative rather than decorative: how a character's expressed temperament moves over time, and how their acts move it back. Astrological realism — you are born a Cancer (natal, fixed) but run more or less Cancer-like (expressed, live). Two feedback terms act on each expressed magnitude: a stabiliser pulling it back toward natal (the cosmos wanting you to stay as born), and an accelerator pushing it further the way it already leans (habit deepening the rut). Near natal the stabiliser wins and you sit still; push expression far enough that the accelerator overpowers it and you break orbit into something birth did not assign. That is the cultivation thesis dropped into the temperament layer — and tribulation gets a mechanical meaning for free: the work done against the restoring force.

What feeds the accelerator is what you do. Action verbs carry intrinsic element stamps (to kill is Salt — the cull of the unnecessary); the lexicon is closed, authored, and hardcoded grammar (a deed is a primitive, like a predicate — only ideas must stay relational and undefined). And intent selects the deed: the winning drive that drove the act names which deed fired — a kill out of Eros resolves as a different deed, with a different stamp, than a kill out of survival. The stamp then splits: the winner takes half (all, while testing), the remainder distributes across the other hot drives by weight — and that remainder is signed by the hexagram. A runner-up concordant with the deed aggravates (deepens the stamp); one opposed mitigates — and mitigation decays, so the act's full weight lands later, after the resistance that held it off wears thin. The man who killed against his own screaming conscience feels clean for a season and curdles slowly.

The same act re-weights the drives that argued over it. A concordant loser ("this isn't why, but it helped") is reinforced — fast and shallow, because nothing resists greasing a wheel that agreed. A mitigating loser ("uncertain, but not enough to stop me") is eroded — slow and deep, because wearing down a no is hard and, once done, does not come back the way it was. So a strong action against resistance pulls every lever at once: it stamps you, eases the next like act, greases the drive that helped, and quiets the drive that objected. Three coupled positive loops — element, drive-reinforcement, resistance-erosion — compounding into a snowball with an unstable tipping point: below it you drift back to nature, above it you are captured and only a kenotic rupture gets you out. A strong action is genuinely dangerous, because the danger is the slope it leaves behind.

• Each expressed magnitude integrates two terms per tick: a stabiliser relaxing it toward its natal set-point, and an accelerator pushing it further along its current lean. Near natal the system rests; past a threshold the accelerator dominates and expression runs away.
• A closed, authored deed-lexicon maps action verbs to intrinsic element stamps. It is a sparse table with a plain default (an unlisted act stamps lightly or not at all), not a total function over every verb × motive.
• Intent selects the deed: the deed that fires is f(physical act, winning drive), read straight from the evaluator's output (D-04). The winning predicate-object names the deed; no separate situational classifier is needed.
• The stamp splits: the winning drive's element takes a fixed share (one-half; configurable to all for testing), and the remainder distributes across the hot contender drives, thresholded (only drives above a heat cutoff) and renormalised, so the residue does not dust a trace of six elements onto every act.
• The remainder is signed by hexagram agreement: a contender concordant with the deed's element aggravates (adds), one opposed mitigates (resists). A drive pointing at the chosen act with a negative sign and losing the resolution is maximal mitigation — the overridden conscience.
• Mitigation decays over time ("for a time"): the deed's true stamp is fixed; the mitigation hold relaxes toward zero, so accrued expression is (true stamp − current hold) and the deferred weight lands as the hold fades. Half-life derives from the mitigating drive's strength — stronger resistance defers longer and lands harder.
• Acts re-weight the contender drives: concordant losers are reinforced (fast, shallow rate); mitigating losers are eroded (slow, deep rate). Eroded resistance is floored, never deleted — a worn-down no still fires, still costs a flicker, forever.
• The feedback loops leak in small per act and integrate across many ticks — never resolve in full within a single resolution. The ground tilts gradually; the slide is felt before it is a cliff, and can be chosen against for a while.
• A world-temperament dial is exposed at setup as a legible genre selector (Realism ↔ Opera), not as raw coefficients; it derives the underlying constants. It governs at least two distinct knobs — the per-act leak (how much an ordinary act tilts the slope) and the runaway threshold (how large an act still redirects a life) — so a high-stability world can still be moved by something great rather than frozen solid.

When an event occurs, knowledge of it enters the graph at the witnessing node and propagates outward along edges. Each hop applies distortion — omission, framing, emotional overlay — weighted by the bond type of the edge being traversed. Philos edges carry practical content fastest; agape edges add emotional coloring; eusebia edges attach status weight. Information does not travel through edges with deeply negative scores without transformation.

• An event injected at node A propagates to nodes B, C, D in the correct hop sequence based on edge weights.
• Information arriving at a node six or more hops from the source is observably different from the original event — at minimum one factual element is missing, reframed, or emotionally colored.
• Propagation stops or degrades significantly across edges with scores at or below a defined negative threshold.
• The diffusion trace is logged internally (not shown to player) — auditable for testing.
• Diffusion is bounded: information does not propagate infinitely; there is a defined maximum hop count or decay function.

The mechanism by which things happen in the world — and by which the player finds out. Events are generated by character drive behavior, by world-state conditions (a poor harvest, a death, a marriage), and by player orders. Each event is injected into the diffusion engine at the relevant node. Some events are public (a declaration of war); most travel through the graph and arrive at the player transformed.

• Events have a type, an origin node, a turn timestamp, and a payload (what happened).
• Events can be flagged as public (known immediately to all nodes) or private (enters diffusion at origin).
• A library of at minimum 20 base event types covers: deaths, births, marriages, harvests, military movements, diplomatic exchanges, covert actions, and rumor arrivals.
• Events that reach the player node are formatted as diegetic prose — the steward mentions it in a briefing, a letter arrives, a servant whispers — never as a system notification.
• Events that have not yet reached the player node do not appear in any player-facing output.

When the head of house dies or is incapacitated, control passes to the next eligible character according to the house's succession rules. The new head inherits the house's assets, its bond edges (modified by their personal history with each node), its debts, and its reputation — for better and worse. Succession is the primary mechanism by which past choices haunt future generations.

• The house maintains a succession order that updates automatically when members die, are born, or change status.
• When a head of house dies, the next in succession becomes the new player-character without requiring a new game.
• The new head's existing bond scores toward all nodes are preserved from before succession; house-level bonds are inherited with a defined modifier reflecting their relationship with their predecessor.
• Inherited debts (financial and social) are visible to the player via the steward's briefing in the first turn after succession.
• If no eligible heir exists, a house extinction event is triggered.

Marriages are political instruments that create new bond edges between houses and generate heirs. They can be arranged by the player or emerge from NPC drive behavior. A marriage event produces: a new family link between two houses, new eusebia edges between the married characters and their respective families, and a relationship between the houses that other characters observe and respond to.

• A marriage can be arranged by player order or triggered by NPC drive resolution.
• A completed marriage creates the appropriate kinship links in the character model and the relevant bond edges.
• Other characters with existing bonds to either party update their assessments in the turn following the marriage event.
• Children born of a marriage are added to the succession order of the appropriate house and inherit initial bond scores derived from their parents' scores.
• A marriage that crosses houses with deeply negative existing bonds generates a tension event that enters the diffusion engine.

Each holding produces output each turn based on its material productivity and its Jinn relationship state. Material productivity responds to investment, infrastructure, and security. Jinn relationship state responds to propitiation practices maintained by the people living on the land — maintained or undermined by the character the player appoints as steward, and by orders that affect local custom. The player never sees a Jinn score. They hear, in the steward's briefing, that "the harvest was thin again this season" or that "the tenants in the eastern quarter seem more settled."

• Each holding produces a grain and coin output each turn, derived from material productivity and Jinn state combined.
• Jinn state is stored internally as a scored value but presented to the player only as a qualitative descriptor in diegetic prose (e.g. "uneasy," "settled," "generous").
• Appointing a steward who is sympathetic to local practices improves Jinn state over time. Appointing a rationalist steward degrades it.
• A holding whose Jinn state falls to a critical level generates a crop failure event that surfaces in the steward's briefing as a plain report of poor harvest — no cause is named unless the player investigates.
• Investment orders (build a mill, repair a road) improve material productivity after a defined number of turns, reported on completion in diegetic prose.

The house treasury receives income from holdings and trade connections and pays out costs (garrison, staff, debt service). Trade connections are relationships — merchants are characters with bond scores, not abstract flow values. A trade route is active while the merchant relationship is sufficiently healthy; it degrades or breaks when the relationship does. The treasury ledger is a diegetic document the player can request.

• The treasury updates each turn: income from holdings and trade, outgoings from costs, net change reported in the steward's briefing as a plain sentence ("The house accounts are healthy this quarter" or "We are spending beyond our means").
• When the player requests a ledger, they receive a formatted text document with line-item coin values — a diegetic document, not a UI panel.
• At least two trade connection types are modelled: a local merchant and a guild factor, each as a character node with bond scores.
• When a merchant's philos score falls below a defined threshold, the trade income from that connection decreases and eventually stops, with the change reported diegetically.
• The treasury can go into deficit; an extended deficit generates a debt event with appropriate consequences.

The player can raise, deploy, and supply military forces; war is seasonal and supply is a first-class mechanic. Resolution is detailed internally and abstracted in presentation. A battle is simulated as an agent engagement — on the order of a thousand-plus combatant nodes per side under heuristic commander orders — but the player never sees the field. What reaches the house is a dispatch, and the detail in that dispatch is filtered by relationship: the flank is abstracted ("the eastern line was lost"); a node the house holds an edge to is legible ("your sister's boy held when the men beside him ran; he took a horseman off his saddle before the line bent"). Commanders run their own drive-stacks against the battle state; named combatants are tracked and logged in full; their deaths are deaths like any other — they enter diffusion and trigger succession. The battle is opaque except for the people in it, and what the player learns of those people arrives secondhand, coloured by whoever carried it home.

• The player can order: raise a unit, disband a unit, assign a commander, set a campaign objective, and withdraw.
• A battle resolves as an agent simulation: two forces of combatant nodes engage under commander-issued heuristic orders, and commanders select those orders by running their own drive-stacks against the battle state (a commander whose Ambition outranks his Loyalty may hold his reserve at the hinge and let the line buckle — emergent, not scripted).
• Two node tiers are honoured: nodes already in the relationship graph fight in full and are tracked for the whole engagement (every morale check, exchange, kill, wound, and death logged); anonymous combatant nodes resolve coarsely and are culled when the campaign ends. The line between tiers is "does anyone at home hold an edge to this man" — if yes, simulate in full and keep the tape; if no, he is weather.
• Player-facing reporting is filtered by edge: the engagement as a whole is reported abstractly, but the conduct and fate of any node the house holds an edge to is reported specifically — and rides diffusion, so the account may be incomplete, flattering, or wrong.
• A combatant's death enters the diffusion engine, and for a node in the succession line it triggers inheritance — a battle is one of the ordinary ways a house loses its people.
• Supply consumption is tracked per unit per turn; a unit without supply degrades regardless of field performance and is reported as "the men are hungry and the road behind us is long."
• A declaration of war is a public event — it enters the graph as a known fact and other characters respond to it according to their drives.

The player assigns characters to covert roles and issues covert orders. Actions — rumor seeding, bribery, blackmail, sabotage, assassination, defection handling — interact directly with the relationship graph. A planted rumor enters diffusion at the target's neighborhood; a bribed official becomes a compromised node; an assassination removes a node and triggers cascades. All of this surfaces to the player only through diegetic channels — a nervous letter, a servant's whisper, a report that something went wrong.

• All six covert action types are implemented: rumor seeding, bribery, blackmail, sabotage, assassination, defection handling.
• Each action modifies the relationship graph in the defined way (see GDD) and injects an event into the diffusion engine.
• Each action has a blowback resolution — if detected, the originating house receives a consequence that itself enters the diffusion engine.
• Covert actions are never announced to the player as "success" or "failure" directly — they learn through subsequent events and character behavior.
• Assassination of a node correctly cascades fear and suspicion events through that node's edge network according to bond type and score.

The primary information delivery mechanism. At the start of each turn, the player's steward (or secretary, or most trusted household officer) presents a prose summary of the house's current situation — what happened last turn, what is pressing now, and what requires the head of house's attention. All game state the player needs to make decisions is channelled through this briefing, in ordinary English sentences, as this person would actually report it. Ledger detail is available on request.

• A briefing is generated each turn drawing from: events that reached the player node via diffusion, holding productivity reports, treasury state, active military situations, and any flagged character changes (deaths, arrivals, departures).
• The briefing contains no mechanical labels, score values, or system names. Every piece of information is in ordinary English prose.
• The briefing is appropriately filtered — the steward only reports what they would know. Events that have not reached the house do not appear.
• Information that arrives distorted through diffusion is presented as the distorted version — the briefing is diegetically honest about what the house actually knows, not what is objectively true.
• A ledger can be requested as a follow-up; it appears as a formatted text document with numerical entries as appropriate for a real household ledger.

After receiving the briefing, the player issues orders for the turn. In Milestone 1 this is a text-based menu of available actions — what the head of house could plausibly do. Orders are grouped by domain: household (staff assignments, estate decisions), diplomatic (letters, visits, negotiations), military (campaign orders), and covert (agent assignments). The available action list is filtered by what the house currently has the capacity and knowledge to do.

• The order menu presents available actions in plain language — "Send a letter to House Valdris" not "Initiate diplomatic event #4."
• Actions that are unavailable (insufficient treasury, no available agent, etc.) are either absent from the menu or clearly marked as unavailable with a plain-English reason.
• The player can issue multiple orders per turn up to a defined capacity limit.
• Each order submitted generates an event injected into the appropriate system for resolution at turn end.
• The player can choose to issue no orders and advance the turn — valid in both active play and Watcher Mode.

The player sets the house's standing values — priorities across bond types, disposition toward the throne question, economic and military posture — and then steps back. The simulation runs turn by turn automatically. The player still receives the steward's briefing each turn but issues no orders. Characters behave according to their drives against the value framework the player established. The player can re-engage at any turn.

• Watcher Mode can be entered and exited at any turn boundary without loss of state.
• When active, the simulation advances automatically and the briefing is generated as normal — the player observes, does not intervene.
• The house's standing values (set before entering Watcher Mode) correctly influence NPC character behavior toward the house during automated turns.
• The briefing in Watcher Mode is no less detailed than in active play — the steward still reports fully.
• At least one run of 10 consecutive automated turns can complete without simulation error.

At game start, the player selects a legacy goal or chooses to play without one. The simulation tracks progress toward that goal silently. If the house is extinguished — no eligible heir, no recoverable title — a loss state is reached and described to the player in diegetic prose. There is no win screen; reaching a legacy goal is acknowledged in the next steward's briefing as a historical note.

• At least three legacy goal types are playable at M1: Dynastic Endurance, Interregnum Defender, and Throne Bid.
• Goal progress is tracked internally and never displayed as a percentage or progress bar.
• When a goal is achieved, the steward mentions it in ordinary prose in the following briefing. Play continues.
• When the last eligible heir dies with no recovery path, a house extinction event fires and the game ends with a diegetic account of the house's fall.
• The player can choose "no goal" at game start; the simulation runs indefinitely until loss or the player stops.

A fully authored starting configuration: a named region, a political situation, a player house with defined members and initial bond scores, rival and allied houses, faction presences, at least one saint in the world (not necessarily recruitable), a set of anchor characters oriented toward each idea-node the scenario uses (so those idea-nodes have adherents and can actually steer behaviour), and a set of opening events ready to enter the diffusion engine at turn one. No particular premise is mandated; the deliverable authors content to a shape, not to a fixed scenario.

• The scenario instantiates without error using the completed data model.
• The player house has at minimum: a head of house, one spouse or sibling, one heir, and one household officer (the steward).
• At least three rival or allied houses exist with their own character rosters and initial bond scores toward the player house.
• At least two holdings exist with defined initial productivity and Jinn states.
• At least one opening event is queued for turn one that enters diffusion and surfaces in the first steward's briefing.
• For every idea-node the scenario references, at least a few anchor characters are authored holding Embody toward it, so the idea-node's emergent signature is non-empty at turn one — a new idea with no adherents cannot steer anyone. (Seeding the cluster is authoring content, not hardcoding a definition.)
• The scenario's political situation creates at least one natural path toward each of the three M1 legacy goal types.

A structured test run of the starting scenario through at least 10 turns in active play and 10 turns in Watcher Mode, verifying that every prior deliverable functions correctly end-to-end. This is not a playtest for fun — it is an integration proof. Every system must produce coherent, diegetically correct output with no mechanical leakage into player-facing text.

• The game runs for 10 active turns and 10 Watcher Mode turns without a simulation error or crash.
• No player-facing text in any briefing, ledger, or event description contains a mechanical label, score value, or system name.
• At least one piece of information that entered the graph at a distant node arrives at the player transformed — the distortion is coherent and traceable in the internal log.
• At least one character death triggers a succession and the new head of house receives an accurate briefing on inherited debts in the following turn.
• At least one battle resolves with a named node's conduct and fate reported to the player by edge (specifically, while the engagement as a whole stays abstract), and at least one battle death feeds a succession.
• At least one covert action is issued, resolved, and produces a downstream event that the player learns about diegetically — not as a direct result notification.