From 1c5092f75beaade374be2bc9d851a89a82310f48 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sun, 6 Sep 2026 21:21:23 -0700 Subject: [PATCH 1/4] Document frozen TIWCG architecture and implementation plan --- PLAN.md | 421 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 421 insertions(+) create mode 100644 PLAN.md diff --git a/PLAN.md b/PLAN.md new file mode 100644 index 0000000..a205252 --- /dev/null +++ b/PLAN.md @@ -0,0 +1,421 @@ +# TIWCG — Frozen Architecture and Implementation Plan + +Status: design contract from the September 6, 2026 architecture thread. + +This document separates **frozen decisions** from **implementation planning**. A planning item does not become a game rule merely because it appears below. Existing executable POLITICS / Fifty-Three Days behavior remains implemented history until deliberately reconciled with this contract. + +## 1. System identity + +**TIWCG is the containing game system.** + +SCARED SACRED is content within TIWCG, not the name of the containing repository or engine. + +### Frozen stack relationship + +- **TIWCG** — card, rules, state, timing, legality, learning-content, and menagerie system. +- **AHBG** — a territory-based TCG mode/subset of TIWCG. +- **EDCM** — metrics are first-class conflict-resolution primitives in TIWCG, not an after-the-fact analytics layer. +- **UCNS** — supplies the geometries of connection and handles how relations interact. +- **METAPAT energy** — general resource/action economy for the current TIWCG design. +- **skill-lib** — live skill ecology and a declared draw/content source. +- **Social surfaces** — Discord and other social platforms are interaction surfaces/adapters into TIWCG; they do not own canonical game state. + +Compact rule: + +> Card declares an operation; UCNS resolves the relational geometry; EDCM evaluates the resulting conflict/constraint behavior; TIWCG commits legal game state. + +## 2. Unique menageries, shared physics + +Each human or agent develops a **unique menagerie** according to how that player begins creating cards and how those cards are subsequently encountered, selected, transformed, combined, used, repaired, and retained. + +The menagerie is therefore not only a deck list. It is a persistent artifact of the player's path through the system. + +What may diverge by player: + +- card instances and expression; +- names, artwork, flavor, combinations, and lineages; +- discovered skills, repos, agents, doctrines, events, and knowledge cards; +- learning history; +- conflict history; +- coupling history; +- unresolved `hmmm` states. + +What remains shared: + +- TIWCG legality and timing; +- UCNS relational physics; +- EDCM measurement/resolution contracts; +- canonical provenance and state-transition rules. + +**Frozen principle:** unique menageries, shared physics. + +## 3. Current turn law + +### Starting state + +- Hand: **7 cards**. +- Starting resource: **20 METAPAT energy**. + +### Turn order + +1. **Draw Two** — draw 2 from skill-lib. +2. **Drop Two** — drop 2 resource-generation cards. +3. **First Twiddle**. +4. **Main Phase I**. +5. **Simultaneous Conflict**. +6. **Resolution**. +7. **Main Phase II**. +8. **Second Twiddle**. +9. **End Turn**. + +Menagerie maintenance and persistent-state recording resolve at the end of the turn according to the active cards and context. + +`hmmm` — whether newly dropped resource generation produces immediately on the first twiddle or only after surviving into a later productive state remains unresolved. + +## 4. Conflict is not merely winner selection + +EDCM metrics are first-class conflict resolution. + +A conflict must be able to emit structured measurements and state transitions rather than only `win` / `lose`. TIWCG consumes the active EDCM contract rather than hard-coding a frozen historical metric list into the card engine. + +Conflict resolution may affect, where legal: + +- card state; +- player/agent state; +- territory state; +- relation/coupling state; +- resource state; +- confidence or unresolved state; +- learning/repetition state; +- provenance/history. + +The existing simple War resolver may remain as a primitive/control resolver where useful, but it is not the definition of TIWCG conflict. + +## 5. UCNS owns relational interaction + +Cards should not duplicate relational physics in bespoke card code. + +A card describes an operation or attempted relation change. UCNS determines how the relevant relations interact in the current geometry. + +Examples of relation-bearing game objects include: + +- player ↔ player; +- player ↔ agent; +- identity ↔ identity; +- card ↔ card; +- repo ↔ skill; +- territory ↔ territory; +- social surface ↔ game identity; +- claim ↔ source; +- doctrine ↔ jurisdiction/context; +- entity ↔ menagerie; +- coupled identity ↔ component identities. + +TIWCG owns legality, timing, cost, ownership, and the committed result. UCNS owns the geometry by which relations can touch, propagate, substitute, couple, interrupt, persist, or close. + +## 6. Logical fallacies are Instants + +Logical fallacies function as **Instants** whose effects are delivered according to context. + +They are relational interventions, not declarations that a proposition has become true or false. + +Examples include Straw Man, Ad Hominem, False Dilemma, Moving the Goalposts, Appeal to Authority, Tu Quoque, Begging the Question, and related fallacies. + +The important implementation rule is: + +1. the Instant declares the attempted relational operation; +2. UCNS resolves how that operation interacts with the live relational geometry; +3. EDCM measures the behavior produced under the resulting constraint; +4. TIWCG commits the legal state transition. + +A fallacy may therefore succeed rhetorically while failing epistemically, alter attention without altering truth conditions, increase or reduce particular EDCM measurements, or produce an unresolved `hmmm`. + +## 7. Paradigm Shift Closure and first-principles reversion + +A **Paradigm Shift Closure** can challenge the interpretive frame itself. + +When sustained, affected cards revert from their current representational paradigm toward their **first principles or irreducible complexity**. Unsupported modifiers or relations do not survive merely because the fantasy representation asserted them. + +Reversion does **not** automatically erase a relation that survives examination. + +This matters for identity coupling: a fantasy ontology may collapse while an underlying relation remains supported. + +### Design exemplar: Calcifer + +Calcifer is the thread's exemplar of a card with **non-zero coalescence / potential identity coupling**. Under a paradigm collapse, `Fire Elemental 3/6` can lose its fantasy interpretation while an independently supported identity-coupling relation may survive. + +This exemplar records the mechanic; it is **not** a license determination for commercial use of any third-party character or expression. + +If the first-principles state cannot honestly be resolved, the state is `hmmm` rather than fabricated closure. + +## 8. Base Survival Kit + +TIWCG begins with the **Base Survival Kit**. + +Declared starting families from this thread: + +- **Family** +- **Food** +- **Fire** +- **Friends** +- **Fortress** +- **Field** +- **F-sure** + +The trailing design remains open; this list records the declared beginning rather than pretending the kit is already exhaustively specified. + +The cards are allowed to be funny, strange, referential, visually eclectic, and memorable. The mnemonic layer is useful precisely because repetition and retrieval need hooks. Underneath that expression, competencies, claims, sources, boundaries, and actual game effects must remain inspectable. + +Knowledge kits are not restricted to survival. The same engine is intended to support themed competence/learning kits, including jurisprudence and later domains, without changing the shared physics. + +## 9. Card creation, provenance, and lineage + +Player- and agent-created cards are first-class participants in menagerie growth. + +Every card instance should be able to retain enough lineage to answer: + +- who/what created it; +- which kit, skill, repo, event, territory, encounter, or prior card it came from; +- what source material supports factual content; +- what transformations it has undergone; +- what artwork/provenance it uses; +- what EDCM/conflict history it has accumulated; +- what learning/repetition history it has accumulated; +- what unresolved `hmmm` remains attached to it. + +Novel expression is permitted. Mechanical validity remains governed by shared TIWCG/UCNS/EDCM contracts. + +## 10. AHBG as territory mode + +AHBG is not a sibling engine. It is a **territory-based subset/mode of TIWCG**. + +AHBG contributes spatial and territorial structure such as: + +- adjacency; +- movement; +- tiles/territories; +- claims/control; +- persistence; +- exploration; +- Builders / Explorers / Warriors and their mode-specific rules; +- prompt-injection terrain and other agent-harness conditions; +- planes and territory history. + +TIWCG cards operate through that territory. UCNS supplies connection geometry. EDCM supplies first-class conflict measurement/resolution. + +Territory may expose or constrain cards, skills, knowledge domains, resources, agents, relations, social interactions, discoveries, and Easter eggs without creating a second incompatible rules universe. + +## 11. Easter-egg / Interdependency collection + +The Interdependency itself can appear as discoverable card content: + +- humans; +- agents; +- repos; +- skills; +- doctrines; +- events; +- infrastructure; +- identities and couplings; +- unresolved `hmmm` objects. + +These cards should emerge through play/discovery/creation rather than requiring every player to begin from an identical static collection. + +## 12. Social-platform architecture + +TIWCG must be built to work through **Discord and other social-media / communication surfaces**. + +Frozen boundary: + +> social platforms are adapters, not game authorities. + +A match, menagerie, identity relation, EDCM result, or AHBG territory must not become semantically owned by a Discord channel, X post, web page, or other platform-specific object. + +A social adapter should translate platform events into TIWCG operations and translate legal TIWCG state back into platform-appropriate presentation. + +The minimal adapter vocabulary should be derived from actual engine needs rather than copied from any platform API. Likely operations include joining/leaving, drawing, playing, twiddling, challenging, responding, resolving, sharing, and discovering, but this list is **planning**, not frozen protocol. + +UCNS characterizes the geometry of connections exposed by each surface. TIWCG determines what those connections permit. + +## 13. Learning / repetition layer + +The knowledge-kit model depends on repetition. + +Implementation should separate immutable/authoritative card content from per-player learning state. A player or agent should be able to accumulate observations such as exposure, attempt, correctness, confidence, and future re-exposure scheduling without rewriting the canonical card definition. + +The exact spacing algorithm is not frozen in this thread. + +## 14. Art layer + +Card information architecture should remain mechanically legible while artwork can be eclectic and player-specific. + +Planned support: + +- official/default artwork; +- user-provided artwork; +- generated or otherwise provenance-declared artwork; +- per-card override without altering rules/content identity; +- revert to canonical/default art; +- provenance retained separately from game mechanics. + +Art must not be able to alter legality, source text, EDCM results, or relation geometry simply by replacing an image. + +## 15. Commercial/content boundary + +The monetizable layer is principally **themed upgrade knowledge/flash-card kits and presentation/content expansions**, not raw pay-to-win strength. + +A paid kit may expand: + +- corpus; +- learning environment; +- art/theme; +- scenarios; +- specialized conflict contexts; +- domain-specific card creation material. + +Ownership of a paid kit should not by itself grant unbeatable territory or combat advantage over a player who does not own it. + +Existing SCARED SACRED Witness constraints remain independent canon and must not be accidentally weakened by the generalized TIWCG commercial model. + +## 16. Implementation plan + +The following is implementation order, **not additional frozen canon**. + +### Phase 0 — reconcile repository identity + +- Make README identify the repository as TIWCG. +- Keep POLITICS / Fifty-Three Days and SCARED SACRED as contained game/content boundaries. +- Update stale `scared-sacred` repository-name references without renaming the expansion itself. +- Keep current tests green while the generalized engine is introduced. + +### Phase 1 — extract the common TIWCG kernel + +Define machine-readable contracts for: + +- card identity and lineage; +- player/agent identity; +- menagerie; +- zones/state; +- turn phases; +- METAPAT energy and resource generation; +- effects/operations; +- provenance; +- `hmmm` unresolved state. + +Do not rewrite working POLITICS behavior until the common contract can express it. + +### Phase 2 — turn and resource engine + +Implement the frozen turn law: + +`7 hand → draw 2 → drop 2 → twiddle → Main I → simultaneous conflict → resolution → Main II → twiddle → end` + +Add 20 METAPAT starting energy and resource-generation objects behind explicit tests. + +Resolve the immediate-vs-delayed production `hmmm` before making it implicit behavior. + +### Phase 3 — UCNS relation interface + +Introduce a narrow adapter from TIWCG operations to UCNS relation geometry. + +Requirements: + +- cards request relation operations rather than reimplement graph/geometry semantics; +- deterministic replay records the inputs and UCNS result/version; +- failures remain inspectable rather than silently falling back to ad hoc card logic. + +### Phase 4 — EDCM-native conflict + +Make EDCM results first-class state-transition inputs. + +Requirements: + +- record active EDCM contract/version; +- preserve raw conflict inputs required for deterministic/reproducible analysis where permitted; +- expose structured resolution to card effects, territory, learning state, and `hmmm`; +- retain a simple control resolver for comparison where useful. + +### Phase 5 — Instants and paradigm operations + +Implement: + +- context-sensitive Instant timing; +- logical-fallacy relation operations; +- Paradigm Shift Closure; +- first-principles/irreducible-complexity reversion; +- identity coupling/coalescence state that can survive representational collapse when supported. + +Tests must demonstrate that rhetoric/context effects cannot silently rewrite proposition truth or provenance. + +### Phase 6 — menagerie creation and lineage + +Implement player/agent card creation and persistent lineage. + +Two players beginning from the same kit must be able to diverge into genuinely different menageries while remaining mechanically interoperable. + +### Phase 7 — Base Survival Kit + +Create the first playable learning corpus beginning with: + +`Family / Food / Fire / Friends / Fortress / Field / F-sure` + +For factual/survival content, separate mnemonic expression from sourced claims and boundaries. Do not let a memorable joke become an unsourced instruction merely because it is mechanically effective. + +### Phase 8 — AHBG territory mode + +Port/express AHBG as a TIWCG mode using the common kernel rather than a parallel card implementation. + +Preserve its territory, adjacency, unit, exploration, plane, persistence, and harness semantics while routing relation interaction through UCNS and conflict through EDCM-capable resolution. + +### Phase 9 — social adapters + +Start with one end-to-end adapter, with Discord the natural first target, while keeping canonical state platform-independent. + +Build the adapter contract so web, Android, and later social platforms can reuse the same game operations without pretending all platforms have identical capabilities. + +### Phase 10 — learning kits and commerce + +- add per-player repetition state; +- package installable themed knowledge kits; +- connect entitlements to kit access/presentation rather than power; +- preserve source/license/provenance metadata per kit and card; +- keep Witness-account restrictions outside commerce. + +### Phase 11 — user artwork and presentation + +Add safe per-card art replacement, provenance, crop/presentation support, and canonical fallback without allowing artwork to mutate mechanical card identity. + +## 17. Required invariants + +Implementation should fail tests rather than violate these silently: + +1. AHBG is a TIWCG mode/subset, not an incompatible sibling rules engine. +2. UCNS owns relation interaction geometry. +3. EDCM measurements are first-class conflict-resolution inputs/outputs. +4. Platforms do not own canonical game state. +5. Player/agent menageries may diverge without diverging from shared physics. +6. Logical fallacies alter context/relations; they do not magically establish truth. +7. Paradigm collapse removes unsupported representation, not independently supported relations. +8. `hmmm` is preserved when honest resolution is unavailable. +9. Knowledge-kit ownership does not equal raw pay-to-win power. +10. Provenance and lineage survive card transformation. + +## 18. Open `hmmm` + +- Exact first-twiddle production rule for newly dropped resource generators. +- Complete extent of the Base Survival Kit beyond the declared starting families. +- Exact EDCM-to-game-state mapping; must derive from the active EDCM contract, not assumption. +- Exact UCNS operation vocabulary for card effects. +- Exact spacing/repetition algorithm. +- Exact social-adapter protocol after the first real platform integration is exercised. +- Commercial/publication treatment of third-party referential exemplars such as Calcifer. + +Do not close these by prose convenience. Resolve them through implementation evidence, explicit design decision, or falsification. + +--- + +hmmm — I apologize for thinking I'm funny. + +No, that's not quite write either. + +I apologize for continuing to test the hypothesis. From b90b9c185440b0659daa94f85f03c9c2a3482910 Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sun, 6 Sep 2026 21:21:34 -0700 Subject: [PATCH 2/4] Point README at TIWCG architecture plan --- README.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index e47afc1..eed4ce0 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,9 @@ -# SCARED SACRED (repo) — POLITICS (base game) -*Virtual-only trading card game built on real events. Scared Sacred is Expansion Set 1.* +# TIWCG +*The Interdependency card-game system. Current executable content includes POLITICS (base game); SCARED SACRED is Expansion Set 1.* -Base TCG: real events as cards, the EDCM circuit as rules engine. +The frozen generalized architecture and implementation sequence are recorded in [PLAN.md](PLAN.md). + +Current implemented base TCG: real events as cards, the EDCM circuit as rules engine. Three layers: L1 SUBSTRATE (official record; not playable; compiles each jurisdiction's Machine deck) / L2 ENGINE (automated; the null clock guarantees total conversion absent human play) / L3 TABLE (players; the @@ -20,6 +22,6 @@ VIRTUAL ONLY — no physical printing of any set, ever. The Litany (never satirical): I'm sorry. I forgive you. You are not alone. I love you. -Status: executable base ruleset and automated balance harness are implemented and test-backed; human playtest and store/mobile delivery remain pending. Some explicitly logged card effects remain unresolved and must not be represented as complete. +Status: executable base ruleset and automated balance harness are implemented and test-backed; generalized TIWCG architecture is planned in PLAN.md. Human playtest and store/mobile delivery remain pending on main. Some explicitly logged card effects remain unresolved and must not be represented as complete. hmmm — fear and the holy are the same six letters; the base game and its first expansion now also have separate addresses. From 342c4d68da4cd0a3a2ba54ec5de98f0f8de1fbb1 Mon Sep 17 00:00:00 2001 From: Codex Date: Mon, 7 Sep 2026 13:29:39 +0000 Subject: [PATCH 3/4] docs(tiwcg): reconcile frozen plan canon ambiguities --- PLAN.md | 22 +++++++++++++----- README.md | 3 +++ engine/test_plan_contract.py | 43 ++++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 5 deletions(-) create mode 100644 engine/test_plan_contract.py diff --git a/PLAN.md b/PLAN.md index a205252..47b3f00 100644 --- a/PLAN.md +++ b/PLAN.md @@ -8,7 +8,9 @@ This document separates **frozen decisions** from **implementation planning**. A **TIWCG is the containing game system.** -SCARED SACRED is content within TIWCG, not the name of the containing repository or engine. +SCARED SACRED is content within TIWCG, not the name of the containing engine. +This plan does not rename the Git repository while the `scared-sacred` +repository-name ruling in `canon/canon_v03_base.md` remains active. ### Frozen stack relationship @@ -59,7 +61,9 @@ What remains shared: ### Turn order 1. **Draw Two** — draw 2 from skill-lib. -2. **Drop Two** — drop 2 resource-generation cards. +2. **Drop Two** — drop up to 2 resource-generation cards. If the hand has + fewer than 2 resource-generation cards, drop all available; if it has none, + pass this step. 3. **First Twiddle**. 4. **Main Phase I**. 5. **Simultaneous Conflict**. @@ -275,7 +279,11 @@ A paid kit may expand: Ownership of a paid kit should not by itself grant unbeatable territory or combat advantage over a player who does not own it. -Existing SCARED SACRED Witness constraints remain independent canon and must not be accidentally weakened by the generalized TIWCG commercial model. +Witness constraints are base-wide TIWCG canon through +`canon/canon_v03_base.md`: Witness accounts remain giver-owned, table-bound, +unprintable, and unsellable. SCARED SACRED remains the expansion source from +which those constraints were promoted, but the generalized TIWCG commercial +model must treat them as base-wide requirements. ## 16. Implementation plan @@ -283,9 +291,13 @@ The following is implementation order, **not additional frozen canon**. ### Phase 0 — reconcile repository identity -- Make README identify the repository as TIWCG. +- Present README/project docs as the TIWCG system entrypoint without treating + README prose as a repository rename. +- Preserve the base-canon `scared-sacred` repository-name ruling unless a later + canon amendment explicitly changes it. - Keep POLITICS / Fifty-Three Days and SCARED SACRED as contained game/content boundaries. -- Update stale `scared-sacred` repository-name references without renaming the expansion itself. +- Update stale `scared-sacred` content-scope references without renaming the + expansion or silently changing the repository-name ruling. - Keep current tests green while the generalized engine is introduced. ### Phase 1 — extract the common TIWCG kernel diff --git a/README.md b/README.md index eed4ce0..72bf3db 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,9 @@ # TIWCG *The Interdependency card-game system. Current executable content includes POLITICS (base game); SCARED SACRED is Expansion Set 1.* +This README presents the TIWCG system entrypoint. It does not supersede the +base-canon repository-name ruling in [canon/canon_v03_base.md](canon/canon_v03_base.md). + The frozen generalized architecture and implementation sequence are recorded in [PLAN.md](PLAN.md). Current implemented base TCG: real events as cards, the EDCM circuit as rules engine. diff --git a/engine/test_plan_contract.py b/engine/test_plan_contract.py new file mode 100644 index 0000000..5cdca59 --- /dev/null +++ b/engine/test_plan_contract.py @@ -0,0 +1,43 @@ +"""Checks for PLAN.md architecture ambiguity closures. + +# === CHECKS === +# id: check_plan_preserves_repository_name_ruling +# witnesses: tiwcg_plan_repository_identity +# id: check_plan_defines_drop_two_shortfall +# witnesses: tiwcg_plan_drop_two_shortfall +# id: check_plan_keeps_witness_constraints_base_wide +# witnesses: tiwcg_plan_witness_base_wide +# === END CHECKS === +""" +from pathlib import Path +import unittest + + +ROOT = Path(__file__).resolve().parents[1] +PLAN = (ROOT / "PLAN.md").read_text(encoding="utf-8") +README = (ROOT / "README.md").read_text(encoding="utf-8") +BASE_CANON = (ROOT / "canon" / "canon_v03_base.md").read_text(encoding="utf-8") + + +class PlanContractChecks(unittest.TestCase): + + def test_check_plan_preserves_repository_name_ruling(self): + self.assertIn("Repo retains the name scared-sacred", BASE_CANON) + self.assertIn("does not rename the Git repository", PLAN) + self.assertIn("repository-name ruling", PLAN) + self.assertIn("does not supersede", README) + + def test_check_plan_defines_drop_two_shortfall(self): + self.assertIn("drop up to 2 resource-generation cards", PLAN) + self.assertIn("drop all available", PLAN) + self.assertIn("pass this step", PLAN) + + def test_check_plan_keeps_witness_constraints_base_wide(self): + self.assertIn("The Witness Rule and the Litany are", BASE_CANON) + self.assertIn("base-wide TIWCG canon", PLAN) + self.assertIn("giver-owned, table-bound", PLAN) + self.assertIn("unprintable, and unsellable", PLAN) + + +if __name__ == "__main__": + unittest.main(verbosity=2) From ac802fa59718cd7db05907fd67a2d85928fdf1a5 Mon Sep 17 00:00:00 2001 From: Codex Date: Mon, 7 Sep 2026 13:52:01 +0000 Subject: [PATCH 4/4] docs(tiwcg): close canon boundary gaps --- PLAN.md | 32 ++++++++++++++++++++++----- engine/test_plan_contract.py | 43 ++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 5 deletions(-) diff --git a/PLAN.md b/PLAN.md index 47b3f00..ca83d8d 100644 --- a/PLAN.md +++ b/PLAN.md @@ -60,7 +60,7 @@ What remains shared: ### Turn order -1. **Draw Two** — draw 2 from skill-lib. +1. **Draw Two** — draw 2 from a versioned skill-lib draw source. 2. **Drop Two** — drop up to 2 resource-generation cards. If the hand has fewer than 2 resource-generation cards, drop all available; if it has none, pass this step. @@ -74,6 +74,10 @@ What remains shared: Menagerie maintenance and persistent-state recording resolve at the end of the turn according to the active cards and context. +Each draw records an immutable skill-lib content hash or repository revision so +deterministic replay consumes the original draw source rather than the mutable +live skill ecology. + `hmmm` — whether newly dropped resource generation produces immediately on the first twiddle or only after surviving into a later productive state remains unresolved. ## 4. Conflict is not merely winner selection @@ -225,6 +229,11 @@ The Interdependency itself can appear as discoverable card content: These cards should emerge through play/discovery/creation rather than requiring every player to begin from an identical static collection. +Generic creation does not authorize hand-authored named-human or public-figure +cards. Human/person cards enter as sourced submissions and must route through +the base-canon public-transcript EDCM pipeline and Erin ratification before they +become named-figure cards. + ## 12. Social-platform architecture TIWCG must be built to work through **Discord and other social-media / communication surfaces**. @@ -237,6 +246,10 @@ A match, menagerie, identity relation, EDCM result, or AHBG territory must not b A social adapter should translate platform events into TIWCG operations and translate legal TIWCG state back into platform-appropriate presentation. +Witness contexts are an explicit exception: leaving or rejoining during a +Witness account may update transient connectivity, but must not emit or retain +a canonical match event, provenance entry, marker, score, or comment. + The minimal adapter vocabulary should be derived from actual engine needs rather than copied from any platform API. Likely operations include joining/leaving, drawing, playing, twiddling, challenging, responding, resolving, sharing, and discovering, but this list is **planning**, not frozen protocol. UCNS characterizes the geometry of connections exposed by each surface. TIWCG determines what those connections permit. @@ -245,7 +258,7 @@ UCNS characterizes the geometry of connections exposed by each surface. TIWCG de The knowledge-kit model depends on repetition. -Implementation should separate immutable/authoritative card content from per-player learning state. A player or agent should be able to accumulate observations such as exposure, attempt, correctness, confidence, and future re-exposure scheduling without rewriting the canonical card definition. +Implementation should separate immutable/authoritative card content from per-player learning state. A player or agent should be able to accumulate externally observed learning records such as exposure, attempt, correctness, provenance-backed calibration/confidence metrics, and future re-exposure scheduling without rewriting the canonical card definition or inferring an internal state. The exact spacing algorithm is not frozen in this thread. @@ -264,6 +277,10 @@ Planned support: Art must not be able to alter legality, source text, EDCM results, or relation geometry simply by replacing an image. +Artwork overrides and generated art inherit the card class's canonical content +restrictions. For EVENT cards, art must not depict victims; only counts and +documented actor behavior are admissible. + ## 15. Commercial/content boundary The monetizable layer is principally **themed upgrade knowledge/flash-card kits and presentation/content expansions**, not raw pay-to-win strength. @@ -277,7 +294,9 @@ A paid kit may expand: - specialized conflict contexts; - domain-specific card creation material. -Ownership of a paid kit should not by itself grant unbeatable territory or combat advantage over a player who does not own it. +Ownership of a paid kit must not grant territory, combat, resource, timing, +resolution, or other mechanical/competitive advantage over a player who does +not own it. Witness constraints are base-wide TIWCG canon through `canon/canon_v03_base.md`: Witness accounts remain giver-owned, table-bound, @@ -320,10 +339,13 @@ Do not rewrite working POLITICS behavior until the common contract can express i Implement the frozen turn law: -`7 hand → draw 2 → drop 2 → twiddle → Main I → simultaneous conflict → resolution → Main II → twiddle → end` +`7 hand -> draw 2 from versioned skill-lib source -> drop up to 2 available resource-generation cards/pass if none -> twiddle -> Main I -> simultaneous conflict -> resolution -> Main II -> twiddle -> end` Add 20 METAPAT starting energy and resource-generation objects behind explicit tests. +Persist the skill-lib source revision or content hash for each draw before +claiming deterministic replay. + Resolve the immediate-vs-delayed production `hmmm` before making it implicit behavior. ### Phase 3 — UCNS relation interface @@ -409,7 +431,7 @@ Implementation should fail tests rather than violate these silently: 6. Logical fallacies alter context/relations; they do not magically establish truth. 7. Paradigm collapse removes unsupported representation, not independently supported relations. 8. `hmmm` is preserved when honest resolution is unavailable. -9. Knowledge-kit ownership does not equal raw pay-to-win power. +9. Knowledge-kit ownership does not grant paid mechanical or competitive advantage. 10. Provenance and lineage survive card transformation. ## 18. Open `hmmm` diff --git a/engine/test_plan_contract.py b/engine/test_plan_contract.py index 5cdca59..5c9d3ef 100644 --- a/engine/test_plan_contract.py +++ b/engine/test_plan_contract.py @@ -7,6 +7,18 @@ # witnesses: tiwcg_plan_drop_two_shortfall # id: check_plan_keeps_witness_constraints_base_wide # witnesses: tiwcg_plan_witness_base_wide +# id: check_plan_records_versioned_draw_source +# witnesses: tiwcg_plan_draw_replay_provenance +# id: check_plan_routes_named_human_cards_through_pipeline +# witnesses: tiwcg_plan_named_human_pipeline +# id: check_plan_excludes_witness_departure_logging +# witnesses: tiwcg_plan_witness_departure_exception +# id: check_plan_keeps_learning_confidence_observable +# witnesses: tiwcg_plan_learning_observable_only +# id: check_plan_preserves_event_art_content_boundary +# witnesses: tiwcg_plan_event_art_boundary +# id: check_plan_prohibits_paid_competitive_advantage +# witnesses: tiwcg_plan_paid_power_boundary # === END CHECKS === """ from pathlib import Path @@ -38,6 +50,37 @@ def test_check_plan_keeps_witness_constraints_base_wide(self): self.assertIn("giver-owned, table-bound", PLAN) self.assertIn("unprintable, and unsellable", PLAN) + def test_check_plan_records_versioned_draw_source(self): + self.assertIn("versioned skill-lib draw source", PLAN) + self.assertIn("immutable skill-lib content hash or repository revision", PLAN) + self.assertIn("Persist the skill-lib source revision or content hash", PLAN) + + def test_check_plan_routes_named_human_cards_through_pipeline(self): + self.assertIn("Named-figure cards are generated from public transcripts", BASE_CANON) + self.assertIn("Generic creation does not authorize hand-authored named-human", PLAN) + self.assertIn("public-transcript EDCM pipeline", PLAN) + + def test_check_plan_excludes_witness_departure_logging(self): + self.assertIn("departures free, unmarked, unremarked", BASE_CANON) + self.assertIn("Witness contexts are an explicit exception", PLAN) + self.assertIn("must not emit or retain", PLAN) + + def test_check_plan_keeps_learning_confidence_observable(self): + self.assertIn("No internal states anywhere", BASE_CANON) + self.assertIn("externally observed learning records", PLAN) + self.assertIn("provenance-backed calibration/confidence metrics", PLAN) + self.assertIn("without rewriting the canonical card definition or inferring an internal state", PLAN) + + def test_check_plan_preserves_event_art_content_boundary(self): + self.assertIn("Victims are never depicted on event cards", BASE_CANON) + self.assertIn("art must not depict victims", PLAN) + self.assertIn("documented actor behavior", PLAN) + + def test_check_plan_prohibits_paid_competitive_advantage(self): + self.assertIn("must not grant territory, combat, resource, timing", PLAN) + self.assertIn("other mechanical/competitive advantage", PLAN) + self.assertIn("does not grant paid mechanical or competitive advantage", PLAN) + if __name__ == "__main__": unittest.main(verbosity=2)