Diagrams

Every LLM call funnels through one boundary (callGenerate) and asks for its model by what kind of work it is , never by a hardcoded id. A three level indirection turns "this is a prose call" into "run it on this OpenRouter model" — and lets the whole fleet re tune with a one line change or a...

Every expert's canonical state rests on one measured spine. Three kinds of knowledge, kept apart because they answer different questions and are recovered differently. Scene deltas mutate the spine; forces (derivations) are deterministic reads over it — never re parse generated prose to recover...

The Entity Interpretation Graph (EIG) is an entity scoped, derived explanation over canonical evidence. It reuses the graph family's typed ontology and the Phase graph's immutable snapshot lifecycle, but its terminal is a field of tendencies rather than a plan or action.

Half of what an expert "knows" is never stored. Forces are pure, stateless computations recovered on read from the domain's deltas — the inverse of generation. Storing them would create a second source of truth that drifts from the spine, so the domain computes them every time instead.

The Phase Reasoning Graph (PRG; Phase Graph in compact UI copy) is the descriptive layer of graph thinking: a mined working model of the world's meta machinery — its patterns, conventions, attractors, agents, rules, pressures, and landmarks. It answers "how does this world WORK?" where the...

The control plane around a running instance. Four ideas that are easy to conflate — kept apart here. Shipped code: src/app/(gateway), src/features/gateway, src/lib/server/gateway, supabase/migrations/, electron/. Design doc: GATEWAY.md. Enforcement: PERMISSIONS.md.

A Projection is the third layer of opinion (three layers): a live forward read that is never marked true or false — it is the reasoning behind a Position , and it is the Position that gets graded (PIVOT). It is not a single number — it is an assembly of three parts that keep it honest and keep...

The Program is the autonomous machine loop that keeps an expert's three layers of opinion current: Research → Opinion → Merge → Position . It runs daily from schedules (manual or autopilot).

An expert's opinion is held in three complementary layers, kept distinct. All three are predictive reads over mutually exclusive outcomes, moved by evidence — what separates them is the WRITE PATH , not the question type (outcome first refactor, 2026 08 03): a Thread is canon, a Stream stages a...

[Concept · product direction] How a Domain, Scenario, branches, situated context, MCP Will, and parallel Worlds relate. This is a concept map, not shipped runtime wiring. The owning contract is the World specification.

AccessProvider (lib/core/reducer/access context) wraps every route and decides what renders before the page. The decision ladder:

The intricate invariant: serverVersion ≥ cacheVersion, always → the browser is a disposable cache the server can always rebuild, even after the user clears everything (the browser DEK included).

A Directive carries human intent into a later Program run. Its state makes the distinction visible between what the operator has staged and what the machine has actually applied.

Every on ramp terminates in the same canonical Domain record. The UI's CreationWizard and the headless operations differ only in how they prepare the input; a malformed model response is a failed generation, not a second repair path.

How a change flows from the UI through the deterministic engine and AI, and how state lands in the canonical record and mirrors to the browser cache. The load bearing rule: the on disk record is canonical; IndexedDB is a rebuildable projection.

How a raw corpus becomes a measured domain: chunk the source, extract scene structure concurrently, reconcile and assemble it, then enrich the assembled Domain through resumable specialist phases. The imperative shell (a singleton runner) orchestrates; extraction calls pass through the one model...

Meridians does not yet have one complete gameplay loop. It has a strong initial knowledge payoff, a machine maintenance loop, a shipped Scenario turn, an incubating Episode form, and a detached learning surface. This diagram keeps those truths separate, then defines the smallest loop worth...

Email/mobile stay the sign in methods ; the work is making one gateway session valid on each instance's own hosting domain (subdomain or custom) — via a token hand off , not a shared cookie. Context: the platform model.

The Program maintains the model through Research → Opinion → Merge → Position . The human loop orients first and escalates only when a consequential judgment is needed.

Reminders and research cycles are created the same way across Domain, Constellation, and Onboarding — a method chooser, one shared planned→record converter , then the cycle runs on cadence.

The MCP surface shares one bounded static catalog and materialises its first class domain capabilities from the daemon manifest (built from the same QUERY SPECS / OPERATION SPECS / ACTION META the docs use). Every result carries a uniform envelope { ok, working set, result, delta?, affordances?...

How local and remote clients reach one generated tool catalog, and where authority becomes an attributed record write. Capability navigation is documented separately in MCP action chains.

The Merge task closes the present day layer. On the domain's cadence it folds every mature Stream and every ready Note into canon through one group Merge that synthesises a Reasoning Graph (opt in) and continues the story with a new Arc. It is autonomous — always armed, no per fold approval. The...

How the app's routes connect, and how a deep link intent travels from the URL to a selected artifact. The URL [id] is the source of truth for the active domain; src/lib/core/routes.ts is the single source of URL truth — every path and query deep link is built there, and consumed through one seam.

A 6 step stepper (ONBOARDING STEPS in lib/core/onboarding.ts) turns interests into a live, maintained Constellation. The document is a proposal the user shapes; a background runner materialises the real records; a completed onboarding is an immutable genesis record.

A Tier 2 operation is the async, streamed machinery that precedes a mutation: it does the I/O (LLM calls, Firecrawl, media render), streams progress, and ends by dispatching reducer actions. 111 ops across 35 handler modules, each a first class Swagger style contract in one catalog. This is what...

A Position holds the reasoning and committed consequence together. Evidence can re price or re ground the live read; market outcomes score the commitment across the book without feeding back into model tuning.

The causal scaffold that grounds planning, projections, and merges. One graph shape — inference nodes over a spine substrate — generated from three different contexts, then rendered as a sequential path for prose. This is the why behind a Reading (projection anatomy) and a Merge (tutor resolution).

State changes only through reducer actions — 247 of them, composed from 22 slices , every one classified in a single exhaustive policy table. This is the single writer discipline made concrete: how a mutation is gated, reduced, and audited without any alternate write path.

One repo, three independent deploy targets — the Vercel gateway , the desktop app, and the Fly instance image — plus the running fleet . This is how a source change reaches each, and why the fleet only moves on a deliberate roll (no commit silently restarts a user's always on expert).

The Research task's evidence engine, now held in one canonical driver — runResearchPipeline (src/lib/engine/research/run pipeline.ts) — called by both shells (the headless research run op and the interactive ResearchRunDashboard) through a ResearchPort. The shells adapt runtime concerns (commit...

A game is a branch ; a GameRoom runs the turn loop as a phase machine. The player facing loop is Brief → Prepare → Commit → Consequence . Generation alternates with deliberate player action: the engine briefs the seat, the seat prepares its reading, the seat commits, then the world plays the...

The headless Program scheduler is the time based orchestration layer: it reads enabled schedules from the record, arms Croner timers, and on each tick runs a Research/Opinion/Merge/Position operation to completion — under concurrency, serialization, and spend gates. The pure when to fire logic...

Every Program task (program loop) emits a canonical DomainProgramEvent. Turning those into an expert forward feed is a pure pipeline : registry → editorial → projection → surfaces. Stories are a projection, never a second source of truth.

A Stream gathers current evidence until it is settled into canon through a Merge, or is closed and later reopened when the question becomes live again.

One daemon owns the record; N browsers connect to it. The sync layer is the two tier replication protocol underneath cache coherence: how a client's optimistic edit reaches the master, how the master's echo suppresses a re write, and how a reconnecting client catches up.

CI automation, not app runtime: turns a week of git + PR activity into a plain English business update committed to main. Manual dispatch only since 2026 08 13 (the Friday cron is off — unpaid Actions minutes); because every run backfills the missing Fridays, running it on demand loses no week....

The sign in and credential surfaces — the doorway into an instance and the gateway. One shared two panel frame (AuthShell) hosts the caller's controls; distinct flows sit behind it for members, Directors, and MCP credentials. Auth is local first; the control plane is a separate, non blocking layer.

Navigation is two layers: the SectionRail picks one of 5 sections, the StageBar switches the stageView within it. Stage.tsx is a render switch on state.stageView ( 33 modes); the persisted literals are the source of truth (view state.ts).

A constellation is the control panel over a portfolio of member Domains. ConstellationShell tabs group into three bands (TAB GROUPS); on a phone they collapse to seven pill groups around a centre Chat (see ui/mobile).

The per Domain configuration modal — where a Director tunes how the expert authors : its generation direction, prose style, point of view, audio, and the AI model allocation behind it all. A tabbed DomainSettingsModal; Director gated.

The surface for turning a corpus into a Domain: a jobs list, a per job detail with live progress, and a new job setup. This is the UI over the extraction pipeline — the same runner that onboarding's Build step drives in the background.

The control plane dashboard: one role aware chrome (GatewayConsoleShell) wrapping a set of console pages. What a viewer sees depends on their platform role and entitlement (platform model) — admins run the business, a paying Director manages billing, an unpaid visitor sees plans.

The public path explains the outcome first, then reveals the maintained system, its reasoning, the runtime, and the purchase boundary. These routes use the public Gateway shell; authenticated account and host controls continue in the Home console.

The regions of GatewayShell — shared by the sign in portal and the home stage, so signing in flows straight into the console (same spine, different stage).

Mobile is a separate focused path, not a squeeze — a different component tree around the same store. Three surfaces collapse to pill navigation.

The domain genesis surface: a full screen workspace with a progress sidebar and a center step container. Six steps carry a constellation of drafts from an idea to extracted, maintained Domains. Two steps (Capture, Maintain) let you move between drafts in any order; the rest are linear.

The right popout — UtilityRail (icon strip) picks a tab; the panes render in UtilityPanel.tsx (separate from the center views). The inspector tab body is driven by viewState.inspectorContext via renderInspector(); detail bodies share the DetailKit presentational vocabulary.

One metaphor, skinned by the app theme: a poker table . The whole game is a single chrome less fullscreen window (ScenarioModal); ScenarioShell lays it out like the domain WorkspaceShell so the two feel like one app. The active tab follows the human loop ( Brief → Prepare → Commit → Consequence...

The workspace TopBar's menus and the modals they open, plus the run/output surfaces reachable from the shell.

The regions of WorkspaceShell — a stable cockpit around a mutable Stage. Two edge rails share the same RailFrame chrome and each toggle a collapsible pane beside them.