diff --git a/docs/DECISION-LOG.md b/docs/DECISION-LOG.md
index 8971443..7839cfb 100644
--- a/docs/DECISION-LOG.md
+++ b/docs/DECISION-LOG.md
@@ -5,6 +5,33 @@ consequences, owner, and conditions to revisit. Newest first.
 
 ---
 
+### 2026-07-31 · D-031 · M0 human-gate readiness: attraction legibility + course-scaled seat duration
+- **Status:** provisional · **Owner:** Builder → owners · Branch `fix/m0-human-gate-readiness` off PR #7 head
+  `e5baa54`; focused PR targets the PR #7 branch. Addresses the PR #7 adjudication's H2 (legibility) + M1 (economics).
+- **H-LEG-1 (attraction legibility):** per-segment `SegmentAttraction` (pool/consideration/composition/parties) is
+  now on `ForecastSnapshot` and `ServiceResult` and rendered pre-service ("Who this plan attracts" table + a
+  plain-language note, largest-remainder reconciled) and post-service (ATTRACTION funnel). New causal categories
+  **weak-attraction / wrong-mix / purchase-conversion** (renamed from weak-demand/menu-fit) with disjoint-PState
+  attribution; wrong-mix is a composition opportunity cost (never double-counted) with a business-consequence line.
+- **MED-ECON-1 (course-scaled seat duration):** flat `EatMin=12` replaced by shared `Tuning.SeatEatMin(coursesX10)`
+  = clamp(6 + 6·courses, 12, 30) → 1/2/3-course = 12/18/24; sim scales by `DistinctCourseCount`, forecast scales
+  `seatCoverCap` by the captured-mix expected courses. Empirically a premium 3-course meal now turns ~1.85× fewer
+  tables/seat-hour than a value 1-course meal; per-seat-minute leverage falls ~4× → ~2.5-3×. Only eat time changes
+  (ticket/kitchen path untouched).
+- **Consequence / gate:** `Verdict: Pass-with-notes / Action: Continue` (request focused independent re-review).
+  146 tests green (added 7 ReadinessTests). No over-correction: premium still wins enthusiast, value wins lunch,
+  KNOWN_RESIDUAL holds. Favorable side effect: best-generalist regret rose 6%→17% on base 271828182 (reducing
+  premium seat-leverage shrank the generalist's edge — as the adjudication predicted; not gate-chasing). Goldens
+  re-baselined (D-032). Report: `reports/m0/M0-HUMAN-GATE-READINESS-REPORT.md`. Do not merge / no human tests / no M1.
+
+### 2026-07-31 · D-032 · Goldens re-baselined for course-scaled seat duration
+- **Status:** locked · **Owner:** Builder · Course-scaled dining duration changes seat occupancy → turns/covers/
+  revenue → checksum. New: Focused Value/lunch `0x53FE6CB73895DFD0`, Premium Craft/enthusiast `0x2DA79E2ACC88CA2F`,
+  Balanced Competent/social `0x05E65C6E8AD6AF07`. Prior (D-030): `0xFB04479B19656E6B` / `0x198E44A139793975` /
+  `0x6CBD8F76B46A51E1`. Attraction legibility (H-LEG-1) does NOT affect the checksum (attraction fields and cause
+  strings are not hashed); the weak-demand→weak-attraction / menu-fit→purchase-conversion renames are cause
+  strings only.
+
 ### 2026-07-30 · D-029 · Menu-responsive demand rewrite: distinct regimes achieved; universal-generalist gate borderline (economic root cause)
 - **Status:** provisional · **Owner:** Builder → owners · **Follows** the PR #5 adjudication (D-028's Fail/Rewrite,
   refined: the fix is a headless demand-model rewrite, not M1). Branch `rewrite/m0-menu-responsive-demand`.
diff --git a/docs/design/M0-HUMAN-GATE-READINESS-CONTRACT.md b/docs/design/M0-HUMAN-GATE-READINESS-CONTRACT.md
new file mode 100644
index 0000000..8e47fb4
--- /dev/null
+++ b/docs/design/M0-HUMAN-GATE-READINESS-CONTRACT.md
@@ -0,0 +1,113 @@
+# M0 Human-Gate Readiness Contract (design lock)
+
+**Branch** `fix/m0-human-gate-readiness` off PR #7 head `e5baa54`. Focused PR targets the PR #7 branch
+(`rewrite/m0-menu-responsive-demand`). Two authorized corrections only; do NOT reopen `DemandModel.Capture`.
+This is committed BEFORE code (§6). Design informed by the read-only A–E investigation (recorded in the PR).
+
+## 1. Authorized findings (from the independent adjudication)
+- **H-LEG-1 — Attraction legibility.** Per-segment consideration/captured demand are computed but never shown;
+  the forecast collapses attraction to one aggregate %, and the autopsy has no "wrong-mix" category.
+- **MED-ECON-1 — Course-scaled seat duration.** Flat `EatMin=12` gives premium multi-course covers ~4×
+  contribution-per-seat-minute (vs ~1.15× per station-minute) because a 3-course dinner holds a seat the same
+  eating window as a 1-course lunch.
+
+Non-goals (§3 of the assignment) unchanged: no reputation/repeat-visits/marketing/reservations/new
+recipes-segments-markets/graphics/etc. No premium-specific penalty. No market/segment NAME branch. Integer/
+deterministic only.
+
+## 2. Correction A — attraction legibility
+
+### 2a. Forecast (pre-service)
+Add to `ForecastSnapshot` (Result.cs) `IReadOnlyList<SegmentAttraction> SegmentAttraction`, record
+`SegmentAttraction(SegmentId Id, string Name, int PoolParties, int ConsiderationBp, int CompositionBp, int AttractedParties)`,
+and `IReadOnlyList<string> AttractionNotes`. Populated in `Forecaster.Compute` from the existing `captured` local
+(no new `Capture` call): `PoolParties = round(ExpectedArrivals·SegmentMixBp[s]/1e4)`, `ConsiderationBp =
+captured.ConsiderationBp[s]`, `CompositionBp = captured.CompositionBp[s]`, `AttractedParties =
+round(attempts·CompositionBp[s]/1e4)`. **Reconciliation (largest-remainder):** the last segment's PoolParties =
+ExpectedArrivals − Σ(others) and AttractedParties = attempts − Σ(others), so the columns sum EXACTLY to
+ExpectedArrivals and to attempts (the aggregate funnel figure the autopsy prints as DemandGenerated).
+
+`TextReport.Forecast` renders a compact "Who this plan attracts (pre-service)" table (segment | pool | appeal% |
+mix% | attracted, + total row) using the existing `Pct()` helper and column idiom, placed before Key Assumptions.
+At most ONE plain-language attraction note fired (priority order), derived from actual data — never generic.
+
+### 2b. Post-service (autopsy)
+Thread the whole `CapturedDemand` into `Finalize` (Simulator currently keeps only `AggregateConversionBp` +
+`CompositionBp`; also keep `ConsiderationBp`). Add per-segment attraction to `ServiceResult`: extend
+`SegmentOutcome` (or add a parallel `SegmentAttractionActual`) with `PoolParties`, `ConsiderationBp`,
+`ArrivedParties` so the autopsy shows **potential → consideration → captured(expected) → arrived → purchased →
+covers** per segment and the player can compare forecast captured mix vs actual arrival mix.
+
+### 2c. Causal categories (§11)
+Extend `DiagnoseBottleneck` vocabulary from {seating, kitchen, menu-fit, weak-demand} to
+{seating, kitchen, **purchase-conversion** (was menu-fit), **weak-attraction** (was weak-demand), **wrong-mix**}.
+Attribution reads DISJOINT slices (no double-count): weak-attraction = parties never generated (volume shortfall
+below the attraction floor, `Tuning.WeakDemandCaptureFloorBp`); seating = `WalkedSeat`; purchase-conversion =
+`NoOrder`; kitchen = `WalkedFood` + comp cents; wrong-mix = a COMPOSITION opportunity cost (below). Every party is
+in exactly one terminal PState; wrong-mix is an opportunity signal, not a party bucket, so it cannot double-count.
+
+**wrong-mix** is PRIMARY only when ALL hold: (1) volume adequate (captured ≥ attraction floor — not weak);
+(2) seated covers largely ordered (`LostToMenuFit` small — not purchase); (3) kitchen kept pace (`LostToWait`
+small, comps modest — not kitchen); (4) the market offered a materially higher-value segment (by pool × budget)
+that the plan under-attracted (its `CompositionBp` well below its pool share) while a lower-value segment
+dominates arrivals. Business-consequence sentence required (e.g. "you filled the room with value diners in a
+market whose enthusiasts would have paid far more"). This uses pool + composition + segment budgets only — no
+per-segment contribution accounting, no name branch. Two-tier report preserved: TIER-1 the single largest
+measured channel (incl. the new attraction ones); TIER-2 0–2 secondary operational warnings.
+
+## 3. Correction B — course-scaled dining duration
+**Model A (base + uniform per DISTINCT course).** Shared primitive in `Tuning`:
+`SeatEatMin(int coursesX10) = clamp(EatBaseMin + MulDivRound(EatPerCourseMin, coursesX10, 10), EatMinFloor, EatMaxCeil)`.
+Params: **EatBaseMin=6, EatPerCourseMin=6, EatMinFloor=12, EatMaxCeil=30** → 1-course=12 (preserves legacy dwell,
+byte-identity for all-1-course services), 2-course=18, 3-course=24 (≈2× the legacy 12, the D4 target). No floats,
+no rounding beyond MulDivRound.
+
+- **Sim** (`Simulator.cs`, Cooking→Eating transition, replacing `p.EatUntil = t + EatMin`): `courses =
+  DistinctCourseCount(p)` = count of distinct `Recipe.Course` among `p.Dishes` (0..3, deterministic, size- and
+  RNG-independent); `p.EatUntil = t + Tuning.SeatEatMin(courses·10)`. Only the EAT window changes — browse, cook,
+  ticket, delivery are untouched (`AvgTicketTimeMin` must NOT move).
+- **Forecast** (`Forecast.cs`): replace flat `ForecastAvgDwellMin=34` in `seatCoverCap` with
+  `ForecastNonEatDwellMin + SeatEatMin(expectedCoursesX10)`, where `expectedCoursesX10 = dishesPerCoverBp·10/1e4`
+  (the existing captured-mix-weighted 1 + P(starter) + P(dessert)). Pick `ForecastNonEatDwellMin` so the
+  composition-weighted dwell reproduces ~34 at the current markets (calibration preserved); premium/high-course
+  menus get a longer dwell → fewer seat turns → lower `seatCoverCap` (directional).
+
+Timing separation preserved (§20): kitchen prep / food wait / eating are distinct causes; only eating is scaled.
+
+## 4. Numeric units & rounding (§18)
+All timing integer minutes. `SeatEatMin` bounded to [12, 30]. `coursesX10` integer (sim: 10/20/30; forecast:
+10 + fractional). `MulDivRound` for the per-course scaling and all bp math. No floating-point authoritative time.
+
+## 5. Authorized files
+`Tuning.cs`, `Simulator.cs`, `Forecast.cs`, `Result.cs`, `TextReport.cs`, `M0Content.cs` (only if a Name lookup is
+needed — no fixture-economics change), harness `Program.cs` (diagnostics/regression only), and the test files +
+new fixtures + reports/docs. **Not** `Demand.cs`/`PriceModel.cs` (no consideration redesign). No new recipes/
+segments/markets; no fixture-economics change to prices/costs/appeal.
+
+## 6. Non-goals
+Repeat visits, reputation, reviews, loyalty, marketing, reservations, table-turn controls, bussing, course-by-
+course service/inter-course stagger (delivery-together stays), per-dish eat animations, new content, graphics,
+save, M1. No premium-specific tax; no market/segment-name branch; do not tune to move the generalist past 10%.
+
+## 7. Pass criteria (§28,29,31)
+- **Attraction legibility:** per-segment pool/consideration/captured/arrival-mix visible pre- AND post-service;
+  ≥1 plain-language attraction reason; totals reconcile; a wrong-mix/weak-attraction/purchase case each attributes
+  to the correct stage (controlled fixtures).
+- **Directionality:** ≥85% overall / ≥75% per-market & per-family forecast/sim agreement retained; audited price &
+  seat directions still correct; adding expected courses lowers forecast table turns; more seats help when
+  seat-bound, neutral/harmful when kitchen-bound.
+- **Economics:** premium contribution-per-seat-minute leverage reduced from ~4× toward ~3×; premium still wins
+  enthusiast; value still wins lunch; a mixed plan still viable in social; multi-course still net-positive.
+- **Technical:** 139 prior tests preserved (+ new); determinism; accounting; RNG isolation; forecast immutability;
+  scope; goldens deliberately re-baselined & documented.
+
+## 8. Fail criteria (§24,27 over-correction)
+Premium stops winning enthusiast / goes loss-making; desserts+starters become universally unprofitable;
+KNOWN_RESIDUAL flips (generalist destroyed) as a side effect; `AvgTicketTimeMin` moves (change leaked into the
+kitchen path); or the duration change is economically inert everywhere (surface honestly, don't force it).
+
+## 9. Timebox & review (§32,35)
+12–22 focused hours, ≤2 refinement cycles. If it cannot complete honestly in the box: stop, preserve evidence,
+report, request an owner decision — do not auto-start another correction. Deliver the §35 report + open the
+focused PR (do not merge; no human tests; no M1). Gate recommendation uses Verdict/Action; `Continue` = request a
+focused independent re-review (does not authorize human tests, M1, or merge).
diff --git a/reports/balance/distribution.md b/reports/balance/distribution.md
index e108ebf..e55b464 100644
--- a/reports/balance/distribution.md
+++ b/reports/balance/distribution.md
@@ -10,15 +10,15 @@ _Value-heavy, high-volume, price-sensitive, small parties, early peak. Rewards f
 
 | Strategy | median contrib | p10 | p90 | loss% | avg covers | avg sat | avg ticket | win% |
 |---|--:|--:|--:|--:|--:|--:|--:|--:|
-| Focused Value | $1682.50 | $1480.00 | $1892.00 | 0% | 170 | 604 | 11m | 93% |
-| Premium Craft | $1064.12 | $635.46 | $1549.56 | 1% | 42 | 719 | 17m | 6% |
-| Broad Menu | $393.00 | -$121.50 | $933.50 | 15% | 79 | 580 | 19m | 0% |
-| Overcapacity | -$572.00 | -$756.00 | -$424.50 | 100% | 23 | 538 | 19m | 0% |
+| Focused Value | $1667.50 | $1441.00 | $1826.00 | 0% | 167 | 605 | 11m | 91% |
+| Premium Craft | $1071.02 | $635.46 | $1564.16 | 1% | 42 | 717 | 17m | 8% |
+| Broad Menu | $550.50 | $19.00 | $1078.00 | 7% | 83 | 576 | 19m | 0% |
+| Overcapacity | -$575.00 | -$756.00 | -$424.50 | 100% | 23 | 533 | 19m | 0% |
 | Understaffed | -$402.00 | -$529.00 | -$261.50 | 100% | 14 | 512 | 21m | 0% |
-| Balanced Competent | -$20.50 | -$429.50 | $388.00 | 53% | 64 | 576 | 19m | 0% |
-| Overpriced Weak Execution | -$245.90 | -$522.50 | $219.20 | 76% | 10 | 404 | 26m | 0% |
-| Station Bottleneck | -$316.00 | -$473.50 | -$50.50 | 93% | 19 | 603 | 19m | 0% |
-| Intentionally Bad | -$118.00 | -$237.50 | $32.00 | 80% | 9 | 548 | 21m | 0% |
+| Balanced Competent | $134.00 | -$376.50 | $632.50 | 38% | 69 | 567 | 19m | 0% |
+| Overpriced Weak Execution | -$245.90 | -$539.20 | $219.20 | 76% | 10 | 402 | 26m | 0% |
+| Station Bottleneck | -$316.00 | -$473.50 | -$44.50 | 92% | 19 | 599 | 19m | 0% |
+| Intentionally Bad | -$118.00 | -$237.50 | $32.00 | 80% | 9 | 547 | 21m | 0% |
 
 **Winner:** Focused Value  ·  **profitable strategies (median >= +$150):** 3
 
@@ -28,17 +28,17 @@ _Mid-budget social diners in groups, multi-course, moderate patience. Rewards a
 
 | Strategy | median contrib | p10 | p90 | loss% | avg covers | avg sat | avg ticket | win% |
 |---|--:|--:|--:|--:|--:|--:|--:|--:|
-| Focused Value | $1816.50 | $1461.00 | $2195.00 | 0% | 153 | 722 | 10m | 60% |
-| Premium Craft | $1412.94 | $274.46 | $2633.06 | 6% | 70 | 590 | 24m | 36% |
-| Broad Menu | $241.50 | -$449.00 | $1153.00 | 30% | 89 | 529 | 25m | 2% |
-| Overcapacity | -$578.50 | -$882.50 | -$211.00 | 98% | 33 | 573 | 21m | 0% |
+| Focused Value | $1805.00 | $1461.50 | $2174.50 | 0% | 152 | 711 | 10m | 7% |
+| Premium Craft | $2623.06 | $769.60 | $3788.42 | 0% | 87 | 579 | 24m | 71% |
+| Broad Menu | $1954.00 | $229.00 | $2667.50 | 7% | 119 | 522 | 24m | 16% |
+| Overcapacity | -$578.50 | -$882.50 | -$211.00 | 98% | 33 | 556 | 21m | 0% |
 | Understaffed | -$421.00 | -$553.00 | -$199.00 | 100% | 17 | 517 | 25m | 0% |
-| Balanced Competent | $135.00 | -$419.50 | $943.00 | 36% | 75 | 597 | 22m | 1% |
-| Overpriced Weak Execution | -$719.40 | -$986.50 | -$438.50 | 98% | 9 | 402 | 28m | 0% |
-| Station Bottleneck | -$521.00 | -$740.00 | -$209.50 | 100% | 20 | 617 | 21m | 0% |
-| Intentionally Bad | -$237.50 | -$381.00 | $10.50 | 87% | 11 | 519 | 24m | 0% |
+| Balanced Competent | $1226.00 | $59.50 | $2122.00 | 6% | 102 | 567 | 22m | 5% |
+| Overpriced Weak Execution | -$687.10 | -$992.50 | -$355.90 | 98% | 9 | 397 | 27m | 0% |
+| Station Bottleneck | -$520.50 | -$740.00 | -$209.50 | 100% | 20 | 610 | 21m | 0% |
+| Intentionally Bad | -$237.50 | -$381.00 | $10.50 | 87% | 11 | 517 | 24m | 0% |
 
-**Winner:** Focused Value  ·  **profitable strategies (median >= +$150):** 3
+**Winner:** Premium Craft  ·  **profitable strategies (median >= +$150):** 4
 
 ## Destination Enthusiast Evening  (`enthusiast-evening`)
 
@@ -46,22 +46,22 @@ _High-budget enthusiasts, lower volume, high quality expectations, patient. Rewa
 
 | Strategy | median contrib | p10 | p90 | loss% | avg covers | avg sat | avg ticket | win% |
 |---|--:|--:|--:|--:|--:|--:|--:|--:|
-| Focused Value | $394.50 | $95.50 | $691.50 | 2% | 71 | 716 | 10m | 0% |
-| Premium Craft | $2313.06 | $845.32 | $3445.88 | 0% | 76 | 583 | 25m | 76% |
-| Broad Menu | $1183.00 | -$21.00 | $2072.00 | 10% | 91 | 549 | 25m | 6% |
-| Overcapacity | $348.00 | -$106.00 | $998.50 | 13% | 50 | 575 | 21m | 0% |
+| Focused Value | $394.50 | $95.50 | $691.50 | 2% | 71 | 715 | 10m | 0% |
+| Premium Craft | $3051.48 | $1879.60 | $3839.04 | 0% | 86 | 586 | 24m | 95% |
+| Broad Menu | $1860.50 | $997.00 | $2485.50 | 0% | 104 | 543 | 24m | 5% |
+| Overcapacity | $348.00 | -$120.00 | $998.50 | 13% | 50 | 562 | 22m | 0% |
 | Understaffed | -$188.50 | -$405.50 | $60.00 | 86% | 24 | 480 | 27m | 0% |
-| Balanced Competent | $1359.00 | $866.50 | $1695.00 | 0% | 83 | 654 | 18m | 17% |
-| Overpriced Weak Execution | -$613.50 | -$903.80 | -$248.80 | 93% | 10 | 344 | 28m | 0% |
-| Station Bottleneck | -$153.00 | -$518.00 | $231.00 | 68% | 26 | 588 | 22m | 0% |
-| Intentionally Bad | -$166.00 | -$334.00 | $151.50 | 73% | 13 | 468 | 25m | 0% |
+| Balanced Competent | $1361.00 | $903.50 | $1759.50 | 0% | 84 | 646 | 18m | 0% |
+| Overpriced Weak Execution | -$632.70 | -$932.10 | -$199.50 | 93% | 10 | 340 | 28m | 0% |
+| Station Bottleneck | -$149.50 | -$518.00 | $227.50 | 67% | 26 | 582 | 22m | 0% |
+| Intentionally Bad | -$166.00 | -$334.00 | $151.50 | 73% | 13 | 466 | 25m | 0% |
 
 **Winner:** Premium Craft  ·  **profitable strategies (median >= +$150):** 5
 
 ## Dominance check
 
 - **lunch-rush** best strategy: `Focused Value`
-- **social-dinner** best strategy: `Focused Value`
+- **social-dinner** best strategy: `Premium Craft`
 - **enthusiast-evening** best strategy: `Premium Craft`
 
 Distinct winning strategies across scenarios: **2** of 3. No single strategy wins across all markets: context changes the best plan. ✅
diff --git a/reports/balance/dominance-search.md b/reports/balance/dominance-search.md
index 418a9e3..e7a65ca 100644
--- a/reports/balance/dominance-search.md
+++ b/reports/balance/dominance-search.md
@@ -11,23 +11,23 @@ Searched **3321** configurations (4x800 random + archetype sweep + review champi
 
 | Market | Best contribution | Winning plan |
 |---|--:|---|
-| lunch-rush | $1390.77 | menu[Classic Burger@$20.97, Roast Chicken@$27.90, Fish & Chips@$22.50, Ice Cream@$10.50] seats 57, 8 staff |
-| social-dinner | $5861.80 | menu[Roast Chicken@$46.50, Ribeye Steak@$79.02, Mushroom Risotto@$50.19, Ice Cream@$14.76] seats 47, 7 staff |
-| enthusiast-evening | $5634.38 | menu[Roast Chicken@$46.50, Ribeye Steak@$84.96, Mushroom Risotto@$54.27, Ice Cream@$14.99] seats 42, 8 staff |
+| lunch-rush | $1378.43 | menu[Classic Burger@$20.97, Roast Chicken@$27.90, Fish & Chips@$20.70, Ice Cream@$10.00] seats 59, 8 staff |
+| social-dinner | $5853.79 | menu[Roast Chicken@$46.50, Ribeye Steak@$79.02, Mushroom Risotto@$51.75, Ice Cream@$14.76] seats 45, 8 staff |
+| enthusiast-evening | $5531.27 | menu[Roast Chicken@$53.29, Ribeye Steak@$88.50, Mushroom Risotto@$58.29, Ice Cream@$11.66] seats 40, 8 staff |
 
 ## Best generalist (the single plan closest to winning everywhere)
 
-Plan: menu[Roast Chicken@$44.64, Ribeye Steak@$82.18, Mushroom Risotto@$49.67, Ice Cream@$14.90] seats 47, 7 staff
-- lunch-rush: $1279.86 (frontier $1390.77)
-- social-dinner: $5938.97 (frontier $5861.80)
-- enthusiast-evening: $5348.25 (frontier $5634.38)
-- **worst-market regret vs frontier: 6%** (deficit -$286.13 in enthusiast-evening)
+Plan: menu[Roast Chicken@$42.31, Ribeye Steak@$76.70, Mushroom Risotto@$45.24, Ice Cream@$14.36] seats 43, 8 staff
+- lunch-rush: $1216.30 (frontier $1378.43)
+- social-dinner: $5192.40 (frontier $5853.79)
+- enthusiast-evening: $4639.91 (frontier $5531.27)
+- **worst-market regret vs frontier: 17%** (deficit -$891.36 in enthusiast-evening)
 
-> **A cross-market dominator EXISTS** — a single fixed plan is within 10% of the frontier in ALL three markets. Report to owners, do not proceed to the human gate.
+> **No cross-market dominator found.** The best generalist is **17% below the frontier in its worst market** (enthusiast-evening) — far outside the 10% near-optimal band. The per-market optima are distinct regimes (fair-priced / high-capacity for the value lunch vs premium for the enthusiast evening), so context changes the best strategy. This is under a bounded two-method search on held-out seeds, not a proof.
 
 ## Note on the NAMED strategies
 The nine named strategies are illustrative archetypes, not frontier-optimal. A searched plan can
 beat every named market winner without being a cross-market dominator (it merely out-optimizes the
 hand-authored baselines). That is why this report tests against the searched frontier, not the named set.
 
-Named-best medians (for reference): lunch-rush $1682.50, social-dinner $1816.50, enthusiast-evening $2313.06.
+Named-best medians (for reference): lunch-rush $1667.50, social-dinner $2623.06, enthusiast-evening $3051.48.
diff --git a/reports/balance/forecast-calibration.md b/reports/balance/forecast-calibration.md
index 47a7150..831b629 100644
--- a/reports/balance/forecast-calibration.md
+++ b/reports/balance/forecast-calibration.md
@@ -7,8 +7,8 @@ range. Stated confidence: **55%**. Seeds/cell: 80.
 
 | Scenario | contribution band coverage | median |covers bias| |
 |---|--:|--:|
-| lunch-rush | 491/720 = 68% | 17% |
-| social-dinner | 601/720 = 83% | 79% |
-| enthusiast-evening | 540/720 = 75% | 25% |
+| lunch-rush | 508/720 = 70% | 21% |
+| social-dinner | 577/720 = 80% | 79% |
+| enthusiast-evening | 549/720 = 76% | 33% |
 
-**Aggregate band coverage: 1632/2160 = 75%** (was ~0% pre-fix; meets the stated 55% confidence).
+**Aggregate band coverage: 1634/2160 = 75%** (was ~0% pre-fix; meets the stated 55% confidence).
diff --git a/reports/determinism/checksums.md b/reports/determinism/checksums.md
index a5993dc..a536bb0 100644
--- a/reports/determinism/checksums.md
+++ b/reports/determinism/checksums.md
@@ -5,14 +5,14 @@ A management sim that promises "same seed reproduces the same result" must pass
 
 | Scenario | Strategy | Seed | Checksum run 1 | Checksum run 2 | Match |
 |---|---|--:|---|---|:--:|
-| lunch-rush | Focused Value | 700042 | `FB04479B19656E6B` | `FB04479B19656E6B` | ✅ |
-| lunch-rush | Premium Craft | 700042 | `D9E4FBCDEA18CF0C` | `D9E4FBCDEA18CF0C` | ✅ |
-| lunch-rush | Broad Menu | 700042 | `FC60BB2C22459925` | `FC60BB2C22459925` | ✅ |
-| social-dinner | Focused Value | 700042 | `B0640E33CF407C80` | `B0640E33CF407C80` | ✅ |
-| social-dinner | Premium Craft | 700042 | `4C9791E2062C6F87` | `4C9791E2062C6F87` | ✅ |
-| social-dinner | Broad Menu | 700042 | `6D3925BD6A900E64` | `6D3925BD6A900E64` | ✅ |
-| enthusiast-evening | Focused Value | 700042 | `9F262D37FD321B3B` | `9F262D37FD321B3B` | ✅ |
-| enthusiast-evening | Premium Craft | 700042 | `198E44A139793975` | `198E44A139793975` | ✅ |
-| enthusiast-evening | Broad Menu | 700042 | `A84C71C59BDA08BD` | `A84C71C59BDA08BD` | ✅ |
+| lunch-rush | Focused Value | 700042 | `53FE6CB73895DFD0` | `53FE6CB73895DFD0` | ✅ |
+| lunch-rush | Premium Craft | 700042 | `1ED20899EFF0DDD8` | `1ED20899EFF0DDD8` | ✅ |
+| lunch-rush | Broad Menu | 700042 | `436FF41289FE7205` | `436FF41289FE7205` | ✅ |
+| social-dinner | Focused Value | 700042 | `03D07167B29AD3DB` | `03D07167B29AD3DB` | ✅ |
+| social-dinner | Premium Craft | 700042 | `88DE7DE1B16EC8E5` | `88DE7DE1B16EC8E5` | ✅ |
+| social-dinner | Broad Menu | 700042 | `1596320D44E545CE` | `1596320D44E545CE` | ✅ |
+| enthusiast-evening | Focused Value | 700042 | `74E86E0E4B14A59B` | `74E86E0E4B14A59B` | ✅ |
+| enthusiast-evening | Premium Craft | 700042 | `2DA79E2ACC88CA2F` | `2DA79E2ACC88CA2F` | ✅ |
+| enthusiast-evening | Broad Menu | 700042 | `99FFF626AF60EE22` | `99FFF626AF60EE22` | ✅ |
 
 **All checksums matched: determinism holds for the sampled matrix.**
diff --git a/reports/m0/M0-HUMAN-GATE-READINESS-REPORT.md b/reports/m0/M0-HUMAN-GATE-READINESS-REPORT.md
new file mode 100644
index 0000000..f075380
--- /dev/null
+++ b/reports/m0/M0-HUMAN-GATE-READINESS-REPORT.md
@@ -0,0 +1,104 @@
+# M0 Human-Gate Readiness — Final Builder Report
+
+Two authorized corrections following the PR #7 adjudication (H-LEG-1 attraction legibility, MED-ECON-1
+course-scaled seat duration). Contract: `docs/design/M0-HUMAN-GATE-READINESS-CONTRACT.md`. Follows §35 A–J.
+
+## A. Baseline
+- **Reviewed PR #7 head:** `e5baa54` · **New branch:** `fix/m0-human-gate-readiness` (off e5baa54).
+- **Changed files:** `Tuning.cs`, `Simulator.cs`, `Forecast.cs`, `Result.cs`, `TextReport.cs` (core);
+  harness `Program.cs` (diagnostics); `ScenarioTests.cs`, `AttributionTests.cs`, new `ReadinessTests.cs`; the
+  contract + this report + regenerated evidence. **No** change to `Demand.cs`/`PriceModel.cs`/fixture economics.
+- Env: Darwin arm64, .NET 8.0.423, Release.
+
+## B. Sub-agent work (read-only design investigation, recorded in the PR)
+A (forecast legibility) → `SegmentAttraction` fields + table + observation templates + largest-remainder
+reconciliation. B (post-service) → causal categories {weak-attraction, wrong-mix, purchase-conversion} + disjoint
+attribution + the §14 fixtures. C (duration) → Model A (base + per-distinct-course), params base 6 / per-course 6
+/ floor 12 / ceil 30. D (forecast/timing) → shared `SeatEatMin` primitive fed by the existing captured-mix
+`dishesPerCoverBp`. E (regression) → equal-compute + over/under-correction signals. Lead verified each against the
+code and adopted them; every High finding reproduced.
+
+## C. Attraction legibility (H-LEG-1)
+**Previous limitation:** `DemandModel.Capture` computed per-segment consideration/composition but they were
+discarded before the player saw them; the forecast showed one aggregate %, the autopsy had no wrong-mix category.
+**Now:** `ForecastSnapshot` and `ServiceResult` carry `SegmentAttraction(pool, considerationBp, compositionBp,
+parties)`. `TextReport` renders a pre-service "Who this plan attracts" table (pool / appeal% / mix% / attracted,
+totals reconciled by largest-remainder) with one plain-language note, and a post-service ATTRACTION funnel, so
+the player can compare expected vs actual arrival mix. New causal categories with disjoint-PState attribution
+(no double-count): **weak-attraction** (too few captured), **wrong-mix** (a composition opportunity cost — the
+market's higher-spending crowd was under-attracted while the operation ran fine), **purchase-conversion**
+(arrived but didn't order), alongside seating/kitchen. **Controlled cases (verified, seed 700042 rendering):** a
+value chassis in the enthusiast market → *"wrong mix — the plan under-attracted food enthusiast, the market's
+higher-spending crowd (~$204 of missed contribution), while filling the room with a lower-value crowd"*; an
+overpriced repellent menu → weak-attraction; a tiny room → seating; an under-staffed premium menu → kitchen.
+
+## D. Dining-duration correction (MED-ECON-1)
+**Prior model:** flat `EatMin = 12` for every party. **New model (Model A, shared `Tuning.SeatEatMin(coursesX10)`):**
+`clamp(EatBaseMin + MulDivRound(EatPerCourseMin, coursesX10, 10), EatMinFloor, EatMaxCeil)` with **6 / 6 / 12 /
+30** → 1-course = 12 (legacy dwell preserved; all-1-course services byte-identical), 2-course = 18, 3-course = 24.
+The sim scales a party's eat window by `DistinctCourseCount(p.Dishes)` (0..3, deterministic, size-independent);
+the forecast scales `seatCoverCap` by `ForecastNonEatDwellMin(20) + SeatEatMin(expectedCoursesX10)` using the same
+primitive, so a higher-course captured mix turns fewer tables. Integer/deterministic; **only the eat window
+changes** — `AvgTicketTimeMin` (kitchen) is untouched (locked by a test).
+
+## E. Economic effects
+Empirical (24-seat seat-bound rooms, 120 held-out seeds): a **value 1-course** service turns **3.67 covers/seat**
+(~33-min dwell); a **premium 3-course** service turns **2.96 covers/seat** over a longer service (~61-min dwell) —
+the premium meal now ties up a table **~1.85× longer per seat-hour**, so its high check no longer comes with
+near-free seat time. Analytically the premium contribution-per-seat-minute leverage falls from ~4× toward ~2.5–3×
+(eat 12→24 on the modal 3-course basket), matching the reviewer's D4 sensitivity. **No over-correction:** premium
+still wins the enthusiast evening and stays profitable; value still wins the lunch; a mixed plan stays viable in
+social; starters/desserts remain net-positive; `KNOWN_RESIDUAL` still passes (the generalist is not destroyed).
+**Favorable side effect (not gate-chasing):** on held-out base 271828182 the best-generalist worst-market regret
+rose **6% → 17%** — reducing premium seat-leverage shrank the premium-anchored generalist's cross-market edge,
+exactly the economic mechanism the adjudication predicted. (Still seed-dependent; the demand-rewrite gate itself
+is out of this pass's scope.)
+
+## F. Forecast and causal evidence
+Forecast reuses the same `SeatEatMin`; directionality preserved — all `ForecastDirectionTests` /
+`EconomicCoherenceTests` price & seat directions pass; adding expected courses lowers `seatCoverCap` by
+construction (SeatEatMin monotonic, asserted). Contribution-band coverage **75%** (stated 55%) — calibration
+preserved. Causal attribution distinguishes attraction (weak / wrong-mix) from conversion (purchase) from service
+(seating / kitchen), each reading a disjoint slice; wrong-mix is reachable for a value chassis in the premium
+market and never fires for a well-matched premium plan (locked by tests).
+
+## G. Strategy regression
+Named winners: **lunch = Focused Value (value/throughput), social = Premium Craft, enthusiast = Premium Craft**;
+2/3 distinct → no single dominant strategy. Frontiers remain distinct regimes (value-lunch vs premium-dinner).
+The premium-anchored generalist remains a viable-but-not-winning all-rounder (KNOWN_RESIDUAL ≥ 0.85 holds), and
+its regret improved on the measured base after the duration correction. No structural regime was destroyed.
+
+## H. Technical integrity
+- **Tests: 146 pass, 0 fail**, stable across two runs (Core 54, Determinism 31, Scenario 61 incl. 7 new
+  ReadinessTests). Build Release clean, 0 warnings.
+- Determinism holds; accounting reconciles; RNG isolated; forecast immutable; scope confined (no non-goal
+  systems; no fixture-economics change; no name branch). Goldens deliberately re-baselined (course-scaled
+  duration changes seat occupancy): Focused Value/lunch `0x53FE6CB73895DFD0`, Premium Craft/enthusiast
+  `0x2DA79E2ACC88CA2F`, Balanced Competent/social `0x05E65C6E8AD6AF07` (H-LEG-1 does not affect the checksum).
+
+## I. Gate recommendation
+```
+Verdict: Pass-with-notes
+Action:  Continue   (request a focused independent re-review)
+```
+Both authorized corrections are implemented, verified, in scope, and free of over-correction. The positioning
+mechanism is now visible pre- and post-service and the causal report distinguishes attraction / conversion /
+service; multi-course premium meals now consume credible table time. `Continue` requests a focused independent
+re-review of these two corrections; it does NOT authorize human tests, M1, or merging. Notes: wrong-mix as the
+*dominant* cause is a narrow (clean-operation) regime by nature; the demand-rewrite generalist residual is
+unchanged in scope here (only nudged favorably).
+
+## J. Required reviewer experiments
+1. `dotnet test` — confirm 146/146 (esp. ReadinessTests, goldens, EconomicCoherenceTests, DominanceFrontierTests).
+2. `--report` — inspect the pre-service attraction table + the post-service ATTRACTION funnel + causal category
+   on the value-in-lunch, value-chassis-in-enthusiast (wrong-mix), and premium-in-enthusiast cases.
+3. Duration: verify `SeatEatMin` monotonic/bounded; a 3-course service turns fewer covers/seat than a 1-course
+   one (24-seat seat-bound rooms); `AvgTicketTimeMin` unchanged in character.
+4. Economics: reproduce the per-seat-minute vs per-station-minute decomposition for 1/2/3-course covers; confirm
+   premium leverage fell toward ~3× and premium still wins enthusiast / value still wins lunch.
+5. Forecast: confirm ≥85% directionality retained; adding expected courses lowers `seatCoverCap`; band coverage
+   ≥ stated.
+6. Causal: confirm the §14 fixtures attribute to the correct stage and that wrong-mix never fires for a
+   well-matched premium plan.
+
+Stop after opening the focused PR. Do not merge. Do not run human tests. Do not begin M1.
diff --git a/reports/m0/example-forecast-vs-actual.txt b/reports/m0/example-forecast-vs-actual.txt
index 29585e6..b7fbd56 100644
--- a/reports/m0/example-forecast-vs-actual.txt
+++ b/reports/m0/example-forecast-vs-actual.txt
@@ -20,7 +20,14 @@ FORECAST (committed before service; immutable):
   Demand opportunity:    178 covers (best case if all completed)
   Expected covers:       100 (completed, after peaking & walkouts)
   Expected revenue:      $2797.39
-  Expected contribution: $811.19   low-confidence range [-$961.30 .. $2228.94]  (55% confidence)
+  Expected contribution: $979.67   low-confidence range [-$792.82 .. $2397.42]  (55% confidence)
+  Who this plan attracts (pre-service):
+    segment           pool  appeal    mix  attracted
+    Value Lunch         14     40%     7%          6
+    Social Dinner       57    100%    78%         59
+    Food Enthusiast     24     41%    13%         10
+    total               95                        75
+    - Your attracted crowd is mostly social dinner (78% of arrivals); service will be tuned to their budget and patience, not the market average.
   Key assumptions:
     - Conversion of attempted visits: 78% (menu fit & pricing vs this market).
     - Demand opportunity (best case): ~178 covers if every seated party completed; binding ceiling = kitchen throughput.
@@ -32,60 +39,66 @@ SERVICE LOG (sampled):
   t=  0  seated= 0  queue= 0  cooking= 0  tickets[Cold:0 Saute:0 Grill:0 Pastry:0]  rev=$0.00
   t= 15  seated= 3  queue= 0  cooking= 2  tickets[Cold:1 Saute:0 Grill:0 Pastry:0]  rev=$0.00
   t= 30  seated= 7  queue= 0  cooking= 5  tickets[Cold:0 Saute:0 Grill:0 Pastry:0]  rev=$0.00
-  t= 45  seated=13  queue= 0  cooking= 6  tickets[Cold:2 Saute:2 Grill:1 Pastry:0]  rev=$113.00
-  t= 60  seated=17  queue= 0  cooking=12  tickets[Cold:2 Saute:0 Grill:8 Pastry:0]  rev=$484.00
-  t= 75  seated=19  queue= 2  cooking=13  tickets[Cold:0 Saute:1 Grill:9 Pastry:0]  rev=$869.00
-  t= 90  seated=19  queue= 2  cooking=12  tickets[Cold:0 Saute:0 Grill:11 Pastry:0]  rev=$1277.00
-  t=105  seated=20  queue= 6  cooking=14  tickets[Cold:7 Saute:0 Grill:12 Pastry:0]  rev=$1525.00
-  t=120  seated=19  queue=11  cooking=15  tickets[Cold:11 Saute:0 Grill:14 Pastry:0]  rev=$1684.50
-  t=135  seated=20  queue=15  cooking=16  tickets[Cold:7 Saute:0 Grill:15 Pastry:0]  rev=$1807.50
-  t=150  seated=22  queue= 6  cooking=14  tickets[Cold:7 Saute:0 Grill:16 Pastry:0]  rev=$2078.50
-  t=165  seated=22  queue= 3  cooking=18  tickets[Cold:10 Saute:1 Grill:21 Pastry:0]  rev=$2266.00
-  t=180  seated=18  queue= 0  cooking=18  tickets[Cold:5 Saute:0 Grill:21 Pastry:0]  rev=$2404.00
-  t=195  seated=10  queue= 0  cooking=10  tickets[Cold:0 Saute:0 Grill:14 Pastry:0]  rev=$2468.50
-  t=210  seated= 4  queue= 0  cooking= 4  tickets[Cold:0 Saute:0 Grill:6 Pastry:0]  rev=$2468.50
+  t= 45  seated=15  queue= 0  cooking= 6  tickets[Cold:2 Saute:2 Grill:1 Pastry:0]  rev=$0.00
+  t= 60  seated=20  queue= 0  cooking=11  tickets[Cold:0 Saute:0 Grill:6 Pastry:0]  rev=$249.50
+  t= 75  seated=20  queue= 4  cooking=12  tickets[Cold:0 Saute:1 Grill:6 Pastry:0]  rev=$617.50
+  t= 90  seated=19  queue= 6  cooking= 8  tickets[Cold:0 Saute:0 Grill:5 Pastry:0]  rev=$1020.00
+  t=105  seated=18  queue=11  cooking=12  tickets[Cold:8 Saute:0 Grill:10 Pastry:0]  rev=$1364.00
+  t=120  seated=21  queue=11  cooking=13  tickets[Cold:8 Saute:0 Grill:7 Pastry:0]  rev=$1782.00
+  t=135  seated=22  queue=15  cooking=16  tickets[Cold:7 Saute:0 Grill:11 Pastry:0]  rev=$2060.50
+  t=150  seated=22  queue= 9  cooking=10  tickets[Cold:0 Saute:0 Grill:5 Pastry:0]  rev=$2244.00
+  t=165  seated=21  queue= 4  cooking= 8  tickets[Cold:0 Saute:0 Grill:2 Pastry:0]  rev=$2551.00
+  t=180  seated=17  queue= 0  cooking= 9  tickets[Cold:0 Saute:0 Grill:4 Pastry:0]  rev=$3108.50
+  t=195  seated=11  queue= 0  cooking= 3  tickets[Cold:0 Saute:0 Grill:0 Pastry:0]  rev=$3531.50
+  t=210  seated= 3  queue= 0  cooking= 0  tickets[Cold:0 Saute:0 Grill:0 Pastry:0]  rev=$4119.00
 
 ====== POST-SERVICE AUTOPSY  [social-dinner] Balanced Competent  seed 700042 ======
 FORECAST vs ACTUAL:
-  Covers:       forecast   100   actual    82
-  Contribution: forecast   $811.19   actual   $323.00   diff -$488.19
+  Covers:       forecast   100   actual   139
+  Contribution: forecast   $979.67   actual  $2419.00   diff $1439.33
 
 DEMAND FUNNEL:
   Attempted parties (after market/pricing): 86
-  Served parties: 37   covers: 82
-  Lost to seating/capacity: 8   walked out waiting: 41   no acceptable dish: 0
+  Served parties: 64   covers: 139
+  Lost to seating/capacity: 19   walked out waiting: 3   no acceptable dish: 0
 
 ECONOMY:
-  Revenue:         $2468.50
-  Ingredients:   - $1390.50
+  Revenue:         $4366.50
+  Ingredients:   - $1192.50
   Labor:         -  $605.00
   Fixed overhead:-  $150.00
-  CONTRIBUTION:     $323.00   (profit)
+  CONTRIBUTION:    $2419.00   (profit)
 
-SERVICE: avg ticket 24 min   service failures 127   menu-complexity load +7%   overall satisfaction 579/1000
+SERVICE: avg ticket 23 min   service failures 65   menu-complexity load +7%   overall satisfaction 559/1000
 
 BY DISH:
   dish                ord  dlv fail  qual   revenue   contrib
-  House Salad          87   45   24   372   $385.00   $167.50
-  Classic Burger       41   18   20   262   $168.00   -$12.00
-  Roast Chicken        77   32   22   509   $713.00   $317.00
-  Fish & Chips         57   32    7   552   $725.00   $440.00
-  Ice Cream            40   15    5   519   $140.00    $80.00
-  Cheese Plate         42   18    8   691   $337.50    $85.50
+  House Salad          75   71   20   395   $594.00   $406.50
+  Classic Burger       34   33   13   396   $441.00   $288.00
+  Roast Chicken        64   60   17   551  $1364.00  $1012.00
+  Fish & Chips         49   46    4   573  $1075.00   $830.00
+  Ice Cream            30   26    2   555   $240.00   $195.00
+  Cheese Plate         35   34    6   696   $652.50   $442.50
 
-BY SEGMENT (satisfaction 0-1000; F=food W=wait S=service V=value):
-  Value Lunch      parties   1 covers   0  sat  120  (F120 W120 S120 V120)
-  Social Dinner    parties  69 covers  70  sat  335  (F310 W323 S413 V415)
-  Food Enthusiast  parties   8 covers  12  sat  374  (F309 W456 S533 V509)
+ATTRACTION (demand model: pool = market offered, appeal = considered you, mix = share of who arrived):
+  segment           pool  appeal    mix  arrived
+  Value Lunch         14     40%     3%        3
+  Social Dinner       57    100%    87%       75
+  Food Enthusiast     24     41%     9%        8
+
+BY SEGMENT (of those served/lost; satisfaction 0-1000; F=food W=wait S=service V=value):
+  Value Lunch      parties   1 covers   3  sat  443  (F457 W358 S694 V627)
+  Social Dinner    parties  58 covers 118  sat  544  (F543 W465 S684 V768)
+  Food Enthusiast  parties   8 covers  18  sat  562  (F476 W620 S788 V817)
 
 BY STATION (utilization / peak queue / dishes / staff):
-  Cold     util   72%  peakQ  13  dishes  129  staff 1
-  Saute    util   63%  peakQ   4  dishes   57  staff 1
-  Grill    util   87%  peakQ  25  dishes  112  staff 2
-  Pastry   util   17%  peakQ   0  dishes   40  staff 1
+  Cold     util   62%  peakQ  10  dishes  110  staff 1
+  Saute    util   55%  peakQ   4  dishes   49  staff 1
+  Grill    util   75%  peakQ  12  dishes   98  staff 2
+  Pastry   util   13%  peakQ   0  dishes   30  staff 1
 
 CAUSAL SUMMARY:
-  Primary loss: the kitchen could not keep pace — 41 parties walked out waiting and 36 dishes were comped (~$1116.99 of lost contribution). The Grill station ran at 87% (peak queue 25) was the tightest point.
-  Most profitable dish: Fish & Chips   Least useful dish: Classic Burger   Busiest station: Grill (a condition, not necessarily the primary loss)
-  checksum: 6CBD8F76B46A51E1
+  Primary loss: the kitchen could not keep pace — 3 parties walked out waiting and 55 dishes were comped (~$1281.70 of lost contribution). The Grill station ran at 75% (peak queue 12) was the tightest point.
+  Most profitable dish: Roast Chicken   Least useful dish: Ice Cream   Busiest station: Grill (a condition, not necessarily the primary loss)
+  checksum: 05E65C6E8AD6AF07
 
diff --git a/src/RestaurantSim.Core/Forecast.cs b/src/RestaurantSim.Core/Forecast.cs
index 85975e9..dcd1dc7 100644
--- a/src/RestaurantSim.Core/Forecast.cs
+++ b/src/RestaurantSim.Core/Forecast.cs
@@ -68,8 +68,11 @@ public static ForecastSnapshot Compute(M0World world, MarketScenario sc, Service
         }
         if (kitchenCoverCap == long.MaxValue) kitchenCoverCap = 0; // no staffed station with dishes
 
-        // seat cover capacity
-        int avgDwell = Tuning.ForecastAvgDwellMin;
+        // seat cover capacity — dwell scales with the captured mix's expected course count (MED-ECON-1), using
+        // the SAME Tuning.SeatEatMin the simulator uses, so a premium/high-course menu turns fewer tables.
+        // expectedCoursesX10 = expected courses per cover x 10 (dishesPerCoverBp is 1 main + P(starter) + P(dessert)).
+        int expectedCoursesX10 = (int)((long)dishesPerCoverBp * 10 / FixedMath.Bp);
+        int avgDwell = Tuning.ForecastNonEatDwellMin + Tuning.SeatEatMin(expectedCoursesX10);
         long seatCoverCap = (long)plan.Seats * sc.ServiceMinutes / avgDwell;
 
         // "Demand opportunity" is the average-capacity, zero-loss ceiling. It is NOT what completes.
@@ -186,8 +189,45 @@ public static ForecastSnapshot Compute(M0World world, MarketScenario sc, Service
             "Confidence is deliberately LOW: pre-service cannot see execution failures, patience walkouts, or peak-minute crowding; the range is wide and skewed low.",
         };
 
+        // Per-segment attraction (H-LEG-1): expose WHO the plan attracts. Largest-remainder reconciliation so the
+        // pool column sums exactly to ExpectedArrivals and the attracted column exactly to attempts.
+        int S = sc.SegmentMixBp.Length;
+        var segAttr = new List<SegmentAttraction>(S);
+        int poolAcc = 0, partyAcc = 0;
+        for (int s = 0; s < S; s++)
+        {
+            var seg = world.Segment((SegmentId)s);
+            int pool = s < S - 1 ? (int)FixedMath.MulDivRound(sc.ExpectedArrivals, sc.SegmentMixBp[s], FixedMath.Bp) : sc.ExpectedArrivals - poolAcc;
+            int party = s < S - 1 ? (int)FixedMath.MulDivRound(attempts, compBp[s], FixedMath.Bp) : attempts - partyAcc;
+            poolAcc += pool; partyAcc += party;
+            segAttr.Add(new SegmentAttraction((SegmentId)s, seg.Name, pool, captured.ConsiderationBp[s], compBp[s], party));
+        }
+        var attractionNotes = AttractionNotes(sc, segAttr, kitchenCoverCap, meanSizeX10);
+
         return new ForecastSnapshot((int)demandOpportunity, (int)expectedCompleted, revenue, contribution,
-            contribLow, contribHigh, confidenceBp, assumptions);
+            contribLow, contribHigh, confidenceBp, assumptions, segAttr, attractionNotes);
+    }
+
+    /// <summary>One or two plain-language attraction observations derived from the actual per-segment forecast
+    /// (never generic-to-every-plan). H-LEG-1.</summary>
+    private static List<string> AttractionNotes(MarketScenario sc, List<SegmentAttraction> a, long kitchenCoverCap, int meanSizeX10)
+    {
+        var notes = new List<string>();
+        int MarketPct(int poolParties) => (int)((long)poolParties * 100 / Math.Max(1, sc.ExpectedArrivals));
+        var top = a.OrderByDescending(x => x.ConsiderationBp).ThenBy(x => (int)x.Id).First();
+        var dominant = a.OrderByDescending(x => x.CompositionBp).ThenBy(x => (int)x.Id).First();
+        var ignored = a.Where(x => x.ConsiderationBp <= Tuning.ConsiderationFloorBp * 3 && x.PoolParties > 0)
+                       .OrderByDescending(x => x.PoolParties).ThenBy(x => (int)x.Id).FirstOrDefault();
+        if (ignored != null && ignored.Id != top.Id)
+            notes.Add($"This plan barely registers with {ignored.Name.ToLowerInvariant()}: only {ignored.ConsiderationBp / 100}% considered it, so they are just {ignored.CompositionBp / 100}% of arrivals despite being {MarketPct(ignored.PoolParties)}% of this market.");
+        else if (dominant.CompositionBp >= 5000)
+            notes.Add($"Your attracted crowd is mostly {dominant.Name.ToLowerInvariant()} ({dominant.CompositionBp / 100}% of arrivals); service will be tuned to their budget and patience, not the market average.");
+        else
+            notes.Add($"Your strongest pull is {top.Name.ToLowerInvariant()} ({top.ConsiderationBp / 100}% of that crowd considered you); they are {top.CompositionBp / 100}% of who walks in.");
+        long attractedCovers = a.Sum(x => (long)x.Parties) * meanSizeX10 / 10;
+        if (kitchenCoverCap > 0 && attractedCovers > kitchenCoverCap * 12 / 10)
+            notes.Add("You are likely to attract more customers than the kitchen can serve — expect walkouts unless you add capacity or narrow the menu's appeal.");
+        return notes;
     }
 
     /// <summary>
diff --git a/src/RestaurantSim.Core/Result.cs b/src/RestaurantSim.Core/Result.cs
index a2cd7da..eea6d65 100644
--- a/src/RestaurantSim.Core/Result.cs
+++ b/src/RestaurantSim.Core/Result.cs
@@ -1,5 +1,16 @@
 namespace RestaurantSim.Core;
 
+/// <summary>
+/// Per-segment attraction (H-LEG-1): makes the menu-responsive demand model visible. Pre-service these are
+/// EXPECTED values from the forecast; post-service they are the REALIZED pool/consideration/arrival mix.
+/// </summary>
+public sealed record SegmentAttraction(
+    SegmentId Id, string Name,
+    int PoolParties,           // the market pool offered for this segment
+    int ConsiderationBp,       // capture rate of this segment's pool (0..10000) — how appealing the plan looked
+    int CompositionBp,         // this segment's share of the attracted arrival mix (row set sums ~10000)
+    int Parties);              // expected (forecast) / actual (autopsy) attracted parties
+
 /// <summary>Immutable pre-service forecast. Computed only from pre-commit information; never recomputed.</summary>
 public sealed record ForecastSnapshot(
     int DemandOpportunity,     // best-case covers if every seated party completed (the average-capacity ceiling)
@@ -9,7 +20,9 @@ public sealed record ForecastSnapshot(
     Money ContributionLow,
     Money ContributionHigh,
     int ConfidenceBp,          // stated confidence the actual falls within [Low, High]
-    IReadOnlyList<string> KeyAssumptions);
+    IReadOnlyList<string> KeyAssumptions,
+    IReadOnlyList<SegmentAttraction> SegmentAttraction, // who the plan is expected to attract (per segment)
+    IReadOnlyList<string> AttractionNotes);             // plain-language attraction observations
 
 public sealed record DishOutcome(
     int RecipeId, string Name, Course Course,
@@ -54,10 +67,11 @@ public sealed record ServiceResult(
     // breakdowns
     IReadOnlyList<DishOutcome> Dishes,
     IReadOnlyList<SegmentOutcome> Segments,
+    IReadOnlyList<SegmentAttraction> Attraction, // realized per-segment pool/consideration/arrival mix (H-LEG-1)
     IReadOnlyList<StationOutcome> StationsOut,
     IReadOnlyList<EmployeeUtil> Employees,
     // causal summary
-    string PrimaryLossCause,   // "seating" | "kitchen" | "menu-fit" | "weak-demand" | "none" — ranked by measured lost contribution
+    string PrimaryLossCause,   // "seating"|"kitchen"|"purchase-conversion"|"weak-attraction"|"wrong-mix"|"none" — ranked by measured lost/missed contribution
     string BottleneckCause,    // full two-tier human text: primary business loss + secondary operational warning
     int MostProfitableRecipeId,
     int LeastUsefulRecipeId,
diff --git a/src/RestaurantSim.Core/Simulator.cs b/src/RestaurantSim.Core/Simulator.cs
index 900d443..688a9eb 100644
--- a/src/RestaurantSim.Core/Simulator.cs
+++ b/src/RestaurantSim.Core/Simulator.cs
@@ -16,7 +16,6 @@ public sealed class ServiceSimulator
 {
     // Tuning constants (named; never inline magic numbers with meaning).
     private const int BrowseMin = 4;
-    private const int EatMin = 12;
     private const int DeliveryBaseMin = 1;
     private const int FohPartiesPerStaff = 8;
     private const int HoldingDecayPerMin = 18;   // milli quality lost per minute held beyond tolerance
@@ -198,7 +197,9 @@ public ServiceResult Run(M0World world, MarketScenario scenario, ServicePlan pla
                             int deliveryDelay = DeliveryBaseMin + (fohRatioBp >= FixedMath.Bp ? 0 : FixedMath.Clamp((FixedMath.Bp - fohRatioBp) / 2000, 0, 6));
                             if (t >= p.ReadyMin + deliveryDelay)
                             {
-                                p.DeliverMin = t; p.EatUntil = t + EatMin; p.State = PState.Eating;
+                                // Course-scaled dining: a multi-course meal occupies the seat longer than a
+                                // single-course one (MED-ECON-1). Deterministic from the party's own dishes.
+                                p.DeliverMin = t; p.EatUntil = t + Tuning.SeatEatMin(DistinctCourseCount(p) * 10); p.State = PState.Eating;
                                 ApplyHoldingLoss(p);
                                 ticketTimeSum += (p.DeliverMin - p.OrderMin); ticketTimeCount++;
                             }
@@ -268,7 +269,7 @@ public ServiceResult Run(M0World world, MarketScenario scenario, ServicePlan pla
         return Finalize(world, scenario, plan, seed, allParties, stations, working, fohCrew,
             revenue, ingredientCost, complexityPenaltyBp, serviceFailures,
             ticketTimeCount == 0 ? 0 : (int)(ticketTimeSum / ticketTimeCount),
-            demandGenerated, menu, log);
+            demandGenerated, captured, menu, log);
     }
 
     // ---- helpers ----
@@ -419,6 +420,20 @@ private void FinishDish(M0World world, Dish d, EmployeeDef emp, St st, int compl
         d.Done = true; // DoneMin is stamped by the station loop with the current minute
     }
 
+    /// <summary>Distinct courses present in a party's order (0..3), deterministic and size-independent — a
+    /// 4-top all ordering mains is a one-course meal, a solo diner with starter+main+dessert is three.</summary>
+    private static int DistinctCourseCount(Party p)
+    {
+        bool s = false, m = false, d = false;
+        foreach (var dish in p.Dishes)
+        {
+            if (dish.Recipe.Course == Course.Starter) s = true;
+            else if (dish.Recipe.Course == Course.Main) m = true;
+            else if (dish.Recipe.Course == Course.Dessert) d = true;
+        }
+        return (s ? 1 : 0) + (m ? 1 : 0) + (d ? 1 : 0);
+    }
+
     private static void ApplyHoldingLoss(Party p)
     {
         // A dish that finished well before the whole party's meal was delivered has been "held":
@@ -448,7 +463,7 @@ private static string SnapshotLine(int t, List<Party> active, List<Party> waitin
     private ServiceResult Finalize(M0World world, MarketScenario sc, ServicePlan plan, ulong seed,
         List<Party> parties, St[] stations, List<EmployeeDef> working, List<EmployeeDef> fohCrew,
         Money revenue, Money ingredientCost, int complexityPenaltyBp, int serviceFailures,
-        int avgTicketTime, int demandGenerated, Dictionary<int, long> menu, List<string> log)
+        int avgTicketTime, int demandGenerated, CapturedDemand captured, Dictionary<int, long> menu, List<string> log)
     {
         // satisfaction per party
         foreach (var p in parties) ComputeSatisfaction(world, p);
@@ -519,6 +534,21 @@ private ServiceResult Finalize(M0World world, MarketScenario sc, ServicePlan pla
             empUtil.Add(new EmployeeUtil(empId, e.Name, asg, util));
         }
 
+        // per-segment attraction (H-LEG-1): realized pool / consideration / arrival mix, so the demand model is
+        // visible after service and can be compared with the forecast's expected mix.
+        int nSeg = sc.SegmentMixBp.Length;
+        var arrivedBySeg = new int[nSeg];
+        foreach (var p in parties) arrivedBySeg[(int)p.Seg]++;
+        int totalArrived = 0; foreach (var v in arrivedBySeg) totalArrived += v;
+        var attraction = new List<SegmentAttraction>(nSeg);
+        for (int s = 0; s < nSeg; s++)
+        {
+            var seg = world.Segment((SegmentId)s);
+            int pool = (int)FixedMath.MulDivRound(sc.ExpectedArrivals, sc.SegmentMixBp[s], FixedMath.Bp);
+            int comp = totalArrived > 0 ? (int)FixedMath.MulDivRound(FixedMath.Bp, arrivedBySeg[s], totalArrived) : 0;
+            attraction.Add(new SegmentAttraction((SegmentId)s, seg.Name, pool, captured.ConsiderationBp[s], comp, arrivedBySeg[s]));
+        }
+
         // causal summary — attribute the PRIMARY loss by MEASURED lost contribution per channel, using
         // this service's own marginal contribution-per-cover as the estimate. Utilization is reported as
         // a SECONDARY operational warning only; a busy station is a condition, not proof of the largest loss.
@@ -540,8 +570,28 @@ private ServiceResult Finalize(M0World world, MarketScenario sc, ServicePlan pla
         long kitchenLoss = lostWaitCovers * cpcFloored + compLossCents;
         long menuLoss = lostMenuCovers * cpcFloored;
         long weakLoss = weakDemandCovers * cpcFloored;
+        // Wrong-mix OPPORTUNITY cost (H-LEG-1): the market offered a higher-spend segment that the plan
+        // under-attracted (its arrival share below its pool share) while the operation otherwise ran fine. This
+        // is a composition mismatch, not a party bucket, so it never double-counts the disjoint loss channels.
+        long wrongMixLoss = 0; string wrongMixSeg = "";
+        {
+            long avgBudget = 0;
+            for (int s = 0; s < nSeg; s++) avgBudget += (long)sc.SegmentMixBp[s] * world.Segment((SegmentId)s).BudgetPerCoverCents;
+            avgBudget /= FixedMath.Bp;
+            int h = -1; long hb = 0;
+            for (int s = 0; s < nSeg; s++) { long b = world.Segment((SegmentId)s).BudgetPerCoverCents; if (sc.SegmentMixBp[s] > 0 && b > hb) { hb = b; h = s; } }
+            if (h >= 0 && attraction[h].CompositionBp < sc.SegmentMixBp[h] && cpcFloored > 0)
+            {
+                long underParties = (long)demandGenerated * (sc.SegmentMixBp[h] - attraction[h].CompositionBp) / FixedMath.Bp;
+                long underCovers = underParties * Math.Max(1000, avgSizeX1000) / 1000;
+                long spendGap = Math.Max(0, hb - avgBudget);
+                wrongMixLoss = underCovers * spendGap * 6000 / FixedMath.Bp; // ~60% gross margin on the missed higher spend
+                wrongMixSeg = world.Segment((SegmentId)h).Name;
+            }
+        }
         var (primaryCause, bottleneck, pressureStation) = DiagnoseBottleneck(sc, demandGenerated, cpcFloored,
-            seatLoss, kitchenLoss, menuLoss, weakLoss, lostCap, lostWait, lostMenu, compedCount, compLossCents, stOut, avgTicketTime);
+            seatLoss, kitchenLoss, menuLoss, weakLoss, wrongMixLoss, wrongMixSeg,
+            lostCap, lostWait, lostMenu, compedCount, compLossCents, stOut, avgTicketTime);
         int mostProfit = dishOut.Count == 0 ? -1 : dishOut.OrderByDescending(d => d.Contribution.Cents).ThenBy(d => d.RecipeId).First().RecipeId;
         int leastUseful = dishOut.Count == 0 ? -1 : dishOut.OrderBy(d => d.Delivered == 0 ? long.MinValue : d.Contribution.Cents).ThenBy(d => d.RecipeId).First().RecipeId;
         int overallSat = covers == 0 ? 0 : (int)(parties.Where(p => p.State == PState.Paid).Sum(p => (long)p.SatOverall * p.Size) / covers);
@@ -553,7 +603,7 @@ private ServiceResult Finalize(M0World world, MarketScenario sc, ServicePlan pla
             demandGenerated, served, covers, lostCap, lostWait, lostMenu,
             revenue, ingredientCost, labor, overhead, contribution,
             avgTicketTime, serviceFailures, complexityPenaltyBp,
-            dishOut, segOut, stOut, empUtil,
+            dishOut, segOut, attraction, stOut, empUtil,
             primaryCause, bottleneck, mostProfit, leastUseful, pressureStation, overallSat, checksum, log);
     }
 
@@ -589,26 +639,29 @@ private static int Meet(int actual, int expected)
     // TIER 2 reports the busiest station as a condition/warning, never as the primary loss on its own.
     private static (string primaryCause, string text, StationId busiest) DiagnoseBottleneck(
         MarketScenario sc, int demandGenerated, long cpcFloored,
-        long seatLoss, long kitchenLoss, long menuLoss, long weakLoss,
+        long seatLoss, long kitchenLoss, long menuLoss, long weakLoss, long wrongMixLoss, string wrongMixSeg,
         int lostCap, int lostWait, int lostMenu, int compedCount, long compLossCents,
         List<StationOutcome> st, int avgTicketMin)
     {
         var peak = st.OrderByDescending(s => s.UtilizationBp).ThenBy(s => (int)s.Id).First();
 
-        // Choose the primary channel by MEASURED harm. When the service earns positive marginal
-        // contribution, rank by lost contribution (covers not captured x cpc, plus comped revenue).
-        // When it is loss-making (cpc <= 0) the contribution estimate is meaningless, so rank by raw
-        // lost-party/dish COUNTS so an operational problem is still named without comp-cents dominating.
-        // Deterministic tie order: seating, kitchen, menu-fit, weak-demand.
+        // Choose the primary channel by MEASURED harm, across THREE demand-side channels (weak-attraction =
+        // too few, wrong-mix = wrong crowd, purchase-conversion = arrived-but-didn't-order) and the operational
+        // channels (seating, kitchen). Each reads a DISJOINT slice so no party/contribution is double-counted:
+        // weak-attraction = parties never generated; wrong-mix = a composition opportunity cost; purchase =
+        // NoOrder; seating = WalkedSeat; kitchen = WalkedFood + comps. When the service earns positive marginal
+        // contribution, rank by lost contribution; when loss-making (cpc<=0) rank by raw counts.
+        // Deterministic tie order: seating, kitchen, purchase-conversion, weak-attraction, wrong-mix.
         string cause;
         if (cpcFloored > 0)
         {
-            long maxLoss = Math.Max(Math.Max(seatLoss, kitchenLoss), Math.Max(menuLoss, weakLoss));
+            long maxLoss = Math.Max(Math.Max(Math.Max(seatLoss, kitchenLoss), Math.Max(menuLoss, weakLoss)), wrongMixLoss);
             if (maxLoss == 0) cause = "none";
             else if (seatLoss == maxLoss) cause = "seating";
             else if (kitchenLoss == maxLoss) cause = "kitchen";
-            else if (menuLoss == maxLoss) cause = "menu-fit";
-            else cause = "weak-demand";
+            else if (menuLoss == maxLoss) cause = "purchase-conversion";
+            else if (weakLoss == maxLoss) cause = "weak-attraction";
+            else cause = "wrong-mix";
         }
         else
         {
@@ -616,8 +669,8 @@ private static (string primaryCause, string text, StationId busiest) DiagnoseBot
             if (maxCount == 0) cause = "none";
             else if (lostCap == maxCount) cause = "seating";
             else if (lostWait + compedCount == maxCount) cause = "kitchen";
-            else if (lostMenu == maxCount) cause = "menu-fit";
-            else cause = "weak-demand";
+            else if (lostMenu == maxCount) cause = "purchase-conversion";
+            else cause = "weak-attraction";
         }
 
         string busyStr = $"the {peak.Id} station ran at {peak.UtilizationBp / 100}% (peak queue {peak.PeakQueue})";
@@ -627,8 +680,9 @@ private static (string primaryCause, string text, StationId busiest) DiagnoseBot
         {
             "seating" => $"Primary loss: seating turned away {lostCap} parties at the door (~{new Money(seatLoss)} of lost contribution). More seats or faster table turns would recover the most.",
             "kitchen" => $"Primary loss: the kitchen could not keep pace — {lostWait} parties walked out waiting and {compedCount} dishes were comped (~{new Money(kitchenLoss)} of lost contribution). {Cap(busyStr)} was the tightest point.",
-            "menu-fit" => $"Primary loss: {lostMenu} seated parties found nothing acceptable to order (~{new Money(menuLoss)} of lost contribution). The menu does not fit this market's tastes or prices.",
-            "weak-demand" => $"Primary loss: weak demand — only {demandGenerated} parties attempted a visit versus roughly {sc.ExpectedArrivals} the market could yield. Menu appeal or pricing kept people away.",
+            "purchase-conversion" => $"Primary loss: {lostMenu} seated parties found nothing acceptable to order (~{new Money(menuLoss)} of lost contribution). Customers arrived but the menu's dishes or prices did not convert them.",
+            "weak-attraction" => $"Primary demand issue: weak attraction — only {demandGenerated} parties considered a visit versus roughly {sc.ExpectedArrivals} the market could yield. Menu appeal or expected meal price kept people away.",
+            "wrong-mix" => $"Primary demand issue: wrong mix — the plan under-attracted {wrongMixSeg.ToLowerInvariant()}, the market's higher-spending crowd (~{new Money(wrongMixLoss)} of missed contribution), while filling the room with a lower-value crowd. The operation ran fine; the menu attracted the wrong customers for this market.",
             _ => "Balanced service: demand was met within capacity with no dominant loss channel.",
         };
 
diff --git a/src/RestaurantSim.Core/TextReport.cs b/src/RestaurantSim.Core/TextReport.cs
index 5d74f52..56d6c8b 100644
--- a/src/RestaurantSim.Core/TextReport.cs
+++ b/src/RestaurantSim.Core/TextReport.cs
@@ -35,6 +35,19 @@ public static string Forecast(ForecastSnapshot f)
         sb.AppendLine($"  Expected covers:       {f.ExpectedCovers} (completed, after peaking & walkouts)");
         sb.AppendLine($"  Expected revenue:      {f.ExpectedRevenue}");
         sb.AppendLine($"  Expected contribution: {f.ExpectedContribution}   low-confidence range [{f.ContributionLow} .. {f.ContributionHigh}]  ({Pct(f.ConfidenceBp)} confidence)");
+        if (f.SegmentAttraction.Count > 0)
+        {
+            sb.AppendLine("  Who this plan attracts (pre-service):");
+            sb.AppendLine($"    {"segment",-16} {"pool",5} {"appeal",7} {"mix",6} {"attracted",10}");
+            int poolT = 0, partyT = 0;
+            foreach (var a in f.SegmentAttraction)
+            {
+                sb.AppendLine($"    {a.Name,-16} {a.PoolParties,5} {Pct(a.ConsiderationBp),7} {Pct(a.CompositionBp),6} {a.Parties,10}");
+                poolT += a.PoolParties; partyT += a.Parties;
+            }
+            sb.AppendLine($"    {"total",-16} {poolT,5} {"",7} {"",6} {partyT,10}");
+            foreach (var n in f.AttractionNotes) sb.AppendLine($"    - {n}");
+        }
         sb.AppendLine("  Key assumptions:");
         foreach (var a in f.KeyAssumptions) sb.AppendLine($"    - {a}");
         return sb.ToString();
@@ -71,7 +84,12 @@ public static string Autopsy(M0World w, ServiceResult r, ForecastSnapshot? forec
         foreach (var d in r.Dishes)
             sb.AppendLine($"  {d.Name,-18} {d.Ordered,4} {d.Delivered,4} {d.Failed,4} {d.AvgQuality,5} {d.Revenue,9} {d.Contribution,9}");
         sb.AppendLine();
-        sb.AppendLine("BY SEGMENT (satisfaction 0-1000; F=food W=wait S=service V=value):");
+        sb.AppendLine("ATTRACTION (demand model: pool = market offered, appeal = considered you, mix = share of who arrived):");
+        sb.AppendLine($"  {"segment",-16} {"pool",5} {"appeal",7} {"mix",6} {"arrived",8}");
+        foreach (var a in r.Attraction)
+            sb.AppendLine($"  {a.Name,-16} {a.PoolParties,5} {Pct(a.ConsiderationBp),7} {Pct(a.CompositionBp),6} {a.Parties,8}");
+        sb.AppendLine();
+        sb.AppendLine("BY SEGMENT (of those served/lost; satisfaction 0-1000; F=food W=wait S=service V=value):");
         foreach (var s in r.Segments)
             sb.AppendLine($"  {s.Name,-16} parties {s.Parties,3} covers {s.Covers,3}  sat {s.AvgSatisfaction,4}  (F{s.AvgFood} W{s.AvgWait} S{s.AvgService} V{s.AvgValue})");
         sb.AppendLine();
diff --git a/src/RestaurantSim.Core/Tuning.cs b/src/RestaurantSim.Core/Tuning.cs
index 14abaa1..e7ded2d 100644
--- a/src/RestaurantSim.Core/Tuning.cs
+++ b/src/RestaurantSim.Core/Tuning.cs
@@ -13,8 +13,27 @@ public static class Tuning
     /// </summary>
     public const int SlotsPerCook = 4;
 
-    /// <summary>Approximate minutes a party occupies its seats, used only by the forecaster's turn estimate.</summary>
-    public const int ForecastAvgDwellMin = 34;
+    // --- Dining duration (MED-ECON-1): seat occupancy scales with COURSE COUNT, shared by sim and forecast ---
+    // A one-course lunch turns the table faster than a three-course dinner, so a premium multi-course meal
+    // consumes more seat capacity (it no longer gets its high check for near-free seat time). Model A: a fixed
+    // seat-settle/pay overhead plus a flat increment per DISTINCT course present. 1-course = 12 (== the legacy
+    // flat EatMin, so all-one-course services are byte-identical), 2-course = 18, 3-course = 24. Integer only.
+    public const int EatBaseMin = 6;        // course-independent seat overhead (settle + pay)
+    public const int EatPerCourseMin = 6;   // added per distinct course present
+    public const int EatMinFloor = 12;      // an ordering party never eats less than the legacy 12
+    public const int EatMaxCeil = 30;       // upper guard (3-course = 24 sits below)
+    // Forecast-side non-eating dwell (browse + order + cook + deliver slack); the total forecast dwell is this
+    // plus the course-scaled eat window, so a higher-course captured mix turns fewer tables. Chosen so a typical
+    // (~1.4-course) mix reproduces the prior flat ~34-minute dwell, preserving forecast calibration.
+    public const int ForecastNonEatDwellMin = 20;
+
+    /// <summary>
+    /// Minutes a party spends eating as a function of its course count (coursesX10 = courses x 10, so a
+    /// deterministic integer covers the sim's whole-course parties AND the forecast's fractional expected
+    /// courses). Shared by ServiceSimulator and Forecaster so seat dwell can never drift between them.
+    /// </summary>
+    public static int SeatEatMin(int coursesX10)
+        => FixedMath.Clamp(EatBaseMin + (int)FixedMath.MulDivRound(EatPerCourseMin, coursesX10, 10), EatMinFloor, EatMaxCeil);
 
     /// <summary>
     /// Menu-complexity load (basis points added to ticket work and mistake chance) as a function of
diff --git a/src/RestaurantSim.Harness/Program.cs b/src/RestaurantSim.Harness/Program.cs
index 18eeb49..7b1e2bc 100644
--- a/src/RestaurantSim.Harness/Program.cs
+++ b/src/RestaurantSim.Harness/Program.cs
@@ -21,6 +21,28 @@
 var strategies = M0Strategies.All(world);
 var sim = new ServiceSimulator();
 
+// --- Text-report diagnostic (dev tool): eyeball attraction table + causal categories ---
+if (args.Contains("--report"))
+{
+    int Pr(int id, double m) => (int)(world.Recipe(id).SuggestedPriceCents * m);
+    var full2 = new Dictionary<int, Assignment> { {1,Assignment.Grill},{3,Assignment.Grill},{6,Assignment.Grill},{5,Assignment.Saute},{2,Assignment.Saute},{4,Assignment.Pastry},{8,Assignment.FrontOfHouse},{7,Assignment.FrontOfHouse} };
+    var cases = new (string sc, string tag, ServicePlan plan)[]
+    {
+        ("lunch-rush", "value-in-lunch", new ServicePlan("value", new[]{ new MenuItem(4,Pr(4,1.0)), new MenuItem(8,Pr(8,0.9)), new MenuItem(10,Pr(10,1.0)) }, full2, 52, 10000)),
+        ("enthusiast-evening", "value-chassis-in-enthusiast (wrong-mix?)", new ServicePlan("chassis", new[]{ new MenuItem(4,Pr(4,1.0)), new MenuItem(8,Pr(8,1.0)), new MenuItem(10,Pr(10,1.0)) }, full2, 55, 10000)),
+        ("enthusiast-evening", "premium-in-enthusiast", new ServicePlan("premium", new[]{ new MenuItem(5,Pr(5,1.4)), new MenuItem(6,Pr(6,1.4)), new MenuItem(7,Pr(7,1.4)), new MenuItem(11,Pr(11,1.4)) }, full2, 42, 10000)),
+    };
+    foreach (var (scId, tag, plan) in cases)
+    {
+        var scen = M0Content.Scenario(scId);
+        Console.WriteLine($"\n############## {tag}  [{scId}] ##############");
+        Console.WriteLine(TextReport.Forecast(Forecaster.Compute(world, scen, plan)));
+        var res = sim.Run(world, scen, plan, 700_042);
+        Console.WriteLine(TextReport.Autopsy(world, res, Forecaster.Compute(world, scen, plan)));
+    }
+    return 0;
+}
+
 // --- Forecast-direction diagnostic (dev tool) ---
 if (args.Contains("--fdir"))
 {
diff --git a/tests/RestaurantSim.Scenario.Tests/AttributionTests.cs b/tests/RestaurantSim.Scenario.Tests/AttributionTests.cs
index 6c147ce..780afc4 100644
--- a/tests/RestaurantSim.Scenario.Tests/AttributionTests.cs
+++ b/tests/RestaurantSim.Scenario.Tests/AttributionTests.cs
@@ -56,14 +56,14 @@ public void Kitchen_saturated_service_attributes_to_kitchen_not_seating()
     }
 
     [Fact]
-    public void Overpriced_menu_with_spare_capacity_attributes_to_weak_demand()
+    public void Overpriced_menu_with_spare_capacity_attributes_to_weak_attraction()
     {
         var overpriced = new ServicePlan("overpriced",
             new[] { new MenuItem(1, 4000), new MenuItem(4, 6000) },
             new Dictionary<int, Assignment> { { 3, Assignment.Grill }, { 6, Assignment.Cold }, { 7, Assignment.FrontOfHouse } },
             60, 10000);
         var r = Run(overpriced, "enthusiast-evening");
-        Assert.Equal("weak-demand", r.PrimaryLossCause);
+        Assert.Equal("weak-attraction", r.PrimaryLossCause);
     }
 
     [Fact]
diff --git a/tests/RestaurantSim.Scenario.Tests/ReadinessTests.cs b/tests/RestaurantSim.Scenario.Tests/ReadinessTests.cs
new file mode 100644
index 0000000..ea7cf01
--- /dev/null
+++ b/tests/RestaurantSim.Scenario.Tests/ReadinessTests.cs
@@ -0,0 +1,114 @@
+using RestaurantSim.Core;
+using Xunit;
+
+namespace RestaurantSim.Scenario.Tests;
+
+/// <summary>
+/// Locks the M0 human-gate readiness corrections (docs/design/M0-HUMAN-GATE-READINESS-CONTRACT.md):
+/// H-LEG-1 (per-segment attraction visible pre- and post-service; weak-attraction / wrong-mix / purchase-
+/// conversion causal categories) and MED-ECON-1 (course-scaled seat duration via the shared SeatEatMin primitive).
+/// </summary>
+public class ReadinessTests
+{
+    private static readonly M0World W = M0Content.World();
+    private static readonly ServiceSimulator Sim = new();
+    private static int P(int id, double m) => (int)(W.Recipe(id).SuggestedPriceCents * m);
+    private static readonly Dictionary<int, Assignment> Full = new()
+    {
+        { 1, Assignment.Grill }, { 3, Assignment.Grill }, { 6, Assignment.Grill }, { 5, Assignment.Saute },
+        { 2, Assignment.Saute }, { 4, Assignment.Pastry }, { 8, Assignment.FrontOfHouse }, { 7, Assignment.FrontOfHouse },
+    };
+    // dominant primary cause over a seed set (robust to per-seed realization noise)
+    private static string ModeCause(ServicePlan p, string sc, int n = 25)
+    {
+        var counts = new Dictionary<string, int>();
+        for (int i = 0; i < n; i++) { var c = Sim.Run(W, M0Content.Scenario(sc), p, 700_000UL + (ulong)i).PrimaryLossCause; counts[c] = counts.GetValueOrDefault(c) + 1; }
+        return counts.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).First().Key;
+    }
+
+    // ---- MED-ECON-1: course-scaled dining duration ----
+
+    [Fact]
+    public void SeatEatMin_is_monotonic_in_courses_bounded_and_preserves_one_course_dwell()
+    {
+        int e1 = Tuning.SeatEatMin(10), e2 = Tuning.SeatEatMin(20), e3 = Tuning.SeatEatMin(30);
+        Assert.True(e1 < e2 && e2 < e3, "eat time strictly increases with course count");
+        Assert.Equal(12, e1);                                   // one course preserves the legacy 12-minute dwell
+        Assert.InRange(e3, 12, Tuning.EatMaxCeil);              // three courses bounded by the ceiling
+        Assert.Equal(Tuning.EatMaxCeil, Tuning.SeatEatMin(1000)); // clamps at the ceiling for a degenerate input
+        Assert.True(Tuning.SeatEatMin(30) >= 2 * e1 - 2, "three-course dwell is roughly double one-course (D4 target)");
+    }
+
+    [Fact]
+    public void Course_scaled_duration_does_not_move_ticket_time_only_seat_time()
+    {
+        // AvgTicketTimeMin is a KITCHEN (order->deliver) metric; the eat-time change is post-delivery, so a
+        // premium multi-course service's ticket time must be governed by cooking, not by the longer meal.
+        var premium = new ServicePlan("p", new[] { new MenuItem(5, P(5, 1.4)), new MenuItem(6, P(6, 1.4)), new MenuItem(7, P(7, 1.4)), new MenuItem(11, P(11, 1.4)) }, Full, 42, 10000);
+        var r = Sim.Run(W, M0Content.Scenario("enthusiast-evening"), premium, 700_042);
+        Assert.True(r.AvgTicketTimeMin > 0 && r.AvgTicketTimeMin < 90, "ticket time stays a plausible kitchen figure, not inflated by eat time");
+    }
+
+    // ---- H-LEG-1: attraction visibility ----
+
+    [Fact]
+    public void Forecast_exposes_per_segment_attraction_that_reconciles_to_the_market()
+    {
+        var plan = new ServicePlan("v", new[] { new MenuItem(4, P(4, 1.0)), new MenuItem(8, P(8, 1.0)), new MenuItem(10, P(10, 1.0)) }, Full, 52, 10000);
+        var f = Forecaster.Compute(W, M0Content.Scenario("lunch-rush"), plan);
+        Assert.Equal(3, f.SegmentAttraction.Count);
+        Assert.Equal(150, f.SegmentAttraction.Sum(a => a.PoolParties)); // pool column reconciles exactly to ExpectedArrivals
+        Assert.All(f.SegmentAttraction, a => Assert.InRange(a.ConsiderationBp, 0, 10000));
+        Assert.NotEmpty(f.AttractionNotes);                            // a plain-language attraction reason is shown
+        // a value menu in the value lunch reads as more appealing to value diners than to enthusiasts
+        var value = f.SegmentAttraction.First(a => a.Id == SegmentId.ValueLunch);
+        var enth = f.SegmentAttraction.First(a => a.Id == SegmentId.FoodEnthusiast);
+        Assert.True(value.CompositionBp > enth.CompositionBp);
+    }
+
+    [Fact]
+    public void Autopsy_exposes_realized_per_segment_attraction()
+    {
+        var plan = new ServicePlan("v", new[] { new MenuItem(4, P(4, 1.0)), new MenuItem(8, P(8, 1.0)), new MenuItem(10, P(10, 1.0)) }, Full, 52, 10000);
+        var r = Sim.Run(W, M0Content.Scenario("lunch-rush"), plan, 700_042);
+        Assert.Equal(3, r.Attraction.Count);
+        var value = r.Attraction.First(a => a.Id == SegmentId.ValueLunch);
+        var enth = r.Attraction.First(a => a.Id == SegmentId.FoodEnthusiast);
+        Assert.True(value.Parties > enth.Parties, "the value-heavy lunch draws more value arrivals than enthusiasts");
+    }
+
+    // ---- causal categories (§11, §14) ----
+
+    private static int CauseCount(ServicePlan p, string sc, string cause, int n)
+    { int c = 0; for (int i = 0; i < n; i++) if (Sim.Run(W, M0Content.Scenario(sc), p, 700_000UL + (ulong)i).PrimaryLossCause == cause) c++; return c; }
+
+    [Fact]
+    public void Wrong_mix_is_reachable_for_a_value_chassis_in_the_premium_market_and_never_for_a_good_premium_plan()
+    {
+        // wrong-mix (clean operation but the WRONG crowd) is a narrow regime: on seeds where a value chassis in
+        // the enthusiast market runs cleanly it correctly reads wrong-mix; on seeds where the crowd it pulls also
+        // clogs the kitchen, kitchen (a real operational loss) correctly wins by measured harm. So assert wrong-mix
+        // is REACHABLE for the chassis, and NEVER fires for a well-matched premium plan (which attracts the right crowd).
+        var chassis = new ServicePlan("chassis", new[] { new MenuItem(4, P(4, 1.0)), new MenuItem(8, P(8, 1.0)), new MenuItem(10, P(10, 1.0)) }, Full, 55, 10000);
+        var premium = new ServicePlan("premium", new[] { new MenuItem(5, P(5, 1.4)), new MenuItem(6, P(6, 1.4)), new MenuItem(7, P(7, 1.4)), new MenuItem(11, P(11, 1.4)) }, Full, 42, 10000);
+        Assert.True(CauseCount(chassis, "enthusiast-evening", "wrong-mix", 40) >= 3, "wrong-mix must be reachable for a value chassis in the premium market");
+        Assert.Equal(0, CauseCount(premium, "enthusiast-evening", "wrong-mix", 40)); // a well-matched premium plan attracts the right crowd
+    }
+
+    [Fact]
+    public void Weak_attraction_when_the_menu_repels_the_whole_market()
+    {
+        // a single wildly overpriced main: almost nobody considers the restaurant.
+        var repel = new ServicePlan("repel", new[] { new MenuItem(6, P(6, 3.0)), new MenuItem(10, P(10, 1.0)) }, Full, 40, 10000);
+        Assert.Equal("weak-attraction", ModeCause(repel, "social-dinner"));
+    }
+
+    [Fact]
+    public void Seating_and_kitchen_remain_distinguishable_from_attraction()
+    {
+        // a well-fitted value menu with a tiny room -> seating; understaffed premium -> kitchen. Neither is an attraction cause.
+        var tinyRoom = new ServicePlan("tiny", new[] { new MenuItem(4, P(4, 1.0)), new MenuItem(8, P(8, 1.0)), new MenuItem(10, P(10, 1.0)) },
+            new Dictionary<int, Assignment> { { 3, Assignment.Grill }, { 1, Assignment.Grill }, { 5, Assignment.Saute }, { 4, Assignment.Pastry }, { 8, Assignment.FrontOfHouse } }, 14, 10000);
+        Assert.Equal("seating", ModeCause(tinyRoom, "lunch-rush"));
+    }
+}
diff --git a/tests/RestaurantSim.Scenario.Tests/ScenarioTests.cs b/tests/RestaurantSim.Scenario.Tests/ScenarioTests.cs
index a8fe910..4de4803 100644
--- a/tests/RestaurantSim.Scenario.Tests/ScenarioTests.cs
+++ b/tests/RestaurantSim.Scenario.Tests/ScenarioTests.cs
@@ -6,15 +6,15 @@ namespace RestaurantSim.Scenario.Tests;
 /// <summary>Golden scenarios: fixed restaurant, fixed seed, fixed commands, locked expected checksum.</summary>
 public class GoldenScenarioTests
 {
-    // Re-baselined after the menu-responsive demand rewrite (arrival volume & composition now respond to the
-    // menu, MakeParty samples the captured mix, the lunch pool was aligned to its value-heavy identity, and the
-    // Focused Value strategy was rebuilt as a full-throughput value operation; see M0-DEMAND-REWRITE-CONTRACT.md
-    // and reports/m0/demand-rewrite/candidate-1.md). Prior baseline (economic-coherence correction):
-    // Focused Value 0xC814AFAA4D8752DE, Premium Craft 0x4D834261A7A6813E, Balanced Competent 0x2D2C5DCA4431A5EF.
+    // Re-baselined for the human-gate readiness pass: course-scaled seat duration (MED-ECON-1) changes seat
+    // occupancy → turns/covers/revenue → checksum. (Attraction legibility H-LEG-1 does NOT affect the checksum:
+    // per-segment attraction fields and cause strings are not hashed.) See M0-HUMAN-GATE-READINESS-CONTRACT.md.
+    // Prior baseline (demand rewrite): Focused Value 0xFB04479B19656E6B, Premium Craft 0x198E44A139793975,
+    // Balanced Competent 0x6CBD8F76B46A51E1.
     [Theory]
-    [InlineData("Focused Value", "lunch-rush", 0xFB04479B19656E6BUL)]
-    [InlineData("Premium Craft", "enthusiast-evening", 0x198E44A139793975UL)]
-    [InlineData("Balanced Competent", "social-dinner", 0x6CBD8F76B46A51E1UL)]
+    [InlineData("Focused Value", "lunch-rush", 0x53FE6CB73895DFD0UL)]
+    [InlineData("Premium Craft", "enthusiast-evening", 0x2DA79E2ACC88CA2FUL)]
+    [InlineData("Balanced Competent", "social-dinner", 0x05E65C6E8AD6AF07UL)]
     public void Golden_checksums_are_stable(string strategyName, string scenarioId, ulong expected)
     {
         var w = M0Content.World();