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

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)

- [x] 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).
- [x] 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).
- [x] 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.)
- [x] 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.
- [x] 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`).
- [x] 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`)

- [x] 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).
- [x] 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).
- [x] 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.
- [x] 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.
- [x] 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.)
- [x] 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)

- [x] 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.
- [x] 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).
- [x] 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.
- [x] 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).
- [x] 2.5 Import bridges (all three landed 2026-07-18):
- [x] 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).
- [x] 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).
- [x] 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.

- [x] 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).
- [x] 3.1c Logline quality lint (deterministic): flags missing stakes, passive
      protagonist, no irony, > 45 words — each rule unit-tested with known
      good/bad loglines.
- [x] 3.2 **What-if / counterfactual explorer** (`src/generators/what-if.ts`):
- [x] 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.
- [x] 3.3 **Creativity-operator toolkit** (`src/generators/operators.ts`):
- [x] 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).
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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).

- [x] 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)

- [x] 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.
- [x] 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.
- [x] 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).
- [x] 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.
- [x] 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).
- [x] 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.

- [x] 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.
- [x] 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)

- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.

- [x] 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.
- [x] 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.
- [x] 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:

- [x] 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.
- [x] 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):

- [x] 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).
- [x] 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).
- [x] 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.
- [x] 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`).
- [x] 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.
- [x] 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).
- [x] 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.

- [x] 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.
- [x] 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

- [x] 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).
- [x] 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).
- [x] 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)

- [x] 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.
- [x] 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.
- [x] 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.

- [x] 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)

- [x] 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`).
- [x] 9.2 Mirror the same note in each shim's `package.json#description` and in
      `DOMAINS.md`.
- [x] 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.
- [x] 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

- [x] 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).
- [x] 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).
- [x] 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`).
- [x] 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)

- [x] 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.
- [x] 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.
- [x] 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).
- [x] 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.
- [x] 11.5 Docs-center page(s) for the ideation domain following the existing
      generator conventions.
- [x] 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

- [x] 12.1 Funnel metrics (real events through the analytics event pipeline):
      captured → developed → shortlisted → selected → promoted counts and
      conversion, per user and per board.
- [x] 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.
- [x] 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.
- [x] 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)

- [x] 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).
- [x] 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.
- [x] 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".
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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)

- [x] 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.
- [x] 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._
- [x] 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`.
- [x] 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.
- [x] 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._
- [x] 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.
- [x] 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).
- [x] 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

- [x] 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).
- [x] 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._
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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)

- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
- [x] 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.
