# Roadmap Depth, Gate Types, Cost Flags, Planning Actions, and Retrospectives

- Poster: claude
- Date: 2026-06-19
- Status: CLOSED — human made the call 2026-06-19; accepted as canon (no Codex ratification required)
- Topic: The milestone set was too thin for the real engineering work. This
  deliberation expands the roadmap, adds a product-milestone rollup, introduces
  testing-gate types and cost-on flags, adds item-page planning actions, and
  establishes a sprint-retrospective process. Human directed the work; Codex
  must ratify the sequencing changes.

## Human Direction

Human direction 2026-06-18/19, in two parts.

Part 1: "I feel milestones are woefully incomplete for all the tech work I need
to build. And likely we need more phases. Many of them should be built first
like the LLM interfaces input output contracts. Many architecture milestones
are flat out not showing. Overall product milestones that are significant
should be tracked separately possibly with percent complete. Also you still
have a page layout and not a landscape view. Also if possible put requirement
ids as individual badges."

Decisions captured for Part 1: (1) **Both** — add an early Platform & Contracts
phase AND deepen every existing phase; (2) product milestones use **auto
roll-up** from constituent phase gates; (3) **author now + flag for Codex**.

Part 2: "HITL QA testing gates later. Testing code gates without QA for
architecture and POC. Should be in the plans and identified. Also any steps
where we turn on api costs should be identified or when we migrate to paid
supabase or paid cloudflare would be good to flag intelligently. Also the item
task details page for a sprint should include these with ability to click move
to backlog for some items or move to a different sprint. Note after a sprint we
should have a sprint retrospective using deliberations by both codex and claude
and capture the findings in the retrospectives. Eventually we can have Codex be
assigned tasks in a sprint and claude code."

## Response From Claude

### 1. Roadmap depth (grounded in source docs, not invented)

- **New Phase P — Platform & Contracts** (lane `foundation`, flagged
  `build-first`): the load-bearing technical layer every feature depends on,
  surfaced as eight gates — P1 scan I/O contract schemas + versioning, P2
  provider-adapter boundary, P3 validation pipeline, P4 deterministic ranking
  (all from `trovesnap-vision-scanning-spec.md` §5-9, 18-20, 28); P5
  ingestion+promotion contract and P6 data-model layers (from `ARCHITECTURE.md`
  and `technical/data-model.md`); P7 MCP tool surface; P8 observability + cost
  policy (§23, 25).
- **New Phase S — Surfaces & Delivery**: S1 web command center (done), S2
  mobile capture, S3 connector harness, S4 deploy/infra — from
  `ARCHITECTURE.md` build order and `technical/architecture.md`.
- **Deepened existing phases**: B+QR/identity tables + status-event audit
  (B4/B5); C+team roles + markdown phases (C5/C6); D+source-import pipeline +
  enrichment mocks (D4/D5); E+room/mark/condition/appraisal scans + watchlist +
  local VLM (E4-E9); F+disposition engine + auction-outbound (F4/F5); G+
  monetization model (G4).
- Roadmap grew from 7 phases / 23 gates to **9 phases / 52 gates**.

### 2. Product milestones (auto roll-up)

Ten significant outcomes (`productMilestones` in `roadmap.json`): Tracking
System Live, LLM Contract Layer Frozen, Ingestion Spine GA, Operational Floor
GA, Capture & Enrich GA, Vision Discovery GA, Appraisal Intelligence GA, Demand
& Recovery GA, Surfaces & Delivery GA, Freemium Launch. Each maps to a set of
phase gates; percent-complete is computed by the generator (gates done / total),
so it stays in sync with the board automatically. Rendered as a dedicated
"Product milestones" strip on the overview, plus a KPI.

### 3. Testing-gate types (Part 2)

Each milestone now carries a `verify` type, defaulted per phase via
`defaultVerify`: architecture/POC phases (A, P, B, C, D, E, F) = **`code`**
(automated code/test gate, no human QA); delivery/launch phases (S, G) =
**`qa`** (HITL QA testing). Overrides: E7 appraisal_value and S1 web command
center = **`both`**. Rendered as `CODE TEST` / `HITL QA` tags on milestone
lists, the phase cards, and the item-page "Gates & testing" section. This makes
"code gates now, HITL QA later" explicit in the plan.

### 4. Cost-on flags (Part 2)

`costFlag` marks the milestones where spend turns on: **E2** (first hosted
vision-provider calls — API spend on), **E7** (strong provider + external comp
queries — highest per-call cost), **S4** (paid Cloudflare Workers + paid
Supabase tier), **G3** (analytics paid tier). Rendered as `💲 API COST` /
`💲 PAID INFRA` tags on the dashboard, phase cards, timeline, and a dedicated
item-page "Cost triggers" section.

### 5. Item-page planning actions (Part 2)

Every item detail page now has a "Planning" section with **Move to backlog** and
**Move to selected sprint** controls (sprint list derived from
`owningSprint`s). Because the tracker is a static generated site, the buttons
copy a ready instruction to the clipboard for Codex/Claude to apply to
`status.json` + regenerate — honest about the static nature while fitting the
two-agent workflow.

### 6. Sprint retrospectives (Part 2)

New `docs/tracking/retrospectives/` with a README (process) and a TEMPLATE.
Each sprint closes with a joint retro run as a deliberation: Codex fills
`## Retro From Codex`, Claude fills `## Retro From Claude`, then a combined
findings + actions list feeds `status.json` / `roadmap.json` /
`decision-log.md`. A "Retros" tab links it from every tracker page.

### 7. Forward-looking: agent task assignment

Item `owner` already accepts an agent name (e.g. `Claude` owns the tracker
items). The retrospective README records the intent that sprint work items will
be assigned to **Codex** or **Claude** the same way they carry a human owner,
with the retro reviewing assignment quality. No automation is proposed yet.

## What Codex needs to ratify

1. **Sequencing**: D6 set Spine (Phase B) first. This proposes a `build-first`
   **Platform & Contracts** phase (esp. P1-P4 LLM I/O contracts, P5/P6
   ingestion + data-model) ahead of / alongside Spine. Confirm or re-order.
2. **The two new phases** (P, S) and the deepened gates as the working roadmap.
3. **Gate-type and cost-flag conventions** (code vs HITL QA; API vs infra cost).
4. **The retrospective process** as the standard sprint close.

Until Codex responds, the expanded `roadmap.json` is live so the tracker shows
the work, but the **sequencing is provisional** and recorded as such in the
decision log (D9). Codex should append `## Response From Codex` and either
confirm (then this closes and D9 is finalized) or propose changes.

## Human decision

**2026-06-19 — Human made the call. Accepted as canon; this is no longer a
deliberation.** The deepened roadmap (9 phases / 52 gates), the build-first
**Platform & Contracts** phase and its contracts-first sequencing, the
**Surfaces & Delivery** phase, the product-milestone rollup, the gate-type
(code vs HITL QA) and cost-on flag conventions, and the sprint-retrospective
process all stand as the working plan. Codex ratification is not required.
D9 is finalized accordingly.