The DreamPro Coaching System

Codename / sellable brand: "The DreamPro Coaching System" — a turnkey, gamified coaching platform a fitness-industry channel partner (first partner: John Rowley) can rebrand, recruit coaches into, and earn a recurring override on. DreamPro.io becomes the coaching front door; the citizen-science platform (Open Energy) migrates to its own home.

Status: Plan / not yet built. This doc is the spine — phases, data model, economics, migration, and the honest gaps. Companion specs: Coach Seat · Channel economics · ClickBank funnel · AI-persona dogfood + backfill. Admin-only pitch surface for John: /for-john (super-admin-gated).

Decisions locked (2026-06-14, with the founder):

1. DreamPro.io = coaching only. Citizen science (Open Energy, experiments, world map, leaderboards) migrates out to openenergy.* with 301 redirects.
2. Two-tier channel economics (ClickBank-style). Client pays → coach earns the bulk → channel partner (John) earns a recurring override on every coach he recruits + their clients → platform takes an infra cut.
3. Operational ownership. John owns the brand, pricing, distribution, and the coach roster. HiveJournal owns the tech, infra, and payout rails. Rev-share relationship (not equity/JV in v1).

0. The core insight (why this is low-risk)

We are not building a fitness app from scratch, and we are not throwing DreamPro away.

The DreamPro engine — dreams as templates → clones → steps, plus competitions/leaderboards (migration 050, 054) — is already a universal substrate for "author a program, let many people clone it, track their progress, rank them." Citizen science (energy experiments) was just one vertical built on that substrate.

This plan promotes fitness coaching to the flagship vertical and moves energy to its own brand. Almost every coaching mechanic already ships:

The client experience is ~80% there today. What turns it into something John promotes and earns from is two focused builds: a coach-facing product — the Coach Seat, a swappable AI/human coach built on the platform's already-shipped swappable-role pattern (Section 2) — and a channel-economics layer (attribution

• multi-party split, Section 3) on top of payout rails that already exist.

1. The three roles

HiveJournal (platform/infra)
      │  owns tech + payout rails, takes infra cut
      ▼
John Rowley (Channel Partner) ── owns brand/pricing/distribution/coach roster
      │  earns recurring OVERRIDE on every coach + their clients
      ▼
Fitness Coaches (recruited by John) ── run their own client cohorts
      │  earn the bulk of client subscription revenue
      ▼
Clients (end users) ── pay the subscription, do the program

• Channel Partner (John): operational owner. Recruits coaches, sets packaging and price, controls the brand. Sees a network-wide dashboard (recruited coaches, conversion, override balance, payouts).
• Coach: a seat, not a person (Section 2) — held by an AI persona coach by default, swappable to / supervised by a human. Authors programs (DreamPro templates), runs cohorts, reviews the AI coach's drafted feedback against client adherence (Throughline trends), gets paid via Stripe Connect.
• Client: onboards through a coach's branded invite/promo link (attribution captured here), clones the program, lives in Workout Window + JQ companion, shares trends back to the coach.

2. The Coach Seat — a swappable AI/human holder

The coach is not a person — it's a seat, held by an AI persona coach by default and swappable to (or supervised by) a human coach. This is the same proven pattern as the platform's 5 AI-or-human role seats (migration 234, PLATFORM_ROLE_SEATS_SETUP.md), pointed at coaching.

The load-bearing invariant (borrowed verbatim from the platform roles): decisions reference the seat, not the holder. Swap an AI coach for a human and the client's coaching history stays continuous — same goals, same audit log, just a different name signing today's feedback.

Granularity: one Coach Seat per client, rolled up into a per-cohort view for the human coach. (Per-client matches the platform pattern and keeps feedback personal; the cohort view is where a human works the whole roster at once.)

Full ready-to-implement spec: DREAMPRO_COACHING_SEAT_SCHEMA.md (tables + brief-generator contract + delivery + RLS + build checklist). Sketch below.

Schema sketch (models content_manager_role, plus one coaching-specific field):

coaching_seats (
  id uuid pk,
  coaching_membership_id uuid references coaching_memberships(id),  -- the client (§4)
  title text default 'Coach',
  held_by_persona_id uuid references ai_personas(id),   -- the AI coach (default)
  held_by_user_id    uuid references auth.users(id),    -- OR a human coach
  -- exactly_one_holder: (persona is not null) XOR (user is not null)
  supervisor_user_id uuid references auth.users(id),    -- NEW: human overseeing an
                                                        -- AI-held seat across many clients
  can_nudge boolean default false,        -- scope flags, same shape as the platform seats
  can_adjust_program boolean default false,
  daily_action_budget int default 0,      -- 0 = advisory-only (drafts wait for approval)
  ...
)
-- + coaching_seat_decisions (advisory→executed→reversed lifecycle, actor stamped
--   at decision time so a swap never rewrites attribution) and coaching_seat_goals.

The one addition the platform roles never needed is supervisor_user_id, distinct from the holder — so a human coach can oversee many AI-held seats without holding each one. That separation is the entire leverage of Tier 2 below.

The AI coach's "brief" = the between-session review. On a daily cron tick (per active seat, with recordHeartbeat + a CRON_REGISTRY toggle like every other cron), the AI coach reads the client's Throughline trends (mood/energy/sleep)

• Workout Window adherence (check-in streak, missed windows) and drafts a personalized nudge / encouragement / program adjustment as a decision with executed_at = NULL (advisory). What happens next is the holder/supervisor mode:

That ladder is not three products — it's one schema with the holder/supervisor set differently, and it doubles as a pricing ladder. It also solves the two things that kill coaching businesses: cold-start (no client ever waits for a human) and coach scaling (a human's leverage is supervising AI drafts).

Reuse vs build. Reuse: the whole swappable-holder pattern — holder XOR constraint, the advisory→executed→reversed decision lifecycle (which is the "AI drafts, human approves" mechanic — already shipped), invite/claim handoff, the brief-loop cron architecture, scope flags + budget, and the all-roles/decisions-timeline admin UI patterns. Build: the coaching_seats table (per-membership, + supervisor_user_id), the coach-brief generator that reads Throughline + Workout Window, client-facing delivery of approved feedback, and the coach review dashboard — which is just Phase 1's roster reframed: the at-risk roster IS the queue of AI drafts awaiting approval.

Guardrail (write it into the brief prompt). The AI coach stays in the wellness / accountability lane — pacing, adherence, encouragement, "you skipped three windows, what's in the way?" — and never gives prescriptive medical / injury / nutrition-pathology advice. Same "wellness, not clinical" posture as Throughline. Tier 2's human review exists partly to manage exactly that liability; anything autonomous (Tier 1) needs claim-safe guardrails baked in.

3. The money model (the heart of "make $ off of it")

What already ships (the rails — ~70% of the payout machinery)

• Stripe billing — multi-plan subscriptions (plan_key discrimination, migration 129), checkout, webhooks, retention/cancellation flows. (payment.ts)
• Creator payouts via Stripe Connect Express — creator_payout_accounts (KYC onboarding), creator_revenue_splits (per-creator split override), creator_earnings (append-only ledger w/ source_kind), creator_payout_periods (scheduled payouts). This is a working pay-many-people-a-revenue-share engine. (creator-payouts.ts, migrations 160/161)
• A referral-code primitive — Lovio waitlist already generates collision-safe codes + tracks referred_by. Copy this for partner/coach codes. (270_lovio_waitlist_referrals.sql)
• Monetization analytics — 4-stage funnel + daily MRR/CAC snapshots.

What we build (the two real gaps)

1. Attribution graph — who recruited whom, who owns each client.
2. Multi-party split — extend creator_revenue_splits from one payee to a policy of N payees so a single subscription event pays coach + channel partner + platform in one transaction.

Example split (illustrative — John sets the real numbers)

Client pays $29/mo:

• Platform (HiveJournal): ~18% infra — $5.22
• Coach (owns the client): ~62% — $17.98
• Channel partner (John) override: ~20% — $5.80

The override is the recurring engine: every coach John recruits, and every client those coaches sign, pays John a slice for the life of the subscription. That is the ClickBank "JV / second-tier" mechanic John already runs in his sleep — he'll likely help design the exact percentages.

Stripe Connect transfers are per-account, so a 3-way split = 2 transfers (coach + John) out of the platform-held charge, both stamped into creator_earnings with distinct source_kinds and reconciled by the existing creator_payout_periods machinery.

4. Data model additions

Reuse first; add only the attribution + multi-party pieces.

Reuse (no change)

• dreams / dream_steps (templates→clones→steps) — coaching programs
• workout_windows + chains/squads/checkins/battles — accountability
• jq_bridge_connections + jq_bridge_permissions — coach↔client trend sharing
• chat_conversations (personality field) — fitness AI persona
• organizations / teams / roles — John's brand org; cohorts as teams
• creator_payout_accounts / creator_payout_periods — payout rails
• dream_coaches (foundation table exists, no UI yet) — coach↔dream link
• ai_personas + the swappable-role pattern (content_manager_role shape, invite/claim, decisions lifecycle) — the Coach Seat (Section 2)

New / extended

1. coach_profiles (or a role='coach' extension of profiles) — a coach belongs to a channel partner: channel_partner_id, branding (display name, logo, accent color), status, stripe_connect_account_id (reuse).
2. partner_referral_codes — copy the Lovio code generator. code, owner_kind (channel_partner | coach), owner_id. Resolves an inbound signup to its recruiter/coach.
3. Attribution edges:
   • client → coach (which coach owns this client / cohort membership)
   • coach → channel partner (already on coach_profiles)
   • the signup's originating referral_code (immutable, set at signup)
4. coaching_revenue_policies — extend/parallel creator_revenue_splits to a multi-party policy: an array of { payee_kind, payee_id, basis_points } that sums to 10000. Default policy editable by the channel partner (operational ownership) within platform-set floors.
5. creator_earnings source_kinds — add coaching_subscription (coach share) and channel_override (partner share). Ledger + transfers already exist.
6. Stripe plan — new plan_key = 'dreampro_coaching' (per-coach custom pricing is a later enhancement; v1 = one platform price John sets).
7. coaching_seats (+ coaching_seat_decisions / _goals) — the per-client AI/human Coach Seat; full schema sketch in Section 2.

Two adaptations that are NOT free (flag these)

• Cohort-scoped Workout Window. ✅ SHIPPED (squads) 2026-06-14. Manual named cohorts (a team under one shared "DreamPro Coaching" org; coaching-cohorts.ts) + per-client assignment (stamps coaching_memberships.cohort_team_id). The chain generator (daily-chain-generator.ts) now runs one matching pass per cohort + a global pass that excludes cohort members, via matchChains(date, {includeUserIds|excludeUserIds}) — clients squad with their cohort, not strangers. Collapses to exactly the old global behavior when no cohorts exist. Weekly battles are cohort-scoped too (migration 375 + battle-system.ts generateAllWeeklyBattles): one red-vs-blue battle per cohort (teams balanced within the cohort) + a global battle excluding cohort members; /battle/current returns the viewer's cohort battle.
• Private/access-controlled competitions. ✅ SHIPPED (cohort leaderboard) 2026-06-14, as a purpose-built surface rather than the citizen-science competition engine — that engine is built on participants scored on dream clone/completion/build, a poor fit (and it would pollute the world map). Instead coaching-cohorts.ts getCohortLeaderboard() ranks a cohort's members by 30-day Workout Window check-ins (tiebroken by program progress), read-time + batched. Access-gated: GET /api/coaching/cohorts/:id/leaderboard → 403 unless the caller is a cohort member, the cohort's coach (team admin), or super-admin. Surfaced to clients on /dashboard/my-coaching ("Your cohort") and to the coach/admin via the clickable cohort chips on /dashboard/coaching. (The shared global citizen-science competitions are untouched.)

5. Product surfaces

Client (mostly shipped — wire + theme)

• Onboard via coach's branded invite/promo link → attribution captured
• Clone the coach's program (DreamPro template → clone)
• Daily steps push into Workout Window (squads, photo proof, battles)
• Fitness-tuned JQ AI companion (daily nudge; reads sleep/energy/mood)
• Share adherence trends with coach via JQ Connect/Throughline
• Sleep / energy / mood tracking + weekly recap

Coach (the main product build — Phase 1)

• Coach review dashboard (the AI-draft queue): for each client the AI coach has read Throughline trends + Workout Window adherence and drafted today's feedback/nudge; the human coach reviews, edits, and approves (or lets it send autonomously in Tier 1). The "at-risk roster" is this queue, sorted by who needs attention. This is the stubbed Throughline Phase 2 roster, now powered by AI drafts — see the Coach Seat (Section 2).
• Seat controls per client: set the mode (autonomous AI / supervised / human-held), scope flags, daily budget; swap the holder via invite/claim.
• Program authoring: create/edit DreamPro fitness templates
• Coach branded landing + promo code / invite link
• Coach earnings dashboard (reuse Stripe Connect creator payout views)

Channel partner / John (Phase 2)

• Partner dashboard: recruited coaches, network-wide conversion funnel, override balance, payout history (reuse monetization-analytics + payout views)
• Recruit coaches: generate partner codes, coach onboarding flow
• Pricing / packaging control (operational ownership, within platform floors)

6. Brand & domain migration (DreamPro.io → coaching; CS moves out)

Current DreamPro public surfaces today serve citizen science: /dreampro, /dreampro/templates, /dreampro/map, /dreampro/competition/[slug], /dreampro/citizen-scientist, /dreampro/classroom, /dreampro/family, /dreampro/meetups, plus /api/dreampro/*.

The split

• Engine stays. dreams/templates/clones/steps/competitions keep powering both verticals — no data migration of the engine.
• Citizen-science surfaces + content move to openenergy.* (decided), with 301 redirects from the old /dreampro/* CS routes. Reuse the host-aware middleware pattern from MULTI_BRAND_DOMAINS.md (the same DNS + Vercel + host-aware middleware recipe that already aliases write.cafe / graphene.fm / hivejournal.com).
• DreamPro.io public surfaces are rebuilt as the coaching front door (John's brand): hero, "how it works," coach directory, client onboarding, pricing, become-a-coach.

Migration checklist

• Register openenergy.* + stand up host-aware routing (MULTI_BRAND_DOMAINS.md)
• 301 redirect old /dreampro/* CS routes → new home (preserve SEO + existing participant links)
• Notify existing Open Energy participants of the new URL
• Rebuild DreamPro.io landing as coaching front door
• Docs sync (per CLAUDE.md): update INDEX.md, ARCHITECTURE.md, the CS feature docs (dreampro-citizen-science.md, open-energy.md), and the public feature pages (features/page.tsx)
• Update project_citizen_scientist_map memory + portfolio board row (product_portfolio, migration 367) so the rollout board reflects the split

7. Phasing

Phase 0 — Demoable config, no new core code (days)

Goal: something clickable to show John this week. Seed script: scripts/seed-dreampro-coaching.ts (follows the established npx tsx + service-role + is_seed pattern, fully reversible via --wipe).

Run it:

npx tsx scripts/seed-dreampro-coaching.ts --generate          # templates + demo competition
npx tsx scripts/seed-dreampro-coaching.ts --generate --coach <john_user_id>   # owned by John
npx tsx scripts/seed-dreampro-coaching.ts --wipe              # remove everything it created

Writes to whatever SUPABASE_URL in apps/backend/.env points at — confirm prod-vs-staging before running. The script does not auto-run.

What it creates (all is_seed=true / slug-namespaced):

• 3 public, cloneable fitness program templates — "Couch to 5K — 9-Week Run Start", "12-Week Strength Foundation", "30-Day Reset — Sleep/Movement/Mindset" — each with ordered steps (the Strength template even threads the hivejournal-20 Amazon affiliate tag on gear materials).
• A demo cohort competition (/dreampro/competition/dreampro-coaching-demo).

The live demo walkthrough (all shipped surfaces):

1. Browse /dreampro/templates → open a coaching program → Clone it.
2. On the cloned dream, add a step to Workout Window → do a photo check-in.
3. Open the JQ companion set to the motivational personality (closest shipped persona — a dedicated "fitness coach" persona is a one-prompt Phase 1 add, not core code).
4. Share trends with a "coach" via JQ Connect/Throughline (trends, not entries).
5. Show the cohort leaderboard at /dreampro/competition/dreampro-coaching-demo.
6. (Optional) a one-page coaching landing teaser on a staging route.

Phase 0.5 — ClickBank front-end + QR "start a plan" (parallel track)

John's native acquisition channel — a cheap front-end product whose QR codes / deep links one-tap-instantiate a real DreamPro program and carry referral attribution into the recurring back-end. Concrete spec: DREAMPRO_COACHING_CLICKBANK_FUNNEL.md.

• dreams.public_slug + coaching_links (durable redirect so printed QRs never break)
• /start/<slug>?ref=<code> (clone + attribution) and /go/<id> (print-safe redirect)
• Lead product: digital "30-Day Reset" challenge-in-a-box (placeholder; John's call)
• Rides the Phase-2 attribution graph so a book sale → subscription → override
• Depends on Phase 2 attribution; the front-end product itself can be produced in parallel.

Phase 1 — Coach product = the Coach Seat (1–2 weeks)

The genuine product gap. Built on the swappable-holder pattern (Section 2). Concrete ready-to-implement schema: DREAMPRO_COACHING_SEAT_SCHEMA.md.

Status (2026-06-14): SHIPPED to main. Migrations 368 (attribution foundation) + 369 (coaching seats); coach-brief.ts (brief generator); routes/coaching.ts (review queue + approve/reverse + mode controls); the coach_brief cron in index.ts (default-off, COACH_BRIEF_ENABLED, heartbeat coach_brief_tick); and the coach review dashboard at /dashboard/coaching (the AI-draft queue — edit/approve/reverse + per-seat mode toggle + manual brief), linked from the admin shortcut list. Backend tsc + frontend lint clean. Next: Phase 2 (channel economics) + seat creation on client onboarding + the AI-persona dogfood seeding to populate the queue.

• coaching_seats table (per client, + supervisor_user_id) + decisions + goals — modeled on content_manager_role. One AI persona coach seated per client by default.
• Coach-brief generator (cron): per active seat, read Throughline trends + Workout Window adherence → draft today's feedback/nudge as an advisory decision. recordHeartbeat + CRON_REGISTRY toggle (per CLAUDE.md).
• Coach review dashboard = the AI-draft queue (the at-risk roster): approve / edit / send; per-client seat-mode controls (autonomous / supervised / human).
• Client-facing delivery of approved feedback + the wellness-lane guardrail baked into the brief prompt.
• Holder swap via invite/claim (reuse the platform-role flow); coach onboarding + branded landing + Connect payout view.
• Program authoring polish for coaches.

Phase 2 — Channel economics (1–2 weeks)

What makes John money. Concrete ready-to-implement schema: DREAMPRO_COACHING_CHANNEL_SCHEMA.md.

Status (2026-06-14): SHIPPED (gated). Attribution graph + coaching_referral_codes, the 3-way split, the coaching_subscription plan + checkout, auto-record on invoice.payment_succeeded, the coaching_payouts cron (real Connect transfers), the partner dashboard (/dashboard/coaching/partner), and one-tap coach payout onboarding (the "Get paid" card on /dashboard/coaching). Both money-moving steps gated by COACHING_PAYOUTS_ENABLED + the cron toggle.

• Attribution graph + coaching_referral_codes (copy Lovio generator)
• 3-way split policy (coach + partner + platform) on the existing Connect/ledger rails
• New coaching_subscription Stripe plan
• Partner dashboard (recruited coaches, override balance, payouts)

Phase 3 — DreamPro.io rebrand + CS migration (1–2 weeks)

Status (2026-06-14): alias + coaching front door SHIPPED (code). The host-aware middleware rewrites dreampro.io/ → /coaching (the public landing), and detectBrandSlug() tags dreampro.io signups brand='dreampro' (🏋️ on the admin user cards). Activation is DNS/Vercel/ Supabase config — see DREAMPRO_IO_DOMAIN.md. Still to do: the CS→openenergy.* migration + 301s (below), and dedicated DreamPro brand chrome.

The two "not-free adaptations" SHIPPED (2026-06-14): cohort-scoped Workout Window (manual named cohorts → squads matched within the cohort + a global pass excluding cohort members; per-group team balance), a private cohort leaderboard (adherence-ranked, access-gated), and cohort-scoped weekly battles (migration 375; one red-vs-blue battle per cohort). See §4 + INDEX. Back-compatible — zero cohorts collapses to the original global behavior.

• Rebuild DreamPro.io as coaching front door
• Migrate Open Energy / CS to its own home + redirects
• Cohort-scoped Workout Window + private competitions (the two not-free adaptations) — SHIPPED (cohort squads + leaderboard + weekly battles)
• Full docs/portfolio sync

Phase 4 — Depth (later, demand-gated)

• Body metrics + structured workout detail (sets/reps/weight) — likely needed for fitness credibility (Workout Window proves presence, not performance)
• Wearable sync (Apple Health / Strava / Fitbit)
• Full white-label tenant (if John later wants Shape B): per-org theming + custom domains, coaches/clients never see HiveJournal
• Coach licensing/verification; per-coach custom pricing

8. Honest gaps & risks (so John isn't oversold)

• No body/nutrition/workout-detail data. Workout Window tracks that you showed up (photo), not sets/reps/weight/macros. Fitness buyers will expect at least lightweight body-metric + workout-detail logging → Phase 4 (or pull forward if it's a deal-breaker for John's audience).
• No wearable sync yet — common ask in fitness; Phase 4.
• Throughline Phase 2 (coach roster/alerts) is stubbed, not built — that's exactly Phase 1 here.
• Throughline demo is therapy-framed — needs fitness-framed demo personas.
• Cohort-scoped squads + private competitions are real adaptations, not config (Section 4).
• AI coaching liability. Tier-1 autonomous nudges must be claim-safe by construction (wellness lane, no medical/injury/nutrition-pathology advice — see Section 2). When in doubt, default a seat to Tier 2 (human-reviewed).
• Legal/IP: operational-ownership rev-share with John needs a simple partner agreement before build heat: rev-share %, brand/domain usage rights, term, and what happens to client data + coach roster if the partnership ends. (Not equity/JV in v1 — if that changes, clear IP first; see legal/IP_STRATEGY.md.)

9. Success metric

North star for the channel: recurring override MRR flowing to the channel partner — because it only grows if coaches stay, clients adhere, and the gamified accountability actually works. A vanity "coaches recruited" number without retained client subscriptions means the product isn't delivering.

10. Reuse-vs-build summary