Master TODO

Purpose

This is the official cross-discipline backlog for EchoSpire: Portals.

It includes design, narrative, content, technical, UX, production, and pipeline work. It is intentionally broader than an engineering task list.

For the short list of immediate priorities, see Current Next Steps.

Critical Design Decisions

• Define XP pacing and how hero progression is earned across tutorial, campaign, and endgame.
• Formalize environment difficulty scaling tables by realm tier and threat tier.
• Define standard campaign run length and chapter structure beyond tutorial scope.
• Decide how much persistent power a leveled hero carries into new runs without flattening roguelike tension.
• Finalize the official rift taxonomy and the variable contract for each rift type.
• Finalize the effect-module and trigger-pipeline contract before large-scale content expansion.
• Finalize the AI subsystem boundaries and the contract split between gameplay AI, generative assistance, and operational agents.

Narrative And Worldbuilding

• Write the full 4-act campaign outline for each faction.
• Define the recurring cast for each faction campaign: handler, ally, rival, outsider, and leader-facing relationship.
• Build the quest spine for each faction after the tutorial.
• Define a realm anthology of attached realities with distinct flavor, provenance, and political meaning.
• Define the major revelations about the founders, Kaelen, and the original collapse.
• Write faction-against-faction storyline arcs that connect political conflict to gameplay encounters.
• Define sector progression patterns that let one realm support a full quest arc without losing variety.
• Create codex structure for world history, sectors, leaders, classes, and major events.
• Establish narrative style rules for dialogue, briefings, codex, and event writing so faction voice remains consistent.

Gameplay Systems

• ~~Rebuild the tutorial runtime around scenario-driven faction onboarding instead of the current hard-coded tutorial slice.~~ ✅ Done — tutorials consolidated into the quest system as QuestType.Tutorial with RunPresets, AuthoredContent, and CompletionReward JSONB sections.
• ~~Replace code-seeded tutorial backfill with Admin/API-owned authoring and validation for tutorial quests, tutorial goal links, and tutorial story beats.~~ ✅ Done — FactionTutorial entity and all *TutorialData.cs seed files removed; Admin quest editor now provides MudBlazor structured sub-editors.
• Sequence advanced redirection mechanics so tutorials teach only supported gameplay first, with Taunt and Intercept introduced later alongside real production-rift content and deck support.
• Implement the quest system so run parameters are actually driven by quest templates.
• Implement single-realm campaign runs with sector progression, escalating pressure, and revealed breach-sites.
• Implement realm-wide passive rules that can help, hurt, or create double-edged pressure.
• Implement the Rift Run casual quick-play mode: class and faction selection, 3-realm random run with no narrative, end-screen stats, and progression boundary that keeps campaign unlocks separate.
• Expand authored content on top of the live rift-rule runtime so all official rift types carry content-rich objectives, rewards, and consequences instead of generator defaults alone.
• Define the universal objective-protection toolkit so every class can handle protection and escort rifts in a flavor-correct way.
• Build official rival hero encounter rules for class-faction opponents.
• Implement deterministic enemy, boss, and rival hero AI policy layers.
• Define how faction-versus-faction battles differ from monster fights in rewards, pacing, and AI behavior.
• Implement meaningful meta progression instead of stub endpoints.
• Finalize relic design philosophy and build a full relic pool.
• Finalize random event structure and build enough event variety for repeatable campaigns.
• Expand boss design beyond tutorial-scope bosses into campaign and endgame boss rosters.

Content Production

• Expand the card pool from starter scope into campaign-scale pools.
• Build rarity distribution and reward cadence for class and faction cards.
• Design more enemies for each realm and faction pressure type.
• Build a production realm roster with enough variety to support climatic, historical, foreign, machine-scar, and conceptual-reality quest chains.
• Build full construct roster and anomaly roster where needed.
• Create a proper reward ecosystem: cards, relics, resources, lore, unlocks, and unique quest rewards.
• Design faction-specific events, elite encounters, and ambient world interactions.

Difficulty And Balance

• Implement enemy HP and damage scaling formulas instead of placeholder values.
• Add realm-to-realm difficulty progression in the live game runner.
• Define threat tiers and optional challenge layers for endgame play.
• Add stronger AI simulation policies beyond the current limited set.
• Finish analytics endpoints for simulation results, analytics, and outlier detection.
• Build the policy portfolio for simulation player behavior and objective-aware testing.
• Build balance dashboards that help identify dead cards, overperformers, weak archetypes, and bad encounter spikes.

Hero, Meta, And Persistence

• Define what a persistent hero record stores beyond name, faction, and class.
• Pin active runs to immutable published content snapshots so card and quest changes do not alter in-progress runs.
• Implement hero XP, level, and chosen power tracking.
• Implement unlock tracking and spending flows.
• Decide what should be account-level versus hero-level progression.
• Harden save, restore, and resume behavior for mid-combat and mid-event states.
• Add explicit save-and-quit behavior outside sanctuary-only autosave.
• Add versioned migration strategy for old saves.

Client And UX

• Build the Windows-first WPF MVP client around title, login, faction selection, class selection, hero list, hero creation, and run bootstrap flows using the live API endpoints.
• Replace generic WPF business-app chrome with a reusable game UI kit: branded typography, ornamental frames, faction and class tiles, hero pedestal or card selectors, and narrative overlay treatments.
• Keep structured local telemetry in the WPF client for lifecycle, API timing, command timing, and exception capture so debugging stays practical during UX iteration.
• Keep gameplay truth in Core and avoid locking core UX contracts to WPF-specific presentation behavior.
• Validate combat readability, flow, and save-resume behavior in the WPF MVP client before spending on a Unity migration.
• Define the event, save, and presentation seams required for a later Unity migration if the product proves itself.
• Start the real Unity client only after the product is validated and the presentation upgrade is justified.
• Design and implement map, combat, reward, shop, event, and codex screens.
• Implement the startup-loading to opening-story to main-menu flow so the client establishes faction, lore, and player role before the first hero or run decision.
• Implement the real hero-builder screen with faction-first selection, filtered allowed classes, portrait framing, and player-facing commitment messaging closer to a character forge than to CRUD.
• Stop shipping WPF screens against sample assets; package and consume approved assets/ screen assets in the actual client output.
• Define how hero progression choices are presented in a readable and exciting way.
• Build UI support for rival hero encounters and faction-vs-faction storytelling.
• Build clear surfacing for status effects, intents, scaling rules, and deck state.

Admin And Tooling

• Add validation rules for bad content references and invalid parameter combinations.
• Add shared API/Admin validation for nested tutorial goals, quest objectives, typed rift payloads, and hero-state payloads now that the richer editors exist.
• Add relationship views across cards, factions, classes, enemies, effects, and quests.
• Add bulk import and export workflows.
• Add preview tooling for cards, encounters, rewards, and quest chains.
• Add publish safeguards and better rollback trust for content changes.
• Add operator management and deeper run operations in Admin beyond the new hero profile, campaign state, and run inspection surfaces.
• Add support for hero progression row editing and rival hero encounter authoring.
• Add tooling to inspect AI policy outputs, recommendation artifacts, and live-site agent evidence summaries.
• Add effect catalog, trigger catalog, and module compatibility validation views.
• Add rift-template authoring with type-specific variable validation.
• Add authoring DTO validation and preview support for each official rift type payload.

Community And Ecosystem

• Expose a public read-only card data API that returns the full card pool, relic pool, class stats, faction passives, and keyword definitions in versioned JSON for community tool builders.
• Build an in-game deck inspector with synergy highlights once the card pool is large enough to warrant it (post-campaign-scale card expansion).
• Do not build an official separate theory-crafting app. Let the community build tools against the public data API.

Architecture And API

• Replace placeholder combat defaults with data-driven class values for max energy, hand size, and related stats.
• Define and implement a Unity-safe shared contract split so the current net10.0 runtime does not have to be forced directly into Unity.
• Expand the new internal auth foundation to cover external provider linking, refresh-token revocation policy, and account lifecycle management.
• Define the promotion rules from completed or abandoned runs into persisted hero profile and hero campaign state.
• Finish meta progression controller behavior.
• Finish simulation controller behavior.
• Add policy and evidence contracts for gameplay AI and live-site operational agents.
• Expand quest template data contracts so they support authored campaigns, rival heroes, and narrative routing.
• Expand realm and quest contracts so they support provenance, sector tags, realm passives, and sector progression logic.
• Expand runtime contracts so effects, triggers, manifests, and UX event payloads are explicit and versioned.
• Define the canonical GameplayEvent, EffectResult, TriggeredEffectBatch, and UxEvent schemas.
• Define the first effect-module manifest schema, compatibility policy, and activation rules.
• Finish type-specific authoring DTOs and persistence contracts for Combat, Elite, Boss, Event, Shop, Rest, Treasure, Anchor, Protection, and Sanctuary rifts so API/Admin own the payloads now supported in Core.
• Keep gameplay rule truth inside Core while Unity remains a presentation client.
• Preserve API-first boundaries for client, admin, and simulation.

Audio, Visual, And Presentation Direction

• Define a production art direction package for cathedral sci-fi environments, UI, and faction identity.
• Maintain a versioned Ludo prompt library for Unity UI kits, faction crests, portrait placeholders, and first-slice presentation assets.
• Establish VFX language for mechanics like Stasis, Echo-Lock, Overload, and Mutation.
• Define audio direction for each faction and for key systems such as rival hero fights and reality fractures.
• Create presentation hooks for boss intros, codex reveals, and campaign act transitions.

QA And Production Hardening

• Execute the hosted early-dev runbook and keep it current as the first tester environment changes.
• Add stronger CI coverage for build, tests, migrations, and content validation.
• Add operational monitoring and failure reporting for API and background systems.
• Add regression coverage for deterministic seeds and golden run sets.
• Add content validation checks as part of publish workflow.
• Maintain this official documentation set as the canonical source when design decisions are locked.

Missing Pieces Called Out By Current Design Review

These are the major missing areas most likely to block the project from becoming a complete shippable game:

• campaign-scale content beyond tutorial scope
• implemented level 10 hero progression rows in runtime, authoring, and persistence flows
• full difficulty growth model across realms and endgame
• rich authored questline strong enough to carry the world's lore
• faction-versus-faction rival hero combat
• meaningful meta progression and persistence
• Unity client validation
• analytics-backed balancing loop
• production-grade content tooling