soldi roadmap

Single source of truth for what's built, what's next, and how we fan the build out. Pairs with BUILD_LOG.md (per-slice ledger) and the docs/SPEC_*.md + docs/DESIGN_SYSTEM.md detail docs.

Last updated: 2026-06-01.

Where we are

Built & locally verified:

  • Marketplace feed from D1 (auctions list/detail, mappers, Zod).
  • Auth/identity (register/login/logout, PBKDF2, signed session cookie, useSession).
  • Bidding — POST /auctions/:id/bid: $5-or-5% increments, balance holds + outbid release, 2-min anti-snipe (max 5 ext), wallet transactions, live bid UI with polling + toasts. 62 tests green.

Direction change (2026-06-01)

The closer — v2 prototype (reference/closer/public/v2/index.html) sets a new design language and expands scope from "auction house" to all-in-one acquisition desk: one tab replaces PropStream (comps), REsimpli (pipeline), and Follow Up Boss (sequences). We adopt the design system wholesale and add three new pages. We do not rip out working marketplace/auth/bidding logic — this is reskin + additive features.

IA = 5 tabs: Market (The Floor) · Comps (AI) · Pipeline · Sequences · Portfolio.

Decisions:

  • Product name (2026-06-01): "soldi" everywhere — name, worker/package, and the wordmark all stay "soldi". We adopt closer-v2's visual system (palette, type, components) but the wordmark text reads "soldi" (Instrument Serif italic).
  • Routing model: keep React Router routes (recommended) vs. single-shell tab switching. Plan assumes routes + a shared shell/TopNav with tab styling.

Backlog → prioritized slices

Each slice is one thin end-to-end increment (migration → Hono+Zod route → frontend wiring replacing mock data → tests → local smoke), shippable in a day.

Foundation (must land first):

  1. Design-system migration — port tokens/type/components into index.css + index.html, restyle TopNav/LiveTicker/Marketplace/LeadDetail/Portfolio. No data changes. See DESIGN_SYSTEM.md. Blocks the visual layer of all new pages.

New pages (each: read/visual slice first, then live backend): 2. Pipeline — board (read): portfolio_stages/portfolio_actions migration

  • seed, GET /pipeline, kanban UI from real D1. (SPEC_PIPELINE.md)
  1. Pipeline — moves: PUT /portfolios/:id/stage, actions log, drag-drop, KPIs, filters. Emits stage-change event.
  2. Comps — UI + mock provider: comp tables/migration, POST /comps/run against a deterministic seeded provider, full ARV/offer/deal-read UI. (SPEC_COMPS.md)
  3. Comps — live provider: swap in ATTOM + Anthropic behind the same contract; cost/latency tracking; streamed deal-read.
  4. Sequences — read: sequences/steps/enrollments/messages migration + seed, list + detail timeline UI. (SPEC_SEQUENCES.md)
  5. Sequences — engine: enroll → schedule → cron dispatch (email via @velli/email-relay) → engagement status; trigger off pipeline events.

Marketplace/auction completion (interleave as the floor gets restyled): 8. Buy-it-now (POST /auctions/:id/buy-now) + wallet charge + portfolio row. 9. Wallet + transactions page/API; auto-reload settings. 10. Cron auction resolution (60s): settle past-end_time auctions, charge winner hold, create portfolio row, release losers, discount re-list unsold. 11. Portfolio real KPIs + spend/revenue chart + recent wins (assignment fee column for ROI). 12. Leaderboard weekly from D1; gamification (confetti, streaks, badges). 13. Admin lead ingest + quality scoring; discount batches. 14. Hardening: optimistic-concurrency on bids (Durable Objects later), test coverage, a11y (drawer/tablist ARIA), mobile, perf (sparkline memoization).

Dependencies: 1 → everything visual. 2 → 3. 4 → 5. 6 → 7. 3 emits the event 7 consumes. 10 feeds 11/12.

Concurrent build workflow (how we fan out)

Run as Workflow invocations, one phase per turn, so we stay in the loop and verify between phases. Within a phase, agents own disjoint files to avoid conflicts; agents that mutate the same tree run in isolation: 'worktree'.

Phase A — Foundation (serialize, 1 agent + verify). Design-system migration (slice 1). Everything downstream paints against it, so it lands alone first. Verify: typecheck/build/test + screenshot diff vs prototype.

Phase B — New-page scaffolds, fan out 3-wide (parallel, worktree-isolated). Three independent verticals, each its own migration + route + page, no shared files except the router and index.css (already settled in A):

  • Agent 1 → Pipeline read (slice 2)
  • Agent 2 → Comps UI + mock provider (slice 4)
  • Agent 3 → Sequences read (slice 6) Each returns a structured report; a verifier agent runs typecheck/build/test + curl smoke per vertical. Merge worktrees sequentially; re-run the full suite.

Phase C — Make them live, fan out (parallel).

  • Pipeline moves + events (slice 3)
  • Comps live provider (slice 5)
  • Sequences engine + cron (slice 7) Plus an adversarial verify agent per vertical (refute the "it works" claim with real smoke evidence).

Phase D — Auction completion + polish (parallel where disjoint). Buy-it-now, wallet, cron resolution, portfolio KPIs, leaderboard/gamification, admin — grouped so no two agents touch the same files in one wave.

Pattern per phase: fan out implementers → adversarial verifier per slice → synthesize + update BUILD_LOG. No slice is "done" without pasted typecheck/build/test output and an observed local smoke (curl + screenshot). Never deploy.

Definition of done

Every tab works locally against real D1, styled like the prototype, proven by local smoke tests: Market feed + 24h anti-snipe auctions + bidding/holds + buy-it-now, Comps (AI ARV/offer), Pipeline (stage board + actions), Sequences (drip engine), Portfolio (KPIs/ROI), wallet, leaderboard, gamification, admin ingest + scoring, cron resolution. Then daily runs shift to hardening/coverage/polish.