Planning Dashboard

The dashboard is your per-project command center. What it shows depends on where the project is in its lifecycle. It has two modes — Imported and Executing — and while a project is still being set up or planned, the dashboard sends you to the Architect, where that work happens in conversation.

Accessing the Dashboard

Click Dashboard in the sidebar's Project section (it's the first item once your project has moved past onboarding).

Dashboard Modes

Trinity picks the mode automatically based on the project's phase.

Imported mode

Shown for projects you imported from an existing codebase, once you've finished the import wizard and before your first plan lands. Presents a doorway into the planning flow:

  • Architect — jump straight into conversational PRD planning

Architect mints your first PRD and the first release. A small note under the doorway links out to Release defaults in project settings so you can set your release policy — how packages version and how their tags are named — before the first release is auto-created.

Setting up and planning (redirects to Architect)

For a greenfield project that's still being set up or planned, the dashboard doesn't show its own screen — it sends you to the Architect, where you shape your roadmap and plan your first work in conversation (see Architect). The dashboard takes over, in Executing mode, once your first plan is committed — whether that plan is a whole PRD or a single story.

Importing (redirects to the import wizard)

While you're still working through the import wizard for an existing codebase, the dashboard sends you back to the wizard, at the step you left it on (see Importing an Existing Project). The dashboard takes over, in Imported mode, once you confirm the import.

Executing mode

Shown once the project has a plan. This is the "normal" dashboard. At the top:

  • Release title + description — the active release's name, with its description (or its version when no description is set) below
  • Release selector (top right) — switches between the project's releases. Selection is persisted per-user via the sync DB, so you land back on the last release you worked with across devices.

Four stats cards:

  • Total Stories — count + how many remaining
  • Completed — merged count + % complete
  • Tokens Used — total input + output tokens spent on the release
  • Total Time — total AI duration + counts of stories completed / PR'd / merged

Followed by:

  • Live Execution — workers and current pipeline activity (paired top-left)
  • Release Health — status of the active release: badge, dependency rollup (which upstream releases are released vs. waiting), blocked-stories-at-gates summary, and a contextual primary action (Release now, View progress, Open Run, View artifacts) (paired top-right)
  • Progress (full-width) — one bar for the active release as a whole and one bar per PRD inside it, click-through to the stories page filtered to that PRD
  • Blocked Stories — stories waiting on unmet dependencies or unmerged complete stories (paired bottom-left)
  • Activity Feed — recent project events (paired bottom-right)

No-plan empty state

When you have a project but no PRDs (and therefore no releases), the dashboard shows a No plan yet panel with two buttons: Open Architect (starts the first PRD) and Release defaults (jump to project settings to set your release policy before the first release is minted).

Generating a PRD

When you generate your first plan in the Architect conversation, Trinity launches the 5-phase planning pipeline:

  1. Architect — designs the phase and epic structure with rationale
  2. Story Writer — writes individual stories with acceptance criteria, including first-pass difficulty and surface_area hints
  3. Dependency Mapper — populates depends_on and places quality checkpoints
  4. Package Mapper — scopes each story to the packages its code changes (every target built from them is affected automatically)
  5. Calibrator — verifies the writer's difficulty / surface-area hints, overrides outliers, and enforces a healthy comparative distribution across the plan

While it runs, the dashboard shows a live phase indicator (current phase highlighted, completed ones green, pending ones dimmed), and the Architect's own run bar tracks the same progress from wherever you're working. You can navigate away safely — you'll be notified when it finishes.

PRDs and Releases

Trinity is release-first: every PRD belongs to exactly one release (prds.release_id). The dashboard is release-scoped — switching releases in the selector re-scopes the cards to that release's stories.

  • Multiple PRDs can live inside a single release as your plan grows
  • Architect proposes a release for each new PRD (existing unshipped one, or a brand-new one) — you settle it in the conversation before the plan is committed
  • Multiple releases can execute simultaneously; each release gets its own coordinator instance (see Releases)

Cross-PRD Story Dependencies

Stories can depend on stories from other PRDs by referencing the upstream story's display ID (its stable 8-character code, like A3F9K2XQ). A dependency can point at a story in any PRD in scope — Trinity works out whether it's cross-PRD by looking at where the referenced story lives, so you never encode a position into the reference. This works within the same release (typical) or across releases (advanced — in that case the upstream release should be shipped before the downstream one).

  • Architect — add features, modify stories, or create new PRDs conversationally
  • Dependency Graph — the visual story-dependency view (lives on its own /graph page, not the dashboard)
  • Releases — create releases, wire dependencies, ship