Eve library

Hathor/Yemaya Ideation, Authoring-Parity & SOTA Tooling — Gap-Closure TODOS

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

Date opened: 2026-07-17. Source: full-domain audit of hathor + yemaya (fabrication seams closed same day; see ~/.claude memory hathor-yemaya-audit-2026-07-17 and commits on oshun-mobile-parity-2026-07-04).

Three gaps drive this initiative:

  • G1 — Ideation. No first-class blank-page-to-premise pipeline. Adjacent assets exist (libs/maya/inspirations mood boards, V8 libs/yemaya/case-writers-room, libs/yemaya/agents creative-director, studio scenario-generation) but nothing owns capture → divergence → selection → development → promotion.
  • G2 — Workbench/studio asymmetry. Cultures, quests, dialogue trees, and story graphs are authorable only via /studio/hathor/* web routes; the dedicated apps/hathor/workbench app covers only worlds / characters / factions / locations / timeline.
  • G3 — Facade shims. libs/hathor/{characters,world,timeline,quests} are CGI import/export facades over domain-models/narrative; fine architecturally, but undocumented and unguarded against logic creep.

Rules of engagement (repo standards apply in full):

  • Checkbox [ ]/[x] is the sole source of truth. One task, one verification, one mark. No batch-marking.
  • Zero tolerance for stubs: every generator, scorer, and editor ships with real domain algorithms and known-value tests, or fails loud behind an honest not_configured seam. LLM-backed steps get a wired provider or a fail-loud refusal — never canned output pretending to be generated.
  • Frontend work is verified with Claude-in-Chrome (visual AND functional) before its checkbox flips.
  • Commit + two-line push (branch and branch:main) after every completed phase slice.

SOTA capability benchmark (what "comprehensive" means here)#

Reference bar assembled from the strongest current tools and research; each row must be either COVERED by a task below or explicitly rejected with a reason in the Phase 0 design doc.

Capability Reference bar Covered by
Frictionless capture (hotkey, inbox, zero-form) Milanote / Notion quick-capture P2
Visual mood boards & reference libraries Milanote, PureRef, libs/maya/inspirations P8
Structured premise/logline formulas Save the Cat loglines, Snyder/Field practice P3.1
Hierarchical story generation (logline → beats → scenes) Dramatron (Mirowski et al. 2023) P5
What-if / counterfactual exploration over canon tree-of-thought exploration UIs P3.2
Systematic creativity operators SCAMPER, morphological analysis (Zwicky box), oblique strategies, Six Thinking Hats P3.3
Diversity-guaranteed option generation quality-diversity search (MAP-Elites, Lehman & Stanley novelty search) P3.4
Multi-agent writers' room with critique rounds Dramatron co-writing, V8 case-writers-room P3.5
Research-grounded ideation Sudowrite/NotebookLM-style source grounding P3.6 (Sophia)
Culture-aware naming/onomastics World Anvil name generators, real phonotactics P3.7
Pairwise/tournament selection with calibrated ratings Elo / Bradley-Terry judging P4.2
Multi-criteria weighted scoring ICE/RICE, weighted decision matrices P4.3
Diversity-aware shortlisting (don't collapse to one cluster) determinantal/maximal-marginal-relevance pruning P4.4
Adversarial critic panels before commitment this repo's verify-pattern; CoT critic ensembles P4.5
Decision records (why chosen / why killed) ADR practice applied to creative choices P4.6
Premise → treatment development ladder logline → synopsis → treatment → beat sheet (industry standard) P5.1
Multiple narrative frameworks 3-act, Save the Cat 15 beats, Harmon Story Circle, Hero's Journey, Kishōtenketsu, Freytag P5.2
Promotion into canonical entities with provenance World Anvil/Campfire linking, plus our canon stack P5.4
Real-time collaborative boards Miro/FigJam multiplayer P7
Idea versioning & lineage graphs git-style history (we already have world versioning/merge) P1.3
Canon-consistency guardrails during ideation our lore validators + Sophia fact-check (unique to us) P10.2
AI-attribution & consent on generated concepts C2PA-style disclosure; our ethics manager P10.3
Funnel analytics & generator win-rates experimentation practice P12
Game design pillars & core-loop ideation (MDA-grounded) industry pillar practice; MDA (Hunicke et al. 2004) — engine already in libs/hathor/theory P13.1–13.2
"X meets Y" comps & market positioning standard pitch practice; Sophia-backed research P13.3, P15.4
Mechanic/systems concepting with simulation preview crucible-balance (Maya), theory dynamics simulate P13.4
Level/biome/encounter concept briefs AAA blockout-brief practice P13.5–13.6
Prototype briefs with kill criteria double-diamond/greybox practice P13.7
Scope & branching-cost estimation at concept stage completion-time-estimator, player-choice-impact-analyzer (exist in yemaya/agents) P13.8
Series bible / season arc / episode grid showrunner bible + episode-breaking practice P14.2–14.4
Corkboard index-card beat board Scrivener/Plottr/writers-room corkboards P6.8, P14.4
Character arc design (want/need, arc types, arc-beat alignment) Truby/Weiland arc practice; character-arc-consistency-validator exists P5.7
Ensemble balance (screen time, POV distribution) writers-room practice; ethics screen-time analyzer exists P6.9
Voiced table reads of scenes/dialogue table-read practice; libs/yemaya/tts-integration exists P14.6
Pitch decks, one-pagers, lookbooks industry pitch materials; presentation-compiler exists P14.5
Executive notes workflow (addressed/rebutted tracking) studio notes process P14.7
Title/logline/tagline A/B variant testing ab-variant-generator + best-variant-selector exist P4.7
Craft critic battery (cliché/trope, plot holes, tension, pacing, foreshadowing) 40+ real analyzers already in libs/yemaya/agents/quality-assurance P4.5b, P5.6
Franchise/transmedia routing & slate portfolio balance studio slate management P15.1–15.2
Stage-gate greenlight with human sign-off greenlight practice; yemaya HITL exists P15.3
Title clearance & premise-similarity search clearance practice (advisory) P15.4
Cultural sensitivity & representation review at concept cultural-sensitivity-validator + ethics bias analysis exist P15.5
Locale-aware naming/title screening case-localization patterns P15.6
Fountain/FDX interop screenwriting interchange standards; Fountain export exists in pre-production P16.7
Command palette, global semantic search, templates, mobile capture modern studio-tool UX baseline P16

Phase 0 — Design & architecture (do first, blocks everything)#

  • 0.1 Write docs/domains/hathor-ideation-proposal.md (path corrected: DOMAINS/ is gitignored build output; tracked proposals live in docs/domains/): goals, non-goals, glossary (spark, premise, option set, tournament, promotion), and an explicit disposition for every row of the SOTA benchmark table above (covered-by / rejected-because).
  • 0.2 Decide and record the namespace: new libs/hathor/ideation (TypeScript, Vitest, tsup) + routes in a new apps/hathor/ideation-api OR extension of world-api. Record the tradeoff (blast radius vs. service sprawl) in the proposal. Default recommendation: libs/hathor/ideation + routes added to apps/hathor/narrative-api (it already owns authoring-adjacent routes).
  • 0.3 Define storage: Prisma models in libs/hathor/database schema (hathor DB) for Idea, IdeaRevision, IdeaLink, OptionSet, Judgment, Tournament, DecisionRecord, PromotionRecord. Migration written and applied to oshun_dev. (2026-07-17: migration 20260717210928_add_ideation_models, 12 tables; applied to the hathor domain DB — the oshun_dev reference here was an error, hathor's schema lives in the hathor database per its README.)
  • 0.4 Define the LLM seam once: a IdeationModelProvider interface (generate, critique, embed) wired through the same provider conventions as libs/hathor/llm-npc (provider chain, fenced prompts, safety filter invoked — the V2/SAFETY-001 lessons). No provider configured ⇒ every generator fails loud with not_configured; nothing fabricates model output.
  • 0.5 Threat/safety review paragraph in the proposal: prompt-injection fencing for user-supplied idea text, content filtering of generated output (libs/yemaya/safety), consent gating for real-person likeness concepts (EthicsManager).
  • 0.6 UX skeleton: low-fi wireframes (md/ascii acceptable) for the five core surfaces — Inbox, Board, Generator Console, Tournament, Develop ladder — reviewed against apps/oshun/web design-language tokens.

Phase 1 — Ideation domain model (libs/hathor/ideation)#

  • 1.1 Scaffold the lib (project.json, package.json, tsconfig, path mapping in tsconfig.base.json, vitest config; builds and lints clean before any feature code).
  • 1.2 Core types + Zod schemas, branded IDs: - Idea kinds: premise, logline, what_if, character_concept, culture_seed, world_seed, location_seed, faction_seed, quest_seed, theme, title, image_ref, fragment (raw text). - Status machine: captured → developing → shortlisted → selected → promoted | killed | archived, with legal-transition guard and tests for every edge (illegal transitions throw). - Structured premise payload: protagonist, want, obstacle, stakes, setting hook, irony/twist, genre tags, tone tags, scope (personal…cosmic, reuse EventScope vocabulary).
  • 1.3 Lineage/provenance graph: IdeaLink edges (derived_from, merged_from, inspired_by, contradicts, promoted_to) forming a DAG; cycle rejection (reuse the DFS recursion-stack pattern from libs/hathor/validation causality); getAncestry/getDescendants traversals with tests on a known diamond-shaped fixture.
  • 1.4 Revisions: every content mutation appends an IdeaRevision (author, timestamp, diff summary); revert(revisionId) restores exactly; property test: revert(head) is a no-op, revert(r) then content equals r.
  • 1.5 Embedding + dedupe/cluster support: embed(idea) through the provider seam; nearest-neighbor duplicate warning at capture (cosine ≥ threshold), cluster labels for board grouping. With no embedding provider: feature reports unavailable, never fake vectors. (The feature-hashing fallback in libs/yemaya/assets/search is acceptable as a labeled lexical fallback — reuse it, credited.)
  • 1.6 In-memory + Prisma repository implementations behind one IdeationStorageProvider interface (same pattern as certification-manager); conformance test suite runs against both.

Phase 2 — Capture (kill the blank page)#

  • 2.1 API: POST /ideation/ideas (raw text ≤ 10s path: text only, all structure optional), GET /ideation/inbox, tag/star/kill endpoints, in apps/hathor/narrative-api with schemas + route tests.
  • 2.2 Workbench global quick-capture: hotkey (Cmd/Ctrl+Shift+I) opens a capture modal from ANY workbench page; writes to inbox; optimistic UI; verified in Chrome (open modal on 3 different pages, capture, confirm inbox shows entry).
  • 2.3 Inbox page (apps/hathor/workbench/src/pages/IdeationInbox.tsx): triage flow — keep (assign kind + board), merge into existing (creates merged_from link), kill (requires one-line reason → DecisionRecord). Keyboard-first (j/k/enter) triage.
  • 2.4 Duplicate surfacing at capture: "3 similar ideas exist" panel using 1.5; measured against a fixture set with known duplicates (test asserts the known duplicate is in top-3).
  • 2.5 Import bridges (all three landed 2026-07-18):
  • 2.5a libs/maya/inspirations mood-board/reference import → image_ref/fragment ideas with inspired_by links (adapter in libs/hathor/ideation/src/bridges/maya-inspirations.ts, structurally typed; the Maya lib was NOT moved).
  • 2.5b Paste-a-URL capture → Sophia-fetched summary attached as source context (UrlSummarizer seam; fails loud with 503/not_configured when no Sophia client is wired; invalid and non-http URLs rejected first).
  • 2.5c Canon import: world-api entity as a seed via /api/ideation/import/canon; anchor payload recorded so what-if generation (3.2) knows its anchor. Entity-picker UI ships with the generator console (P6.5).

Phase 3 — Divergent generation engines (multiple options by design)#

Every generator: (a) produces an OptionSet (N ≥ 3 distinct options), never a single answer; (b) records generator id + parameters + prompt hash on each option for the learning loop (P12); (c) passes generated text through libs/yemaya/safety content filtering before persisting; (d) has a deterministic-tool tier that works with NO model configured, and a model-backed tier behind the provider seam.

  • 3.1 Premise/logline engine (src/generators/premise.ts): - [x] 3.1a Deterministic tier: logline assembly from structured slots ("When ⟨inciting⟩, ⟨protagonist⟩ must ⟨goal⟩ before/or ⟨stakes⟩ — but ⟨obstacle/irony⟩."), slot vocabularies drawn from the seeded world's actual entities (factions, locations, eras via world-api) so output is world-grounded, not generic. Tests assert slot grammar and that seeded-world nouns appear. - [x] 3.1b Model tier: N-option premise generation with explicit diversity instruction + post-hoc dissimilarity check (pairwise embedding distance floor; regenerate near-duplicates).

  • 3.1c Logline quality lint (deterministic): flags missing stakes, passive protagonist, no irony, > 45 words — each rule unit-tested with known good/bad loglines.

  • 3.2 What-if / counterfactual explorer (src/generators/what-if.ts):

  • 3.2a Anchor on a canon fact (imported via 2.5c); generate branches by mutation operators: negate, invert-outcome, swap-actors, shift-era, escalate-scope, remove-keystone. Deterministic operators produce real structured mutations of the entity (e.g. faction outcome flipped), not text templates. - [x] 3.2b Consequence sketch per branch: run the RELEVANT simulator where one exists (economy/politics/culture tick preview via apps/hathor/simulation-worker) and attach honest simulated: {domain, ticks} labels; where no simulator covers it, the consequence text is model-tier or absent — never a fabricated "simulation says". - [ ] 3.2c Tree UI: explorable branch tree (reuse libs/yemaya/diagram-renderer layout-engine), expand-on-demand depth ≤ 4, any node capturable as a new idea with lineage.

  • 3.3 Creativity-operator toolkit (src/generators/operators.ts):

  • 3.3a SCAMPER (substitute/combine/adapt/modify/put-to-other-use/ eliminate/reverse) implemented as typed transforms over the structured premise payload — each operator has a real structural effect on the payload plus optional model elaboration; per-operator tests with expected structural diffs. - [x] 3.3b Morphological matrix (Zwicky box): user- or auto-defined axes (e.g. genre × conflict-type × setting-era × POV), full or sampled cross-product enumeration with combination dedupe; test: 3×3×3 box yields 27 unique combinations. - [x] 3.3c Random-stimulus deck: oblique-strategy-style prompt cards (authored corpus ≥ 100 cards, curated, in-repo data file) + "collide with random canon entity" draw; draws are seeded-RNG reproducible in tests. - [x] 3.3d Six-Thinking-Hats reframe: one-click re-examination of an idea from each hat, persisted as structured critique notes (model tier; fail-loud without provider).

  • 3.4 Diversity sampler (src/generators/diversity.ts): quality-diversity selection over a candidate pool — behavior descriptors (genre, tone, scope, era, conflict-type) define a grid; keep the best-scored candidate per cell (MAP-Elites style; scores from 4.3 rubric or model critic). Tests: pool with engineered clusters yields one representative per cell, never N from one cell.

  • 3.5 Writers' room (src/writers-room/): generalize the V8 libs/yemaya/case-writers-room shape, genre-agnostic: - [x] 3.5a Persona roster: Visionary (pitch), Skeptic (holes), Canon-Keeper (checks against world-api + validation stack), Audience Advocate (market/appeal), Historian (precedent via Sophia). Personas are prompt-config data, not code forks. - [x] 3.5b Round protocol: pitch → parallel critiques → revision → (optional) second round → summary; full transcript persisted on the OptionSet; max-round and token budget caps enforced. - [x] 3.5c Canon-Keeper is REAL: it must call the lore validators / contradiction detector with the idea's claims against the seeded world and cite specific conflicts — not a vibes prompt. Test with a fixture world containing a known contradiction the idea trips. - [x] 3.5d Session-limit hygiene: agents run sequentially (repo rule), resumable mid-room from persisted transcript.

  • 3.6 Research-grounded mode: any generator accepts groundingDocumentIds; retrieved Sophia passages are injected as fenced context and cited on the produced options (reuse libs/hathor/sophia-integration citation transforms); ungrounded claims in grounded mode get flagged by a lore-fact-check pass. Fail-loud without a Sophia client.

  • 3.7 Onomastics / title engine (src/generators/naming.ts): culture-aware name generation — per-culture phonotactic profiles (syllable inventories, onset/coda constraints, vowel harmony flags) stored on domain-models culture entities; deterministic generator produces names valid under the profile (validator + generator round-trip test: generated names pass the profile's own validator); model tier for meaning-bearing names/titles. No Math.random() without seeded-RNG injection (reuse DeterministicRNG xorshift128+ from libs/hathor/simulation/src/economy/providers.ts — export it to a shared util first).

  • 3.8 Mechanic & systems ideation (games) (src/generators/mechanics.ts): aesthetic-target-driven mechanic suggestion — pick target aesthetics (MDA vocabulary from libs/hathor/theory), generate candidate mechanics/dynamics; preview second-order dynamics with the REAL DefaultDynamicsSimulator.simulate (its timing metric fixed 2026-07-17); mechanic mutation operators (add/remove constraint, resource-loop inversion, cross-genre transplant) as typed transforms with structural-diff tests, mirroring 3.3a.

Phase 4 — Convergent selection (choosing between options)#

  • 4.1 OptionSet model + board UI: side-by-side compare of 2–4 options (synchronized field-level diff of structured premises), keyboard navigation, per-option notes.

  • 4.2 Pairwise tournament (src/selection/tournament.ts): - [x] 4.2a Bradley-Terry/Elo rating from pairwise human votes; real math (log-likelihood BT fit or standard Elo update, K documented), known-value tests (fixed vote history ⇒ expected ranking; BT recovers a planted ordering). - [x] 4.2b Smart pair scheduling: maximize information (pair items with closest ratings / highest uncertainty), test that scheduling beats random pairing on synthetic data (fewer comparisons to correct top-1). - [x] 4.2c Tournament UI in workbench: swipe/arrow A-vs-B flow, progress indicator, live leaderboard; multi-judge support with per-judge ratings + aggregate.

  • 4.3 Weighted rubric scoring (src/selection/rubric.ts): configurable criteria (novelty, canon-fit, feasibility, audience appeal, personal excitement, franchise potential…) with weights; scores entered by humans and/or critic agents (labeled per source); weighted totals + sensitivity view ("winner changes if you weight novelty ≤ 0.2"); the sensitivity computation is real (threshold solve, tested against hand-computed fixtures).

  • 4.4 Diversity-aware shortlist: maximal-marginal-relevance selection (λ-tradeoff between score and dissimilarity to already selected) so a shortlist of 5 never collapses into one cluster; MMR math unit-tested on engineered embeddings.

  • 4.5 Adversarial critic pass (repo pattern): before an option can move to selected, N sequential critic-agent verdicts prompted to REFUTE (find the fatal flaw); verdicts recorded; a majority-refuted option requires an explicit human override note to proceed. Fail-loud without provider (selection then requires human-only confirmation, honestly labeled).

  • 4.6 Decision records: promoting or killing writes an immutable DecisionRecord (chosen option, rejected siblings, scores at time of decision, stated reason, deciding user); rendered on the idea's history view. Killed ideas remain queryable ("graveyard" board) — revivable with lineage intact.

  • 4.7 A/B variant testing for titles/loglines/taglines: wire the EXISTING ab-variant-generator and best-variant-selector (libs/yemaya/agents/src/quality-assurance/) into OptionSets — generate labeled variants, collect judgments through the tournament machinery (4.2), and record the winning variant + margin on the DecisionRecord. No new variant engine; reuse and integrate.

  • 4.8 Craft critic battery (deterministic critics): register the EXISTING yemaya QA analyzers as first-class critics in the 4.5 pass where their input contract fits ideation artifacts: cliche-trope-detector, emotional-resonance-predictor, engagement-predictor, ending-satisfaction-predictor, dialogue-naturalness-scorer / dialogue-authenticity-scorer (for dialogue-bearing options), character-voice-distinctiveness-analyzer, theme-consistency-validator, replayability-scorer (game ideas). Each is a real analyzer already in-repo — the task is adapters + surfacing their findings in the critic UI with per-critic attribution, NOT reimplementation. Adapter tests feed a known-cliché fixture and assert the detector's finding appears on the option.

Phase 5 — Development ladder (premise → production-ready)#

  • 5.1 Ladder transforms, each a distinct versioned artifact with lineage: logline → synopsis (1 para) → treatment (1–2 pages) → beat outline. Model tier generates DRAFTS clearly labeled as drafts; each rung editable; no rung auto-marks the next as done.

  • 5.2 Framework-aware beat outlines: selectable structure templates — three-act, Save the Cat 15-beat, Harmon Story Circle (8), Hero's Journey (12), Kishōtenketsu (4), Freytag (5) — as structured beat slot definitions (name, function, target % position) in a data module shared with libs/hathor/theory narrative constants (dedupe with the existing "hero's journey" data there, single source of truth). Beat-coverage lint: outline missing required slots is flagged.

  • 5.3 Structure diagnostics on an outline (deterministic, reuse libs/hathor/narrative where possible): pacing curve preview (beat positions vs. targets), missing-stakes and protagonist-agency lints from 3.1c applied per-beat.

  • 5.4 Promotion flows (the payoff — ideas become canon drafts): - [x] 5.4a character_concept → draft Character in domain-models shape, opened in workbench Characters page for completion; promoted_to link recorded both directions. - [x] 5.4b culture_seed → draft culture (traits scaffolded onto the culture model, phase formative), opened in the new Cultures page (P6.1). - [x] 5.4c world_seed/location_seed/faction_seed → draft world-api entities on a new WORLD BRANCH (reuse world-api versioning/branch/merge!) so speculative promotion never dirties canon; merging the branch is the canonization act. - [x] 5.4d quest_seed + beat outline → draft quest graph in narrative-api (beats become quest stages), opened in the new Quest editor (P6.2). - [x] 5.4e Promotion validation gate: the draft runs the relevant lore validators immediately; conflicts shown before commit, never silently created.

  • 5.5 Round-trip integrity tests: promote → edit → the idea's history view still resolves the live entity; deleting a promoted entity marks (not deletes) the link.

  • 5.6 Deep structure diagnostics on outlines/treatments: wire the EXISTING analyzers — tension-curve-analyzer (curve vs. framework targets, false-release/fake-out placement), pacing-analysis-system, exposition-balance-analyzer, foreshadowing-payoff-tracker (setup/payoff ledger with orphan warnings), plot-hole-detection-system — into a diagnostics panel on the develop ladder. Each result rendered with the analyzer's real metrics (charts via d3-visualizations), never a synthesized roll-up that hides which analyzer said what.

  • 5.7 Character arc designer: per-character arc artifact — arc type (positive change / flat-tested / disillusionment / corruption), want vs. need, lie-the-character-believes, arc beats aligned to plot beats (alignment matrix UI); character-arc-consistency-validator wired as its critic; promotion into the character draft (5.4a) carries the arc artifact.

  • 5.8 Theme & motif tools: thematic-statement artifact on any idea moving past shortlisted; motif tracker (motif → intended recurrences across beats); theme-consistency-validator wired to check outline beats against the stated theme.

Phase 6 — Workbench/studio parity (G2)#

Shared groundwork first:

  • 6.0a Extract a reusable pan/zoom node-canvas component (apps/hathor/workbench/src/components/GraphCanvas.tsx) — nodes, edges, selection, drag, minimap, auto-layout via libs/yemaya/diagram-renderer layout-engine; keyboard a11y (tab-focus nodes, arrow nudge); unit + Chrome-verified.
  • 6.0b Workbench API client extensions for narrative-api (quests/dialogues/story-graphs/validation) and simulation-worker (culture jobs) with typed services + tests.

Pages (each: CRUD + editor + validation overlay + Chrome-verified functional pass + a spec file; match existing page conventions):

  • 6.1 Cultures page (pages/Cultures.tsx): culture list/detail, trait editor (category/stability/significance), phase timeline strip (formative→…→transformation with real dates), contact/diffusion map (which cultures exchange, via what mechanism), and a "simulate N years" control that enqueues a real simulation-worker culture job and renders the tick results (trait drift chart via d3-visualizations). Phase-transition preview uses the REAL CulturePhaseTransition.shouldTransition (with currentDate — the seam fixed 2026-07-17).

  • 6.2 Quests page (pages/Quests.tsx): quest list + GraphCanvas editor for objectives/stages/branches, prerequisite links, reward editor, and inline results from narrative-api validation routes (orphan objectives, unreachable stages).

  • 6.3 Dialogue page (pages/Dialogues.tsx): tree editor on GraphCanvas — speaker assignment, line editing, per-choice condition/effect editors (reuse the ConditionEvaluator vocabulary from libs/hathor/narrative so conditions authored here are the ones the engine evaluates), and a playtest panel: run the tree live against libs/hathor/llm-npc (persona-fenced) — fail-loud "playtest requires a configured model provider" when absent.

  • 6.4 Story graphs page (pages/StoryGraphs.tsx): full graph editor; node state visualization honoring the real completion semantics (nodes complete on exit; saves persist completedNodeIds — 2026-07-17 fix); save/load state inspector; validation overlay (cycles, dead ends from validateGraph).

  • 6.5 Ideation hub (pages/Ideation.tsx + Inbox from P2.3): boards, generator console (launch 3.x engines), tournament view (4.2c), develop ladder view (5.1), graveyard.

  • 6.6 Navigation/IA update: sidebar groups (World / People / Story / Ideation / Simulation); route parity guard test in the style of the mobile parity suites — every entity kind authorable in studio hathor routes asserts a corresponding workbench route exists (or is explicitly listed in a documented exceptions file with a reason).

  • 6.7 Studio back-parity: anything NEW built workbench-first in this initiative (ideation hub, tournaments) gets a studio route entry or a documented web/desktop-only exception, so the asymmetry doesn't simply reverse.

  • 6.8 Corkboard beat board (pages or embedded in the develop ladder): index-card UI for beats/scenes — drag-to-reorder within and across act columns, card color by plotline, collapse/expand acts, card-level notes; reordering updates the underlying beat outline (single source of truth, no divergent copy); keyboard reorder for a11y; Chrome-verified drag AND keyboard paths.

  • 6.9 Relationship web & ensemble balance: character/faction relationship editor on GraphCanvas (typed edges: ally/rival/family/ romance/debt; conflict matrix view highlighting pairs with no defined tension); ensemble balance view — screen-time / POV / role distribution using the REAL representation analysis in libs/yemaya/safety EthicsManager (role-bias + screen-time analyzers), rendered per attribute with the Gini/balance verdicts.

Phase 7 — Collaboration & multiplayer ideation#

  • 7.1 CRDT-backed idea boards: Yjs docs via libs/yemaya/collaboration (the real Yjs path in sync/crdt-manager.ts) for board layout + idea text; presence cursors; two-client merge test (concurrent edits to one idea converge; concurrent card moves both survive).
  • 7.2 Comments/annotations on ideas and options (reuse the studio commenting-annotation-system contract if compatible; otherwise a minimal thread model in the ideation lib).
  • 7.3 Group voting sessions: a tournament (4.2) opened to multiple judges simultaneously; live aggregate; per-judge disagreement surfaced (highest-variance pairs highlighted for discussion).

Phase 8 — Visual ideation (G1 visual half)#

  • 8.1 Mood boards inside the ideation hub: image cards (upload or asset-library reference), free-form canvas layout, board→idea linking. Reuse libs/maya/inspirations data structures through the 2.5a bridge rather than duplicating.

  • 8.2 Concept-art generation from a premise: one-click "visualize" sends a structured prompt (from the premise slots) to Isis generation (through the pluggable Isis client contract in libs/yemaya/asset-generation — the documented honest seam); async job status honest at all times; generated images attach as image_ref ideas with AI-attribution labels (P10.3). No wired Isis client ⇒ button disabled with an honest tooltip, not a fake image.

  • 8.3 Style-consistency check for a board: run libs/yemaya/style-transfer consistency-validator (color-blind-safe palette checks included) across board images; report real metrics.

  • 8.4 Sonic identity boards: audio reference cards (libs/maya/inspirations audio-style-references bridged like 2.5a), temp-track lists with rights-status field (owned / licensed / reference-only — reference-only tracks excluded from any export), and a sonic-palette note attached to promoted worlds/series bibles. Playback through existing asset-library streaming only; no new audio infra.

Phase 9 — Facade shims (G3)#

  • 9.1 Add a README.md to each of libs/hathor/{characters,world, timeline,quests} stating: facade role, the CGI packet contract it owns, and a "logic lives in" pointer table (characters→domain-models/character+pre-production; world→domain-models/{culture,geography,location,timeline}; timeline→domain-models/timeline; quests→narrative/quest).
  • 9.2 Mirror the same note in each shim's package.json#description and in DOMAINS.md.
  • 9.3 Guard against logic creep: a lint/test in each shim asserting the source stays under a line budget (e.g. 800 lines) and imports no deep implementation modules — only domain-models / pre-production public entry points; failing message explains where new logic belongs.
  • 9.4 Contract tests for the CGI packet shapes (golden-file import/export round-trips) so engine-facing consumers get explicit breakage instead of silent drift.

Phase 10 — Safety, canon & governance#

  • 10.1 Every model-generated idea/option passes ContentFilterManager.checkContent before persist; blocked content stored as a redacted tombstone with the category result (auditable, not silently dropped). Prompt-injection screening on user text routed into prompts (the filter's injection detector).
  • 10.2 Canon guardrails: capture and promotion both run contradiction/causality checks against the linked world; warnings are advisory at capture, blocking-with-override at promotion (override requires a DecisionRecord note).
  • 10.3 AI attribution: generated options carry attribution records via the yemaya EthicsManager labeling provider (percentage AI vs human after edits, disclosure text on export); character concepts flagged as resembling a real person require a consent record before promotion (consent scope machinery already real in libs/yemaya/safety).
  • 10.4 RBAC: ideation read/write/judge/promote as distinct permissions through libs/yemaya/rbac conventions; promotion to canon requires the promote permission.

Phase 11 — Quality gates (apply to every phase above)#

  • 11.1 Per-module vitest suites with known-value assertions (BT/Elo fixtures, MMR fixtures, phonotactic round-trips, SCAMPER structural diffs, ladder round-trips) — no shape-only tests.
  • 11.2 Adversarial stub scan (the repo grep + silent-stub patterns) run over libs/hathor/ideation and all touched workbench code before each phase's commit; zero actionable hits.
  • 11.3 Chrome-verified functional walkthroughs for every new workbench page (capture→triage→generate→tournament→promote happy path, plus the fail-loud no-provider path renders honestly).
  • 11.4 Accessibility pass on new pages via the jsdom+axe adapter (libs/yemaya/organizations accessibility-audit — fixed for jsdom@29 on 2026-07-17): zero serious/critical violations.
  • 11.5 Docs-center page(s) for the ideation domain following the existing generator conventions.
  • 11.6 Memory/TODO hygiene: update this file's checkboxes one-by-one as verified; commit + two-line push per slice.

Phase 12 — Telemetry & learning loop#

  • 12.1 Funnel metrics (real events through the analytics event pipeline): captured → developed → shortlisted → selected → promoted counts and conversion, per user and per board.
  • 12.2 Generator scoreboard: per-generator (and per-operator) selection-rate and tournament-rating aggregates — which engines produce ideas that actually win; surfaced in the generator console so defaults improve.
  • 12.3 Prompt/parameter lineage: each option retains generator id + parameter hash (from P3 requirement) so 12.2 is computable; test that a synthetic history yields correct per-generator win rates.
  • 12.4 Periodic review artifact: a generated (honest, data-backed) monthly ideation report — top ideas, kill reasons histogram, cluster map of the idea space — rendered from real stored data only.

Phase 13 — Game-specific concepting (AAA games)#

  • 13.1 Design pillars artifact: 3–5 pillars + explicit anti-pillars per game idea; pillar editor UI; a pillar-fit criterion auto-added to the 4.3 rubric for game-kind ideas; promotion of a world_seed/ quest_seed flagged as a game requires pillars (blocking-with- override, DecisionRecord note).
  • 13.2 Core-loop designer: loop diagram on GraphCanvas (actions → rewards → upgrades edges with cycle timing estimates); MDA mapping panel — each loop element tagged with mechanics/dynamics/aesthetics from libs/hathor/theory vocabularies; "simulate dynamics" preview via the real theory simulator with honest simulated labeling; loop lints (no reward edge, dead-end action, single-currency collapse) each unit-tested.
  • 13.3 Comps & positioning: comp picker ("X meets Y" with 2–4 titles), feature/genre matrix vs. comps (rows = features, columns = comps + us), USP statement with lint (must name what NO comp does); Sophia-backed research capture attaches sourced market notes with citations — fail-loud without a Sophia client, never invented "market data".
  • 13.4 Systems concepting with balance preview: proposed economy/progression sketches (sources/sinks/converters as typed graph); where the sketch maps onto an existing simulator (hathor economy engine; Maya crucible-balance for combat/economy balance), run it and attach real tick output with domain labels; where no simulator fits, the sketch remains an unsimulated draft — labeled as such, no fabricated balance claims.
  • 13.5 Level/biome concept briefs: location seed → blockout brief artifact (player-goal, navigation intent, sightline notes, encounter density target, landmark list, mood/palette reference links); geography-modeling entities linkable; brief completeness lint.
  • 13.6 Enemy/boss/ability kit concepting: archetype library (authored data), kit sheets (abilities, counters, telegraphs); counterplay-completeness lint — every ability must list at least one counter or carry an explicit "uncounterable by design" flag; combat-encounter-difficulty-analyzer wired where its inputs exist.
  • 13.7 Prototype briefs (promotion target for game ideas): paper-prototype / greybox brief artifact — hypothesis, questions to answer, success criteria, KILL criteria, timebox; the game equivalent of a treatment; stage-gate (15.3) requires it before greenlight for game-kind ideas; libs/bellona/gameplay-systems referenced in the brief's feasibility notes where AI/behavior mechanics are proposed.
  • 13.8 Scope & branching-cost estimation: wire the EXISTING completion-time-estimator and player-choice-impact-analyzer to produce rough scope bands (content hours, branch-cost curve for narrative games) on prototype briefs; outputs labeled as estimates with their input assumptions visible; resource-allocation-optimizer consulted for the slate view (15.2).

Phase 14 — Film & series development (movies, TV)#

  • 14.1 Format decision artifact: film / limited series / returning series / short-form, with runtime + episode-count targets and a recorded rationale; format-fit critique (does the premise's engine sustain the chosen format) as a critic-pass question.
  • 14.2 Series bible builder: assembled document — world, tone, principal characters (from promoted character drafts), relationship web snapshot (6.9), the episode ENGINE statement ("why this generates 100 stories"), pilot summary, season-one arc; assembly pulls live canon entities (no copy-drift); exported via libs/yemaya/presentation-compiler (real renderer) and Fountain/MD. - Scope note (2026-07-19): Markdown and the presentation-compiler deck are implemented. Fountain export is deliberately NOT implemented for the bible: Fountain is a screenplay grammar (scene headings, action, dialogue) with no representation for a series bible, so emitting one would produce a file that parses as a screenplay and is not one. The real Fountain exporter (exportChronicle in @hathor/pre-production) belongs on script artifacts — see 16.7.
  • 14.3 Season arc & episode grid: grid editor (episodes × A/B/C plotlines), serialized-vs-episodic balance meter (computed from plotline spans, tested on fixtures), arc beats (5.2 frameworks) mapped onto episode cells, season-level tension curve via the real tension-curve-analyzer.
  • 14.4 Episode breaking board: the corkboard (6.8) specialized for breaking an episode — act templates per format (teaser + 5-act network, 3-act streaming, half-hour two-act), act-break placement lint against the chosen template.
  • 14.5 Pitch materials: one-pager generator (assembled from real artifacts: logline, comps, format, bible excerpts — never invented filler), pitch deck via presentation-compiler with the data-true chart renderer (fixed 2026-07-17), lookbook from mood boards (8.1), poster/tagline concepts via Isis (8.2) + A/B tested via 4.7. - Scope note (2026-07-19): the one-pager and the presentation-compiler deck are implemented. The lookbook and poster/tagline halves are NOT: both depend on an Isis generation client, and this deployment has none — the existing visualize surface already fails loud with "Concept-art generation requires a wired Isis generation client". Building them now would mean either a surface that only ever refuses, or invented art, so they are deferred until Isis is wired rather than stubbed. A/B testing of taglines (4.7) follows the same dependency.
  • 14.6 Voiced table reads: read a scene/dialogue tree aloud with per-character voices via libs/yemaya/tts-integration (voice-manager + SSML engine); voice assignments consent-gated through the EthicsManager voice-likeness consent machinery for any cloned/likeness voice (stock synthetic voices exempt but labeled); transport controls + line-by-line highlight in the dialogue page playtest panel (6.3); fail-loud when no TTS engine configured.
  • 14.7 Notes workflow (studio notes): structured notes rounds on any artifact — note, severity, source; per-note resolution state (addressed → links the resolving revision / rebutted → requires rationale / deferred → target rung); notes dashboard per artifact; unresolved blocking notes gate stage-gate advancement (15.3).
  • 14.8 Casting archetype sheets: per-character archetype + "in the vein of" reference performers as DESCRIPTIVE references only — no likeness generation from real performers without a consent record (10.3 machinery); sheet feeds the bible and pitch deck.

Phase 15 — Franchise, portfolio & greenlight governance#

  • 15.1 Cross-product routing: fit-assessment of an idea against the V-series product lines (tags + a routed-to field); transmedia note (game/film/series potential from the same canon) captured at shortlist time; routing changes recorded (it is a decision).
  • 15.2 Slate/portfolio view: all ideas at developing+ across boards; balance lenses — genre, format, budget-tier band, audience quadrant, risk (novelty score from 4.3 as proxy); gap callouts computed from configurable slate targets (targets are data, gaps are arithmetic — tested); resource-allocation-optimizer consulted for capacity conflicts. - Note (2026-07-19): the slate is a cross-board portfolio surface, so it lives at its own route (/ideation/slate) rather than as a panel on the develop ladder.
  • 15.3 Stage-gate greenlight: explicit gates (concept → develop → greenlight) with per-gate required artifacts (premise+rubric / treatment-or-prototype-brief + critic pass + notes clear / bible-or-greybox + slate fit); human sign-off through the yemaya HITL approval patterns — a gate NEVER auto-advances; every gate decision is a DecisionRecord with the artifact snapshot ids.
  • 15.4 Title clearance & premise-similarity (advisory): Sophia/web-backed search for existing works with colliding titles or near-identical premises; results attached as sourced citations with an explicit "advisory — not legal clearance" label; fail-loud without a search client. Search lives in @sophia/crawling (web-search/, Brave/Tavily/Serper, no offline fallback — an unconfigured factory throws); scoring in libs/hathor/ideation/src/portfolio/title-clearance.ts (Sørensen–Dice bigrams for titles, Jaccard over content tokens for premises, both named on every finding). The report type has no clear field, results without a source URL are dropped and counted, and the panel renders "never searched" and "searched, found nothing" as distinct states.
  • 15.5 Cultural sensitivity & representation review: wire the EXISTING cultural-sensitivity-validator (libs/yemaya/agents/src/sophia-integration/) and the EthicsManager bias/representation analysis over the concept text + character roster; advisory at capture, blocking-with-override at greenlight; findings carry the analyzers' real evidence, never a bare pass/fail.
  • 15.6 Locale-aware naming screen: titles and principal names screened against per-locale profanity/false-friend lexicons (authored data, extendable; case-localization conventions); screening scope honestly reported (only the locales with lexicons — listed), with tests on known collision fixtures.

Phase 16 — Platform UI/UX polish & interop (studio-grade)#

  • 16.1 Command palette (Cmd/Ctrl+K) in workbench: entities, ideas, boards, actions ("start tournament", "new what-if from…"); fuzzy match; keyboard-only path Chrome-verified.
  • 16.2 Global search: full-text across ideas/artifacts/canon + semantic mode through the 1.5 embedding seam (lexical-only when no provider, labeled); filters by kind/status/board; recents + pins. libs/hathor/ideation/src/search/ — BM25 with field weighting (Robertson & Walker), mode on every result, mode=semantic without a provider refused rather than downgraded (auto degrades and says so). Canon is fetched through PrismaCanonSearch and reported as an unreachable scope when unwired. Recents and pins are separate stores: the cap only ever evicts recents.
  • 16.3 Undo/redo + autosave everywhere: command-stack undo/redo in every new editor including canvas operations (min depth 50); autosave with draft recovery; collaborative surfaces rely on CRDT history (7.1), solo surfaces on local drafts — behavior documented per surface; test: kill the tab mid-edit, reopen, draft restored. src/lib/command-stack.ts (depth floor 50 enforced at construction, default 100, forward-only time+key coalescing) + draft-store.ts (debounced localStorage drafts, versioned keys, 7-day cap) + use-editor-history.ts / use-crdt-history.ts (Y.UndoManager over LOCAL_ORIGIN only) + EditorHistoryBar. Wired into all 17 solo editors (13.x/14.x panels, both P8 composers incl. canvas drag as per-gesture undo steps, corkboard keyed to outline-version id, quick capture) and the CRDT idea board. Shortcuts are region-scoped — the develop ladder mounts ~16 editors, so a window listener would undo in all of them at once; only the focused editor's stack responds. Drafts mirror UNSAVED edits only (a viewed panel writes nothing; a completed save discards), and a restored draft marks the editor dirty so a background refetch cannot clobber it. Per-surface classes (incl. why immediate-commit surfaces have no stack) in apps/hathor/workbench/docs/undo-autosave-per-surface.md. Kill test automated in use-editor-history.spec.tsx AND run live in Chrome: killed the tab mid-edit, reopened, draft offered with age, restored; ⌘Z scoping and board undo/redo also Chrome-verified.
  • 16.4 Template gallery: authored starter templates — genre packs (heist film, prestige-drama season, monster-of-the-week, roguelike run-based, cozy sim), world-seed templates, quest archetype library (fetch/escort/investigation/siege/heist/mystery- box patterns with their known pitfalls noted); templates are curated in-repo data with review, not model output.
  • 16.5 Mobile quick-capture: idea capture screen in the consumer mobile app (BFF-composed like existing screens) + OS share-sheet intake (text/image/URL → inbox); offline queue with sync; Maestro flow covering capture→inbox-visible. BFF bridge apps/oshun/bff/src/routes/ideation-capture.ts — the FIRST HTTP-proxy consumer route, deliberately: the ideation inbox lives behind the hathor narrative-api (safety screening, similarity, provenance), and a second in-BFF store would drift, so phone captures land in the SAME inbox the workbench triages. Discovery via OSHUN_HATHOR_IDEATION_API_BASE_URL (dev defaults to :3003), 503 ideation_not_configured when unwired; createdBy derived from the session (mobile:<userId>), never the body. Mobile: app/capture-idea.tsx + src/navigation/mobileIdeaCapture.ts — three unblurred states (captured / queued "waiting to sync" via the existing offlineQueueController with an ideation.capture processor / honest 503 refusal that queues nothing); share-sheet intake maps text/URL/image to prefilled drafts, an image stored as a device-local reference (no invented upload), plus a fourth oshun-share-idea target on the home share-intake card routing to the capture screen. Maestro e2e/flows/shell/idea-quick-capture.yaml (regression suite) covers capture→inbox-visible; the share-ingest coverage guard extended itself to the new target. Live-verified end-to-end with curl through a real BFF + narrative-api + postgres: capture stored with createdBy=mobile:<user> + share-url source in payload, inbox read back through the bridge listed it alongside the workbench's ideas.
  • 16.6 Notifications & digests: tournament invitations, notes assigned, gate decisions, stale-shortlist nudges (no activity in N days — N configurable); routed through existing notification patterns; per-user digest opt-in. The feed is DERIVED at read, never stored (libs/hathor/ideation/src/notifications/): a derivation over the facts the store already holds — active tournaments with an invited judge panel the user hasn't voted in (panel stored in tournament config at create; judges on the create schema + Tournament page input), open notes assigned to the user (assignee column added to IdeationNote, migration 20260719131845, listNotesByAssignee through both storage decorators), gate decisions on the user's ideas (now stamped decidedAt; pre-stamp records surface as "no recorded date" and are counted apart in the digest, never silently windowed), and shortlisted ideas idle ≥ N days (N a query param, default 7). Routes GET /notifications + /notifications/digest; workbench NotificationsPanel on the Ideation hub with client-side read-state (seen-id set — a time cursor can't mark undated facts read), mark-all-read, per-user digest opt-in and stale-N control persisted in notification-prefs. No mailer exists in this deployment, so the digest is in-app — nothing pretends to send email. Tests at every layer (derivation known-values, route flows incl. invitation-clears-on-vote and note-clears-on-addressed, panel specs); Chrome-verified live against postgres: assigned note → 1-unread badge → mark-read → digest opt-in renders the section.
  • 16.7 Interop: Fountain IMPORT (parser exists in libs/hathor/pre-production/scriptwriting — extend to intake), FDX (Final Draft) export for treatments/scripts, CSV/JSON export for boards and grids, best-effort World Anvil import mapping with a documented field-coverage table (unmapped fields listed, not silently dropped). InteropPanel on the ideation hub, three tabs. Fountain intake runs the REAL chronicle parser in-browser (workbench now depends on @hathor/pre-production, which was also missing its type:lib tag — the third lib caught by that bug class); diagnostics listed by line, errors block the capture, warnings ride along, and the captured idea carries payload.chronicle provenance (speakers/word/element counts). FDX export is a new real exporter (scriptwriting/fdx.ts): chronicle elements projected onto Final Draft's paragraph vocabulary with XML escaping, chronicle-only concepts (annotations, historical notes) exported as ScriptNotes AND reported in exportedAsNotes — a projection that names its losses; treatments and synopses export via chronicleFromProse from buttons on the develop ladder, and any parsed intake downloads as .fdx. CSV/JSON exports: RFC-4180 builders (interop-export.ts) for the board (with manifest, cap named when it bites) and the season grid from EpisodeGridPanel (unjudged intensity stays blank, never zero). World Anvil import: declared mapping WORLD_ANVIL_FIELD_MAP rendered as the in-UI coverage table and documented in docs/world-anvil-field-coverage.md; preview shows mapped AND unmapped fields per article before import; unmapped fields also stored on the idea's payload; HTML stripped for the body with the original kept; every import goes through the standard capture route so P10.1 screening applies. Specs at every layer (fdx golden assertions incl. escaping, CSV escaping known values, WA coverage contract, panel flows with the real parser un-mocked); axe gate caught and fixed the unlabeled textareas. Chrome-verified live against postgres: fountain paste→import→provenance in DB, WA preview→unmapped-listed→import→provenance in DB, board CSV download.
  • 16.8 Onboarding & help: purposeful empty states on every new surface (what this is + one-click seeded example), keyboard-shortcut sheet (?), a seeded demo board for new workspaces. ShortcutSheet on ? (never while typing in a field), rendered from a declared SHORTCUT_GROUPS contract that lists only bindings that exist — palette, quick-capture, per-editor undo/redo, corkboard and canvas keys — with a spec pinning the declaration. Seeded demo: src/lib/demo-seed.ts — curated in-repo ideas (16.4 rule: reviewed data, never model output) pushed through the REAL routes (capture → triage keep → option set → tournament), everything tagged demo-seed, second run refused with the reason; DemoSeedCard renders on the empty ideation hub with what-this-is copy and retires once content exists. Empty states: hub card added; inbox/tournament/compare empties were already purposeful; graveyard's enriched to explain revivable kills. The seed exposed a real pre-existing bug live: the hub board queried inbox() (captured-only), so the developing/shortlisted/selected/ promoted columns could never show anything. Fixed with a GET /ideas?status=&limit= route + service + client and the board re-pointed at it; route test proves the list spans statuses while the inbox stays captured-only triage. Chrome-verified on a fresh database: seed card → click → 5 ideas captured, 2 developing, tournament open, board columns populated, ? opens the sheet, card gone on revisit.
  • 16.9 Design-language conformance + theming audit: all new pages audited against apps/oshun/web design tokens; dark/light parity; the axe accessibility pass (11.4) re-run after theming. Audit + implementation, written up in docs/design-conformance-and-theming-2026-07-19.md: accent scale conformant with the web token system's domain-accent pattern; status tones match trust-signal behavior; raw hexes only where color is DATA (plotline hashing, cursor palette, node kinds). Dark/light parity IMPLEMENTED across all 57 sources (1,347 dark: utilities via a reviewed mapping + base css), keyed off html[data-theme] — the same data-attribute theming the web app uses — with system-following resolution, a persisted header toggle (lib/theme.ts, spec'd), and declared paper-surface exceptions (GraphCanvas keeps light ink-on-paper in both schemes). Chrome-verified live in both schemes on the ideation hub and the develop ladder (a missed dark:disabled: surface found and fixed there). Axe suite (11.4) re-run after theming: 9/9 green — the same gate that caught the unlabeled interop textareas earlier this phase. Full workbench suite 466/466.

Sequencing & dependency notes#

  • P0 → P1 → P2 are strictly sequential. P3.x engines are independent of each other after P1/P2; build 3.1 first (highest leverage), then 3.5, 3.2, 3.4, 3.3, 3.6, 3.7.
  • P4 needs P3 output but 4.2/4.3 math can be built and tested standalone.
  • P6.0a/6.0b unblock all four parity pages; the pages themselves are independent — ship Cultures (6.1) first (only entity with zero workbench presence today).
  • P9 is independent and small — safe filler work between larger slices.
  • P7/P8/P12 are enhancement layers; P10/P11 are cross-cutting and apply from the first line of code, not at the end.
  • P13 (games) and P14 (film/series) depend on P1–P5 primitives and the P6 canvases; they are independent of each other — pick by production need.
  • P15 depends on P4 (rubrics/decisions) + P13.7/P14.2 artifacts for its gates; P16 is incremental polish, safe to interleave from P6 onward.
  • Reuse-first rule for P4.7/4.8, P5.6/5.7/5.8, P13.8, P15.5: the yemaya QA analyzers and validators named there already exist and were spot-audited — tasks are ADAPTERS and UI, and any adapter that finds an analyzer's contract unfit records that finding instead of forking a parallel implementation.