Nishi Compare · capabilities, evidence and delivery

Folk Games

Compare capabilities and delivery evidence. Source discovery, qualification, deployment and accepted outcomes are separate; an open contract names work still to verify.

The public-domain traditional games of the world -- board, tile, card and dice -- as ONE data-driven emitter rather than one program per game. A game is a ludeme spec parsed into a board graph; the family engine plays it. Measured 2026-08-25: the ALIGN family is live and green at 23 of 23 teeth, bite-proven by mutation twice over -- once against the rules library and once against the search -- its move generator validated against the published Tic-Tac-Toe game-tree constant of 255168, carrying Tic-Tac-Toe, Three Mens Morris, Achi, Nine Mens Morris, Morabaraba, Twelve Mens Morris and Dara plus Gomoku from 5356 bytes of spec data and no per-game code -- eight of the registry's 117 games, and Twelve Mens Morris cost three lines because an alias points it at Morabaraba's rules rather than copying them. It is natively playable against an alpha-beta opponent that draws itself at Tic-Tac-Toe, the published perfect-play result. The SOW family landed 2026-08-27 at 12 of 12: Oware, Kalah, Congkak and Pallanguzhi on one engine, with seeds conserved at all 33798 positions of the Oware tree to depth six. The RACE track family landed the same day at 14 of 14: Backgammon and Nard, opening at the published 167 pips measured on BOTH sides. THREE families of eleven, FOURTEEN of the 117 games, all three bite-proven, and each proven to the STRONGEST standard its game admits rather than to one house standard -- a published game-tree count where one exists, a published opening constant where one exists, an exhaustive invariant where neither does. Eight families and the served browser page remain as watch contracts.

Overview

The purpose, declared position and evidence coverage of this domain. Source presence and completed acceptance are different measures.

Where we are. One family of eleven is live and natively playable. nx_folkgame_lib parses a ludeme spec into a board graph with every array sized from the spec rather than from a cap, and the align engine plays Tic-Tac-Toe, Three Mens Morris, Achi, Nine Mens Morris, Morabaraba, Twelve Mens Morris, Dara and Gomoku from 5356 bytes of data with no per-game code -- Twelve Mens Morris through an alias at Morabaraba rather than a copied board. nx_folkgame_align_gate is GREEN at 23 of 23 through the served API and bite-proven twice, its move generator validated against the published Tic-Tac-Toe game-tree constant 255168 and its parser proven to refuse an unknown key, a lineless game, a short line and an alias chain. nx_folkgame_play is a NATIVE binary from our own toolchain with an alpha-beta opponent whose depth and weights are conf rows; playing itself at full depth it draws Tic-Tac-Toe, the published perfect-play result. The population is declared: 117 games, 45 distinct engine symbols, 11 families, of which 8 games play today. Ten families and the served browser page are open.

Where we need to go. Total coverage of the declared population -- all 117 games playable in a browser against an opponent on nishifamily.com/games, each one a spec row set rather than an organ -- and then the tier the corpus exists to unlock: SEARCHING the ludeme space under playability constraints to emit games nobody has played, the result Browne's Ludi system demonstrated when it evolved Yavalath into a commercially published game. The 117 are not the product; they are the proof that the vocabulary is broad enough to generate.

The unit. 1 u = one measured session-leg. Calibration: the align family -- substrate, engine, gate, seven games, promote and register -- was one leg. A family with a genuinely new state model (cards have hidden information, race games have a randomiser) is estimated at more.

Where we are: 2 of 11 families. Align and sow are live, green and bite-proven. Coverage against the declared population of 117 games is measured by the registry and never asserted: twelve games play today. THE TWO FAMILIES ARE PROVEN TO DIFFERENT STANDARDS AND THAT DIFFERENCE IS THE POINT -- align against the published Tic-Tac-Toe game-tree constant 255168 and a perfect-play draw, sow against seed conservation at all 33798 positions of the Oware tree, because no cheap published count exists for a mancala board. A green is only as strong as what produced it.

Cost to the board games: 6 u. M1: the eight remaining perfect-information families -- sow, race, chess, leap, hunt, domino, paper and Go. These share the board-graph substrate that already exists.

Cost to total coverage: 11 u. M2 adds the hidden-information families, the AI ladder and a playable page per game. Cards are the real work: a deck model, hidden hands and four sub-engines covering 25 registry rows.

Cost to generative emission: 16 u. M3 is the Ludi tier: constraints, self-play evaluation and a search over the ludeme space that proposes games rather than transcribing them.

Research bar. Ludii is measured on the reference general game system for traditional games, games described in ludemes rather than coded, developed under the ERC Digital Ludeme Project [@ludii-readme]. Theirs: CC BY-NC-ND 4.0 and a JDK 8 or higher runtime requirement [ludii-license] [ludii-readme]. Ours: original NishiLang at license_tier ORIGINAL, no runtime to install, and therefore shippable where Ludii is not. NAMED HERE AS A BAR AND NOTHING ELSE: we do not bundle it, do not run it, and do not mirror its files, because NonCommercial reaches use and not merely distribution. The referees in FG12 are OpenSpiel under Apache 2.0 and Fairy-Stockfish under GPL-3 as a separate process, both of which permit exactly that.

Research bar. OpenSpiel is measured on a broad hand-coded game set under Apache 2.0 that publishes a per-game tested status of thoroughly-tested, lightly-tested or known-issues [@openspiel-games] [@openspiel-license]. Theirs: Backgammon thoroughly-tested and an m,n,k-game covering the align family lightly-tested. Ours: our align family is validated against an exhaustive published constant rather than graded by its own author, and our per-game status is the registry.

Research bar. Fairy-Stockfish is measured on a chess-variant engine covering Xiangqi, Shogi, Janggi and Makruk plus user-defined variants through src/variants.ini [@fairysf-readme]. Theirs: GPL-3 [fairysf-license], so it may run as a separate-process oracle and may never be linked into a served artifact. Ours: the chess family is a watch contract; Fairy-Stockfish is its intended perft oracle rather than its replacement.

Research bar. boardgame.io is measured on an MIT engine for turn-based games in JavaScript shipping state sync, realtime multiplayer, a lobby, automatically generated bots and time-travel game logs [@bgio-readme] [@bgio-license]. Theirs: 0.50.2 pinned live from the npm registry [bgio-npm]. Ours: it beats us outright on delivery: we have no served page and no opponent, which are rungs FG10 and FG11, and it is the right bar for both.

Latest recorded release

No valid dated release entry is recorded for this domain.

Release entries describe recorded changes; they do not establish that every capability passed evaluation.

10 of 12 capability source symbols found|0 of them authored stronger-claims|2 open|coverage 833/1000|adoption 7 full / 3 partial

Evidence profile — what the gaps on this board actually are

Measured by nx_swcompare_evidence, read back by nx_evprofile_lib. Every figure is a count with its denominator — there is deliberately no score, no grade and no percentage anywhere in this band, because a stored scalar is a field a seat can edit and a counted partition is not.

proven able to fail counts the gates that have a RECORDED RED — nx_gate_bite mutated the gate subject, rebuilt it, watched the gate go red, and that record is inside the shared TTL. never bitten is its complement over the same denominator: those gates ran and were green, and nothing has ever shown them able to detect anything, so their green is a statement about this run and not about the gate. green at 0/0 is a separate and much weaker observation — the gate printed GREEN on a zero denominator, so its own tooth counter says it examined nothing. A gate can be green, non-zero, and still never bitten; that is the common case and it is now visible instead of implied.

partition: grounded + unsupported = 10 vs present 10 · named + unnamed + withheld = 2 vs open 2 · both reconcile

liar-kill conj=GPQN · all four conjuncts held

graded document: BUILDROOT tree, 14471 bytes · gates map: PRIMARY · stamped 2d 7h ago · source ../knowledge/status/evstamp_folkgames.verdict

Gap class	What it is, and the work it names
NONE	No gap class fires on this board: every published claim is grounded, the declared gates ran and were green, no watch contract is unnamed or already landed, and the stamp is inside its TTL. That is a statement about evidence, not about depth, scale or polish.

This band reports the referee counts. The per-axis worklist rows — which axis is unsupported, which watch is ready to flip, which gap is unnamed — are printed by nx_swcompare_evidence folkgames itself and are not carried on the stamp, so this page names the classes and the producer names the rows. That split is stated rather than hidden: a count without a worklist is not actionable, and this band is honest about which half of that it is.

Production map

Follow the dependencies, declared acceptance criteria and recorded priorities. Inspect source binding before treating a rank as executable work.

Ranking source binding: PLAN_MATRIX_BOUND_ONLY. Recorded priorities require current acceptance evidence and resource checks before execution.

Ranking matches the captured plan and matrix only. Latest execution outcome, research freshness, accepted delivery and investment return are unverified.

Recorded priority estimates

Order from nx_compare_rank (nx_dr_ocm: (deficit + cost-of-delay + option + enables) x sponsor x self-sufficiency x momentum / cost). FINISH rows are rungs whose symbol is present but whose organ is short of full adoption: listed before new work by this heuristic. Priority is not measured delivery cost or execution readiness. Stamp: # asof=1790082052 domain=folkgames target_version=0.1 rungs=14 done=2 open=12 finish=1 ranker=nx_dr_ocm

#	Stage	Rung	Priority	Derivation
F	FINISH	Sow family: mancala (FG1) fgs_sow dossier	LIB-GATE-ONLY importers=1	imported only by validation organs (gates, tests, benches): wire it into a shipping program
#1	0.1	Chess family: one movement vocabulary (FG3) fgc_move dossier	1000	v=30 m=1 c=30
#2	0.1	Race family: track, randomiser, entry and bearing off (FG2) fgr_race dossier	0	v=0 m=1 c=20
#3	0.1	Leap family: alquerque and draughts (FG4) fgl_leap dossier	0	v=0 m=1 c=10
#4	0.1	Hunt family: asymmetric forces (FG5) fgh_tafl dossier	0	v=0 m=1 c=10
#5	0.1	Domino and paper families (FG8) fgt_match dossier	0	v=0 m=1 c=20
#6	0.1	Go (FG9) fgo_go dossier	0	v=0 m=1 c=20
#7	later	Playability constraints (FG13) fggen_eval dossier	1000	v=10 m=2 c=20
#8	later	A playable page per game, emitted (FG10) fge_emit dossier	133	v=2 m=2 c=30
#9	later	Card family: deck, hidden hands and four sub-engines (FG6) fgk_trick dossier	0	v=0 m=1 c=30
#10	later	Dice family: categories and push-your-luck (FG7) fgd_cat dossier	0	v=0 m=1 c=10
#11	later	External referee harness (FG12) fgref_perft dossier	0	v=0 m=1 c=20
#12	later	Generative emission: search the ludeme space (FG14) fggen_search dossier	0	v=0 m=1 c=40

Declared roadmap — contract, acceptance, executor, effort

Rung	Closes with	Definition of done (pre-declared)	Executor	Est.
Sow family: mancala (FG1)	fgs_sow	Oware, Kalah, Congkak and Pallanguzhi play from spec data with single-lap sowing and capture; Bao and Omweso add multi-lap. Gate carries a seed-conservation tooth -- seeds are never created or destroyed by a sow -- and a neg-control that a spec declaring more seeds than pits is REFUSED	Organ	1 u
Race family: track, randomiser, entry and bearing off (FG2)	fgr_race	Backgammon, Senet, the Royal Game of Ur, Pachisi and Patolli play from spec data. Done rule is an external check: our Backgammon opening-roll move counts match OpenSpiel's thoroughly-tested Backgammon over an enumerated set of positions [openspiel-games]	Organ	2 u
Chess family: one movement vocabulary (FG3)	fgc_move	Chess, Shatranj, Chaturanga, Xiangqi, Janggi, Shogi and Makruk from one leaper-rider-hopper vocabulary with palace, river, promotion zone and drops. Done rule is PERFT AGAINST FAIRY-STOCKFISH: our node counts match its published perft to depth 5 on each variant, run as a separate process and never linked [fairysf-readme]	Organ	3 u
Leap family: alquerque and draughts (FG4)	fgl_leap	Draughts, Alquerque, Felli, Zamma and Awithlaknannai from spec data with forced-capture and maximal-capture flags as spec fields, plus Seega custodial capture	Organ	1 u
Hunt family: asymmetric forces (FG5)	fgh_tafl	Hnefatafl, Tablut, Brandubh, Bagh Chal, Fox and Geese, Aadu Puli Attam. Two goal sets in one game -- king escape versus encirclement -- is the new vocabulary this family adds	Organ	1 u
Card family: deck, hidden hands and four sub-engines (FG6)	fgk_trick	Trick, shed, meld and bank sub-engines over one deck model covering 25 registry rows from Whist to Koi-Koi. Hidden information is the new state model; the gate proves a player's legal moves never depend on a card they cannot see	Organ	3 u
Dice family: categories and push-your-luck (FG7)	fgd_cat	Yacht, Generala, Farkle, Liar's Dice, Mia, Bunco, Craps, Cho-Han and Lu-Lu. The gate asserts the category scoring table is data and that a fixed seed replays bit-identically	Organ	1 u
Domino and paper families (FG8)	fgt_match	Block, Draw and All Fives dominoes plus Dots and Boxes, Sprouts, Hex, Nim and Hangman. Several are near-bespoke and the plan says so rather than pretending one engine covers them	Organ	2 u
Go (FG9)	fgo_go	Go is declared bespoke in the registry and gets its own engine: liberties, capture, ko and area scoring. Done rule is agreement with OpenSpiel's Go on scored terminal positions [openspiel-games]	Organ	2 u
A playable page per game, emitted (FG10) after FG1	fge_emit	Every green game gets a browser page through the existing lane: a base-relative integer core conforming to the estate init tick render click score contract, compiled to wasm and framed by nx_game_page_emit, the same path Sudoku already ships on. Done rule is that /games lists every game whose family gate is green and no game whose gate is not	Organ	3 u
Opponent ladder (FG11) after FG10	fgai_search	One search core -- alpha-beta with iterative deepening for perfect-information families, determinized search for hidden-information ones -- with per-game depth and time budgets as conf rows and never as literals, admitted through the estate load governor so a game never competes with a build. Done rule is that the opponent beats a random player at a published rate per game and that its budget is readable from conf	Organ	3 u
External referee harness (FG12) after FG3	fgref_perft	A build-lane harness that runs Fairy-Stockfish and OpenSpiel as separate processes and diffs their node counts against ours per game. Nothing borrowed enters a served artifact; the harness exists so a coverage claim is refereed rather than self-graded	Organ	2 u
Playability constraints (FG13) after FG11	fggen_eval	Termination, branching factor, game length, drawishness and absence of a first-player forced win, measured by self-play over a spec. This is the evaluator Ludi used and it must exist before any search can propose anything	Organ	2 u
Generative emission: search the ludeme space (FG14) after FG13	fggen_search	A search over spec space under FG13's constraints that proposes games the corpus does not contain, with a self-play referee and a human-readable rule sheet per candidate. Done rule is one novel game that passes every constraint and survives a judge panel; the Yavalath result is the bar	Organ	4 u

Milestones

Milestone	Rungs	Cumulative
M1 · Every perfect-information family plays	FG1,FG2,FG3,FG4,FG5,FG8,FG9	6 u
M2 · Total coverage, playable, with an opponent	FG6,FG7,FG10,FG11,FG12	11 u
M3 · Generative emission	FG13,FG14	16 u

Ladder verdict. NOT DECLARED. This board names no dated best-in-class or frontier target and no rung roles (sotatarget and rungrole rows on its plan); the ranker labels it NO-LADDER until it does, and until then its rungs climb toward a target nobody has written down. Bars read NO-BAR against the current month 2026-10.

Bar freshness, counted
Class	Count	Note
bars	0	sotabar rows on the plan
fresh	0	the bar month is the current month
attested	0	an older bar with a this-month barscan reporting no newer entry
stale	0	a this-month scan saw a newer month the bar ignores
unattested	0	nobody looked this month
malformed	0	a sotabar row missing a field
duplicate	0	bar ids an earlier row already carries
bars, summed	0	RECONCILED: the parts sum to the total 0
current month	2026-10	the month every bar is judged against

Treatment verdict. NOT DECLARED. No rung on this board declares its three-step treatment (a treat row naming the MCP row, the API route, the primitive it composes, the workflow that composes it and the agent beat that runs it); the ranker labels every rung TREATMENT-UNDECLARED until it does.

Inspect a rung and its prerequisites

Declared nodes 14. Rank input binding: PLAN_MATRIX_BOUND_ONLY. Dependency order is authored. Implementation, acceptance evidence, authority and resource readiness are unverified. No action is recommended or dispatched here.

Plan SHA-256 e35df3915264e069b33c3a6c9993ce85cf96a58a5f09a2f2746b3df33a924824. Target rows 0; role rows 0. Existing risks and release worklog retain their own scope; no node completion is inferred.

Runtime observation coverage: 0 of 14 rungs have current, identity-bound execution observations. Observation may report RED. Accepted completion remains unknown; source presence, qualification and deployment do not establish it.

Use Enter or Space on a rung to inspect its contract. Prerequisite links locate another rung in this list; open its summary to inspect it. Estimates are authored effort, not forecasts.

FG1 — Sow family: mancala
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgs_sow
Acceptance: Oware, Kalah, Congkak and Pallanguzhi play from spec data with single-lap sowing and capture; Bao and Omweso add multi-lap. Gate carries a seed-conservation tooth -- seeds are never created or destroyed by a sow -- and a neg-control that a spec declaring more seeds than pits is REFUSED
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG2 — Race family: track, randomiser, entry and bearing off
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgr_race
Acceptance: Backgammon, Senet, the Royal Game of Ur, Pachisi and Patolli play from spec data. Done rule is an external check: our Backgammon opening-roll move counts match OpenSpiel's thoroughly-tested Backgammon over an enumerated set of positions [@openspiel-games]
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG3 — Chess family: one movement vocabulary
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgc_move
Acceptance: Chess, Shatranj, Chaturanga, Xiangqi, Janggi, Shogi and Makruk from one leaper-rider-hopper vocabulary with palace, river, promotion zone and drops. Done rule is PERFT AGAINST FAIRY-STOCKFISH: our node counts match its published perft to depth 5 on each variant, run as a separate process and never linked [@fairysf-readme]
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG4 — Leap family: alquerque and draughts
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgl_leap
Acceptance: Draughts, Alquerque, Felli, Zamma and Awithlaknannai from spec data with forced-capture and maximal-capture flags as spec fields, plus Seega custodial capture
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG5 — Hunt family: asymmetric forces
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgh_tafl
Acceptance: Hnefatafl, Tablut, Brandubh, Bagh Chal, Fox and Geese, Aadu Puli Attam. Two goal sets in one game -- king escape versus encirclement -- is the new vocabulary this family adds
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG6 — Card family: deck, hidden hands and four sub-engines
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgk_trick
Acceptance: Trick, shed, meld and bank sub-engines over one deck model covering 25 registry rows from Whist to Koi-Koi. Hidden information is the new state model; the gate proves a player's legal moves never depend on a card they cannot see
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG7 — Dice family: categories and push-your-luck
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgd_cat
Acceptance: Yacht, Generala, Farkle, Liar's Dice, Mia, Bunco, Craps, Cho-Han and Lu-Lu. The gate asserts the category scoring table is data and that a fixed seed replays bit-identically
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG8 — Domino and paper families
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgt_match
Acceptance: Block, Draw and All Fives dominoes plus Dots and Boxes, Sprouts, Hex, Nim and Hangman. Several are near-bespoke and the plan says so rather than pretending one engine covers them
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG9 — Go
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fgo_go
Acceptance: Go is declared bespoke in the registry and gets its own engine: liberties, capture, ko and area scoring. Done rule is agreement with OpenSpiel's Go on scored terminal positions [@openspiel-games]
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG10 — A playable page per game, emitted
Prerequisites: FG1 (acceptance unverified)
Contract: fge_emit
Acceptance: Every green game gets a browser page through the existing lane: a base-relative integer core conforming to the estate init tick render click score contract, compiled to wasm and framed by nx_game_page_emit, the same path Sudoku already ships on. Done rule is that /games lists every game whose family gate is green and no game whose gate is not
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG11 — Opponent ladder
Prerequisites: FG10 (acceptance unverified)
Contract: fgai_search
Acceptance: One search core -- alpha-beta with iterative deepening for perfect-information families, determinized search for hidden-information ones -- with per-game depth and time budgets as conf rows and never as literals, admitted through the estate load governor so a game never competes with a build. Done rule is that the opponent beats a random player at a published rate per game and that its budget is readable from conf
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG12 — External referee harness
Prerequisites: FG3 (acceptance unverified)
Contract: fgref_perft
Acceptance: A build-lane harness that runs Fairy-Stockfish and OpenSpiel as separate processes and diffs their node counts against ours per game. Nothing borrowed enters a served artifact; the harness exists so a coverage claim is refereed rather than self-graded
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG13 — Playability constraints
Prerequisites: FG11 (acceptance unverified)
Contract: fggen_eval
Acceptance: Termination, branching factor, game length, drawishness and absence of a first-player forced win, measured by self-play over a spec. This is the evaluator Ludi used and it must exist before any search can propose anything
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
FG14 — Generative emission: search the ludeme space
Prerequisites: FG13 (acceptance unverified)
Contract: fggen_search
Acceptance: A search over spec space under FG13's constraints that proposes games the corpus does not contain, with a self-play referee and a human-readable rule sheet per candidate. Done rule is one novel game that passes every constraint and survives a judge panel; the Yavalath result is the bar
Authored effort: 4. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.

Learning and practice paths

No structured learning path is declared for this plan. Existing research, roadmap and worklog remain available above.

Rung dossiers — every record that bears on a rung, in one place

Joined by symbol, never typed. Each dossier is assembled on every publish from the rows this board already carries: the plan's rung row, the matrix row that carries its contract symbol (its status re-measured by the one symbol ruler), the gate the organ declares and the verdict the evidence referee recorded on its last run, the reference marks in the rung text, the design rows that name the rung and the work log filed against it. The capability matrix links each cell to its dossier and each dossier links back to its cell and forward to the rungs it stands on; a dependency naming no rung on this plan is written as UNRESOLVED rather than linked. Absences are named: NO-MATRIX-ROW, NO-GATE-DECLARED, UNRECORDED.

Gate verdicts: UNSTAMPED — no per-gate verdict artifact is published for this domain yet (nx_swcompare_evidence folkgames writes it beside its stamp); every gate below reads UNRECORDED until it runs.

Gate declarations: knowledge/organ_gate.conf read from this working directory (1 rows) and from the estate root (196 rows); rows in both counted once: 0; declarations read: 197. Every declaration in either copy counts, so a stub beside the publisher can never hide the root.

FG1 Sow family: mancala · cell PRESENT · gate NO-GATE-DECLARED

Contract	`fgs_sow` · executor Organ · 1 u · stands on nothing
Definition of done	Oware, Kalah, Congkak and Pallanguzhi play from spec data with single-lap sowing and capture; Bao and Omweso add multi-lap. Gate carries a seed-conservation tooth -- seeds are never created or destroyed by a sow -- and a neg-control that a spec declaring more seeds than pits is REFUSED
Matrix cell	SOW family: mancala as pits, seeds, laps and capture · `runtime/nx_folkgame_sow_lib.nx` · PRESENT decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_folkgame_sow_lib`; declare `nx_folkgame_sow_lib TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

FG2 Race family: track, randomiser, entry and bearing off · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgr_race` · executor Organ · 2 u · stands on nothing
Definition of done	Backgammon, Senet, the Royal Game of Ur, Pachisi and Patolli play from spec data. Done rule is an external check: our Backgammon opening-roll move counts match OpenSpiel's thoroughly-tested Backgammon over an enumerated set of positions [openspiel-games]
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgr_race`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG3 Chess family: one movement vocabulary · cell WATCHING · gate NO-GATE-DECLARED

Contract	`fgc_move` · executor Organ · 3 u · stands on nothing
Definition of done	Chess, Shatranj, Chaturanga, Xiangqi, Janggi, Shogi and Makruk from one leaper-rider-hopper vocabulary with palace, river, promotion zone and drops. Done rule is PERFT AGAINST FAIRY-STOCKFISH: our node counts match its published perft to depth 5 on each variant, run as a separate process and never linked [fairysf-readme]
Matrix cell	CHESS family: one piece-movement vocabulary over a board with palaces, rivers and drops · `runtime/nx_folkgame_lib.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_folkgame_lib`; declare `nx_folkgame_lib TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

FG4 Leap family: alquerque and draughts · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgl_leap` · executor Organ · 1 u · stands on nothing
Definition of done	Draughts, Alquerque, Felli, Zamma and Awithlaknannai from spec data with forced-capture and maximal-capture flags as spec fields, plus Seega custodial capture
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgl_leap`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG5 Hunt family: asymmetric forces · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgh_tafl` · executor Organ · 1 u · stands on nothing
Definition of done	Hnefatafl, Tablut, Brandubh, Bagh Chal, Fox and Geese, Aadu Puli Attam. Two goal sets in one game -- king escape versus encirclement -- is the new vocabulary this family adds
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgh_tafl`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG6 Card family: deck, hidden hands and four sub-engines · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgk_trick` · executor Organ · 3 u · stands on nothing
Definition of done	Trick, shed, meld and bank sub-engines over one deck model covering 25 registry rows from Whist to Koi-Koi. Hidden information is the new state model; the gate proves a player's legal moves never depend on a card they cannot see
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgk_trick`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG7 Dice family: categories and push-your-luck · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgd_cat` · executor Organ · 1 u · stands on nothing
Definition of done	Yacht, Generala, Farkle, Liar's Dice, Mia, Bunco, Craps, Cho-Han and Lu-Lu. The gate asserts the category scoring table is data and that a fixed seed replays bit-identically
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgd_cat`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG8 Domino and paper families · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgt_match` · executor Organ · 2 u · stands on nothing
Definition of done	Block, Draw and All Fives dominoes plus Dots and Boxes, Sprouts, Hex, Nim and Hangman. Several are near-bespoke and the plan says so rather than pretending one engine covers them
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgt_match`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG9 Go · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgo_go` · executor Organ · 2 u · stands on nothing
Definition of done	Go is declared bespoke in the registry and gets its own engine: liberties, capture, ko and area scoring. Done rule is agreement with OpenSpiel's Go on scored terminal positions [openspiel-games]
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgo_go`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG10 A playable page per game, emitted · cell WATCHING · gate NO-GATE-DECLARED

Contract	`fge_emit` · executor Organ · 3 u · stands on FG1
Definition of done	Every green game gets a browser page through the existing lane: a base-relative integer core conforming to the estate init tick render click score contract, compiled to wasm and framed by nx_game_page_emit, the same path Sudoku already ships on. Done rule is that /games lists every game whose family gate is green and no game whose gate is not
Matrix cell	PLAYABLE IN A BROWSER: a served page per game with no plugin and no account · `runtime/nx_folkgame_lib.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_folkgame_lib`; declare `nx_folkgame_lib TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

FG11 Opponent ladder · cell PRESENT · gate NO-GATE-DECLARED

Contract	`fgai_search` · executor Organ · 3 u · stands on FG10
Definition of done	One search core -- alpha-beta with iterative deepening for perfect-information families, determinized search for hidden-information ones -- with per-game depth and time budgets as conf rows and never as literals, admitted through the estate load governor so a game never competes with a build. Done rule is that the opponent beats a random player at a published rate per game and that its budget is readable from conf
Matrix cell	OPPONENT: a bot that can actually play the game · `runtime/nx_folkgame_ai_lib.nx` · PRESENT decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_folkgame_ai_lib`; declare `nx_folkgame_ai_lib TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

FG12 External referee harness · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fgref_perft` · executor Organ · 2 u · stands on FG3
Definition of done	A build-lane harness that runs Fairy-Stockfish and OpenSpiel as separate processes and diffs their node counts against ours per game. Nothing borrowed enters a served artifact; the harness exists so a coverage claim is refereed rather than self-graded
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fgref_perft`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG13 Playability constraints · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fggen_eval` · executor Organ · 2 u · stands on FG11
Definition of done	Termination, branching factor, game length, drawishness and absence of a first-player forced win, measured by self-play over a spec. This is the evaluator Ludi used and it must exist before any search can propose anything
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fggen_eval`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

FG14 Generative emission: search the ludeme space · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`fggen_search` · executor Organ · 4 u · stands on FG13
Definition of done	A search over spec space under FG13's constraints that proposes games the corpus does not contain, with a self-play referee and a human-readable rule sheet per candidate. Done rule is one novel game that passes every constraint and survives a judge panel; the Yavalath result is the bar
Matrix cell	NO-MATRIX-ROW — no matrix row carries `fggen_search`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	no log row names this rung yet

dossiers=14 cells_joined=4 no_matrix_row=10 (sum 14) gates_recorded=0 gates_unrecorded=0 no_gate_declared=4 (sum 4 of cells_joined) evgates=UNSTAMPED

Capability comparisons

Compare the field, search individual capabilities and open their source and adoption evidence. Documented presence does not establish comparative quality.

Position map — centrality and distinctiveness

The four-quadrant map the field uses for brand strategy (Dawar and Bagga, HBR June 2015), re-derived from this matrix on every publish. Centrality is the share of the category's feature mass a player covers, each feature weighted by how many hold it; distinctiveness is the average lead over each rival on the rows the player holds; breadth is the depth-weighted share of the whole matrix (the bubble); depth is how deeply the rows held are held; momentum is the day-over-day move off the spine (green rising, red falling, grey until day two); the dashed path runs first day → previous day → today. Dividers are the category means. Axes are fitted to the field of play, so read the tick numerals, not the frame. Rival marks are documented presence, so a rival's position reads the record, never its quality. The picture grades its own readability below; the table beside it is the same data for a screen reader or a second method.

Rows. 12 feature rows mapped of 12 matrix rows; 0 substrate rows (kernels, bounds and instruments the plan's rungrole marks substrate) are the estate's scaffolding, not category features, and stay off the map

Views. 2D cut: centrality, distinctiveness · 3D cube: centrality, distinctiveness, breadth · axes registered: centrality, distinctiveness, breadth, depth, momentum · a board picks its own in knowledge/compare/folkgames.cdmap (cut|x|y, cube|x|y|z); absent = the HBR defaults

bubble area = breadth · ring = momentum (green rising, red falling, grey until day two) · dashed = category means · axes fitted to the field of play: centrality 200–1000, distinctiveness 200–500 of 0–1000 permil (the full range put every player in one corner)
readability of the 2D cut, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 0 (a fact of the data: two players that close are that close) · data spread 726 permil of the plot · quadrant words unseated 0
text contrast, measured with wcag2-ratio (floors from contrast.conf), light theme: labels 16.24 (floor 4.50) · notes 16.24 (floor 4.50) · quadrant words 5.89 (floor 4.50) · tick numerals 5.89 (floor 4.50) · axis titles 5.59 (floor 4.50) · dark theme: labels 13.78 (floor 4.50) · quadrant words 5.55 (floor 4.50) · axis titles 5.97 (floor 4.50) · dark classes under their floor 0 (one figure serves both themes: a dark shortfall is a token to fix, never a class to hide) · classes refused under their floor 0 (a refused class is not drawn; the scale classes are measured, never hidden) · export: SVG PNG (receipt, rendered by the estate's own rasteriser from this page)

axes fitted: centrality 200–1000 · distinctiveness 200–500 · breadth 200–900 permil · farther bubbles are painted first, nearer ones over them · the floor shadow is each bubble's (x, y) at height 0
readability of the 3D cube, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 1 (a fact of the data: two players that close are that close) · data spread 396 permil of the plot

Nishi Ludii OpenSpiel Fairy-Stockfish boardgame.io
10 panels over 5 registered axes, every pair once (the lower axis on x, the higher on y) · each panel fitted to its own field of play, first and last tick numerals shown · no labels in a small cut, the legend names the colours; the grade below reports the mark terms only (MM summed over the panels, spread averaged)
readability of the small multiples, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 2 (a fact of the data: two players that close are that close) · data spread 557 permil of the plot

Player	Quadrant	centrality	distinctiveness	breadth	depth	momentum	Rows held	Days on spine	First seen
Nishi	Mainstream	902	241	555	666	0 since 2026-09-23	10	10	2026-09-15
Ludii	Aspirational	878	466	777	933	0 since 2026-09-23	10	10	2026-09-15
OpenSpiel	Mainstream	829	314	611	814	0 since 2026-09-23	9	10	2026-09-15
Fairy-Stockfish	Peripheral	731	260	472	708	0 since 2026-09-23	8	10	2026-09-15
boardgame.io	Unconventional	341	416	305	916	0 since 2026-09-23	4	10	2026-09-15

Day	Matrix rows reviewed	Players recorded
2026-09-15	12	5
2026-09-16	12	5
2026-09-17	12	5
2026-09-18	12	5
2026-09-19	12	5
2026-09-20	12	5
2026-09-21	12	5
2026-09-22	12	5
2026-09-23	12	5
2026-10-08	12	5

How to read this evidence. A Nishi source mark records whether the named symbol is declared in the selected source file. It does not establish working behavior or accepted delivery. A watching tag names an expected source entry; discovering it updates source coverage only. A dark tag means the file exists but the named symbol was not found: inspect the source and contract before assuming the capability is missing or renaming code. Peer codes are authored assessments; unassessed means no comparison is established, not absence. Qualification, deployment identity, runtime observations and acceptance must carry their own evidence. Adoption records the catalog's observed path through source, build, promotion, registration and invocation; libraries use importer evidence and gates use declared execution surfaces. A full catalog path does not establish quality, freshness or a successful user outcome. Partial and unknown states retain their stated next action. Census stamps: importers asof 1790637268, gate census asof 1790104131 (unix seconds; -1 = census absent).

Capability matrix — measured against source

◉ authored stronger claim; source present● present◐ partial○ absent? unassessed; excluded from relative comparison · click any capability for its evidence

Peer cell coverage: authored assessed 48, unassessed 0. Authored assessments are not verified outcomes.

Capability	Nishi	Ludii	OpenSpiel	Fairy-Stockfish	boardgame.io
RULES ARE DATA: a game is a ludeme spec parsed into a board graph, never an organ per game Measured: `fg_parse` exists in `runtime/nx_folkgame_lib.nx`, verified at emit. Ludii is a general game system whose games are described in ludemes rather than coded [ludii-readme] and leads here. OpenSpiel implements each game as code and publishes a per-game tested status rather than a rule description [openspiel-games]. Fairy-Stockfish is partly data-driven through its variants.ini user-defined variant file but only within a chess-shaped board [fairysf-readme]. boardgame.io asks you to write JavaScript functions describing how state changes on a move [bgio-readme], which is code per game. Ours parses a spec into a graph plus a line set. Adoption: `LIB-WIRED importers=7 nonval=6` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of OpenSpiel, Fairy-Stockfish, boardgame.io; fully adopted on the estate ladderCons behind Ludii (leads)	●	◉	○	◐	○
LICENCE
whether a rival corpus may be shipped, run, or redistributed by us at all Measured: `fg_parse_named` exists in `runtime/nx_folkgame_lib.nx`, verified at emit. THE POSTURE, STATED ONCE AND TRUE OF EVERY ROW ON THIS BOARD: no third-party game corpus is imported, executed, linked or redistributed by this estate, and every spec we ship was authored from the public-domain rules themselves. Ludii is Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 [ludii-readme] [ludii-license]. NonCommercial reaches USE, not merely shipping, so we do not run it -- not as a bundled dependency and not as a private test oracle either. NoDerivatives plus NonCommercial reach REDISTRIBUTION, so its files are cited by URL and are the only rival documents on this board that we do not mirror. OpenSpiel is Apache 2.0 [openspiel-license] and boardgame.io is MIT [bgio-license], both permissive and both mirrored. Fairy-Stockfish is GPL-3 [fairysf-license]: usable and redistributable, but copyleft, so it may only ever run as a SEPARATE PROCESS in the build lane and must never be linked into a served artifact. Ours is original NishiLang at license_tier ORIGINAL. Adoption: `LIB-WIRED importers=7 nonval=6` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of Ludii; fully adopted on the estate ladderCons behind OpenSpiel (leads), boardgame.io (leads)	●	○	◉	●	◉
SCOPE
how many distinct game families the system spans Measured: `fg_moves` exists in `runtime/nx_folkgame_lib.nx`, verified at emit. Ludii is a general game system by construction [ludii-readme]. OpenSpiel spans a broad hand-coded set including Backgammon at its thoroughly-tested grade and an m,n,k-game covering the align family at its lightly-tested grade [openspiel-games]. Fairy-Stockfish is chess variants only, by its own README [fairysf-readme]. boardgame.io is any turn-based game but you implement each one [bgio-readme]. Ours declares eleven families of which one is live. Adoption: `LIB-WIRED importers=7 nonval=6` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of Fairy-Stockfish; fully adopted on the estate ladderCons behind Ludii (leads)	●	◉	●	○	●
COVERAGE
the population of games is declared as data so total coverage is measurable Measured: `fga_games` exists in `runtime/nx_folkgame_align_gate.nx`, verified at emit. OpenSpiel publishes its population WITH a per-game status of thoroughly-tested, lightly-tested or known-issues [openspiel-games], which is the practice worth copying and the reason this board carries a registry rather than a headline. Ludii ships its corpus as the declaration [ludii-readme]. Fairy-Stockfish lists its variants in its README [fairysf-readme]. boardgame.io is a framework and ships no game corpus at all [bgio-readme]. Ours is 117 rows with the family engine named per row. Adoption: `GATE:LIVE trial=GREEN` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of boardgame.io; fully adopted on the estate ladderCons behind Ludii (leads), OpenSpiel (leads)	●	◉	◉	●	○
GENERATED RULE SETS: a line set stated as a rule and expanded, never enumerated by hand Measured: `fg_fill_gridlines` exists in `runtime/nx_folkgame_lib.nx`, verified at emit. A 15 by 15 five-in-a-row board carries 572 lines and a 6 by 5 three-in-a-row board carries 38 orthogonal or 62 with diagonals. Ours states the rule once and expands it, and the gate counts one board both ways so a mode that was silently ignored fails. Ludii composes rules from ludemes [ludii-readme]. OpenSpiel and Fairy-Stockfish are PART: each parameterises one family -- the m,n,k-game [openspiel-games] and variants.ini [fairysf-readme] -- rather than generating rule sets generally. boardgame.io has no such layer [bgio-readme]. Adoption: `LIB-WIRED importers=7 nonval=6` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of OpenSpiel, Fairy-Stockfish, boardgame.io; fully adopted on the estate ladderCons behind Ludii (leads)	●	◉	◐	◐	○
REFUSAL
a malformed rule set is refused by name rather than silently ignored Measured: `fg_keyis` exists in `runtime/nx_folkgame_lib.nx`, verified at emit. Ours refuses an unknown spec key, a game with no line and a line shorter than its declared run, each by name, and three negative controls prove it. THE RIVAL CELLS HERE ARE INDEX-LEVEL AND NOT WITNESSED BEHAVIOUR: Ludii and Fairy-Stockfish are coded 1 because each parses a declared game description language [ludii-readme] [fairysf-readme] and a parser necessarily rejects some input, while OpenSpiel and boardgame.io are coded 0 because a game is code there [openspiel-games] [bgio-readme] so a malformed game is a compile or runtime error rather than a named rule refusal. None of these four was observed refusing anything. Adoption: `LIB-WIRED importers=7 nonval=6` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of OpenSpiel, boardgame.io; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	○	●	○
CHESS family
one piece-movement vocabulary over a board with palaces, rivers and drops DARK — `runtime/nx_folkgame_lib.nx` EXISTS but does not declare `fgc_move`: something shipped at this path under another name, and this mark would read open forever. Repoint the contract to the real entry point (the plan rung AND this row) or rename the function; the flip follows on the next beat, and the `comparewatch-` plane row reads DARK until then. Chess, Shatranj, Chaturanga, Xiangqi, Janggi, Shogi, Makruk and Minixiangqi are eight registry rows over one movement vocabulary. Fairy-Stockfish leads and is the intended perft oracle for this family, supporting Xiangqi, Shogi, Janggi and Makruk plus user-defined variants [fairysf-readme]. Ludii covers it as a general system [ludii-readme]; OpenSpiel carries chess and variants as coded games [openspiel-games]; boardgame.io ships no chess [bgio-readme]. dossierwatching fgc_move Pros none measured yetCons behind Ludii (leads), OpenSpiel, Fairy-Stockfish (leads); open contract; expected source declaration not established	○	◉	●	◉	○
RACE family
a track, a randomiser, entry and bearing off, hitting and blocking Measured: `fgr_moves` exists in `runtime/nx_folkgame_race_lib.nx`, verified at emit. TRACK SUB-FAMILY LANDED 2026-08-27, gate 14 of 14. Backgammon and Nard play from spec data, differing in exactly one flag. PROVEN AGAINST A PUBLISHED CONSTANT AND CHECKED FROM BOTH ENDS: the opening position is 167 pips per side, and BOTH players are asserted on it, because one side alone would still read 167 under a reversed direction or an off-by-one in the indexing. Checkers conserved across 128 plies of a played-out race, and the seeded randomiser lives inside the saved position so a replay reproduces the die that follows it -- proven by a same-seed match AND a different-seed divergence, so a die ignoring its seed cannot pass. SCOPE STATED, NOT IMPLIED: this reaches the eight linear-track games of the twenty-two. The cross-and-circle boards (Pachisi, Ludo, Yut Nori, Patolli) and the spiral and ladder boards (Goose, Snakes and Ladders) are separate rungs, and a family row that let those be read as covered would be the claim this board exists to prevent. OpenSpiel carries Backgammon at its thoroughly-tested grade and is the oracle for the modern end [openspiel-games]. Fairy-Stockfish has no race games [fairysf-readme] and boardgame.io ships none [bgio-readme]. Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separate; ahead of Fairy-Stockfish, boardgame.ioCons behind Ludii (leads), OpenSpiel (leads); not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	◉	◉	○	○
SOW family
mancala as pits, seeds, laps and capture Measured: `fgs_sow` exists in `runtime/nx_folkgame_sow_lib.nx`, verified at emit. LANDED 2026-08-27, gate 12 of 12. Oware, Kalah, Congkak and Pallanguzhi play from spec data on one engine: sowing that skips the opponent's store, multi-lap relay with a ceiling DERIVED from the position so a cyclic spec cannot hang it, Oware's count-capture with its backward walk, Kalah's empty-pit capture and its extra-turn-on-own-store, and Oware's feeding rule which may never forbid every move. PROVEN BY AN EXHAUSTIVE INVARIANT, NOT A PUBLISHED COUNT: seeds are conserved at all 33798 positions of the Oware tree to depth six, zero violations, and the checker is proven able to fail. THE HONEST GAP IS NAMED: unlike the align family's 255168 there is no cheap published constant here -- Oware was solved across 889 billion positions -- so conservation proves the arithmetic and NOT that the capture rules match Oware as played. OpenSpiel grades its own Oware THOROUGHLY-TESTED [openspiel-games] and cross-checking against it is the open rung. Ludii covers mancala as a general system [ludii-readme]; neither Fairy-Stockfish nor boardgame.io has any [fairysf-readme] [bgio-readme]. Bao and the four-row boards remain: their multi-lap rules are the hard case. Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. dossiernot adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separate; ahead of Fairy-Stockfish, boardgame.ioCons behind Ludii (leads), OpenSpiel (leads); not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	◉	◉	○	○
OPPONENT
a bot that can actually play the game Measured: `fgai_search` exists in `runtime/nx_folkgame_ai_lib.nx`, verified at emit. LANDED 2026-08-25 and still LAST of five, which is why the cells are unchanged. Alpha-beta negamax over the same generator the gate validated, with depth and weights as conf rows. Proven by an external constant rather than self-graded: playing ITSELF at full depth it draws Tic-Tac-Toe, the published perfect-play result, and a mutation bite of this very file was KILLED so the tooth is not vacuous. Honest limits: the evaluation is material only, there is no repetition detection, and the Morris depth is a strength dial not a solve. Ludii ships an AI module [ludii-readme]; OpenSpiel exists to build agents [openspiel-games]; Fairy-Stockfish is a Stockfish derivative and strong by construction [fairysf-readme]; boardgame.io generates bots automatically [bgio-readme] [bgio-npm]. All four are ahead. Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder). dossier Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons behind Ludii (leads), OpenSpiel (leads), Fairy-Stockfish (leads), boardgame.io (leads)	●	◉	◉	◉	◉
PLAYABLE NATIVELY: a binary from our own toolchain that a person can sit down and play Measured: `fgp_render` exists in `runtime/nx_folkgame_play.nx`, verified at emit. The operator's standing correction is the reason this row exists: an internal GREEN gate is not a thing anyone can open and play. nx_folkgame_play is a NATIVE x86 binary from nx_cc and nxasm_x86 with no gcc, no WebAssembly, no browser and no borrowed VM in the path -- it renders the board from the (x,y) each cell carries, takes cell ids, and plays the alpha-beta opponent. Fairy-Stockfish leads: a native engine binary is exactly what it is [fairysf-readme]. Ludii is a playable Java desktop application, so it counts, but it requires a JDK [ludii-readme]. OpenSpiel is a research library you drive from Python [openspiel-games]. boardgame.io is browser-only and ships no native binary [bgio-readme]. Adoption: `REGISTERED-DARK` — PARTIAL: callable, authorised, completed MCP invocation not established by supplied journal window; lifetime history unknown (direct execution may be recorded elsewhere; this scan does not establish lifetime use); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked). not adopted: callable, authorised, completed MCP invocation not established by supplied journal window; lifetime history unknown (direct execution may be recorded elsewhere; this scan does not establish lifetime use); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked) Pros Implementing source symbol found; runtime acceptance separate; ahead of boardgame.ioCons behind Fairy-Stockfish (leads); not adopted yet: callable, authorised, completed MCP invocation not established by supplied journal window; lifetime history unknown (direct execution may be recorded elsewhere; this scan does not establish lifetime use); no execution surface runs it either (clock, cron, daemon, roster, actlog and surfaced forks checked)	●	●	●	◉	○
PLAYABLE IN A BROWSER: a served page per game with no plugin and no account DARK — `runtime/nx_folkgame_lib.nx` EXISTS but does not declare `fge_emit`: something shipped at this path under another name, and this mark would read open forever. Repoint the contract to the real entry point (the plan rung AND this row) or rename the function; the flip follows on the next beat, and the `comparewatch-` plane row reads DARK until then. boardgame.io leads outright: it is an engine for turn-based games in JavaScript with multiplayer and a lobby [bgio-readme]. Ludii is a Java desktop application requiring a JDK [ludii-readme]. OpenSpiel is a C++ and Python research library [openspiel-games]. Fairy-Stockfish is coded 0 from the mirrored README, which describes UCI, UCCI, USI and CECP protocols for desktop GUIs and does not witness a browser build [fairysf-readme] -- that is the limit of the evidence held, not a claim that none exists. Ours is the open contract: seven games are green and none is served. dossierwatching fge_emit Pros none measured yetCons behind boardgame.io (leads); open contract; expected source declaration not established	○	○	○	○	◉

Rival-claim provenance. Every Yes, Best or Part mark in a rival column is a claim about someone else's product. A cited row carries a reference mark that resolves to a pinned mirror (the refs gate measures that); an uncited row is an observation read and is badged in its evidence until a reference lands. The badge is the receipt, never the proof: a mark proves a mirror exists, not that the mirror supports the code. The rows are counted below.

Rival claims, counted
Class	Count	Note
rows with rival marks	12	rows carrying a Yes, Best or Part in a rival column
cited	12	a reference mark resolves to a pinned mirror
uncited	0	an observation read, badged until a reference lands
rows, summed	12	RECONCILED: the parts sum to the total 12

Delivery and evidence

Inspect risks, technical debt, rendered observations, experiments and references. Read scope and limitations alongside every result.

Risk register

Risk	Likelihood x impact	Mitigation
A family engine is declared done when its spec parses rather than when its rules are right	certain x high	Every family gate must carry at least one EXTERNAL constant or external-engine agreement, the way the align family carries 255168. A gate whose only teeth are shape checks is not a proof and the plan names the oracle per rung.
The registry count is read as coverage	likely x high	The registry declares 117 games and the census reports played versus declared. The board prints both and never the population alone; seven of 117 is the honest number today.
Borrowed rules leak into shipped data	possible x high	Ludii is BY-NC-ND [ludii-license] and Fairy-Stockfish is GPL-3 [fairysf-license]. Both are separate-process referees in the build lane only. No third-party corpus is imported and every spec here is authored from the public-domain rules.
A trademarked name ships as a product name	possible x medium	The registry carries a name_status column: three rows are tm-risk and three tm-elsewhere. Yahtzee ships as Yacht and Generala, Battleship as Salvo, Barricade as Blocker. The emitter reads the title from the registry so a rename is data.
An opponent search saturates the box	likely x medium	FG11 budgets are conf rows admitted through the estate load governor, which already refused a build during this session and is the same control. A game that cannot get admission degrades to a weaker opponent and says so rather than queueing.

On these two registers. Rows are declared in the domain's plan file and carry the debt id, which is the join key back to the sovereign debt plane — that plane, not this page, is the authority on state. Reconciling them automatically (the regen reading the plane and refreshing these rows) is a named, owed rung; until it lands, treat an id here as a pointer to look up, not a status to trust.

Honest verdict. The engineering claim is small and true: two families of eleven are shipped and twelve of the 117 games play, adding Dara cost one optional spec field rather than an organ, and Twelve Mens Morris cost three lines of alias rather than a copied board. The two families are deliberately proven to DIFFERENT standards, and that difference is the most useful thing on this board: align is checked against a constant nobody here chose, sow against an invariant that arithmetic forces, because no cheap published count exists for a mancala. A green is only as strong as what produced it and each row says which it holds. The load-bearing result is not a feature, it is a LICENCE finding -- Ludii, the only corpus in the world that has already encoded a thousand traditional games, is CC BY-NC-ND, and NonCommercial reaches use and not merely shipping, so a commercial estate can neither bundle it nor quietly run it as a test oracle, and NoDerivatives means we do not redistribute its files either. Fairy-Stockfish is GPL, so it may only ever run as a separate process and never be linked. That makes an original sovereign implementation the only lawful route to this capability rather than a stylistic preference, and it is why the remaining ten families are build contracts and not an import job. Nothing third-party is imported, executed, linked or redistributed here; every spec was authored from the public-domain rules themselves. The honest gap is the whole right-hand side of the board: no opponent and no served page yet, where boardgame.io ships both.

Person · product · place — not yet measured for this domain

Every compare carries this layer. Declare knowledge/compare/folkgames.ppp (rows surface|nishi or c1..c4|label|url|connect naming OUR live surface and each rival's front door), run nx_ppp_probe domain folkgames, and this section fills itself on the next beat: the same ruler on both sides — privacy and CX (third-party hosts, tracker classes, cookies, security headers), design and longevity (design hygiene, computed WCAG contrast, render-blocking resources, unsized media, script weight, theme and motion queries), findability (landmarks, skip link, on-site search, breadcrumb, headings, internal links).

The field — discovered, not chosen

Rows written by nx_field_discover from folkgames.seeds: the industry's own lists (Wikipedia wikitext, GitHub topics, awesome lists) read mechanically, every candidate counted across seeds. The matrix columns above are a SEAT'S pick; this band is the population they were picked from, and the stats line measures one against the other. A rival here is a lead, never a verdict — it earns a column when its capabilities are read and pinned.

Discovery receipt. One row per counter the run wrote, in the receipt's own order; the rival rows follow in their own table.

Field discovery, counted
Class	Count	Note
seeds	3
scanned	3
fetched	3
reused	0
failed	0
named	3
candidates	3
mentions	3
capped	0

Rank	Rival	Seeds	Mentions	First seed	Kind	Link
1	Ludii	1	1	col0-ludii	named	https://raw.githubusercontent.com/Ludeme/Ludii/master/README.md
2	Fairy-Stockfish	1	1	col2-fairy	named	https://raw.githubusercontent.com/fairy-stockfish/Fairy-Stockfish/master/README.md
3	boardgame.io	1	1	col3-boardgame	named	https://raw.githubusercontent.com/boardgameio/boardgame.io/main/README.md

Exclusive and shared capabilities

One capability is graded on one board; every other board references it. The fleet duplicate census (nx_rivalcensus dupes, on the fleetdupes clock row) reads every board's matrix and names each capability graded as a row on two or more boards, with a home derived from evidence: rung when exactly one board's plan contracts the symbol (that board is starred), gates when no plan contracts it and exactly one board's executed gate map runs the organ's gate (that board is plussed), ambiguous when several boards carry the deciding evidence (a decision for their seats), and none when no evidence decides it, with the reason beside it: unmapped (no board of the duplicate declares a gates map; declare the maps) or unproven (a map exists and runs none of the organ's gates; gate the organ on its proving board, or declare it a shared library by policy). A home elsewhere means this board should carry an @xrow reference to the home board's row rather than a graded row of its own; a home here means the other boards should. The table is this board's slice of one estate-wide census: the shape is shared, the rows are the board's.

This board grades 12 capabilities: 12 exclusive to it and 0 shared with other boards. Shared rows on this page: 0 = home here 0 + home elsewhere 0 + ambiguous 0 + undecided 0 + refused 0 (partition 0); undecided = unmapped 0 + unproven 0 + unevidenced 0; homonyms 0; since the previous census: new 0, resolved 0. Census FRESH age_s=6942.

Gaps from the record — what the estate does that no board carries

The record census (nx_goalmap record) reads the invoked-tool population and every plan queue row and files each organ or directive that NO matrix, plan or gates row names. A row here is a callout the boards missed: adjudicate it onto a board or declare it infrastructure. Census state STALE (age 1396047 s), sources read 4 of 7 declared — a BLIND census is a FLOOR: unread sources can only add rows.

kind	name	board	source	evidence

rows shown 0|this board's directives 0|estate-wide un-boarded organs 452 (listed in full on /compare/ecosystem)|census rows 639|malformed 0 (counted, never rendered)

References

Beyond a link list. Every reference below resolves twice — the publisher's copy and, where banked, the estate's own non-rottable library mirror with a content pin — and carries its evidence class plus the exact claim on this page it grounds. Keyed marks like [key] in the matrix notes jump here. A dash means honestly absent, never assumed.

[ludii-readme] The Ludii General Game System README, Cameron Browne and the ERC Digital Ludeme Project, read live 2026-08-25 and deliberately not mirrored publisher · accessed 2026-08-25 · source-readGrounds: RULES ARE DATA: a game is a ludeme spec parsed into a board graph, never an organ per game
[ludii-license] Ludii licence file read live 2026-08-25: Creative Commons Attribution-NonCommercial-NoDerivatives 4.0, and deliberately not mirrored because redistribution is the condition it restricts publisher · accessed 2026-08-25 · source-readGrounds: LICENCE: whether a rival corpus may be shipped, run, or redistributed by us at all
[openspiel-games] OpenSpiel available-games table with a per-game tested status publisher · read in our library knowledge/fetched/cmp_folkgames_openspiel_games.md · pin h3dc5fc789986817f0dc1f9fd3ca6f47aaa82bc9942a1ba7bd3dfd7c65a843578 · accessed 2026-08-25 · source-readGrounds: RULES ARE DATA: a game is a ludeme spec parsed into a board graph, never an organ per game
[openspiel-license] OpenSpiel licence file: Apache License Version 2.0 publisher · read in our library knowledge/fetched/cmp_folkgames_openspiel_license.txt · pin hcfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30 · accessed 2026-08-25 · source-readGrounds: LICENCE: whether a rival corpus may be shipped, run, or redistributed by us at all
[fairysf-readme] Fairy-Stockfish README naming its regional variants and its variants.ini configuration publisher · read in our library knowledge/fetched/cmp_folkgames_fairysf_readme.md · pin h5332b6c7cfb8a8983536ddcdc4a6dddf3b9a79ad5f2be07e44fbbd4d59653e2a · accessed 2026-08-25 · source-readGrounds: SCOPE: how many distinct game families the system spans
[fairysf-license] Fairy-Stockfish Copying.txt: GNU General Public License Version 3 publisher · read in our library knowledge/fetched/cmp_folkgames_fairysf_license.txt · pin h0b383d5a63da644f628d99c33976ea6487ed89aaa59f0b3257992deac1171e6b · accessed 2026-08-25 · source-readGrounds: LICENCE: whether a rival corpus may be shipped, run, or redistributed by us at all
[bgio-readme] boardgame.io README: an engine for creating turn-based games in JavaScript, listing multiplayer, lobby, automatically generated bots and time-travel logs publisher · read in our library knowledge/fetched/cmp_folkgames_bgio_readme.md · pin h9ef0a43068674b595d8406da3e277ce0550ef9c39640fbb4a018d51cea1bffae · accessed 2026-08-25 · source-readGrounds: PLAYABLE IN A BROWSER: a served page per game with no plugin and no account
[bgio-license] boardgame.io licence file: MIT License publisher · read in our library knowledge/fetched/cmp_folkgames_bgio_license.txt · pin h516bc5dc1560ba43d2097b5f9b4029a23d073ac7feaa94979ac011f4f959620c · accessed 2026-08-25 · source-readGrounds: LICENCE: whether a rival corpus may be shipped, run, or redistributed by us at all
[bgio-npm] boardgame.io npm latest registry entry, read live for the pinned version publisher · read in our library knowledge/fetched/cmp_folkgames_bgio_npm.json · pin hd820f16dc35c0a755a11491a1a3b5b2710a57008c10909c4462fe77cf647ec68 · accessed 2026-08-25 · mirrored-indexGrounds: OPPONENT: a bot that can actually play the game

generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/folkgames.matrix · source checks show implementation presence; runtime and user-outcome evidence are reported separately · JavaScript supports page controls